PlayerController.cs

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

public class PlayerController : MonoBehaviour {

	//These are the general settings to get the player positions.
	private Vector2 Pos;
	private Vector2 CurrentPos;
	private Vector2 SwipePos;
	private Vector3 Dir;
	private Vector3 HitPos;

	[Header("Player Settings")]
	public Rigidbody PlayerRigidbody; 					//The rigidbody of the player.
	public float PlayerSpeed = 15; 						//The movement speed of the player.
	public int SwipeSpeed = 500; 						//The Swipe Speed of the player.
	private bool isItMoving;							//Is the player ball moving?
	private Color GroundColor;							//Get the Ground Color.
	//public AudioClip PlayerCollideSound; 				//The sound that will play when player collide. (WIP)
	public static PlayerController singleton;			//Singleton to be used.
	private GroundBlock[] CalculateAllGroundBlocks;		//Calculate how many Ground Blocks are in the scene.
	//public bool PlayerCollideSoundEnabled; 			//If this is enabled then the Player will play a sound when it moves. 
	public bool AutoColorChange; 						//If this is enabled then the Player Ball will change color automatically. (WIP)
	private bool PlayerWaitTime = true; 				//Is wait time enabled?
	public float PlayerWaitingTime = 5f; 				//Is wait time enabled?

	[Header("UIs Settings")]
	public GameObject completeGameOverUI;				//The Complete Game Over UI to display when game is over.
	public AudioClip GameOverSound;						//The gamer over sound that will play when the game is over.
	public AudioClip GameOverSplatSound; 				//The splat sound that will play when the game is over.

	private int currentSceneIndex; 						//This will get your current scene so you can continue your progress.

	public static AudioClip impact;
	public static AudioSource audioSource;

	private void Start() {
		audioSource = GetComponent<AudioSource>();
		completeGameOverUI.gameObject.SetActive(false);

		if (AutoColorChange) {
		GroundColor = Random.ColorHSV(.5f, 1);
		GetComponent<MeshRenderer>().material.color = GroundColor;
		} else {
			
		GroundColor = GetComponent<Renderer>().material.color;
		GetComponent<MeshRenderer>().material.color = GroundColor;
	}
		CalculateAllGroundBlocks = FindObjectsOfType<GroundBlock>();
		
		AdmobHelper.Instance().ShowBanner();
	}

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

	public void LevelComplete() {
		bool isFinished = true;
		for (int i = 0; i < CalculateAllGroundBlocks.Length; i++)
		{
			if (CalculateAllGroundBlocks[i].ColoredBlock == false)
			{
				isFinished = false;
				break;
			}
		}

		if (isFinished)
			NextLevel();
	}

	private void NextLevel() {
		PlayerWaitTime = false;
		completeGameOverUI.gameObject.SetActive(true);
		GetComponent<AudioSource>().PlayOneShot(GameOverSound, 7.7F); //Play the score Sound audio.
		GetComponent<AudioSource>().PlayOneShot(GameOverSplatSound, 7.7F); //Play the score Sound audio.
		Destroy (GameObject.FindWithTag("BackgroundMusic"));

		currentSceneIndex = SceneManager.GetActiveScene().buildIndex;
		PlayerPrefs.SetInt("SavedScene", currentSceneIndex);
		this.gameObject.GetComponentInChildren<Collider> ().enabled = false;
		this.gameObject.GetComponentInChildren<Renderer> ().enabled = false;
		foreach (Renderer r in GetComponentsInChildren<Renderer>())
		r.enabled = false;
		AdmobHelper.Instance().showRandomInterstitial();
		//SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex + 1);
	}
		
	IEnumerator Reload() {
		yield return new WaitForSeconds(PlayerWaitingTime);
		PlayerWaitTime = true;
	}

	/*
	void OnCollisionEnter(Collision collision)
	{
		if (PlayerCollideSoundEnabled) {
			if (!audioSource.isPlaying) {
				audioSource.clip = PlayerCollideSound;
				audioSource.Play();
					
				}
		}
	}
*/

	private void FixedUpdate() {
		if (isItMoving) {
			PlayerRigidbody.velocity = Dir * PlayerSpeed;
		}

		Collider[] hitColliders = Physics.OverlapSphere(transform.position - (Vector3.up/2), .05f);


		int i = 0;
		while (i < hitColliders.Length) {
			
			GroundBlock ground = hitColliders[i].transform.GetComponent<GroundBlock>();

			if (ground && !ground.ColoredBlock) {
				ground.ActiveColor(GroundColor);
			}

			i++;	
		}

		if (HitPos != Vector3.zero) {
			
			if (Vector3.Distance(transform.position, HitPos) < 1) {
				isItMoving = false;
				Dir = Vector3.zero;
				HitPos = Vector3.zero;
			}
				
		}

		if (isItMoving)
			return;

		if (Input.GetMouseButton(0)) {
			CurrentPos = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
			if (Pos != Vector2.zero) {


				

				SwipePos = CurrentPos - Pos;

				if (SwipePos.sqrMagnitude < SwipeSpeed) 
					return;
				SwipePos.Normalize();
				float limit = 0.3f;
				if (PlayerWaitTime) {
					if (SwipePos.x > -limit && SwipePos.x < limit) {

						if (Math.Abs(SwipePos.y) > 0.5f)
						{
							StartDes(SwipePos.y > 0 ? Vector3.forward : Vector3.back); 
							StartCoroutine(Reload());
							PlayerWaitTime = false;
						}
					}
				}   
				if (PlayerWaitTime) {
					if (SwipePos.y > -limit && SwipePos.y < limit) {

						if (Math.Abs(SwipePos.x) > 0.5f)
						{
							StartCoroutine(Reload());
							StartDes(SwipePos.x > 0 ? Vector3.right : Vector3.left);
							PlayerWaitTime = false;
						}
					}
				}
			}

			Pos = CurrentPos;
		}
		if (Input.GetMouseButtonUp(0)) {
			Pos = Vector2.zero;
			SwipePos = Vector2.zero;
		}

}

	private void StartDes(Vector3 direction) {
		Dir = direction;

		RaycastHit hit;
		if (Physics.Raycast(transform.position, direction, out hit, 100f)) {

			HitPos = hit.point;
		}
			isItMoving = true;
	

	}
	
    private void OnApplicationFocus(bool hasFocus)
    {
        if (hasFocus)
        {
            StartCoroutine (showFocusAd ());
        }
        else
        {
            AdmobHelper.Instance().RequsetNewInterstitial();
        }
    }

    IEnumerator showFocusAd()
    {
        yield return new WaitForSeconds(0.5f);
	    AdmobHelper.Instance().ShowInterstitial();
    }
}