Webplayer Templates issue

using UnityEngine;
using System.Collections;

/*	NOTES:
	 * Is there just one starting spawn? For SetStartingPage? Or does the spawn point come into it for other reasons?
	 * In multi-player games with SUN and SHADOW (Dawn/Dusk) there needs to be a way to hard set the hex locations. In this blue sky version, it's irrelevant.
	 * Look at utilizing MessageManager instead of Message
*/

[System.Serializable]
public class UIElements {
	public UIStateToggleBtn allies;
	public UIStateToggleBtn germans;
	public UIButton tailing;
	public UIButton hitFrame;
	public UIButton lost;
	public UIButton aboveYou;
	public UIButton belowYou;
	public UIButton victory;
	public UIButton defeat;
	public GameObject fokkerCover;
	public GameObject sopwithCover;
	public GameObject coverPage;
}

public class PageData {
	public int pageNumber;
	public int hexID;
	public int hexFacing;
	public int relativeRange;
	public bool tailing;
	public bool canFire;
	public bool targeted;
	public int direction;
	public int facing;
}

public class UnitDetails {
//	public GameObject spawn;
	public GameObject aircraft;
	public GameObject bullets;
	public Transform aircraftTransform;
	public Transform cameraSpawn;
	public UIStateToggleBtn moveIcon;
	public GameObject turnCover;
	public PageData[] hexData;
	public int[,] maneuverData;
	public int currentHealth;
}

public class GameManager : MonoBehaviour {
	#region Variable Declaration
	public bool testing;											//	TESTING??
	public bool usingMoves;											//	OBSOLETE
	public bool isPlayer;											//	SET PRIVATE
	public int moveScale;
	public float overflyDistance;
	public bool lookAt;												//	TESTING??
	public Camera gameCamera;
	public SpriteText MessageObject;
	public GameObject[] aircraft;
	public GameObject[] bullets;
	public GameObject[] spawnPoints;
	public GameObject[] cameraSpawnPoints;
	public GameObject[]	hexes;
	public Vector3[] maneuverData;
	public PageData[] hexDataAllies;
	public PageData[] hexDataGermans;
	public int[,] maneuverDataAllies;
	public int[,] maneuverDataGermans;
	public bool iPhone4;											//	TESTING
	public UIElements uIElements;
	private GameObject playersSpawn;
	private UnitDetails players;
	private UnitDetails opponents;
	private int currentPage;
	private int playersManeuverID;
	private int opponentsManeuverID;
	private int playersManeuverPage;
	private int opponentsManeuverPage;
	private bool topOfTheTurn;
	private static GameManager gameManager;							//	To set an instance of this script

//	Reference Support
//	This can be cached on start as GameManager gameManager; & in Start() gameManager = GameManager.Instance();
//	Once cached, requires function calls as: gameManager.SomeFunction ();

	public static GameManager Instance () {
		if (!gameManager) {
			gameManager = FindObjectOfType(typeof (GameManager)) as GameManager;
			if (!gameManager)
				Debug.LogError ("There needs to be one active GameManager script on a GameObject in your scene.");
		}

		return gameManager;
	}
	#endregion

	void Awake () {
		players = new UnitDetails ();
		opponents = new UnitDetails ();
		isPlayer = true;
		topOfTheTurn = true;
		uIElements.allies.SetState (1);
		uIElements.germans.SetState (1);
		uIElements.tailing.Hide(true);
		uIElements.lost.Hide(true);
		uIElements.hitFrame.Hide(true);
		uIElements.aboveYou.Hide(true);
		uIElements.belowYou.Hide(true);
		uIElements.victory.Hide(true);
		uIElements.defeat.Hide(true);
	}

	public void StartGame (int aircraftID) {						//	Refactor this to "Allies" and "Germans" rather than in int? Or use an enum? int is a bit obtuse...
		//	SetManeuver the refernces depending upon faction
		if (aircraftID == 0) {										//	This annoys me that 1 = 0 for playuer aircraft... refactor??
			// Player is Allies
			playersSpawn = spawnPoints[0];

			players.aircraft = aircraft[0];
			players.bullets = bullets[0];
			players.cameraSpawn = cameraSpawnPoints[0].transform;
			players.hexData = hexDataAllies;
			players.maneuverData = maneuverDataAllies;
			players.moveIcon = uIElements.allies;
			players.turnCover = uIElements.sopwithCover;

			opponents.aircraft = aircraft[1];
			opponents.bullets = bullets[1];
			opponents.cameraSpawn = cameraSpawnPoints[1].transform;
			opponents.hexData = hexDataGermans;
			opponents.maneuverData = maneuverDataGermans;
			opponents.moveIcon = uIElements.germans;
			opponents.turnCover = uIElements.fokkerCover;
		} else if (aircraftID == 1) {
			//	Player is German
			playersSpawn = spawnPoints[1];

			players.aircraft = aircraft[1];
			players.bullets = bullets[1];
			players.cameraSpawn = cameraSpawnPoints[1].transform;
			players.hexData = hexDataGermans;
			players.maneuverData = maneuverDataGermans;
			players.moveIcon = uIElements.germans;
			players.turnCover = uIElements.fokkerCover;

			opponents.aircraft = aircraft[0];
			opponents.bullets = bullets[0];
			opponents.cameraSpawn = cameraSpawnPoints[0].transform;
			opponents.hexData = hexDataAllies;
			opponents.maneuverData = maneuverDataAllies;
			opponents.moveIcon = uIElements.allies;
			opponents.turnCover = uIElements.sopwithCover;
		}

		//	Set a reference to the aircraft transforms
		players.aircraftTransform = players.aircraft.transform;
		opponents.aircraftTransform = opponents.aircraft.transform;

		//	Set the health values
		players.currentHealth = 12;
		opponents.currentHealth = 12;

		//	Turn on the aircraft
		for (int i = 0; i < aircraft.Length; i ++) {
			aircraft[i].SetActiveRecursively (true);
		}

		//	Turn off the bullets
		for (int i = 0; i < bullets.Length; i ++) {
			bullets[i].SetActiveRecursively (false);
		}

		//	Find and Set the start page
		currentPage = (Random.Range(0,2) == 0) ? 170 : 173;								//	This could be split off into it's own method in consideration of completely random pages...
		Debug.Log ("Start Game - current page: " + currentPage);

		//	Place the player's aircraft at its starting hex.
		players.aircraftTransform.position = playersSpawn.transform.position;
		players.aircraftTransform.rotation = playersSpawn.transform.rotation;

		//	Place the Opponent's Aircraft at its starting hex.
		opponents.aircraftTransform.position = hexes[players.hexData[currentPage].hexID].transform.position;
		Vector3 setRotation = Vector3.zero;
		setRotation.y = ((players.hexData[currentPage].hexFacing) - 1) * 60.0f;			// Page hex facing should be changed from 1-6 to 0-5 and remove the -1
		opponents.aircraftTransform.eulerAngles = setRotation;

		//	Set the Games's Camera
		SetPlayersLook ();

		//	Hide the splash page
		uIElements.coverPage.SetActiveRecursively (false);								//	This may change if there is a scene change based on game type...
	}

	public void SetManeuver (int newManeuverID) {
		if (topOfTheTurn) {
			Debug.Log ("Top of the Turn, Player goes first");
			if (isPlayer) {
							Debug.Log("Player's Move");
				SetPlayersMove (newManeuverID);

				Debug.Log ("Top of turn, Set camera");
				ChangeGameCamera ();

			} else {
							Debug.Log("Opponent's Move");
				SetOpponentsMove(newManeuverID);

				ResolveMove();
				Debug.Log ("Resolve Move returns: " + currentPage);

			}
		} else if (!topOfTheTurn) {
			Debug.Log ("NOT Top of the Turn, Opponent goes first");
			if (!isPlayer) {
							Debug.Log("Opponent's Move");
				SetOpponentsMove(newManeuverID);

				Debug.Log ("!Top of turn, Set camera");
				ChangeGameCamera ();

			} else {
							Debug.Log("Player's Move");
				SetPlayersMove (newManeuverID);

				ResolveMove();
				Debug.Log ("Resolve Move returns: " + currentPage);
			}
		}
	}

	void SetPlayersMove (int newManeuverID) {
		playersManeuverID = newManeuverID;
		playersManeuverPage = players.maneuverData [currentPage, playersManeuverID];
		players.moveIcon.SetState(0);
	}

	void SetOpponentsMove (int newManeuverID) {
		opponentsManeuverID = newManeuverID;
		opponentsManeuverPage = opponents.maneuverData[currentPage, opponentsManeuverID];
		opponents.moveIcon.SetState(0);
	}

	void ChangeGameCamera () {
		isPlayer = !isPlayer;
		if (isPlayer) {
			SetPlayersLook();
			players.turnCover.SetActiveRecursively(true);
		} else {
			SetOpponentsLook();
			opponents.turnCover.SetActiveRecursively(true);
		}
	}

	void SetPlayersLook () {
		gameCamera.transform.position = players.cameraSpawn.position;
		if (lookAt) {
			gameCamera.transform.LookAt (opponents.aircraftTransform);
		} else {
			Vector3 setRotation = Vector3.zero;
			setRotation.y = players.aircraftTransform.eulerAngles.y;
				Debug.Log("SetPlayersLook; setRotation.y: " + setRotation.y);
			setRotation.y += ((players.hexData[currentPage].direction) - 1) * 45.0f;			// Page hex facing should be changed from 1-6 to 0-5 and remove the -1
				Debug.Log("SetPlayersLook += players.hexData[currentPage].direction: " + setRotation.y);
			gameCamera.transform.eulerAngles = setRotation;
		}

		if (players.hexData[currentPage].hexID == 0) {
			uIElements.aboveYou.Hide(false);
		} else {
			uIElements.aboveYou.Hide(true);
		}

		if (players.hexData[currentPage].targeted) {
			uIElements.hitFrame.Hide(false);
			opponents.bullets.SetActiveRecursively(true);
			Debug.Log ("targeted" + players.hexData[currentPage].relativeRange);
			switch (players.hexData[currentPage].relativeRange) {
				case 1:
					players.currentHealth -= 4;
				break;
				case 2:
					players.currentHealth -= 2;
				break;
				case 3:
					players.currentHealth -= 1;
				break;
			}
			Debug.Log("Player's Current Health: : " + players.currentHealth);
			if (players.currentHealth <= 0) {
				uIElements.victory.Hide(true);
				uIElements.defeat.Hide(false);
			}
		} else {
			uIElements.hitFrame.Hide(true);
			opponents.bullets.SetActiveRecursively(false);
		}

		if (players.hexData[currentPage].canFire) {
			players.bullets.SetActiveRecursively(true);
			if (opponents.currentHealth <= 0) {
				uIElements.victory.Hide(false);
				uIElements.defeat.Hide(true);
			}
		} else {
			players.bullets.SetActiveRecursively(false);
		}

		if (players.hexData[currentPage].tailing) {
			uIElements.tailing.Hide(false);
		} else {
			uIElements.tailing.Hide(true);
		}
	}

	void SetOpponentsLook () {
		//	Set Camera Position
		gameCamera.transform.position = opponents.cameraSpawn.position;

		//	Set Camera Rotation
		if (lookAt) {
			gameCamera.transform.LookAt (players.aircraftTransform);
		} else {
			Vector3 setRotation = Vector3.zero;
			setRotation.y = opponents.aircraftTransform.eulerAngles.y;
				Debug.Log("SetOpponentsLook; setRotation.y: " + setRotation.y);
			setRotation.y += ((opponents.hexData[currentPage].direction) - 1) * 45.0f;		// Page hex facing should be changed from 1-6 to 0-5 and remove the -1
				Debug.Log("SetOpponentsLook += opponents.hexData[currentPage].direction: " + setRotation.y);
			gameCamera.transform.eulerAngles = setRotation;
		}

		//	Set HexID:0 Message																//	This is TEMP TESTING and Needs Perfection
		if (opponents.hexData[currentPage].hexID == 0) {
			uIElements.aboveYou.Hide(false);
		} else {
			uIElements.aboveYou.Hide(true);
		}

		if (opponents.hexData[currentPage].targeted) {
			uIElements.hitFrame.Hide(false);
			players.bullets.SetActiveRecursively(true);
			Debug.Log ("targeted range: " + players.hexData[currentPage].relativeRange);
			switch (opponents.hexData[currentPage].relativeRange) {
				case 1:
					opponents.currentHealth -= 4;
				break;
				case 2:
					opponents.currentHealth -= 2;
				break;
				case 3:
					opponents.currentHealth -= 1;
				break;
			}
			Debug.Log("Opponent's Current Health: : " + opponents.currentHealth);
			if (opponents.currentHealth <= 0) {
				uIElements.victory.Hide(true);
				uIElements.defeat.Hide(false);
			}
		} else {
			uIElements.hitFrame.Hide(true);
			players.bullets.SetActiveRecursively(false);
		}

		if (opponents.hexData[currentPage].canFire) {
			opponents.bullets.SetActiveRecursively(true);
			if (players.currentHealth <= 0) {
				uIElements.victory.Hide(false);
				uIElements.defeat.Hide(true);
			}
		} else {
			opponents.bullets.SetActiveRecursively(false);
		}

		if (opponents.hexData[currentPage].tailing) {
			uIElements.tailing.Hide(false);
		} else {
			uIElements.tailing.Hide(true);
		}
	}

	void ResolveMove() {
		Vector3 setPosition = Vector3.zero;
		Vector3 setRotation = Vector3.zero;
		Vector3 movement = Vector3.zero;

		//	Get New Current Page
		currentPage = GetNewCurrentPage ();


		//	Player
		setPosition.x = 8.661f * moveScale * maneuverData[playersManeuverID].x;
		setRotation.y = 60 * maneuverData[playersManeuverID].y;
		setPosition.z = 5.0f * moveScale * maneuverData[playersManeuverID].z;

		movement = players.aircraftTransform.TransformDirection (setPosition);

		players.aircraftTransform.position += movement;
		players.aircraftTransform.eulerAngles += setRotation;

		//	Opponent
		setPosition.x = 8.661f * moveScale * maneuverData[opponentsManeuverID].x;
		setRotation.y = 60 * maneuverData[opponentsManeuverID].y;
		setPosition.z = 5.0f * moveScale * maneuverData[opponentsManeuverID].z;

		movement = opponents.aircraftTransform.TransformDirection (setPosition);

		opponents.aircraftTransform.position += movement;
		opponents.aircraftTransform.eulerAngles += setRotation;

		//	Remove Opponent from view (This will need work if there is a multiplayer game...? No hot-seat on MP?)
		setPosition = Vector3.zero;
		setPosition.x = opponents.aircraftTransform.position.x;
		setPosition.y = (players.hexData[currentPage].hexID == 0) ? overflyDistance : 0.0f;
		setPosition.z = opponents.aircraftTransform.position.z;
		opponents.aircraftTransform.position = setPosition;

		if (isPlayer)
			SetPlayersLook ();
		else
			SetOpponentsLook ();

		players.moveIcon.SetState(1);
		opponents.moveIcon.SetState(1);

		topOfTheTurn = !topOfTheTurn;
	}

	int GetNewCurrentPage () {
		//	Initialize the variables.
		int newPagePlayer = -1;
		int newPageOpponent = -1;

		//	Check the ManeuverPage. Is it 0?
		if (opponentsManeuverPage == 0 && playersManeuverPage == 0) {
			Debug.Log("Both Player's Maneuver Page Read 0! Returning 0!");
			return 0;
		}

		//	Find the new page
		if (playersManeuverPage != 0) {
			newPageOpponent = opponents.maneuverData [playersManeuverPage, opponentsManeuverID];
		}
		if (opponentsManeuverPage != 0) {
			newPagePlayer = players.maneuverData [opponentsManeuverPage, playersManeuverID];
		}

		//	Check the new page number
		if (playersManeuverPage == 0) {
			Debug.Log ("Player Maneuver Page = 0! Returning newPagePlayer: " + newPagePlayer);
			return newPagePlayer;

		} else if (opponentsManeuverPage == 0) {
			Debug.Log ("Opponent's Maneuver Page = 0! Returning newPageOpponent: " + newPageOpponent);
			return newPageOpponent;

		}else if (newPagePlayer == newPageOpponent) {
			Debug.Log("Page: " + newPagePlayer);
			return newPagePlayer;
		} else {
			Debug.LogError ("newPagePlayer " + newPagePlayer + " newPageOpponent: " + newPageOpponent);
			Debug.LogError("Maneuver Resolution does not Match! Check page " + currentPage + "\nAlso check MT Pages! Player Book: " + opponentsManeuverPage + " Opponent Book: " + playersManeuverPage);
			return 0;
		}
	}

	void Message (string message) {
		MessageObject.Text = message;
		StartCoroutine(CancelMessage ());
	}

	public IEnumerator CancelMessage () {
		yield return new WaitForSeconds (1.0f);
		MessageObject.Text = "";
	}

	void RestartLevel () {
		Application.LoadLevel (Application.loadedLevel);
	}

//	void OnGUI () {
//				GUI.Label (new Rect (180, 10, 70, 50), currentPage.ToString());
//				GUI.Box (new Rect(10, 10, 150, 50),"");
//				lookAt = GUI.Toggle(new Rect(10, 10, 150, 50), lookAt, "Look At");
//	}
}