battlearray_client/Assets/Scripts/Battle/InputController.cs

using UnityEngine;
using UnityEngine.EventSystems;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

public class InputController : MonoBehaviour {

	private const float ORIGIN_SIZE = 25f;
	private const float MIN_SIZE = 10f;
	private const float MAX_SIZE = 25f;

	private const float MIN_ANGLE = 30f;
	private const float MAX_ANGLE = 80f;

	private const float FAR_AWAY_SIZE = 100f;

	public enum State
	{
		Faraway,
		ZoomIn,
		Battle,
	}

	public enum CameraMode
	{
		LockCraft = 0,
		FreeLook = 1
	}

	public State state;
	public CameraMode cameraMode;

	private BattleController battleController;
	private Plane groundPlane;

	private Vector3 lastMousePosition;

	public MoveMark moveMark;

	public bool lockCamera = true;

	private float targetDistance = FAR_AWAY_SIZE;

	public ITarget cameraLockedTarget;

	public Transform cameraPivot;
	public CameraShake cameraShake;
	public Transform cameraTrans;

	private float cameraSpeed = 2f;

	void Start () 
	{
		groundPlane = new Plane(new Vector3(0, 1f, 0), Vector3.zero);
		cameraPivot = GameObject.Find ("CameraPivot").transform;
		cameraShake = Camera.main.GetComponent<CameraShake>();
		cameraTrans = cameraShake.transform;

		UpdateCamera ();
	}

	private bool IsPointerOverUIObject()
	{
		PointerEventData eventDataCurrentPosition = new PointerEventData(EventSystem.current);
		eventDataCurrentPosition.position = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
		
		List<RaycastResult> results = new List<RaycastResult>();
		EventSystem.current.RaycastAll(eventDataCurrentPosition, results);

		Debuger.LogWarning (results.Count);
		return results.Count > 0;
	}

	public void SetBattleController(BattleController battleController)
	{
		this.battleController = battleController;
	}

	public Vector3 cameraPosition
	{
		get{
			return cameraPivot.position;
		}
	}

	public void SetCameraTo(Vector3 pos)
	{
		cameraPivot.position = pos;
	}

	private void UpdateCameraPivot ()
	{
		if (cameraMode != CameraMode.LockCraft)
			return;
		
		if(lockCamera)
		{
			if(cameraLockedTarget != null)
			{
				if(state == State.ZoomIn)
				{
					targetDistance -= GameTime.deltaTime*(targetDistance - MAX_SIZE) * 3f;
					if(targetDistance < MAX_SIZE+0.1f)
					{
						targetDistance = MAX_SIZE;
						state = State.Battle;
						battleController.ReadyToAction();
					}

					UpdateCamera ();
				}

				cameraPivot.transform.position = Vector3.Lerp (cameraPivot.transform.position, cameraLockedTarget.position, GameTime.deltaTime * cameraSpeed);
			}
		}
		else
		{
			if(Input.GetMouseButtonDown(0))
			{
				lastMousePosition = Input.mousePosition;
			}
			else if(Input.GetMouseButton(0))
			{
				Vector3 currentMousePosition = Input.mousePosition;
				
				Vector3 lastWorldPosition = Camera.main.ScreenToWorldPoint(lastMousePosition);
				Vector3 currentWorldPosition = Camera.main.ScreenToWorldPoint(currentMousePosition);
				
				float deltaX = currentWorldPosition.x - lastWorldPosition.x;
				float deltaY = (currentWorldPosition.z - lastWorldPosition.z)/Mathf.Cos(Mathf.PI*10/180);
				
				Vector3 cameraPosition = Camera.main.transform.position;
				cameraPosition.x -= deltaX;
				cameraPosition.z -= deltaY;
				Camera.main.transform.position = cameraPosition;
				
				lastMousePosition = currentMousePosition;
			}
		}
	}


	private void UpdateCamera()
	{
		Vector3 camPos = cameraTrans.localPosition;
		camPos.z = -targetDistance;
		cameraTrans.localPosition = camPos;
	}


	void LateUpdate()
	{
		UpdateCameraPivot ();
	}

	// Update is called once per frame
	void Update () 
	{
		float mouseScrollWheel = Input.GetAxis("Mouse ScrollWheel");
		if(mouseScrollWheel != 0)
		{
			zoom(-mouseScrollWheel*2);
		}

		if(battleController.isGameOver || BattleController.battleType == BattleController.BattleType.Edit)
		{
			return;
		}

		if (cameraMode == CameraMode.LockCraft)
			CameraLockCraft ();
		else if (cameraMode == CameraMode.FreeLook)
			CameraFreeLook ();
	}

	private Vector3 mouseDownPos;
	private Vector3 mouseDownCameraPos;
	private void CameraFreeLook()
	{
		if (Input.GetMouseButtonDown (0)) {
			mouseDownPos = Input.mousePosition;
			mouseDownCameraPos = Camera.main.transform.position;
		}

		if(Input.GetMouseButton(0))
		{
			Vector3 currentMousePos = Input.mousePosition;
			Vector3 pos = Camera.main.transform.position;

			float deltaX = (currentMousePos.x - mouseDownPos.x) / Screen.width;
			float deltaY = (currentMousePos.y - mouseDownPos.y) / Screen.height;

			pos.x = mouseDownCameraPos.x - deltaX * 20f;
			pos.z = mouseDownCameraPos.z - deltaY * 20f;
			Camera.main.transform.position = Vector3.Lerp (pos, Camera.main.transform.position, GameTime.deltaTime * 10f);
		}
	}

	private void CameraLockCraft()
	{
		Craft ctrlCraft = battleController.GetCtrlCraft();
		if (ctrlCraft != null) {
			if (Input.GetMouseButtonDown (0) && !IsPointerOverUIObject ()) {
				doClick ();
			}

			if (Input.GetKeyDown (KeyCode.Q)) {
				battleController.AttempUsePower (ctrlCraft.GetPowerManager ().GetPowers () [1].GetId ());
			} else if (Input.GetKeyDown (KeyCode.W)) {
				battleController.AttempUsePower (ctrlCraft.GetPowerManager ().GetPowers () [2].GetId ());
			} else if (Input.GetKeyDown (KeyCode.E)) {
				battleController.AttempUsePower (ctrlCraft.GetPowerManager ().GetPowers () [3].GetId ());
			} else if (Input.GetKeyDown (KeyCode.A)) {
				battleController.AttempUsePower (ctrlCraft.GetPowerManager ().GetCrystalPowers () [0].GetId ());
			} else if (Input.GetKeyDown (KeyCode.S)) {
				battleController.AttempUsePower (ctrlCraft.GetPowerManager ().GetCrystalPowers () [1].GetId ());
			}
		} else {
			if (Input.GetMouseButtonDown (0) && !IsPointerOverUIObject ()) {
				LockNextCraft ();
			}
		}
	}


	private void doClick()
	{
		Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
		RaycastHit hitInfo;
		if (Physics.Raycast (ray, out hitInfo)) {

			Debuger.LogWarning ("Physics.Raycast " + hitInfo.collider.gameObject.tag);

			if (hitInfo.collider.gameObject.tag == "Craft" || hitInfo.collider.gameObject.tag == "Tower") {
				Craft craft = hitInfo.collider.GetComponent<Craft> ();
				if (craft == null) {
					Debuger.LogError ("craft is null");
					return;
				}

				if (craft.team != battleController.GetCtrlCraft ().team) {
					battleController.GetCtrlCraft ().target = craft;
					battleController.GetCtrlCraft ().GetComponent<CraftAI> ().followTarget = true;
					return;
				}
			}
		}


		//do move
		float rayDistance;
		if (groundPlane.Raycast (ray, out rayDistance)) {

			Vector3 hitPos = ray.GetPoint (rayDistance);
			Debuger.LogWarning ("groundPlane.Raycast " + hitPos);

			moveMark.transform.position = hitPos;
			moveMark.particleSystem.Emit (1);

			battleController.GetCtrlCraft().GetComponent<CraftAI>().followTarget = false;
			battleController.GetCtrlCraft().forceMove = true;
			battleController.GetMessageManager().Move(battleController.GetCtrlCraft(), hitPos);
		}
	}

	public void LockNextCraft()
	{
		if (state != State.Battle)
			return;

		if (cameraLockedTarget == null || !(cameraLockedTarget is Craft) || (cameraLockedTarget as Craft).IsDead ())
			cameraLockedTarget = null;

		List<Player> playerList = battleController.GetBattleSession ().GetPlayerList ();
		Craft firstCraft = null;
		for(int i=0; i<playerList.Count; i++)
		{
			Player player = playerList [i];
			if (player.GetHero ().GetCraft () == null)
				continue;

			if (firstCraft == null)
				firstCraft = player.GetHero ().GetCraft ();

			if (cameraLockedTarget != null) {
				if(cameraLockedTarget == player.GetHero().GetCraft())
				{
					cameraLockedTarget = null;
				}
			} else {
				cameraLockedTarget = player.GetHero ().GetCraft ();
				break;
			}
		}

		if (cameraLockedTarget == null) {
			cameraLockedTarget = firstCraft;
		}
	}

	private void zoom(float value)
	{
		if(state == State.Battle)
		{
			targetDistance += value*10f;
			targetDistance = NumberUtil.forceBetween(targetDistance, MIN_SIZE, MAX_SIZE);

			UpdateCamera ();

			Vector3 rotation = Vector3.zero;
			rotation.x = MIN_ANGLE + (MAX_ANGLE - MIN_ANGLE) * ((targetDistance - MIN_SIZE) / (MAX_SIZE - MIN_SIZE));
			cameraPivot.transform.localEulerAngles = rotation;
		}
	}
	
}