/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of Penumbra Overture.
 *
 * Penumbra Overture is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Penumbra Overture is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Penumbra Overture.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "StdAfx.h"
#include "PlayerState_Misc.h"

#include "Init.h"
#include "Player.h"
#include "EffectHandler.h"
#include "GameLadder.h"


//////////////////////////////////////////////////////////////////////////
// NORMAL STATE
//////////////////////////////////////////////////////////////////////////

cPlayerState_Normal::cPlayerState_Normal(cInit *apInit,cPlayer *apPlayer) : iPlayerState(apInit,apPlayer,ePlayerState_Normal)
{
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnUpdate(float afTimeStep)
{
	if(	mpInit->mpNotebook->IsActive()==false && 
		mpInit->mpInventory->IsActive()==false &&
		mpInit->mpNumericalPanel->IsActive()==false &&
		mpInit->mpDeathMenu->IsActive()==false)
	{
		mpPlayer->ResetCrossHairPos();
	}

	/////////////////////////////////////
	// If run is down, run!!
	cInput *pInput = mpInit->mpGame->GetInput();
	if(	pInput->IsTriggerd("Run") && 
		mpPlayer->GetMoveState() == ePlayerMoveState_Walk)
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Run);
	}

	/////////////////////////////////////////////////
	// Cast ray to see if anything is picked.
	iPhysicsWorld *pPhysicsWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();
	cVector3f vStart,vEnd;

	vStart = mpPlayer->GetCamera()->GetPosition();
	vEnd = vStart + mpPlayer->GetCamera()->GetForward() * mpPlayer->GetPickRay()->mfMaxDistance;

	mpPlayer->GetPickRay()->Clear();
	pPhysicsWorld->CastRay(mpPlayer->GetPickRay(),vStart,vEnd,true,false,true);
	mpPlayer->GetPickRay()->CalculateResults();

	//Log("Picked body: %d\n",(size_t)mpPlayer->GetPickedBody());

	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();
		
		//Set cross hair state
		eCrossHairState CrossState = pEntity->GetPickCrossHairState(mpPlayer->GetPickedBody());
		
		if(	CrossState == eCrossHairState_Active || 
			(CrossState == eCrossHairState_Examine && !pEntity->GetHasBeenExamined()))
		{
			mpPlayer->SetCrossHairState(CrossState);
		}
		else
		{
			mpPlayer->SetCrossHairState(eCrossHairState_None);
		}

		//Call entity
		pEntity->PlayerPick();
	}
	else
	{
		mpPlayer->SetCrossHairState(eCrossHairState_None);
	}
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnStartInteract()
{
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();

		pEntity->PlayerInteract();
	}
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnStartExamine()
{
	//Log("Picked body: %d\n",(size_t)mpPlayer->GetPickedBody());
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();

		pEntity->PlayerExamine();
	}
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnStartRun()
{
	if( mpPlayer->GetMoveState() == ePlayerMoveState_Walk ||
		mpPlayer->GetMoveState() == ePlayerMoveState_Crouch)
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Run);
	}
	if( mpPlayer->GetMoveState() == ePlayerMoveState_Jump)
	{
		mpPlayer->SetPrevMoveState(ePlayerMoveState_Run);
	}
}
void cPlayerState_Normal::OnStopRun()
{
	if(mpPlayer->GetMoveState() == ePlayerMoveState_Run)
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
	else if(mpPlayer->GetMoveState() == ePlayerMoveState_Jump)
		mpPlayer->SetPrevMoveState(ePlayerMoveState_Walk);
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnStartCrouch()
{
	if(mpPlayer->GetMoveState() == ePlayerMoveState_Jump)return;

	if(mpInit->mpButtonHandler->GetToggleCrouch())
	{
		if(mpPlayer->GetMoveState() == ePlayerMoveState_Crouch)
			mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
		else
			mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
	else
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
}

void cPlayerState_Normal::OnStopCrouch()
{
	if( mpPlayer->GetMoveState() == ePlayerMoveState_Crouch &&
		mpInit->mpButtonHandler->GetToggleCrouch()==false)
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
	}
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::OnStartInteractMode()
{
	mpPlayer->ChangeState(ePlayerState_InteractMode);
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::EnterState(iPlayerState* apPrevState)
{
	mpPlayer->ResetCrossHairPos();
}

//-----------------------------------------------------------------------

void cPlayerState_Normal::LeaveState(iPlayerState* apNextState)
{
	//Can cause crashes!!
	//mpPlayer->GetPickRay()->mpPickedBody = NULL;
}

//-----------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
// INTERACT MODE STATE
//////////////////////////////////////////////////////////////////////////

cPlayerState_InteractMode::cPlayerState_InteractMode(cInit *apInit,cPlayer *apPlayer) : iPlayerState(apInit,apPlayer,ePlayerState_InteractMode)
{
	mvLookSpeed =0;
	mfRange = 15.0f;
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::OnUpdate(float afTimeStep)
{
	/////////////////////////////////////////////////
	// Move viewport.
	/*if(mvLookSpeed.x != 0)
	{
		mpPlayer->GetCamera()->AddYaw(mvLookSpeed.x * afTimeStep * 1.0f);
		mpPlayer->GetCharacterBody()->SetYaw(mpPlayer->GetCamera()->GetYaw());
	}
	if(mvLookSpeed.y != 0)
	{
		mpPlayer->GetCamera()->AddPitch(mvLookSpeed.y * afTimeStep * 1.0f);
	}*/

	//LogUpdate("  Casting ray\n");
	/////////////////////////////////////////////////
	// Cast ray to see if anything is picked.
	iPhysicsWorld *pPhysicsWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();
	cVector3f vStart,vEnd;

	cVector3f vDir = mpPlayer->GetCamera()->UnProject(
		mpPlayer->GetCrossHairPos(),
		mpInit->mpGame->GetGraphics()->GetLowLevel());
	vStart = mpPlayer->GetCamera()->GetPosition();
	vEnd = vStart + vDir * mpPlayer->GetPickRay()->mfMaxDistance;

	mpPlayer->GetPickRay()->Clear();
	pPhysicsWorld->CastRay(mpPlayer->GetPickRay(),vStart,vEnd,true,false,true);

	//LogUpdate("  Calc pickray results\n");	
	mpPlayer->GetPickRay()->CalculateResults();

	//LogUpdate("  Use picked body\n");	
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();

		eCrossHairState CrossState = pEntity->GetPickCrossHairState(mpPlayer->GetPickedBody());
		
		if(CrossState == eCrossHairState_None)
			mpPlayer->SetCrossHairState(eCrossHairState_Inactive);
		else
			mpPlayer->SetCrossHairState(CrossState);

		pEntity->PlayerPick();
	}
	else
	{
		mpPlayer->SetCrossHairState(eCrossHairState_Inactive);
	}
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::OnStartInteract()
{
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();

		pEntity->PlayerInteract();
	}
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::OnStartExamine()
{
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();

		pEntity->PlayerExamine();
	}
}

//-----------------------------------------------------------------------

bool cPlayerState_InteractMode::OnAddYaw(float afVal)
{
	cInput *pInput = mpInit->mpGame->GetInput();

	if(pInput->IsTriggerd("LookMode"))
	{
		mpPlayer->GetCamera()->AddYaw( -afVal * 2.0f * mpPlayer->GetLookSpeed());
		mpPlayer->GetCharacterBody()->SetYaw(mpPlayer->GetCamera()->GetYaw());
	}
	else
	{
		if(mpPlayer->AddCrossHairPos(cVector2f(afVal * 800.0f,0)))
		{
			mpPlayer->GetCamera()->AddYaw( -afVal * mpPlayer->GetLookSpeed());
			mpPlayer->GetCharacterBody()->SetYaw(mpPlayer->GetCamera()->GetYaw());
		}
		
		cVector2f vBorder = mpPlayer->GetInteractMoveBorder();
		cVector2f vPos = mpPlayer->GetCrossHairPos();
		
		if(vPos.x < vBorder.x + mfRange || vPos.x > (799 - vBorder.x - mfRange))
		{
			float fDist;
			if(vPos.x < vBorder.x + mfRange)
			{
				fDist = (vPos.x - vBorder.x);
				mvLookSpeed.x = 1 - (fDist / mfRange) * 1;
			}
			else 
			{
				fDist = ((799 - vBorder.x) - vPos.x);
				mvLookSpeed.x = (1-(fDist / mfRange)) * -1;
			}
		}
		else
		{
			mvLookSpeed.x =0;
		}
	}

	return false;
}

bool cPlayerState_InteractMode::OnAddPitch(float afVal)
{
	cInput *pInput = mpInit->mpGame->GetInput();

	if(pInput->IsTriggerd("LookMode"))
	{
		float fInvert = mpInit->mpButtonHandler->GetInvertMouseY() ? -1.0f : 1.0f;
		mpPlayer->GetCamera()->AddPitch( -afVal *2.0f*fInvert * mpPlayer->GetLookSpeed());
	}
	else
	{
		if(mpPlayer->AddCrossHairPos(cVector2f(0,afVal * 600.0f)))
		{
			mpPlayer->GetCamera()->AddPitch( -afVal * mpPlayer->GetLookSpeed());
		}

		cVector2f vBorder = mpPlayer->GetInteractMoveBorder();
		cVector2f vPos = mpPlayer->GetCrossHairPos();
		
		if(vPos.y < vBorder.y + mfRange || vPos.y > (599 - vBorder.y - mfRange))
		{
			float fDist;
			if(vPos.y < vBorder.y + mfRange)
			{
				fDist = (vPos.y - vBorder.y);
				mvLookSpeed.y = 1 - (fDist / mfRange) * 1;
			}
			else 
			{
				fDist = ((599 - vBorder.y) - vPos.y);
				mvLookSpeed.y = (1-(fDist / mfRange)) * -1;
			}
		}
		else
		{
			mvLookSpeed.y =0;
		}
	}

	return false;
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::OnStartInteractMode()
{
	mpPlayer->ChangeState(ePlayerState_Normal);
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::EnterState(iPlayerState* apPrevState)
{
	mPrevMoveState = mpPlayer->GetMoveState();

	if(mpPlayer->GetMoveState() == ePlayerMoveState_Run)
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);

	mvLookSpeed =0;
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::LeaveState(iPlayerState* apNextState)
{
	/*if(mPrevMoveState != ePlayerMoveState_Run)
	mpPlayer->ChangeMoveState(mPrevMoveState);
	else
	mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);*/

	if(apNextState->mType == ePlayerState_Normal)
		mpPlayer->ResetCrossHairPos();

	//Can cause crashes!!
	//mpPlayer->GetPickRay()->mpPickedBody = NULL;
}

//-----------------------------------------------------------------------

void cPlayerState_InteractMode::OnStartCrouch()
{
	if(mpPlayer->GetMoveState() == ePlayerMoveState_Jump)return;

	if(mpInit->mpButtonHandler->GetToggleCrouch())
	{
		if(mpPlayer->GetMoveState() == ePlayerMoveState_Crouch)
			mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
		else
			mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
	else
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
}

void cPlayerState_InteractMode::OnStopCrouch()
{
	if( mpPlayer->GetMoveState() == ePlayerMoveState_Crouch &&
		mpInit->mpButtonHandler->GetToggleCrouch()==false)
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
	}
}

//-----------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
// USE ITEM STATE
//////////////////////////////////////////////////////////////////////////

cPlayerState_UseItem::cPlayerState_UseItem(cInit *apInit,cPlayer *apPlayer) : iPlayerState(apInit,apPlayer,ePlayerState_UseItem)
{
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::OnUpdate(float afTimeStep)
{
	/////////////////////////////////////////////////
	// Cast ray to see if anything is picked.
	iPhysicsWorld *pPhysicsWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();
	cVector3f vStart,vEnd;

	cVector3f vDir = mpPlayer->GetCamera()->UnProject(
		mpPlayer->GetCrossHairPos(),
		mpInit->mpGame->GetGraphics()->GetLowLevel());
	vStart = mpPlayer->GetCamera()->GetPosition();
	vEnd = vStart + vDir * mpPlayer->GetPickRay()->mfMaxDistance;

	mpPlayer->GetPickRay()->Clear();
	pPhysicsWorld->CastRay(mpPlayer->GetPickRay(),vStart,vEnd,true,false,true);
	mpPlayer->GetPickRay()->CalculateResults();	

	iPhysicsBody *pBody = mpPlayer->GetPickedBody();
	iGameEntity *pEntity = NULL;
	if(pBody) pEntity = (iGameEntity*)pBody->GetUserData();

	if(pEntity && mpPlayer->GetPickedDist() <= pEntity->GetMaxInteractDist())
	{
		mpInit->mpPlayer->SetItemFlash(true);
	}
	else
	{
		mpInit->mpPlayer->SetItemFlash(false);
	}
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::OnStartInteract()
{
	iPhysicsBody *pBody = mpPlayer->GetPickedBody();
	iGameEntity *pEntity = NULL;
	if(pBody) pEntity = (iGameEntity*)pBody->GetUserData();

	if(pEntity && mpPlayer->GetPickedDist() <= pEntity->GetMaxExamineDist())
	{
		if(	mpPlayer->GetPickedDist() <= pEntity->GetMaxInteractDist())
		{
			iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();
			cGameItemType *pType = mpInit->mpInventory->GetItemType(mpPlayer->GetCurrentItem()->GetItemType());
			
			if(	mPrevState == ePlayerState_WeaponMelee || 
				mPrevState == ePlayerState_Throw)
			{
				mpPlayer->ChangeState(ePlayerState_Normal);
			}
			else
			{
				mpPlayer->ChangeState(mPrevState);
			}

			pType->OnUse(mpPlayer->GetCurrentItem(), pEntity);
		}
		else 
		{
			mpInit->mpEffectHandler->GetSubTitle()->Add(kTranslate("Player", "UseItemTooFar"),2.0f,true);
			return;
		}
	}
	else
	{
		if(	mPrevState == ePlayerState_WeaponMelee || 
			mPrevState == ePlayerState_Throw)
		{
			mpPlayer->ChangeState(ePlayerState_Normal);
		}
		else
		{
			mpPlayer->ChangeState(mPrevState);
		}
	}
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::OnStartExamine()
{
	if(mpPlayer->GetPickedBody())
	{
		iGameEntity *pEntity = (iGameEntity*)mpPlayer->GetPickedBody()->GetUserData();
		
		if(mpPlayer->GetPickedDist() <= pEntity->GetMaxExamineDist())
		{
			pEntity->PlayerExamine();
		}
	}
	else
	{
        if(	mPrevState == ePlayerState_WeaponMelee || 
			mPrevState == ePlayerState_Throw)
		{
			mpPlayer->ChangeState(ePlayerState_Normal);
		}
		else
		{
			mpPlayer->ChangeState(mPrevState);
		}
		
	}
}

//-----------------------------------------------------------------------

bool cPlayerState_UseItem::OnAddYaw(float afVal)
{ 
	cInput *pInput = mpInit->mpGame->GetInput();

	if(pInput->IsTriggerd("LookMode"))
	{
		mpPlayer->GetCamera()->AddYaw( -afVal * 2.0f * mpPlayer->GetLookSpeed());
		mpPlayer->GetCharacterBody()->SetYaw(mpPlayer->GetCamera()->GetYaw());
	}
	else if(mpPlayer->AddCrossHairPos(cVector2f(afVal * 800.0f,0)))
	{
		mpPlayer->GetCamera()->AddYaw( -afVal * mpPlayer->GetLookSpeed());
		mpPlayer->GetCharacterBody()->SetYaw(mpPlayer->GetCamera()->GetYaw());
	}

	return false;
}

bool cPlayerState_UseItem::OnAddPitch(float afVal)
{
	cInput *pInput = mpInit->mpGame->GetInput();

	if(pInput->IsTriggerd("LookMode"))
	{
		float fInvert = mpInit->mpButtonHandler->GetInvertMouseY() ? -1.0f : 1.0f;
		mpPlayer->GetCamera()->AddPitch( -afVal *2.0f*fInvert * mpPlayer->GetLookSpeed());
	}
	else if(mpPlayer->AddCrossHairPos(cVector2f(0,afVal * 600.0f)))
	{
		mpPlayer->GetCamera()->AddPitch( -afVal * mpPlayer->GetLookSpeed());
	}

	return false;
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::EnterState(iPlayerState* apPrevState)
{
	mPrevMoveState = mpPlayer->GetMoveState();
	mPrevState = apPrevState->mType;

	mpPlayer->SetCrossHairState(eCrossHairState_Item);
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::LeaveState(iPlayerState* apNextState)
{
	mpPlayer->SetCrossHairState(eCrossHairState_None);
}

//-----------------------------------------------------------------------

void cPlayerState_UseItem::OnStartCrouch()
{
	if(mpPlayer->GetMoveState() == ePlayerMoveState_Jump)return;

	if(mpInit->mpButtonHandler->GetToggleCrouch())
	{
		if(mpPlayer->GetMoveState() == ePlayerMoveState_Crouch)
			mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
		else
			mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
	else
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Crouch);
	}
}

void cPlayerState_UseItem::OnStopCrouch()
{
	if( mpPlayer->GetMoveState() == ePlayerMoveState_Crouch &&
		mpInit->mpButtonHandler->GetToggleCrouch()==false)
	{
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
	}
}

//-----------------------------------------------------------------------

bool cPlayerState_UseItem::OnStartInventory()
{
	mpPlayer->ChangeState(mPrevState);
	return true;
}

//-----------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
// MESSAGE STATE
//////////////////////////////////////////////////////////////////////////

cPlayerState_Message::cPlayerState_Message(cInit *apInit,cPlayer *apPlayer) : iPlayerState(apInit,apPlayer,ePlayerState_Message)
{
}

//-----------------------------------------------------------------------


void cPlayerState_Message::OnUpdate(float afTimeStep)
{	
}

//-----------------------------------------------------------------------

bool cPlayerState_Message::OnJump()
{ 
	return false;
}

//-----------------------------------------------------------------------

void cPlayerState_Message::OnStartInteract()
{
	mpInit->mpGameMessageHandler->ShowNext();
}

void cPlayerState_Message::OnStopInteract()
{
}

//-----------------------------------------------------------------------

void cPlayerState_Message::OnStartExamine()
{
	mpInit->mpGameMessageHandler->ShowNext();
}

//-----------------------------------------------------------------------

bool cPlayerState_Message::OnMoveForwards(float afMul, float afTimeStep){	return false;}
bool cPlayerState_Message::OnMoveSideways(float afMul, float afTimeStep){	return false;}

//-----------------------------------------------------------------------

bool cPlayerState_Message::OnAddYaw(float afVal){ return false;}
bool cPlayerState_Message::OnAddPitch(float afVal){return false;}

//-----------------------------------------------------------------------

void cPlayerState_Message::EnterState(iPlayerState* apPrevState)
{
	//Change move state so the player is still
	mPrevMoveState = mpPlayer->GetMoveState();
	//mpPlayer->ChangeMoveState(ePlayerMoveState_Still);

	mpPlayer->SetCrossHairState(eCrossHairState_None);
}

//-----------------------------------------------------------------------

void cPlayerState_Message::LeaveState(iPlayerState* apNextState)
{
	if(mPrevMoveState != ePlayerMoveState_Run && mPrevMoveState !=ePlayerMoveState_Jump)
		mpPlayer->ChangeMoveState(mPrevMoveState);
	else
		mpPlayer->ChangeMoveState(ePlayerMoveState_Walk);
}

//-----------------------------------------------------------------------

bool cPlayerState_Message::OnStartInventory()
{
	return false;
}

//-----------------------------------------------------------------------

bool cPlayerState_Message::OnStartInventoryShortCut(int alNum)
{ 
	return false;
}
//-----------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
// CLIMB STATE
//////////////////////////////////////////////////////////////////////////

cPlayerState_Climb::cPlayerState_Climb(cInit *apInit,cPlayer *apPlayer) : iPlayerState(apInit,apPlayer,ePlayerState_Climb)
{
	mpLadder = NULL;

	mfUpSpeed = mpInit->mpGameConfig->GetFloat("Movement_Climb","UpSpeed",0);
	mfDownSpeed = mpInit->mpGameConfig->GetFloat("Movement_Climb","DownSpeed",0);

	mfStepLength = mpInit->mpGameConfig->GetFloat("Movement_Climb","StepLength",0);

	mfStepCount =0;

	mlState =0;
}

//-----------------------------------------------------------------------

void cPlayerState_Climb::PlaySound(const tString &asSound)
{
	if(asSound=="") return;

	iCharacterBody *pCharBody = mpPlayer->GetCharacterBody();
	cWorld3D *pWorld = mpInit->mpGame->GetScene()->GetWorld3D();

	cSoundEntity *pSound = pWorld->CreateSoundEntity("LadderStep",asSound,true);
	if(pSound) pSound->SetPosition(pCharBody->GetPosition());
}

//-----------------------------------------------------------------------

void cPlayerState_Climb::EnterState(iPlayerState* apPrevState)
{
	mpPlayer->SetCrossHairState(eCrossHairState_None);

	mvPrevPitchLimits = mpPlayer->GetCamera()->GetPitchLimits();
	
	mlState =0;
	mpPlayer->GetCharacterBody()->SetGravityActive(false);
	mpPlayer->GetCharacterBody()->SetTestCollision(false);

	mvGoalPos = mvStartPosition;
	mvGoalRot.x = 0;
	mvGoalRot.y = mpLadder->GetStartRotation().y;

	//Different time if you are above the ladder.
    float fTime = 0.5f;
	if(mpPlayer->GetCharacterBody()->GetPosition().y > mpLadder->GetMaxY()) fTime = 1.2f;
	
	cVector3f vStartRot;
	vStartRot.x = mpPlayer->GetCamera()->GetPitch();
	vStartRot.y = mpPlayer->GetCamera()->GetYaw();

	mvPosAdd = (mvGoalPos - mpPlayer->GetCharacterBody()->GetPosition()) / fTime;

	mvRotAdd.x = cMath::GetAngleDistance(vStartRot.x, mvGoalRot.x,k2Pif) / fTime;
	mvRotAdd.y = cMath::GetAngleDistance(vStartRot.y, mvGoalRot.y,k2Pif) / fTime;

	mvCharPosition = mpPlayer->GetCharacterBody()->GetPosition();

	mfTimeCount = fTime;

	mfStepCount =0;

	mbPlayedSound = false;

	//Play Sound
	PlaySound(mpLadder->GetAttachSound());
}

//-----------------------------------------------------------------------

void cPlayerState_Climb::LeaveState(iPlayerState* apNextState)
{
	mpPlayer->SetCrossHairState(eCrossHairState_None);

	mpPlayer->GetCharacterBody()->SetGravityActive(true);
	
	mpPlayer->GetCamera()->SetPitchLimits(mvPrevPitchLimits);
	mpPlayer->GetCamera()->SetYawLimits(cVector2f(0, 0));
}


//-----------------------------------------------------------------------

void cPlayerState_Climb::OnUpdate(float afTimeStep)
{
	iCharacterBody *pCharBody = mpPlayer->GetCharacterBody();
	cCamera3D *pCam = mpPlayer->GetCamera();

	//////////////////////////////////
	// Attach To Ladder
	if(mlState ==0)
	{
		mfTimeCount -= afTimeStep;
		
		mvCharPosition += mvPosAdd*afTimeStep;
		pCharBody->SetPosition(mvCharPosition);
		mvCharPosition = pCharBody->GetPosition();

		pCam->AddPitch(mvRotAdd.x *afTimeStep);
		pCam->AddYaw(mvRotAdd.y *afTimeStep);
		pCharBody->SetYaw(pCam->GetYaw());
		
		if(mfTimeCount<=0)
		{
			mpPlayer->GetCharacterBody()->SetTestCollision(true);
			
			////////////////////////////
			//Set turn head limits
			cVector2f vMaxHeadLimits = cVector2f(cMath::ToRad(120),cMath::ToRad(79));
			cVector2f vMinHeadLimits = cVector2f(cMath::ToRad(-120),cMath::ToRad(-60));
			float fXmax = pCam->GetYaw() + vMaxHeadLimits.x;
			float fYmax = pCam->GetPitch() + vMaxHeadLimits.y;

			float fXmin = pCam->GetYaw() + vMinHeadLimits.x;
			float fYmin = pCam->GetPitch() + vMinHeadLimits.y;

			pCam->SetPitchLimits(cVector2f(fYmax, fYmin));
			pCam->SetYawLimits(cVector2f(fXmax, fXmin));

			mlState++;
		}
	}
	//////////////////////////////////
	// Move On Ladder
	else if(mlState == 1)
	{

	}
	//////////////////////////////////
	// On the top of the ladder
	else if(mlState == 2)
	{
		mfLeaveAtTopCount -= afTimeStep;
		pCharBody->Move(eCharDir_Forward,1,afTimeStep);

		if(pCharBody->IsOnGround())
		{
			mfLeaveAtTopCount -= afTimeStep;
		}
		
		if(mfLeaveAtTopCount <=0)
		{
			mpPlayer->ChangeState(ePlayerState_Normal);
		}
	}

}

//-----------------------------------------------------------------------

void cPlayerState_Climb::OnStartInteract()
{
	if(mlState!=0)
		mpPlayer->ChangeState(ePlayerState_Normal);
}

//-----------------------------------------------------------------------

void cPlayerState_Climb::OnStartExamine()
{
	if(mlState!=0)
		mpPlayer->ChangeState(ePlayerState_Normal);
}

//-----------------------------------------------------------------------

bool cPlayerState_Climb::OnAddYaw(float afVal)
{ 
	if(mlState!=0)
		mpPlayer->GetCamera()->AddYaw( -afVal * mpPlayer->GetLookSpeed());
	
	return false;
}

bool cPlayerState_Climb::OnAddPitch(float afVal)
{
	//if(mlState!=0)
	//	mpPlayer->GetCamera()->AddPitch( -afVal * mpPlayer->GetLookSpeed());
	if(mlState==0) 
		return false;
	else
		return true;
}

//-----------------------------------------------------------------------

bool cPlayerState_Climb::OnMoveForwards(float afMul, float afTimeStep)
{
	if(mlState==0 || mlState==2) return false;

	iCharacterBody *pCharBody = mpPlayer->GetCharacterBody();
	iPhysicsWorld *pWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();

	mvCharPosition = pCharBody->GetPosition();
	if(afMul > 0)
	{
		mvCharPosition.y += afMul*mfUpSpeed*afTimeStep;
		
		if(mfStepCount<0)mfStepCount=0;
	}
	else if(afMul < 0)
	{
		mvCharPosition.y += afMul*mfDownSpeed*afTimeStep;

		if(mfStepCount>0)mfStepCount=0;
	}
	else
	{
		if(!mbPlayedSound)
		{
			if(mfStepCount>0) PlaySound(mpLadder->GetClimbUpSound());
			if(mfStepCount<0) PlaySound(mpLadder->GetClimbDownSound());
		}

		mfStepCount =0;
		mbPlayedSound = false;
	}

	//Check collision
	cMatrixf mtxPos = cMath::MatrixTranslate(mvCharPosition);
	cVector3f vNewPos;
	pWorld->CheckShapeWorldCollision(&vNewPos,pCharBody->GetShape(),mtxPos,
										pCharBody->GetBody(),false,true,NULL,true);
	if(vNewPos != mtxPos.GetTranslation())
	{
		return false;	
	}
	
	if(afMul > 0)
	{
		mfStepCount += afMul*mfUpSpeed*afTimeStep;
		if(mfStepCount >= mfStepLength)
		{
			mfStepCount =0;
			PlaySound(mpLadder->GetClimbUpSound());
			mbPlayedSound = true;
		}
	}
	else if(afMul < 0)
	{
		mfStepCount += afMul*mfDownSpeed*afTimeStep;
		if(mfStepCount <= -mfStepLength)
		{
			mfStepCount =0;
			PlaySound(mpLadder->GetClimbDownSound());
			mbPlayedSound = true;
		}
	}
	else
	{

	}

	pCharBody->SetPosition(mvCharPosition);

	if((mvCharPosition.y - pCharBody->GetSize().y*0.5f) > mpLadder->GetMaxY())
	{
		//mpPlayer->ChangeState(ePlayerState_Normal);
		mlState = 2;
		mfLeaveAtTopCount = 2;
		mpPlayer->GetCharacterBody()->SetGravityActive(true);
	}
	else if((mvCharPosition.y - pCharBody->GetSize().y/2) < mpLadder->GetMinY())
	{
		mpPlayer->ChangeState(ePlayerState_Normal);
	}
	
	return false;
}
bool cPlayerState_Climb::OnMoveSideways(float afMul, float afTimeStep)
{
	iCharacterBody *pCharBody = mpPlayer->GetCharacterBody();
	


	return false;
}

//-----------------------------------------------------------------------

void cPlayerState_Climb::OnStartCrouch()
{
}

void cPlayerState_Climb::OnStopCrouch()
{
	
}

//-----------------------------------------------------------------------

bool cPlayerState_Climb::OnJump()
{
	mpPlayer->ChangeState(ePlayerState_Normal);
	return true;
}

//-----------------------------------------------------------------------

bool cPlayerState_Climb::OnStartInventory()
{
	return false;
}

//-----------------------------------------------------------------------