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

public class headBob : MonoBehaviour
{
	public playerController playerControllerManager;

	public bool headBobEnabled;
	public bool firstPersonMode;
	public bool externalShakeEnabled;
	public bool externalShakingActive;
	public bool headBobCanBeUsed = true;
	public string currentState = "";
	public string externalForceStateName;
	public bool useDynamicIdle;

	public string staticIdleName;
	public string dynamicIdleName;

	public string jumpStartStateName = "Jump Start";
	public string jumpEndStateName = "Jump End";

	public float timeToActiveDynamicIdle;
	public bool shakeCameraInLockedMode;
	public List<bobStates> bobStatesList = new List<bobStates> ();
	public List<externalShakeInfoListElement> externalShakeInfoList = new List<externalShakeInfoListElement> ();

	public enum bobTransformType
	{
		onlyPosition,
		onlyRotation,
		both,
		none
	}

	public enum viewTypes
	{
		firstPerson,
		thirdPerson,
		both
	}

	public float resetSpeed;
	public Vector3 jumpStartMaxIncrease;
	public float jumpStartSpeed;
	public Vector3 jumpEndMaxDecrease;
	public float jumpEndSpeed;
	public float jumpResetSpeed;
	public bool headBobPaused = false;
	public bobStates playerBobState;
	public bool damageShakeActive;

	public externalShakeListManager externalShakeManager;

	public string mainManagerName = "External Shake List Manager";

	public bool firstPersonActive;

	public bool cameraTypeFree;

	bool stateChanged = false;
	bool checkResetCamera;
	Coroutine coroutineStartJump;
	Coroutine coroutineEndJump;
	Coroutine coroutineToStop;
	Coroutine externalForceCoroutine;
	Coroutine waitToActiveCoroutine;
	Vector3 initialTargetEul;
	Vector3 initialTargetPos;
	Transform mainCameraTransform;
	bool dead;

	float externalShakeDuration;
	float externalShakeDelay;

	bool useDelayBeforeStartDecrease;
	float delayBeforeStartDecrease;

	Coroutine decreaseShakeInTimeCoroutime;
	bool decreaseShakeInTime;
	float decreaseShakeSpeed;
	string defaultState;

	bool changePos;
	bool changeRot;
	float posTargetX;
	float posTargetY;
	float posTargetZ;
	Vector3 posTarget;
	float eulTargetX;
	float eulTargetY;
	float eulTargetZ;
	Vector3 eulTarget;

	bool stopHeadMovementsActive;

	int currentNumberOfRepeatShake;

	externalShakeInfo currentExternalShakeInfo;

	UnityEvent currentEventAtStart;
	UnityEvent currentEventAtEnd;
	bool useShakeEvent;

	bool headBobCanBePlayed;

	Coroutine stopHeadBobCoroutine;

	float currentTimeTime;

	float currentDeltaTime;

	Vector3 currentPosSpeed;
	Vector3 currentPostAmount;
	Vector3 currentEulSpeed;
	Vector3 currentEulAmount;


	void Awake ()
	{
		if (!headBobEnabled) {
			return;
		}

		//get the object to shake, in this case the main camera
		mainCameraTransform = transform;
	}

	void Start ()
	{
		if (!headBobEnabled) {
			return;
		}

		//set the position and rotation to reset the camera transform
		initialTargetEul = Vector3.zero;
		initialTargetPos = Vector3.zero;

		//set the initial state of the player
		playerBobState = new bobStates ();

		setState (currentState);

		defaultState = currentState;

		bool externalShakeManagerLocated = externalShakeManager != null;

		if (!externalShakeManagerLocated) {
			externalShakeManager = externalShakeListManager.Instance;

			externalShakeManagerLocated = externalShakeManager != null;
		}

		if (!externalShakeManagerLocated) {
			GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (externalShakeListManager.getMainManagerName (), typeof(externalShakeListManager), true);

			externalShakeManager = externalShakeListManager.Instance;
		}
	}

	void Update ()
	{
		//if headbod enabled, check the current state
		if (headBobEnabled && headBobCanBeUsed) {
			if (playerBobState.bobTransformStyle != bobTransformType.none) {
				if (canBeUsed ()) {
					
					movementBob (playerBobState);

					if (stateChanged) {
						stateChanged = false;
					}

				}
			} else {
				if (!stateChanged) {
					if (!headBobPaused) {
						stopBobTransform ();
					}

					stateChanged = true;
				}
			}
		}
	}

	public bool isExternalShakingActive ()
	{
		return externalShakingActive;
	}

	public bool canBeUsed ()
	{
		//if the camera is not being moved from the third to first move or viceversa,
		//or the camera is in first person mode and the current bobstate is only applied in first mode, 
		//or the camera is in third person mode and the current bobstate is only applied in third mode,
		//or the in the current bob state the camera is shake in both modes, then
		if (playerBobState.enableBobIn == viewTypes.both ||
		    ((playerBobState.enableBobIn == viewTypes.firstPerson && firstPersonActive && firstPersonMode) ||
		    (playerBobState.enableBobIn == viewTypes.thirdPerson && !firstPersonActive)) && !headBobPaused) {
			return true;
		}

		return false;
	}

	public void setFirstPersonViewActiveState (bool state)
	{
		firstPersonActive = state;
	}

	public void setCameraTypeFreeState (bool state)
	{
		cameraTypeFree = state;
	}

	public bool cameraLockedAllowsShake ()
	{
		if (cameraTypeFree) {
			return true;
		} else {
			if (shakeCameraInLockedMode) {
				return true;
			}
		}

		return false;
	}

	public void stopBobTransform ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (coroutineToStop != null) {
			StopCoroutine (coroutineToStop);
		}

		coroutineToStop = StartCoroutine (resetCameraTransform ());
	}

	public void stopBobRotation ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (coroutineToStop != null) {
			StopCoroutine (coroutineToStop);
		}

		coroutineToStop = StartCoroutine (resetCameraRotation ());
	}
		
	//set a state in the current player state
	public void setState (string stateName)
	{
		if (!headBobEnabled) {
			return;
		}

		if (!headBobCanBePlayed) {
			if (Time.time > 1) {
				headBobCanBePlayed = true;
			} else {
				return;
			}
		}
			
		//search the state recieved
		if ((!stateName.Equals (currentState) && !externalShakingActive) ||
		    stateName.Equals (externalForceStateName) ||
		    (!externalShakingActive && useDynamicIdle && stateName.Equals (dynamicIdleName)) && !damageShakeActive) {

			int bobStatesListCount = bobStatesList.Count;

			for (int i = 0; i < bobStatesListCount; i++) {
				if (bobStatesList [i].Name.Equals (stateName)) {
					//if found, set the state values, and the enable this state as the current state
					playerBobState = bobStatesList [i];

					currentState = bobStatesList [i].Name;

					playerBobState.isCurrentState = true;
				} else {
					bobStatesList [i].isCurrentState = false;
				}
			}

			if (firstPersonMode) {
				if (stateName.Equals (jumpStartStateName)) {
					jumpStarted ();
				}

				if (stateName.Equals (jumpEndStateName)) {
					jumpEnded ();
				}
			}
		}
	}

	public void setFirstOrThirdHeadBobView (bool state)
	{
		if (!headBobEnabled) {
			return;
		}

		//if the camera is in first person view, then check the headbob
		firstPersonMode = state;

		//if the camera is set back to the third person mode, reset the camera rotation
		if (!firstPersonMode) {
			//stop the previous coroutine and play the reset camera rotation coroutine
			if (coroutineToStop != null) {
				StopCoroutine (coroutineToStop);
			}

			coroutineToStop = StartCoroutine (resetCameraRotation ());
		}
	}

	public void setFirstOrThirdMode (bool state)
	{
		firstPersonMode = state;
	}

	public void setShotShakeState (IKWeaponSystem.weaponShotShakeInfo shotShakeInfo)
	{
		if (!headBobEnabled) {
			return;
		}

		if (externalShakeEnabled) {
			
			setState (externalForceStateName);

			if (firstPersonMode) {
				playerBobState.eulAmount = shotShakeInfo.shakeRotation;
				playerBobState.posAmount = shotShakeInfo.shakePosition;
				playerBobState.posSmooth = shotShakeInfo.shakeSmooth;
				playerBobState.eulSmooth = shotShakeInfo.shakeSmooth;
				playerBobState.bobTransformStyle = bobTransformType.both;
			} else {
				playerBobState.eulAmount = shotShakeInfo.shakeRotation;
				playerBobState.posAmount = Vector3.zero;
				playerBobState.posSmooth = 0;
				playerBobState.eulSmooth = shotShakeInfo.shakeSmooth;
				playerBobState.bobTransformStyle = bobTransformType.onlyRotation;
			}

			playerBobState.posSpeed = shotShakeInfo.shotForce * Vector3.one;
			playerBobState.eulSpeed = shotShakeInfo.shotForce * Vector3.one;

			externalShakeDuration = shotShakeInfo.shakeDuration;

			setExternalShakeDuration ();
		}
	}

	public void setExternalShakeState (externalShakeInfo shakeInfo)
	{
		if (!headBobEnabled) {
			return;
		}

		if (externalShakeEnabled) {
			currentExternalShakeInfo = shakeInfo;
			
			setState (externalForceStateName);

			if (firstPersonMode) {
				playerBobState.eulAmount = shakeInfo.shakeRotation;
				playerBobState.posAmount = shakeInfo.shakePosition;
				playerBobState.posSmooth = shakeInfo.shakePositionSmooth;
				playerBobState.eulSmooth = shakeInfo.shakeRotationSmooth;
				playerBobState.bobTransformStyle = bobTransformType.both;
			} else {
				playerBobState.eulAmount = shakeInfo.shakeRotation;
				playerBobState.posAmount = Vector3.zero;
				playerBobState.posSmooth = 0;
				playerBobState.eulSmooth = shakeInfo.shakeRotationSmooth;
				playerBobState.bobTransformStyle = bobTransformType.onlyRotation;
			}

			playerBobState.posSpeed = shakeInfo.shakePositionSpeed;
			playerBobState.eulSpeed = shakeInfo.shakeRotationSpeed;

			externalShakeDuration = shakeInfo.shakeDuration;
			externalShakeDelay = shakeInfo.externalShakeDelay;

			decreaseShakeInTime = shakeInfo.decreaseShakeInTime;
			decreaseShakeSpeed = shakeInfo.decreaseShakeSpeed;

			useDelayBeforeStartDecrease = shakeInfo.useDelayBeforeStartDecrease;
			delayBeforeStartDecrease = shakeInfo.delayBeforeStartDecrease;

			playerBobState.repeatShake = shakeInfo.repeatShake;
			playerBobState.numberOfRepeats = shakeInfo.numberOfRepeats;
			playerBobState.delayBetweenRepeats = shakeInfo.delayBetweenRepeats;

			currentNumberOfRepeatShake = 0;

			setExternalShakeDuration ();

			checkDecreaseShake ();
		}
	}

	public void setExternalShakeStateByIndex (int index, bool isFirstPerson)
	{
		if (!headBobEnabled) {
			return;
		}

		externalShakeInfoListElement newShake = externalShakeInfoList [index];

		if (isFirstPerson) {
			setExternalShakeState (newShake.firstPersonDamageShake);
		} else {
			setExternalShakeState (newShake.thirdPersonDamageShake);
		}
	}

	public void setExternalShakeStateByName (string shakeName, float multiplier)
	{
		if (!headBobEnabled) {
			return;
		}

		if (!playerControllerManager.driving) {
			bool shakeNameFound = false;

			externalShakeInfo newShake = new externalShakeInfo ();

			int externalShakeInfoListCount = externalShakeInfoList.Count;

			for (int i = 0; i < externalShakeInfoListCount; i++) {
				if (externalShakeInfoList [i].name.Equals (shakeName)) {	
					if (externalShakeInfoList [i].sameValueBothViews) {
						newShake = new externalShakeInfo (externalShakeInfoList [i].thirdPersonDamageShake);

						if (!externalShakeInfoList [i].useDamageShakeInThirdPerson) {
							return;
						}
					} else {
						if (firstPersonMode) {
							if (!externalShakeInfoList [i].useDamageShakeInFirstPerson) {
								return;
							}

							newShake = new externalShakeInfo (externalShakeInfoList [i].firstPersonDamageShake);
						} else {
							if (!externalShakeInfoList [i].useDamageShakeInThirdPerson) {
								return;
							}

							newShake = new externalShakeInfo (externalShakeInfoList [i].thirdPersonDamageShake);
						}
					}

					shakeNameFound = true;
				}
			}

			if (shakeNameFound) {
				if (multiplier != 1) {
					newShake.shakePosition = multiplier * newShake.shakePosition;

					newShake.shakePositionSpeed = multiplier * newShake.shakePositionSpeed;

					newShake.shakeRotation = multiplier * newShake.shakeRotation;

					newShake.shakeRotationSpeed = multiplier * newShake.shakeRotationSpeed;
				}
					
				setExternalShakeState (newShake);

				damageShakeActive = true;
			} else {
				print ("WARNING: the shake type called " + shakeName + " wasn't found, make sure the name exist in the external " +
				"shake list manager and it is assigned in the head bod manager");
			}
		}
	}

	public void setExternalShakeStateToRepeat (externalShakeInfo shakeInfo)
	{
		if (!headBobEnabled) {
			return;
		}

		if (externalShakeEnabled) {

			setState (externalForceStateName);

			if (firstPersonMode) {
				playerBobState.eulAmount = shakeInfo.shakeRotation;
				playerBobState.posAmount = shakeInfo.shakePosition;
				playerBobState.posSmooth = shakeInfo.shakePositionSmooth;
				playerBobState.eulSmooth = shakeInfo.shakeRotationSmooth;
				playerBobState.bobTransformStyle = bobTransformType.both;
			} else {
				playerBobState.eulAmount = shakeInfo.shakeRotation;
				playerBobState.posAmount = Vector3.zero;
				playerBobState.posSmooth = 0;
				playerBobState.eulSmooth = shakeInfo.shakeRotationSmooth;
				playerBobState.bobTransformStyle = bobTransformType.onlyRotation;
			}

			playerBobState.posSpeed = shakeInfo.shakePositionSpeed;
			playerBobState.eulSpeed = shakeInfo.shakeRotationSpeed;
			externalShakeDuration = shakeInfo.shakeDuration;
			externalShakeDelay = shakeInfo.externalShakeDelay;

			decreaseShakeInTime = shakeInfo.decreaseShakeInTime;
			decreaseShakeSpeed = shakeInfo.decreaseShakeSpeed;

			useDelayBeforeStartDecrease = shakeInfo.useDelayBeforeStartDecrease;
			delayBeforeStartDecrease = shakeInfo.delayBeforeStartDecrease;

			playerBobState.repeatShake = shakeInfo.repeatShake;
			playerBobState.numberOfRepeats = shakeInfo.numberOfRepeats;
			playerBobState.delayBetweenRepeats = shakeInfo.delayBetweenRepeats;

			setExternalShakeDuration ();

			checkDecreaseShake ();
		}
	}

	public void setExternalShakeDuration ()
	{
		externalShakingActive = true;

		if (externalForceCoroutine != null) {
			StopCoroutine (externalForceCoroutine);
		}

		externalForceCoroutine = StartCoroutine (setExternalShakeDurationCoroutine ());
	}

	IEnumerator setExternalShakeDurationCoroutine ()
	{
		bool repeatShake = false;

		if (useShakeEvent) {
			currentEventAtStart.Invoke ();
		}

		WaitForSeconds delay = new WaitForSeconds (externalShakeDelay);

		yield return delay;

		delay = new WaitForSeconds (externalShakeDuration);

		yield return delay;

		if (useShakeEvent) {
			currentEventAtEnd.Invoke ();
		}

		if (playerBobState.repeatShake) {

			if (currentNumberOfRepeatShake < playerBobState.numberOfRepeats) {
				currentNumberOfRepeatShake++;

				repeatShake = true;

				float delayBetweenRepeats = playerBobState.delayBetweenRepeats;

				stopExternalShake ();

				damageShakeActive = false;

				delay = new WaitForSeconds (delayBetweenRepeats);

				yield return delay;

				setExternalShakeStateToRepeat (currentExternalShakeInfo);
			} else {
				useShakeEvent = false;
			}
		} else {
			useShakeEvent = false;
		}

		if (!repeatShake) {
			stopExternalShake ();

			damageShakeActive = false;

			yield return null;	
		}
	}

	public void stopExternalShake ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (externalShakingActive) {
			playerControllerManager.setLastTimeMoved ();
		}

		externalShakingActive = false;

		if (!firstPersonMode) {
			stopBobRotation ();

			stateChanged = true;
		}

		playerControllerManager.resetHeadBodState ();
	}

	public void setCurrentExternalCameraShakeSystemEvents (UnityEvent eventAtStart, UnityEvent eventAtEnd)
	{
		currentEventAtStart = eventAtStart;
		currentEventAtEnd = eventAtEnd;
		useShakeEvent = true;
	}

	public void disableUseShakeEventState ()
	{
		useShakeEvent = false;
	}

	public void checkDecreaseShake ()
	{
		if (decreaseShakeInTime) {
			if (decreaseShakeInTimeCoroutime != null) {
				StopCoroutine (decreaseShakeInTimeCoroutime);
			}

			decreaseShakeInTimeCoroutime = StartCoroutine (checkDecreaseShakeInTimeCoroutime ());
		}
	}

	IEnumerator checkDecreaseShakeInTimeCoroutime ()
	{
		float t = 0;
		bool eulTargetIsZero = false;
		bool posTargetIsZero = false;

		float eulSmoothTarget = 0;
		float posSmoothTarget = 0;

		if (useDelayBeforeStartDecrease) {
			WaitForSeconds delay = new WaitForSeconds (delayBeforeStartDecrease);

			yield return delay;
		}

		while (t < 1) {
			t += Time.deltaTime / (1 / decreaseShakeSpeed);

			if (externalShakingActive) {
				if (playerBobState.eulSmooth == eulSmoothTarget) {
					eulTargetIsZero = true;
				}

				playerBobState.eulSmooth = Mathf.MoveTowards (playerBobState.eulSmooth, eulSmoothTarget, t);

				if (playerBobState.posSmooth == posSmoothTarget) {
					posTargetIsZero = true;
				}

				playerBobState.posSmooth = Mathf.MoveTowards (playerBobState.posSmooth, posSmoothTarget, t);
			
				if (posTargetIsZero && eulTargetIsZero) {
					t = 2;
				}
			}
			yield return null;
		}

		decreaseShakeInTime = false;

		if (!playerBobState.repeatShake || currentNumberOfRepeatShake >= playerBobState.numberOfRepeats) {
			stopExternalShake ();
		}

		yield return null;			
	}

	public void playerAliveOrDead (bool state)
	{
		if (!headBobEnabled) {
			return;
		}

		dead = state;

		headBobCanBeUsed = !dead;

		if (dead) {
			stateChanged = true;

			headBobPaused = false;

			setState (staticIdleName);
		}
	}

	public void playOrPauseHeadBob (bool state)
	{
		headBobCanBeUsed = state;
	}

	public void stopAllHeadbobMovements ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (coroutineToStop != null) {
			StopCoroutine (coroutineToStop);
		}

		if (coroutineStartJump != null) {
			StopCoroutine (coroutineStartJump);
		}

		if (coroutineEndJump != null) {
			StopCoroutine (coroutineEndJump);
		}

		if (decreaseShakeInTimeCoroutime != null) {
			StopCoroutine (decreaseShakeInTimeCoroutime);
		}

		if (externalForceCoroutine != null) {
			StopCoroutine (externalForceCoroutine);
		}

		externalShakingActive = false;

		damageShakeActive = false;

		stopHeadMovementsActive = false;

		stateChanged = true;

		setState (staticIdleName);
	}

	//check the info of the current state, to apply rotation, translation, both or anything according to the parameters of the botState
	void movementBob (bobStates state)
	{
		if (!cameraLockedAllowsShake ()) {
			return;
		}

		if (stopHeadMovementsActive) {
			return;
		}

		changePos = false;
		changeRot = false;

		//check the type of shake
		if (playerBobState.bobTransformStyle == bobTransformType.onlyPosition) {
			changePos = true;
		} else if (playerBobState.bobTransformStyle == bobTransformType.onlyRotation) {
			changeRot = true;
		} else if (playerBobState.bobTransformStyle == bobTransformType.both) {
			changePos = true;
			changeRot = true;
		}

		currentTimeTime = Time.time;

		currentDeltaTime = Time.deltaTime;

		if (playerBobState.useUnscaledTime) {
			if (Time.timeScale != 1) {
				currentTimeTime = Time.unscaledTime;
				currentDeltaTime = Time.unscaledDeltaTime;
			}
		}

		//apply translation
		if (changePos) {
			currentPosSpeed = state.posSpeed;
			currentPostAmount = state.posAmount;

			posTargetX = Mathf.Sin (currentTimeTime * currentPosSpeed.x) * currentPostAmount.x;
			posTargetY = Mathf.Sin (currentTimeTime * currentPosSpeed.y) * currentPostAmount.y;
			posTargetZ = Mathf.Cos (currentTimeTime * currentPosSpeed.z) * currentPostAmount.z;

			posTarget = new Vector3 (posTargetX, posTargetY, posTargetZ);

			mainCameraTransform.localPosition = Vector3.Lerp (mainCameraTransform.localPosition, posTarget, currentDeltaTime * state.posSmooth);
		}

		//apply rotation
		if (changeRot) {
			currentEulSpeed = state.eulSpeed;
			currentEulAmount = state.eulAmount;

			eulTargetX = Mathf.Sin (currentTimeTime * currentEulSpeed.x) * currentEulAmount.x;
			eulTargetY = Mathf.Sin (currentTimeTime * currentEulSpeed.y) * currentEulAmount.y;
			eulTargetZ = Mathf.Cos (currentTimeTime * currentEulSpeed.z) * currentEulAmount.z;

			eulTarget = new Vector3 (eulTargetX, eulTargetY, eulTargetZ);

			mainCameraTransform.localRotation = Quaternion.Lerp (mainCameraTransform.localRotation, Quaternion.Euler (eulTarget), currentDeltaTime * state.eulSmooth);
		}
	}

	public void jumpStarted ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (stopHeadMovementsActive) {
			return;
		}

		//if the player jumps, stop the current coroutine, and play the jump coroutine
		if (coroutineEndJump != null) {
			StopCoroutine (coroutineEndJump);
		}

		coroutineStartJump = StartCoroutine (startJump ());
	}

	public void jumpEnded ()
	{
		if (!headBobEnabled) {
			return;
		}

		if (stopHeadMovementsActive) {
			return;
		}

		//if the player is in firts person view and the camera is not moving from first to third mode, then
		if (firstPersonActive && !dead) {
			//if the player reachs the ground after jump, stop the current coroutine, and play the landing coroutine
			if (coroutineStartJump != null) {
				StopCoroutine (coroutineStartJump);
			}

			coroutineEndJump = StartCoroutine (endJump ());
		}
	}

	IEnumerator startJump ()
	{
		//walk or run shakes are blocked
		headBobPaused = true;

		float i = 0.0f;
		float rate = jumpStartSpeed;
		//add to the current rotation the jumpStartMaxIncrease value, when the player jumps
		Vector3 targetEUL = new Vector3 (mainCameraTransform.localEulerAngles.x - jumpStartMaxIncrease.x, 
			                    mainCameraTransform.localEulerAngles.y - jumpStartMaxIncrease.y, 
			                    mainCameraTransform.localEulerAngles.z - jumpStartMaxIncrease.z);
		
		//store the current rotation
		Quaternion currentQ = mainCameraTransform.localRotation;

		//store the target rotation
		Quaternion targetQ = Quaternion.Euler (targetEUL);

		while (i < 1.0f) {
			i += Time.deltaTime * rate;

			mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, targetQ, i);

			yield return null;
		}

		headBobPaused = false;
	}

	IEnumerator endJump ()
	{
		headBobPaused = true;

		float i = 0.0f;
		float rate = jumpEndSpeed;
		//add to the current rotation the jumpMaxDrecrease value, when the player touch the ground again after jumping
		Vector3 targetEUL = new Vector3 (mainCameraTransform.localEulerAngles.x + jumpEndMaxDecrease.x, 
			                    mainCameraTransform.localEulerAngles.y + jumpEndMaxDecrease.y, 
			                    mainCameraTransform.localEulerAngles.z + jumpEndMaxDecrease.z);

		//store the current rotation
		Quaternion currentQ = mainCameraTransform.localRotation;

		//store the target rotation
		Quaternion targetQ = Quaternion.Euler (targetEUL);

		while (i < 1.0f) {
			i += Time.deltaTime * rate;

			mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, targetQ, i);

			yield return null;
		}

		//reset again the rotation of the camera
		i = 0;
		rate = jumpResetSpeed;
		currentQ = mainCameraTransform.localRotation;
		targetQ = Quaternion.Euler (initialTargetEul);

		while (i < 1.0f) {
			i += Time.deltaTime * rate;

			mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, targetQ, i);

			yield return null;
		}

		//the jump state has finished, so the camera can be shaked again
		headBobPaused = false;
	}

	IEnumerator resetCameraTransform ()
	{
		if (firstPersonMode || playerBobState.bobTransformStyle == bobTransformType.none) {
			float i = 0.0f;
			float rate = resetSpeed;
			//store the current rotation
			Quaternion currentQ = mainCameraTransform.localRotation;

			//store the current position
			Vector3 currentPos = mainCameraTransform.localPosition;

			while (i < 1.0f) {
				//reset the position and rotation of the camera to 0,0,0
				i += Time.deltaTime * rate;

				mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, Quaternion.Euler (initialTargetEul), i);
				mainCameraTransform.localPosition = Vector3.Lerp (currentPos, initialTargetPos, i);

				yield return null;
			}

			headBobPaused = false;
		}
	}

	IEnumerator resetCameraRotation ()
	{
		float i = 0.0f;
		float rate = resetSpeed;

		//store the current rotation
		Quaternion currentQ = mainCameraTransform.localRotation;

		while (i < 1.0f) {
			//reset the rotation of the camera to 0,0,0
			i += Time.deltaTime * rate;

			mainCameraTransform.localRotation = Quaternion.Lerp (currentQ, Quaternion.Euler (initialTargetEul), i);

			yield return null;
		}
	}

	public void setDefaultState ()
	{
		if (!headBobEnabled) {
			return;
		}

		setState (defaultState);

		playerControllerManager.resetHeadBodState ();
	}

	public void setShakeInManagerList (int index)
	{
		if (!headBobEnabled) {
			return;
		}

		externalShakeManager.setShakeInManagerList (externalShakeInfoList [index], index);
	}

	public void pauseHeadBodWithDelay (float delayAmount)
	{
		if (!headBobEnabled) {
			return;
		}

		stopAllHeadbobMovements ();

		if (stopHeadBobCoroutine != null) {
			StopCoroutine (stopHeadBobCoroutine);
		}

		if (gameObject.activeInHierarchy) {
			stopHeadBobCoroutine = StartCoroutine (pauseHeadBodWithDelayCoroutine (delayAmount));
		}
	}

	IEnumerator pauseHeadBodWithDelayCoroutine (float delayAmount)
	{
		stopHeadMovementsActive = true;
	
		WaitForSeconds delay = new WaitForSeconds (delayAmount);

		yield return delay;

		stopHeadMovementsActive = false;

		yield return null;		
	}

	public void updateExternalShakeInfoList (List<externalShakeInfoListElement> newExternalShakeInfoList)
	{
		externalShakeInfoList = newExternalShakeInfoList;

		updateComponent ();
	}

	public void updateComponent ()
	{
		GKC_Utils.updateComponent (this);

		GKC_Utils.updateDirtyScene ("Update Head Bob", gameObject);
	}

	[System.Serializable]
	public class bobStates
	{
		public string Name;
		public bobTransformType bobTransformStyle;
		public viewTypes enableBobIn;
		public Vector3 posAmount;
		public Vector3 posSpeed;
		public float posSmooth;
		public Vector3 eulAmount;
		public Vector3 eulSpeed;
		public float eulSmooth;
		public bool isCurrentState;

		public bool repeatShake;
		public int numberOfRepeats;
		public float delayBetweenRepeats;

		public bool useUnscaledTime;
	}
}