battlearray_client/Assets/Scripts/Battle/Map/Craft/PowerManager.cs

using System;
using UnityEngine;
using Sfs2X.Entities.Data;

public class PowerManager
{

	private IPowerOwner owner;

	private Power[] powers;
	private Power[] crystalPowers;
//	private Power activePower;

	public PowerManager (IPowerOwner owner, int attackId, int[] powerIds, int[] crystalPowerIds)
	{
		this.owner = owner;

		UpdatePower(attackId, powerIds);

		if(crystalPowerIds != null)
		{
			int length = crystalPowerIds.Length;
			crystalPowers = new Power[length];
			for(int i=0; i<crystalPowerIds.Length; i++)
			{
				crystalPowers[i] = PowerDataManager.GetInstance().CreatePower(i, crystalPowerIds[i], owner);
			}
		}
	}

	public void UpdatePower(int attackId, int[] powerIds)
	{
		int length = powerIds != null ? powerIds.Length+1 : 1;
		powers = new Power[length];
		
		powers[0] = PowerDataManager.GetInstance().CreatePower(0, attackId, owner, true);

		if(powerIds != null)
		{
			for(int i=0; i<powerIds.Length; i++)
			{
				int index = i+1;
				powers[index] = PowerDataManager.GetInstance().CreatePower(index, powerIds[i], owner);
			}
		}
	}

	public float GetDamage()
	{
		if (owner is Craft) {
			return (owner as Craft).GetDamage ();
		}
		return 0;
	}

	public Power GetAttack()
	{
		return powers[0];
	}

	public bool IsAttack(Power power)
	{
		return powers[0] == power;
	}

//	public void SetActivePowerByIndex(int index)
//	{
//		if(index == 0)
//			activePower = null;
//		else
//			activePower = GetPowerByIndex (index);
//	}
//
//	public void SetActivePower(Power power)
//	{
//		if(activePower != null)
//		{
//			activePower.isActivating = false;
//		}
//		if(activePower == power)
//		{
//			activePower = null;
//		}
//		else
//		{
//			activePower = power;
//			if(activePower != null)
//			{
//				activePower.isActivating = true;
//			}
//		}
//	}
//
//	public Power GetActivePower()
//	{
//		return activePower;
//	}

	public Power GetPowerById(int powerId)
	{
		for(int i=0; i<powers.Length; i++)
		{
			Power power = powers[i];
			if(power.GetId() == powerId)
			{
				return power;
			}
		}
		if(crystalPowers != null)
		{
			for(int i=0; i<crystalPowers.Length; i++)
			{
				Power power = crystalPowers[i];
				if(power.GetId() == powerId)
				{
					return power;
				}
			}
		}
		return null;
	}

	public Power GetPowerByIndex(int index)
	{
		if(index >= 0 && index < powers.Length)
		{
			return powers[index];
		}
		return null;
	}

	public Power[] GetPowers()
	{
		return powers;
	}

	public Power GetCrystalPowerByIndex(int index)
	{
		if(crystalPowers != null)
		{
			if(index >= 0 && index < crystalPowers.Length)
			{
				return crystalPowers[index];
			}
		}
		return null;
	}

	public Power[] GetCrystalPowers()
	{
		return crystalPowers;
	}


	public bool AttempUserPower(int powerId, BattleController battleController)
	{
		if(!owner.enablePower || owner.holdAction)
		{
			return false;
		}

		Power power = GetPowerById(powerId);
		if(power == null)
		{
			return false;
		}

		if(owner.userId == battleController.GetMyPlayer().userId && power.crystalNeed > 0)
		{
			if(Session.GetInstance().myUserData.coin < power.crystalNeed)
			{
				battleController.coinNotEnough();
				return false;
			}
		}

		if(!power.IsCoolDown())
		{
			return false;
		}

		if(power.GetTargetRange() == Power.TargetRange.Self)
		{
			UsePower(power, owner.target, battleController);
		}
		else if(power.GetTargetRange() == Power.TargetRange.Nova)
		{
			TeamUtil.Team team = TeamUtil.Team.Yellow;
			if(TargetType.IsContainTarget(TargetType.ENEMY, power.targetType))
				team = TeamUtil.GetOpponentTeam(owner.team);
			else if(TargetType.IsContainTarget(TargetType.ALLY, power.targetType))
				team = owner.team;

			if(battleController.GetMap().GetBattleObjectByRange(owner.position, power.GetDistance(), team).Count == 0)
			{
				if(owner == battleController.GetCtrlCraft() && !IsAttack(power))
				{
					battleController.battleUI.ShowBottomTip(Language.GetStr("PowerTip", "noTargetInRange"));
				}
				return false;
			}
			UsePower(power, owner.target, battleController);
		}
		else if(power.GetPowerType() == Power.PowerType.Summon)
		{
			Player player = battleController.GetBattleSession().GetPlayer(owner.userId);
			if(player != null && player.SoldierCount() < power.GetTargetLimit())
			{
				UsePower(power, owner.target, battleController);
			}
		}
		else if(owner.target == null)
		{
			if(owner == battleController.GetCtrlCraft() && !IsAttack(power))
			{
				battleController.battleUI.ShowBottomTip(Language.GetStr("PowerTip", "needTarget"));
			}
			return false;
		}
		else if(power.IsInRange(owner.target))
		{
			UsePower(power, owner.target, battleController);
		}
		else
		{
			if(owner == battleController.GetCtrlCraft() && !IsAttack(power))
			{
				battleController.battleUI.ShowBottomTip(Language.GetStr("PowerTip", "needCloser"));
			}
			return false;
		}
		return true;
	}

	private void UsePower(Power power, ITarget target, BattleController battleController)
	{
		if (power.crystalNeed > 0) {
			if (battleController.GetMyPlayer ().userId == power.GetOwner ().userId) 
			{
				Player player = battleController.GetBattleSession ().GetPlayer (power.GetOwner ().userId);
				power.RenewLastLaunchTime ();
				player.CrystalPowerLaunched (power.GetId (), power.GetLastLaunchTime ());
			}
		} else {
			power.RenewLastLaunchTime ();
		}
		battleController.GetMessageManager().Power(power, target);
	}
	
	public void ParsePower(int powerId, ISFSObject powerData, BattleController battleController)
	{
		Power power = GetPowerById(powerId);
		if(power != null)
		{
			if(owner is Craft)
			{
				(owner as Craft).OnUserPower();
			}

			power.ParseMessage(powerData, battleController);

			if(owner is Craft)
			{
				Craft craft = owner as Craft;
				craft.GetSwapManager().AbortSwap();
				if(power == GetAttack())
				{
					craft.SetState(Craft.State.Attack);
				}
				else
				{
					craft.SetState(Craft.State.Attack);
				}
			}
		}
		else
		{
			Debuger.LogError("parsePower::can not find power("+powerId+") owner("+owner.ToString()+")");
		}
	}



}