using UnityEngine;
using System.Collections;
using UnityEngine.UI;

public class PlayerController : MonoBehaviour {
	public float m_Speed;

	public Text m_CountText;

	public Text m_WinText;

	private Rigidbody m_RB;

	private int m_Count;

	void Start()
	{
		m_RB = GetComponent<Rigidbody> ();
		m_Count = 0;
		SetCountText();
		m_WinText.text = "";
	}

	void FixedUpdate()
	{
		float moveHorizontal = Input.GetAxis ("Horizontal");
		float moveVertical = Input.GetAxis ("Vertical");

		Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
		m_RB.AddForce (movement * m_Speed);
	}

	void OnTriggerEnter(Collider other)
	{
		if (other.gameObject.CompareTag ("Pickup")) 
		{
			other.gameObject.SetActive(false);
			m_Count++;
			SetCountText();
		}
	}

	void SetCountText()
	{
		m_CountText.text = "Count: " + m_Count.ToString();
		if (m_Count >= 12) 
		{
			m_WinText.text = "You Win!";
		}
	}
}

using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour {
	public GameObject m_Player;

	private Vector3 m_Offset;

	// Use this for initialization
	void Start () {
		m_Offset = transform.position - m_Player.transform.position;
	}
	
	// Update is called once per frame
	void LateUpdate () {
		transform.position = m_Player.transform.position + m_Offset;
	}
}

using UnityEngine;
using System.Collections;

public class Rotator : MonoBehaviour {

	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
		transform.Rotate (new Vector3 (15, 35, 45) * Time.deltaTime);
	}
}

using UnityEngine;
using System.Collections;

[System.Serializable]
public class Boundary
{
	public float m_MinX,m_MaxX,m_MinZ,m_MaxZ;
}

public class ShipController : MonoBehaviour {

	public float m_Speed = 8;

	public float m_Tilt = 4;
	
	public float fireRate = 0.5F;

	private float nextFire = 0.0F;

	public Boundary m_Boundary;

	public GameObject m_Shot;

	public Transform m_ShotSpawn;

	private AudioSource m_FireAudio;
	
	private Rigidbody m_ShipRB;

	private GameController m_GameController;

	// Use this for initialization
	void Start () {
		m_ShipRB = GetComponent<Rigidbody> ();
		m_FireAudio = GetComponent<AudioSource> ();
		GameObject gamecontrollerobject = GameObject.FindGameObjectWithTag ("GameController");
		if (gamecontrollerobject != null) {
			m_GameController = gamecontrollerobject.GetComponent<GameController>();
		}
		if (m_GameController == null) {
			Debug.Log("m_GameController == null in ShipController::Start()");
		}
	}

	void Update(){
		if (Input.GetKey(KeyCode.J) && Time.time > nextFire) {
			nextFire = Time.time + fireRate;
			GameObject clone = Instantiate (m_Shot, m_ShotSpawn.position, m_ShotSpawn.rotation) as GameObject;
			m_FireAudio.Play();
		}
	}

	void FixedUpdate(){
		if (!m_GameController.IsGameEnd ()) {
			float moveHorizontal = Input.GetAxis ("Horizontal");
			float moveVertical = Input.GetAxis ("Vertical");
			Vector3 movement = new Vector3 (moveHorizontal, 0.0f, moveVertical);
			m_ShipRB.velocity = movement * m_Speed;

			m_ShipRB.position = new Vector3 (
				Mathf.Clamp (m_ShipRB.position.x, m_Boundary.m_MinX, m_Boundary.m_MaxX),
				0.0f,
				Mathf.Clamp (m_ShipRB.position.z, m_Boundary.m_MinZ, m_Boundary.m_MaxZ)
			);
			m_ShipRB.rotation = Quaternion.Euler (0.0f, 0.0f, -m_ShipRB.velocity.x * m_Tilt);
		} else {
			m_ShipRB.rotation = Quaternion.Euler(0.0f,0.0f,0.0f);
			m_ShipRB.velocity = new Vector3(0.0f,0.0f,0.0f);
		}
	}
}

using UnityEngine;
using System.Collections;
using UnityEngine.UI;

public class GameController : MonoBehaviour {

	public GameObject m_Hazard;

	public Vector3 m_SpawnValue = new Vector3(5.5f,0.0f,8.0f);

	public int m_HazardCount = 4;

	public float m_SpawnWait = 1.0f;

	public float m_StartWait = 3.0f;

	public float m_WaveWait = 4.0f;

	public Text m_ScoreText;

	public Text m_WinText;

	public Button m_RestartButton;

	public int m_WinningScore = 200;

	private int m_Score = 0;

	private bool m_IsGameEnd = false;

	private bool m_RestartGame = false;

	private AudioSource m_BackgroundAudio;

	// Use this for initialization
	void Start () {
		StartCoroutine (SpawnAsteriod());
		UpdateScore ();
		m_WinText.text = "";
		m_RestartButton.gameObject.SetActive (false);
		m_RestartButton.onClick.AddListener (RestartGame);
		m_BackgroundAudio = GetComponent<AudioSource> ();
	}

	void Update()
	{
		if (m_RestartGame) {
			Debug.Log("Restart Game Now");
			Application.LoadLevel(Application.loadedLevel);
		}
	}

	public bool IsGameEnd()
	{
		return m_IsGameEnd;
	}

	private void RestartGame()
	{
		Debug.Log("Restart Button clicked");
		m_RestartGame = true;
	}

	IEnumerator SpawnAsteriod(){
		yield return new WaitForSeconds (m_StartWait);
		while (true) {
			for (int i = 0; i < m_HazardCount; i++) {
				Vector3 spawnposition =  new Vector3 (Random.Range (-m_SpawnValue.x, m_SpawnValue.x), 0.0f, m_SpawnValue.z);
				Quaternion spawnrotation = Quaternion.identity;
				Instantiate(m_Hazard,spawnposition,spawnrotation);
				yield return new WaitForSeconds (m_SpawnWait);
			}
			yield return new WaitForSeconds (m_WaveWait);
			if(m_IsGameEnd)
			{
				break;
			}
		}
	}

	public void AddScore(int score)
	{
		m_Score += score;
		UpdateScore ();
	}

	void UpdateScore()
	{
		m_ScoreText.text = "Score: " + m_Score;
		if (m_Score >= m_WinningScore) {
			m_WinText.text = "Congratulation! You Win";
			m_IsGameEnd = true;
			m_RestartButton.gameObject.SetActive (true);
			m_BackgroundAudio.Stop();
		}
	}
}

using UnityEngine;
using System.Collections;

public class DestroyByContact : MonoBehaviour {

	public GameObject m_ExplosionObject;

	public GameObject m_PlayerExplosionObject;

	private GameController m_GameController;

	public int m_ScoreValue = 10;

	void Start()
	{
		GameObject gamecontrollerobject = GameObject.FindGameObjectWithTag ("GameController");
		if (gamecontrollerobject != null) {
			m_GameController = gamecontrollerobject.GetComponent<GameController>();
		}
		if (m_GameController == null) {
			Debug.Log("m_GameController == null");
		}
	}

	void OnTriggerEnter(Collider other) {
		if (other.tag == "Boundary") {
			return ;
		}
		Debug.Log ("other.tag = " + other.tag);

		Instantiate (m_ExplosionObject, transform.position, transform.rotation);
		if (other.tag == "Player") {
			Instantiate (m_PlayerExplosionObject, other.transform.position, other.transform.rotation);
		}
		if (other.tag == "Bullet") {
			Debug.Log("Asteriod is destroied by Bullet");
			m_GameController.AddScore(m_ScoreValue);
		}
		Destroy(other.gameObject);
		Destroy (gameObject);
	}
}

using UnityEngine;
using System.Collections;

public class DestroyByTime : MonoBehaviour {

	public float m_LifeTime = 5.0f;

	// Use this for initialization
	void Start () {
		Destroy (gameObject,m_LifeTime);
	}
}

using UnityEngine;
using System.Collections;

public class GameBoundary : MonoBehaviour {

	void OnTriggerExit(Collider other) {
		Destroy(other.gameObject);
	}
}

using UnityEngine;
using System.Collections;

public class Mover : MonoBehaviour {

	public float m_Speed = 8;

	private Rigidbody m_RigidBody;
	
	private GameController m_GameController;

	// Use this for initialization
	void Start () {
		m_RigidBody = GetComponent<Rigidbody> ();
		m_RigidBody.velocity = transform.forward * m_Speed;
		GameObject gamecontrollerobject = GameObject.FindGameObjectWithTag ("GameController");
		if (gamecontrollerobject != null) {
			m_GameController = gamecontrollerobject.GetComponent<GameController>();
		}
		if (m_GameController == null) {
			Debug.Log("m_GameController == null in ShipController::Start()");
		}
	}

	void Update(){
		if (m_GameController.IsGameEnd ()) 
		{
			m_RigidBody.rotation = Quaternion.Euler(0.0f,0.0f,0.0f);
			m_RigidBody.velocity = new Vector3(0.0f,0.0f,0.0f);
		}
	}
}

using UnityEngine;
using System.Collections;

public class RandomRotator : MonoBehaviour {

	public float m_Tumble = 5;

	private Rigidbody m_Rigidbody;

	// Use this for initialization
	void Start () {
		m_Rigidbody = GetComponent<Rigidbody> ();
		m_Rigidbody.angularVelocity = Random.insideUnitSphere * m_Tumble;
	}
	
	// Update is called once per frame
	void Update () {
		
	}
}

using UnityEngine;
using System.Collections;


public class CameraFollow : MonoBehaviour {
	public Transform m_Target;

	public float m_Smoothing = 5.0f;

	Vector3 m_Offset;

	// Use this for initialization
	void Start () {
		m_Offset = transform.position - m_Target.position;
	}

	// Update is called once per frame
	void Update () {
		Vector3 targetCamPos = m_Target.position + m_Offset;
		transform.position = Vector3.Lerp (transform.position, targetCamPos, m_Smoothing * Time.deltaTime);
	}
}

using UnityEngine;

public class PlayerShooting : MonoBehaviour
{
    public int damagePerShot = 20;
    public float timeBetweenBullets = 0.15f;
    public float range = 100f;




    float timer;
    Ray shootRay;
    RaycastHit shootHit;
    int shootableMask;
    ParticleSystem gunParticles;
    LineRenderer gunLine;
    AudioSource gunAudio;
    Light gunLight;
    float effectsDisplayTime = 0.2f;

    void Awake ()
    {
        shootableMask = LayerMask.GetMask ("Shootable");
        gunParticles = GetComponent<ParticleSystem> ();
        gunLine = GetComponent <LineRenderer> ();
        gunAudio = GetComponent<AudioSource> ();
        gunLight = GetComponent<Light> ();
    }

    void Update ()
    {
        timer += Time.deltaTime;

		if(Input.GetButton ("Fire1") && timer >= timeBetweenBullets && Time.timeScale != 0)
        {
            Shoot ();
        }

        if(timer >= timeBetweenBullets * effectsDisplayTime)
        {
            DisableEffects ();
        }
    }

    public void DisableEffects ()
    {
        gunLine.enabled = false;
        gunLight.enabled = false;
    }

    void Shoot ()
    {
        timer = 0f;

        gunAudio.Play ();

        gunLight.enabled = true;

        gunParticles.Stop ();
        gunParticles.Play ();

        gunLine.enabled = true;
        gunLine.SetPosition (0, transform.position);

        shootRay.origin = transform.position;
        shootRay.direction = transform.forward;

        if(Physics.Raycast (shootRay, out shootHit, range, shootableMask))
        {
            EnemyHealth enemyHealth = shootHit.collider.GetComponent <EnemyHealth> ();
			Debug.Log("Shootting");
			Debug.Log("shootHit.collider.name = " + shootHit.collider.name);
			if(enemyHealth != null)
            {
				Debug.Log("enermyHealth != null");
                enemyHealth.TakeDamage (damagePerShot, shootHit.point);
            }
            gunLine.SetPosition (1, shootHit.point);
        }
        else
        {
			Debug.Log("Not shot");
            gunLine.SetPosition (1, shootRay.origin + shootRay.direction * range);
        }
    }
}

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
	public float m_Speed = 6.0f;

	Vector3 m_Movement;

	Animator m_Anim;

	Rigidbody m_PlayerRigidbody;

	int m_FloorMask;

	float m_CamRayLength = 100.0f;

	void Awake()
	{
		m_FloorMask = LayerMask.GetMask ("Floor");

		m_Anim = GetComponent<Animator> ();

		m_PlayerRigidbody = GetComponent<Rigidbody> ();
	}


	void FixedUpdate()
	{
		float h = Input.GetAxisRaw ("Horizontal");
		float v = Input.GetAxisRaw ("Vertical");

		Move (h, v);
		Turning ();
		Animating(h,v);
	}

	void Move(float h, float v)
	{
		m_Movement.Set (h, 0.0f, v);
		m_Movement = m_Movement.normalized * m_Speed * Time.deltaTime;
		m_PlayerRigidbody.MovePosition (transform.position + m_Movement);
	}


	void Turning()
	{
		Ray camRay = Camera.main.ScreenPointToRay (Input.mousePosition);

		RaycastHit floorHit;

		if(Physics.Raycast(camRay,out floorHit,m_CamRayLength, m_FloorMask))
	   {
		Vector3 playerToMouse = floorHit.point - transform.position;
		playerToMouse.y = 0.0f;


		Quaternion newRotation = Quaternion.LookRotation(playerToMouse);
		m_PlayerRigidbody.MoveRotation(newRotation);
		}
	}

	void Animating(float h, float v)
	{
		bool walking = (h != 0.0f || v != 0.0f);
		m_Anim.SetBool ("IsWalking", walking);
	}
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;

public class PlayerHealth : MonoBehaviour
{
    public int startingHealth = 100;
    public int currentHealth;
    public Slider healthSlider;
    public Image damageImage;
    public AudioClip deathClip;
    public float flashSpeed = 5f;
    public Color flashColour = new Color(1f, 0f, 0f, 0.1f);

    Animator anim;
    AudioSource playerAudio;
    PlayerMovement playerMovement;
    //PlayerShooting playerShooting;
    bool isDead;
    bool damaged;

    void Awake ()
    {
        anim = GetComponent <Animator> ();
        playerAudio = GetComponent <AudioSource> ();
        playerMovement = GetComponent <PlayerMovement> ();
        //playerShooting = GetComponentInChildren <PlayerShooting> ();
        currentHealth = startingHealth;
    }

    void Update ()
    {
        if(damaged)
        {
            damageImage.color = flashColour;
        }
        else
        {
            damageImage.color = Color.Lerp (damageImage.color, Color.clear, flashSpeed * Time.deltaTime);
        }
        damaged = false;
    }

    public void TakeDamage (int amount)
    {
        damaged = true;

        currentHealth -= amount;

        healthSlider.value = currentHealth;

        playerAudio.Play ();

        if(currentHealth <= 0 && !isDead)
        {
            Death ();
        }
    }

    void Death ()
    {
        isDead = true;

        //playerShooting.DisableEffects ();

        anim.SetTrigger ("Die");

        playerAudio.clip = deathClip;
        playerAudio.Play ();

        playerMovement.enabled = false;
        //playerShooting.enabled = false;
    }

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

using UnityEngine;
using System.Collections;

public class EnemyMovement : MonoBehaviour
{
    Transform player;
    PlayerHealth playerHealth;
    EnemyHealth enemyHealth;
    NavMeshAgent nav;

    void Awake ()
    {
        player = GameObject.FindGameObjectWithTag ("Player").transform;
        playerHealth = player.GetComponent <PlayerHealth> ();
        enemyHealth = GetComponent <EnemyHealth> ();
        nav = GetComponent <NavMeshAgent> ();
    }

    void Update ()
    {
        if(enemyHealth.currentHealth > 0 && playerHealth.currentHealth > 0)
        {
            nav.SetDestination (player.position);
        }
        else
        {
            nav.enabled = false;
        }
    }
}

using UnityEngine;

public class EnemyHealth : MonoBehaviour
{
    public int startingHealth = 100;
    public int currentHealth;
    public float sinkSpeed = 2.5f;
    public int scoreValue = 10;
    public AudioClip deathClip;

    Animator anim;
    AudioSource enemyAudio;
    ParticleSystem hitParticles;
    CapsuleCollider capsuleCollider;
    bool isDead;
    bool isSinking;

    void Awake ()
    {
        anim = GetComponent <Animator> ();
        enemyAudio = GetComponent <AudioSource> ();
        hitParticles = GetComponentInChildren <ParticleSystem> ();
        capsuleCollider = GetComponent <CapsuleCollider> ();

        currentHealth = startingHealth;
		isDead = false;
    }

    void Update ()
    {
        if(isSinking)
        {
            transform.Translate (-Vector3.up * sinkSpeed * Time.deltaTime);
        }
    }
	
	public void TakeDamage (int amount, Vector3 hitPoint)
    {
		Debug.Log ("isDead = " + isDead);
        if(isDead)
            return;

        enemyAudio.Play ();

        currentHealth -= amount;
            
        hitParticles.transform.position = hitPoint;
        hitParticles.Play();

        if(currentHealth <= 0)
        {
            Death ();
        }
    }

    void Death ()
    {
        isDead = true;

        capsuleCollider.isTrigger = true;

        anim.SetTrigger ("Dead");

        enemyAudio.clip = deathClip;
        enemyAudio.Play ();
    }

    public void StartSinking ()
    {
        GetComponent <NavMeshAgent> ().enabled = false;
        GetComponent <Rigidbody> ().isKinematic = true;
        isSinking = true;
        ScoreManager.score += scoreValue;
        Destroy (gameObject, 2f);
    }
}

using UnityEngine;
using System.Collections;

public class EnemyAttack : MonoBehaviour
{
    public float timeBetweenAttacks = 0.5f;
    public int attackDamage = 10;

	public float validAttackDistance = 1.0f;

    Animator anim;
    GameObject player;
    PlayerHealth playerHealth;
    EnemyHealth enemyHealth;
    bool playerInRange;
    float timer;

    void Awake ()
    {
        player = GameObject.FindGameObjectWithTag ("Player");
        playerHealth = player.GetComponent <PlayerHealth> ();
        enemyHealth = GetComponent<EnemyHealth>();
        anim = GetComponent <Animator> ();
    }

/*
    void OnTriggerEnter (Collider other)
    {
        if(other.gameObject == player)
        {
            playerInRange = true;
        }
    }

    void OnTriggerExit (Collider other)
    {
        if(other.gameObject == player)
        {
            playerInRange = false;
        }
    }
*/

	void OnCollisionEnter(Collision collision) {
		if(collision.gameObject == player)
		{
			playerInRange = true;
		}
	}

	void OnCollisionExit(Collision collision) {
		if(collision.gameObject == player)
		{
			playerInRange = false;
		}
	}

    void Update ()
    {
        timer += Time.deltaTime;

        if(timer >= timeBetweenAttacks && playerInRange && enemyHealth.currentHealth > 0)
        {
            Attack ();
        }

        if(playerHealth.currentHealth <= 0)
        {
            anim.SetTrigger ("PlayerDead");
        }
	}

    void Attack ()
    {
        timer = 0f;

        if(playerHealth.currentHealth > 0)
        {
            playerHealth.TakeDamage (attackDamage);
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;

public class ScoreManager : MonoBehaviour
{
    public static int score;

    Text text;

    void Awake ()
    {
        text = GetComponent <Text> ();
        score = 0;
    }

    void Update ()
    {
        text.text = "Score: " + score;
    }
}

using UnityEngine;

public class EnemyManager : MonoBehaviour
{
    public PlayerHealth playerHealth;
    public GameObject enemy;
    public float spawnTime = 3f;
    public Transform[] spawnPoints;

    void Start ()
    {
        InvokeRepeating ("Spawn", spawnTime, spawnTime);
    }

    void Spawn ()
    {
        if(playerHealth.currentHealth <= 0f)
        {
            return;
        }

        int spawnPointIndex = Random.Range (0, spawnPoints.Length);

        Instantiate (enemy, spawnPoints[spawnPointIndex].position, spawnPoints[spawnPointIndex].rotation);
    }
}

using UnityEngine;

public class GameOverManager : MonoBehaviour
{
    public PlayerHealth playerHealth;

    Animator anim;

    void Awake()
    {
        anim = GetComponent<Animator>();
    }

    void Update()
    {
		Debug.Log ("playerHealth.currentHealth = " + playerHealth.currentHealth);
        if (playerHealth.currentHealth <= 0)
        {
            anim.SetTrigger("GameOver");
        }
    }
}

using UnityEngine;
using System;
using System.Collections.Generic;
using Random = UnityEngine.Random;

public class BoardManager : MonoBehaviour {
	[Serializable]
	public class Count
	{
		public int minimum;
		public int maximum;

		public Count(int min, int max)
		{
			minimum = min;
			maximum = max;
		}
	}

	public int columns = 8;
	public int rows = 8;
	public Count wallCount = new Count(5,9);
	public Count foodCount = new Count(1,5);
	public GameObject exit;
	public GameObject[] floorTiles;
	public GameObject[] wallTiles;
	public GameObject[] foodTiles;
	public GameObject[] enemyTiles;
	public GameObject[] outerwallTiles;

	private Transform boardHolder;
	private List<Vector3> gridPositions = new List<Vector3>();

	void InitialiseList()
	{
		gridPositions.Clear ();

		for (int x = 1; x < columns - 1; x++) 
		{
			for(int y = 1; y < rows - 1; y++)
			{
				gridPositions.Add(new Vector3(x,y,0f));
			}
		}
	}

	void BoardSetup()
	{
		boardHolder = new GameObject ("Board").transform;

		for(int x = -1; x < columns + 1; x++)
		{
			for(int y = -1; y < rows + 1; y++)
			{
				GameObject toInstantiate = floorTiles[Random.Range (0,floorTiles.Length)];
				if(x == -1 || x == columns || y == -1 || y == rows)
				{
					toInstantiate = outerwallTiles[Random.Range(0,outerwallTiles.Length)];
				}

				GameObject instance = Instantiate (toInstantiate, new Vector3(x,y,0f),Quaternion.identity) as GameObject;

				instance.transform.SetParent(boardHolder);
			}
		}
	}

	Vector3 RandomPosition()
	{
		int randomIndex = Random.Range (0, gridPositions.Count);
		Vector3 randomPosition = gridPositions [randomIndex];
		gridPositions.RemoveAt(randomIndex);
		return randomPosition;
	}

	void LayoutObjectAtRandom(GameObject[] tileArray, int minimum, int maximum)
	{
		int objectCount = Random.Range (minimum, maximum + 1);
		for (int i = 0; i < objectCount; i++) {
			Vector3 randomPosition = RandomPosition();
			GameObject tileChoice = tileArray[Random.Range (0, tileArray.Length)];
			Instantiate(tileChoice, randomPosition, Quaternion.identity);
		}
	}

	public void SetupScene(int level)
	{
		BoardSetup ();
		InitialiseList ();
		LayoutObjectAtRandom (wallTiles, wallCount.minimum, wallCount.maximum);
		LayoutObjectAtRandom (foodTiles, foodCount.minimum, foodCount.maximum);
		int enemyCount = (int)Mathf.Log (level, 2f);
		LayoutObjectAtRandom (enemyTiles, enemyCount, enemyCount);
		Instantiate (exit, new Vector3 (columns - 1, rows - 1, 0f), Quaternion.identity);
	}
}

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

public class GameManager : MonoBehaviour {

	public float levelStartDelay = 2f;

	public float turnDelay = 0.1f;

	public static GameManager instance = null;

	public BoardManager boardScript;

	public int playerFoodPoints = 30;

	[HideInInspector]public bool playerTurn = true;

	private Text levelText;
	private GameObject levelImage;
	private int level = 1;
	private bool doingSetup;

	private List<Enemy> enemies;
	private bool enemiesMoving;

	void Awake()
	{
		if (instance == null) 
		{
			instance = this;
		} else if (instance != this) 
		{
			Destroy (gameObject);
		}

		DontDestroyOnLoad(gameObject);

		enemies = new List<Enemy> ();

		boardScript = GetComponent<BoardManager> ();
		InitGame ();
	}

	private void OnLevelWasLoaded(int index)
	{
		level++;

		InitGame ();
	}

	void InitGame()
	{
		doingSetup = true;
		levelImage = GameObject.Find ("LevelImage");
		levelText = GameObject.Find ("LevelText").GetComponent<Text> ();
		levelText.text = "Day " + level;
		levelImage.SetActive (true);
		Invoke ("HideLevelImage", levelStartDelay);

		enemies.Clear ();
		boardScript.SetupScene (level);
	}

	private void HideLevelImage()
	{
		levelImage.SetActive (false);
		doingSetup = false;
	}

	public void GameOver()
	{
		levelText.text = "After " + level + " days, you starved.";
		levelImage.SetActive (true);
		enabled = false;
	}

	// Update is called once per frame
	void Update () {
		if (playerTurn || enemiesMoving || doingSetup ) {
			return ;
		}

		StartCoroutine (MoveEnemies ());
	}

	public void AddEnemyToList(Enemy script)
	{
		enemies.Add (script);
	}

	IEnumerator MoveEnemies()
	{
		enemiesMoving = true;
		yield return new WaitForSeconds(turnDelay);

		if (enemies.Count == 0) {
			yield return new WaitForSeconds(turnDelay);
		}

		for (int i = 0; i < enemies.Count; i++) {
			enemies[i].MoveEnemy();
			yield return new WaitForSeconds(turnDelay);
		}

		Debug.Log ("GameManager::MoveEnemies");
		playerTurn = true;
		enemiesMoving = false;
	}
}

using UnityEngine;
using System.Collections;

public abstract class MovingObject : MonoBehaviour {

	public float moveTime = 0.1f;
	public LayerMask blockingLayer;
	
	private BoxCollider2D BoxCollider;
	private Rigidbody2D rb2D;
	private float inverseMoveTime;

	// Use this for initialization
	protected virtual void Start () {
		BoxCollider = GetComponent<BoxCollider2D> ();
		rb2D = GetComponent<Rigidbody2D> ();
		inverseMoveTime = 1f / moveTime;
	}

	protected bool Move(int xDir, int yDir, out RaycastHit2D hit)
	{
		Vector2 start = transform.position;
		Vector2 end = start + new Vector2 (xDir, yDir);

		BoxCollider.enabled = false;
		hit = Physics2D.Linecast (start, end, blockingLayer);
		BoxCollider.enabled = true;

		if( hit.transform == null)
		{
			StartCoroutine(SmoothMovement(end));
			return true;
		}

		return false;
	}

	protected IEnumerator SmoothMovement(Vector3 end)
	{
		float sqrRemainingDistance = (transform.position - end).sqrMagnitude;

		while (sqrRemainingDistance > float.Epsilon) {
			Vector3 newPosition = Vector3.MoveTowards(rb2D.position, end, inverseMoveTime * Time.deltaTime);
			rb2D.MovePosition(newPosition);
			sqrRemainingDistance = (transform.position - end).sqrMagnitude;
			yield return null;
		}
	}

	protected virtual void AttemptMove<T>(int xDir, int yDir) where T : Component
	{
		RaycastHit2D hit;
		bool canMove = Move (xDir, yDir, out hit);
		if (hit.transform == null) {
			return ;
		}

		T hitComponent = hit.transform.GetComponent<T> ();

		if (!canMove && hitComponent != null) {
			OnCanMove(hitComponent);
		}
	}

	protected abstract void OnCanMove<T>(T component) where T : Component;
}

using UnityEngine;
using System.Collections;
using UnityEngine.UI;

public class Player : MovingObject {

	public int wallDamage = 1;
	public int pointsPerFood = 10;
	public int pointsPerSoda = 20;
	public float restartLevelDelay = 1f;
	public Text foodText;

	public AudioClip moveSound1;
	public AudioClip moveSound2;
	public AudioClip eatSound1;
	public AudioClip eatSound2;
	public AudioClip drinkSound1;
	public AudioClip drinkSound2;
	public AudioClip gameOverSound;

	private Animator animator;

	private int food;

	private Vector2 touchOrigin = -Vector2.one;
	
	protected override void Start()
	{
		foodText.text = "Food:" + food;

		animator = GetComponent<Animator> ();

		food = GameManager.instance.playerFoodPoints;

		base.Start();
	}

	private void OnDisable()
	{
		GameManager.instance.playerFoodPoints = food;
	}

	// Update is called once per frame
	void Update () {
		if (!GameManager.instance.playerTurn) {
			return ;
		}

		Debug.Log ("Player::Update() called");
		int horizontal = 0;
		int vertical = 0;

		#if UNITY_EDITOR || UNITY_STANDLONE || UNITY_WEBPLAYER
		horizontal = (int)Input.GetAxisRaw ("Horizontal");
		vertical = (int)Input.GetAxisRaw ("Vertical");

		if (horizontal != 0) {
			vertical = 0;
		}

		#else

		if(Input.touchCount > 0)
		{
			Touch myTouch = Input.touches[0];
			if(myTouch.phase == TouchPhase.Began)
			{
				touchOrigin = myTouch.position;
			}
			else if(myTouch.phase == TouchPhase.Ended && touchOrigin.x >= 0)
			{
				Vector2 touchEnd = myTouch.position;
				float x = touchEnd.x - touchOrigin.x;
				float y = touchEnd.y - touchOrigin.y;
				touchOrigin.x = -1;
				if(Mathf.Abs(x) > Mathf.Abs(y))
				{
					horizontal = x > 0 ? 1 : -1;
				}
				else
				{
					vertical = y > 0 ? 1 : -1;
				}
			}
		}
		#endif

		if (horizontal != 0 || vertical != 0 ) {
			AttemptMove<Wall>(horizontal, vertical);
		}
	}

	protected override void AttemptMove<T>(int xDir, int yDir)
	{
		food--;
		foodText.text = "Food:" + food;

		base.AttemptMove<T> (xDir, yDir);

		RaycastHit2D hit;
		if(Move (xDir, yDir, out hit))
		{
			SoundManager.instance.RandomizeSfx(moveSound1,moveSound2);
		}

		CheckIfGameOver ();

		GameManager.instance.playerTurn = false;
	}

	private void OnTriggerEnter2D(Collider2D other)
	{
		if (other.tag == "Exit") {
			Invoke ("Restart", restartLevelDelay);
			enabled = false;
		} else if (other.tag == "Food") {
			food += pointsPerFood;
			other.gameObject.SetActive(false);
			foodText.text = "+:" + pointsPerFood + "Food: " + food;
			SoundManager.instance.RandomizeSfx(drinkSound1,drinkSound2);
		} else if (other.tag == "Soda") {
			food += pointsPerSoda;
			other.gameObject.SetActive(false);
			foodText.text = "+:" + pointsPerSoda + "Food: " + food;			
			SoundManager.instance.RandomizeSfx(drinkSound1,drinkSound2);

		}
	}

	protected override void OnCanMove<T>(T component)
	{
		Wall hitWall = component as Wall;
		hitWall.DamageWall (wallDamage);
		animator.SetTrigger ("PlayerChop");
	}

	private void Restart()
	{
		Application.LoadLevel (Application.loadedLevel);
	}

	public void LoseFood(int loss)
	{
		animator.SetTrigger ("PlayerHit");
		food -= loss;
		foodText.text = "-:" + loss + "Food: " + food;
		CheckIfGameOver();
	}

	private void CheckIfGameOver()
	{
		if (food <= 0) {
			SoundManager.instance.PlaySingle(gameOverSound);
			SoundManager.instance.musicSource.Stop();
			GameManager.instance.GameOver();
		}
	}
}

using UnityEngine;
using System.Collections;

public class Enemy : MovingObject {

	public int playerDamager;

	private Animator animator;
	private Transform target;
	private bool skipMove;

	public AudioClip enemyAttack1;
	public AudioClip enemyAttack2;

	protected override void Start () {
		GameManager.instance.AddEnemyToList (this);
		animator = GetComponent<Animator> ();
		target = GameObject.FindGameObjectWithTag ("Player").transform;
		base.Start ();
	}

	protected override void AttemptMove<T>(int xDir, int yDir)
	{
		if (skipMove) {
			skipMove = false;
			return;
		}

		base.AttemptMove<T> (xDir, yDir);

		skipMove = true;
	}

	public void MoveEnemy()
	{
		int xDir = 0;
		int yDir = 0;

		if (Mathf.Abs (target.position.x - transform.position.x) < float.Epsilon) {
			yDir = target.position.y > transform.position.y ? 1 : -1;
		} else {
			xDir = target.position.x > transform.position.x ? 1 : -1;
		}

		AttemptMove<Player> (xDir, yDir);
	}

	protected override void OnCanMove<T>(T component)
	{
		Player hitPlayer = component as Player;

		animator.SetTrigger ("enemyAttack");

		hitPlayer.LoseFood (playerDamager);

		SoundManager.instance.RandomizeSfx (enemyAttack1, enemyAttack2);
	}
}

using UnityEngine;
using System.Collections;

public class SoundManager : MonoBehaviour {

	public AudioSource efxSource;
	public AudioSource musicSource;
	public static SoundManager instance = null;

	public float lowPitchRange = 0.95f;
	public float highPitchRange = 1.05f;

	void Awake()
	{
		if (instance == null) {
			instance = this;
		} else if (instance != this) {
			Destroy(gameObject);
		}
		DontDestroyOnLoad (gameObject);
	}

	public void PlaySingle(AudioClip clip)
	{
		efxSource.clip = clip;
		efxSource.Play ();
	}

	public void RandomizeSfx(params AudioClip[] clips)
	{
		int randomIndex = Random.Range (0, clips.Length);
		float randomPitch = Random.Range (lowPitchRange, highPitchRange);

		efxSource.pitch = randomPitch;
		efxSource.clip = clips [randomIndex];
		efxSource.Play ();
	}

	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

using UnityEngine;
using System.Collections;

public class Wall : MonoBehaviour {

	public Sprite dmgSprite;

	public int hp = 4;

	private SpriteRenderer spriteRenderer;

	public AudioClip wallChop1;
	public AudioClip wallChop2;

	void Awake()
	{
		spriteRenderer = GetComponent<SpriteRenderer> ();
	}

	public void DamageWall(int loss)
	{
		spriteRenderer.sprite = dmgSprite;
		hp -= loss;
		SoundManager.instance.RandomizeSfx (wallChop1, wallChop2);
		if (hp <= 0) {
			gameObject.SetActive(false);
		}
	}
}

using UnityEngine;
using System.Collections;

public class Loader : MonoBehaviour {

	public GameObject gameManager;

	void Awake()
	{
		if (GameManager.instance == null) 
		{
			Instantiate (gameManager);
		}
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}