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

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class Craft : BattleObject, IPowerOwner
{
	public enum State
	{
		None,
		Idle,
		Run,
		Attack,
		Power,

	}

	public enum Part
	{
		All,
		Top,
		Bottom,
	}

	public string nick;

	private LinkedList<AStarNode> path;
	private Vector3 nextMovePosition;
	private bool _isMoving;
	public override bool isMoving
	{
		get{return _isMoving;}
	}
	public AStarPoint targetMovePosition = new AStarPoint();

	public bool forceMove;

	private float rotateSpeed = 200f;
	public float rotateTargetAngle;
	private bool _isTargetRotating;

	public float rotateMoveTargetAngle;
	private bool _isMoveRotating;

	public Transform bodyTrans;
	public Transform topPartTrans;
	public Transform bottomPartTrans;

	private Animation animationTop;
	private Animation animationBottom;
	
	public Material materialTop;
	public Material materialBottom;

	private PowerManager powerManager;
	private SwapManager swapManager;
	private ShotManager shotManager;

	public State state;
	private CraftData craftData;

	public MiniCraft miniCraft;

	private GameObject haloObj;
	private int haloId = -1;
	private int skinId;

	public event EventUtil.SimpleEventDelegate MoveStepComplete;
	public event EventUtil.SimpleEventDelegate OnSwapped;
	public event EventUtil.SimpleEventDelegate OnCtrlChanged;


	void Awake()
	{
		swapManager = new SwapManager(this);
	}

	public virtual void Init(Map map, CraftData craftData)
	{
		base.Init(map);
		this.craftData = craftData;

		id = craftData.id;
		userId = craftData.userId;
		_originMaxHp = hp = maxHp = craftData.GetMaxHp();
		nick = craftData.nick;
		PositionTo(craftData.position);

		Init();

		headBar.UpdateColor();
		headBar.text.text = nick;
	}

	public void Init()
	{
		bodyTrans = transform.Find("Body");
		
		topPartTrans = bodyTrans.Find("Top");
		if(topPartTrans != null)
		{
			animationTop = topPartTrans.GetComponent<Animation>();
			materialTop = topPartTrans.GetComponentInChildren<Renderer>().material;
			material = materialTop;
		}
		
		bottomPartTrans = bodyTrans.Find("Bottom");
		if(bottomPartTrans != null)
		{
			animationBottom = bottomPartTrans.GetComponent<Animation>();
			materialBottom = bottomPartTrans.GetComponentInChildren<Renderer>().material;
		}

		if(topPartTrans == null)
			animation = bodyTrans.GetComponentInChildren<Animation>();

		if(craftData != null)
		{
			if(powerManager == null)
				powerManager = new PowerManager(this, craftData.GetAttackId(), craftData.GetPowerIds(), new int[]{2001, 2002});
			else
				powerManager.UpdatePower(craftData.GetAttackId(), craftData.GetPowerIds());
			team = craftData.team;
		}

		shotManager = GetComponentInChildren<ShotManager>();
		
		SetState (State.Idle);
	}


	public float GetDamage()
	{
		return craftData.GetDamage ();
	}


	public override TeamUtil.Team team {
		get {
			return _team;
		}
		set {
			_team = value;
			if(textureArr.Length > 0)
			{
				int index = value.GetHashCode() - 1;
				if(topPartTrans == null)
				{
					SkinnedMeshRenderer[] renderers = bodyTrans.GetComponentsInChildren<SkinnedMeshRenderer>();
					for(int i=0; i<renderers.Length; i++)
					{
						renderers[i].material.mainTexture = textureArr[index];
					}
				}
				else
				{
					SkinnedMeshRenderer[] renderers = topPartTrans.GetComponentsInChildren<SkinnedMeshRenderer>();
					for(int i=0; i<renderers.Length; i++)
					{
						renderers[i].material.mainTexture = textureArr[index];
					}
					renderers = bottomPartTrans.GetComponentsInChildren<SkinnedMeshRenderer>();
					for(int i=0; i<renderers.Length; i++)
					{
						renderers[i].material.mainTexture = textureArr[index];
					}
				}
			}
		}
	}

	public SwapManager GetSwapManager()
	{
		return swapManager;
	}

	public ShotManager GetShotManager()
	{
		return shotManager;
	}


	private bool isCtrl = false;
	public void SetCtrl(bool value)
	{
		isCtrl = value;
		UpdateHaloColor ();
		headBar.UpdateColor ();

		if(OnCtrlChanged != null)
			OnCtrlChanged();
	}

	public bool IsCtrl()
	{
		return isCtrl;
	}

	public void SetHalo(int id)
	{
		if(haloId != id)
		{
			haloId = id;

			if(haloObj != null)
				Destroy(haloObj);

			haloObj = HaloManager.GetInstance().CreateHaloObjById(id);
			haloObj.transform.SetParent(transform);
			haloObj.transform.localPosition = new Vector3(0, 0.01f, 0);
			haloObj.transform.localScale = new Vector3(1f, 1f, 1f);
			haloObj.transform.localEulerAngles = new Vector3(0, 0, 0);

			UpdateHaloColor ();
		}
	}

	private void UpdateHaloColor()
	{
		if (haloObj == null || craftData == null)
			return;

		if(isCtrl)
		{
			Color color = TeamUtil.GetTeamColor(TeamUtil.Team.Yellow.GetHashCode());
			haloObj.GetComponent<HaloObj>().SetColor(color);
		}
		else
		{
			Color color = TeamUtil.GetTeamColor(team.GetHashCode());
			haloObj.GetComponent<HaloObj>().SetColor(color);
		}
	}

	public int GetHalo()
	{
		return haloId;
	}

	public void SetSkin(int id, Texture texture)
	{
		this.skinId = id;
		if(texture != null)
		{
			SkinnedMeshRenderer[] rendererArr = bodyTrans.GetComponentsInChildren<SkinnedMeshRenderer>();
			for(int i=0; i<rendererArr.Length; i++)
			{
				rendererArr[i].material.mainTexture = texture;
			}
		}
	}

	public int GetSkin()
	{
		return skinId;
	}

	public bool IsHero()
	{
		if (craftData != null)
			return craftData.isHero;
		return false;
	}

	public void SetCraftId(int id)
	{
		craftData.SetCraftId(id);
	}

	public int GetCraftId()
	{
		return craftData.GetCraftId();
	}

	public string GetIcon()
	{
		return craftData.GetIcon();
	}

	public override Transform GetBaseTransform()
	{
		if(topPartTrans != null)
			return topPartTrans;
		return transform;
	}

	public void SetState(State state)
	{
		if(this.state != state)
		{
			this.state = state;
			string animName = state.ToString();
			if(animation != null)
			{
				if(animation.GetClip(animName) != null)
					animation.Play(animName);
			}

			if(animationTop == null)
				return;

			if(state == State.Idle)
			{
				if(animationTop.GetClip(animName) != null)
				{
					animationTop.Play(animName);
					animationBottom.Play(animName);
				}
			}
			else if(state == State.Run)
			{
				if(animationTop.GetClip(animName) != null)
				{
					animationTop.Play(animName);
					animationBottom.Play(animName);
				}
			}
			else if(state == State.Attack)
			{
				if(animationTop.GetClip(animName) != null)
					animationTop.Play(animName);
				if(isMoving)
				{
					if(animationBottom.GetClip(State.Run.ToString()) != null)
						animationBottom.Play(State.Run.ToString());
				}
				else
				{
					if(animationBottom.GetClip(State.Idle.ToString()) != null)
						animationBottom.Play(State.Idle.ToString());
				}
			}
		}
	}

	public bool IsPlayingState(State state, Part part = Part.All)
	{
		string animName = state.ToString();
		if(animation != null)
		{
			return animation.IsPlaying(animName);
		}

		if(animationTop != null && (part == Part.Top || part == Part.All))
		{
			return animationTop.IsPlaying(animName);
		}

		if(animationBottom != null && (part == Part.Bottom || part == Part.All))
		{
			return animationBottom.IsPlaying(animName);
		}
		return false;
	}

	public void PositionTo(Vector3 position)
	{
		StopMove();
		transform.position = position;
	}

	public override bool enableMove
	{
		set{
			base.enableMove = value;
			if(!value && isMoving)
			{
				StopMove();
			}
		}
		get{
			return _enableMove;
		}
	}

	public float moveSpeed
	{
		get{
			return originMoveSpeed + modifyMoveSpeed;
		}
	}

	public void MoveTo(int col, int row)
	{
		if(!enableMove || holdAction)
			return;

		StartMove(col, row);
	}

	public void MoveTo(float x, float y)
	{
		int col = Map.XToColumn(x);
		int row = Map.ZToRow(y);
		MoveTo(col, row);
	}

	protected void StartMove(int col, int row)
	{
		targetMovePosition.x = col;
		targetMovePosition.y = row;
		
		Vector3 position = transform.position;
		int startCol = (int)(position.x/Map.TILE_WIDTH);
		int startRow = (int)(position.z/Map.TILE_LENGTH);
		
		map.PathSearchEnqueue(new AStarPoint(startCol, startRow), new AStarPoint(col, row), this);
	}

	public void SetPath(LinkedList<AStarNode> path)
	{
		//long startTime = System.DateTime.Now.ToFileTime();
		//path = map.GetPath(new AStarPoint(startCol, startRow), new AStarPoint(col, row), this);
		//long endTime = System.DateTime.Now.ToFileTime();
		//Debuger.Log("search path spend time : "+(endTime-startTime));

		this.path = path;
		if(!IsDead() && path != null)
		{
			path.RemoveFirst();

			_isMoving = true;

			if(state == State.Idle)
				SetState(State.Run);

			if(_teleportStep > 0)
				Teleport(_teleportStep);
			else
				setNextMovePosition();

			OnMove();
			swapManager.AbortSwap();
		}
	}

	public void StopMove()
	{
		if(holdAction)
		{
			if(target != null)
			{
				for(int i=0; i<buffList.Count; i++)
				{
					if(buffList[i].hasCloseTarget)
					{
						int col = Map.XToColumn(target.position.x);
						int row = Map.ZToRow(target.position.z);
						StartMove(col, row);
						break;
					}
				}
			}
			return;
		}

		path = null;
		_isMoving = false;
		forceMove = false;

		if(state == State.Run)
			SetState(State.Idle);
	}

	// Update is called once per frame
	void Update () {

		if(IsDead())
		{
			if(GameTime.time-deadTime>5f)//do not remove immediately
			{
				Destroy(this.miniCraft.gameObject);
				Destroy(this.gameObject);
			}
			return;
		}

		if(_isMoving)
		{
			moving();
		}

		if(target != null && target.CanShoot())
		{
			Vector3 targetPosition = target.position;
			float theta = NumberUtil.getRadianByATan(targetPosition.x, targetPosition.z, position.x, position.z);
			float rotateAngle = 90-NumberUtil.radianToAngle(theta);
			if(!rotateTargetAngle.Equals(rotateAngle))
			{
				rotateTargetAngle = rotateAngle;
				_isTargetRotating = true;
			}
		}


		rotating();
		CheckHpRecover();
		DealBuff();


		if((state == State.Attack || state == State.Power) && !IsPlayingState(state, Part.Top))
		{
			if(isMoving)
			{
				SetState(State.Run);
			}
			else
			{
				SetState(State.Idle);
			}
		}


		if(swapManager.isPreparingSwap && !swapManager.requestedSwap)
		{
			headBar.SetSpellProgress(swapManager.GetPreparingSwapTime(), SwapManager.PREPARING_SWAP_DURATION);
		}
	}

	private void moving()
	{
		float timeLeft = updateMovePosition(GameTime.deltaTime);
		if(_isMoving && timeLeft > 0)
		{
			updateMovePosition(timeLeft);
		}
	}

	private float updateMovePosition(float deltaTime)
	{
		Vector3 position = transform.position;
		
		float deltaX = nextMovePosition.x-position.x;
		float deltaY = nextMovePosition.z-position.z;
		float theta = Mathf.Atan2(deltaY, deltaX);
		
		float distance = Mathf.Sqrt(deltaX*deltaX+deltaY*deltaY);
		float moveDistance = moveSpeed*deltaTime;
		
		float timeLeft = 0;
		if(moveDistance >= distance)
		{
			timeLeft = deltaTime*(1f-distance/moveDistance);
			DealMoveStepComplete();
			setNextMovePosition();
		}
		else
		{
			float movX = moveDistance*Mathf.Cos(theta);
			float movZ = moveDistance*Mathf.Sin(theta);

			position.x += movX;
			position.z += movZ;
			transform.position = position;
		}

		return timeLeft;
	}

	private void DealMoveStepComplete()
	{
		Vector3 position = transform.position;
		position.x = nextMovePosition.x;
		position.z = nextMovePosition.z;
		transform.position = position;
		if(MoveStepComplete != null)
			MoveStepComplete();
	}

	private void setNextMovePosition()
	{
		if(path != null)
		{
			if(path.Count > 0)
			{
				AStarNode astarNode = path.First.Value;
				path.RemoveFirst();

				nextMovePosition = AstarNodeToPosition(astarNode);

				Vector3 position = transform.position;
				
				float theta = NumberUtil.getRadianByATan(nextMovePosition.x, nextMovePosition.z, position.x, position.z);
				float rotateAngle = 90-NumberUtil.radianToAngle(theta);
				Rotate (rotateAngle);
			}
			else
			{
				StopMove();
			}

			if(miniCraft != null)
				miniCraft.UpdatePos();
		}
	}


	public void Rotate(float rotateAngle)
	{
		rotateMoveTargetAngle = rotateAngle;
		_isMoveRotating = true;

		if(target == null)
		{
			if(!rotateTargetAngle.Equals(rotateMoveTargetAngle))
			{
				rotateTargetAngle = rotateMoveTargetAngle;
				_isTargetRotating = true;
			}
		}
	}


	private Vector3 AstarNodeToPosition(AStarNode astarNode)
	{
		return new Vector3((astarNode.X+0.5f)*Map.TILE_WIDTH, 0, (astarNode.Y+0.5f)*Map.TILE_LENGTH);
	}
	

	public void setRotateTargetAngle(float value)
	{
		rotateTargetAngle = value;
		_isTargetRotating = true;
	}

	private void rotating()
	{
		if(!enableMove || swapManager.isPreparingSwap)
			return;

		if(bottomPartTrans == null)
		{
			if(_isMoveRotating || _isTargetRotating)
			{
				float targetRotation = 0;
				if(_isMoving)
				{
					targetRotation = rotateMoveTargetAngle;
				}
				else
				{
					targetRotation = rotateTargetAngle;
				}

				Vector3 eulerAngles = bodyTrans.eulerAngles;
				float currentRotation = eulerAngles.y;
				float rotateStep = rotateSpeed*GameTime.deltaTime;
				
				currentRotation = NumberUtil.getCloseToTargetAngle(currentRotation, targetRotation, rotateStep);
				eulerAngles.y = currentRotation;
				bodyTrans.eulerAngles = eulerAngles;

				if(_isMoving)
				{
					if(rotateMoveTargetAngle.Equals(currentRotation))
					{
						_isMoveRotating = false;
					}
				}
				else
				{
					if(rotateTargetAngle.Equals(currentRotation))
					{
						_isTargetRotating = false;
					}
				}
			}
		}
		else
		{
			Vector3 eulerAngles;
			float rotateStep = rotateSpeed*GameTime.deltaTime;

			if(_isTargetRotating)
			{
				eulerAngles = topPartTrans.localEulerAngles;
				float currentRotation = eulerAngles.y;
				
				currentRotation = NumberUtil.getCloseToTargetAngle(currentRotation, rotateTargetAngle, rotateStep);
				eulerAngles.y = currentRotation;
				topPartTrans.localEulerAngles = eulerAngles;
				if(shotManager != null)
					shotManager.transform.localEulerAngles = eulerAngles;
				if(rotateTargetAngle.Equals(currentRotation))
				{
					_isTargetRotating = false;
				}
			}

			if(_isMoveRotating)
			{
				eulerAngles = bottomPartTrans.localEulerAngles;
				float currentBottomRotation = eulerAngles.y;
				
				currentBottomRotation = NumberUtil.getCloseToTargetAngle(currentBottomRotation, rotateMoveTargetAngle, rotateStep);

				eulerAngles.y = currentBottomRotation;
				bottomPartTrans.localEulerAngles = eulerAngles;
				if(rotateMoveTargetAngle.Equals(currentBottomRotation))
				{
					_isMoveRotating = false;
				}
			}
		}
	}


	private int _teleportStep = 0;
	public void Teleport(int step)
	{
		_teleportStep = Mathf.Max(_teleportStep, step);

		if(!isMoving)
		{
			return;
		}

		GameObject disappearObj = EffectUtil.CreateDisappear();
		disappearObj.transform.position = position;

		for(int i=0; i<step; i++)
		{
			setNextMovePosition();
			if(!isMoving)
			{
				break;
			}
		}

		DealMoveStepComplete();

		_teleportStep = 0;

		GameObject landingObj = EffectUtil.CreateLanding();
		landingObj.transform.position = position;
	}



	public override void MakeDamage (Bullet bullet)
	{
		base.MakeDamage (bullet);
		swapManager.AbortSwap();
	}



	override public void SetInvisible(bool invisible, bool isAlly)
	{
		if(invisible == this.invisible)
		{
			return;
		}

		base.SetInvisible(invisible, isAlly);
		if(invisible)
		{
			haloObj.gameObject.SetActive(isAlly);
		}
		else
		{
			haloObj.gameObject.SetActive(true);
		}
	}


	public PowerManager GetPowerManager()
	{
		return powerManager;
	}




	public void RadioAlert()
	{
		headBar.RadioAlert();
		if(miniCraft != null)
			miniCraft.RadioAlert();
	}


	public void SwapComplete()
	{
		if(OnSwapped != null)
			OnSwapped();
	}



	override public void Remove()
	{
		map.RemoveBattleObject(this);
	}

	public override string ToString()
	{
		return "User["+userId+"] Id["+id+"] Type["+typeId+"]";
	}
}