RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
FC1/CryGame/XPlayer.cpp
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

7629 lines
194 KiB
C++
Raw Permalink Blame History

//////////////////////////////////////////////////////////////////////
//
// Game Source Code
//
// File: XEntityPlayer.cpp
// Description: Entity player class.
//
// History:
// - August 16, 2001: Created by Alberto Demichelis
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "XPlayer.h"
#include "WeaponClass.h"
#include "XVehicle.h"
#include "WeaponSystemEx.h"
#include "ScriptObjectStream.h"
#include <IEntitySystem.h>
#include <IAISystem.h>
#include <IAgent.h>
// remove this
//#include <IAISystem.h>
#include <ISound.h>
// <<FIXME>> look above
#include "I3DEngine.h"
#include <crycharanimationparams.h>
// to use _isnan()
#include <float.h>
//! Minimal time before player can be alive again.
#define PLAYER_RESPAWN_TIME 1.0f
//! Minimal time before player can be respawned.
#define PLAYER_DEATH_TIME 1.0f
//! Minimal time before player can change weapon.
#define PLAYER_WEAPON_CHANGE_TIME 0.1f
/*
static int64 g_nValidateHeapCounter = 0;
// central place to turn on/off the heap validation
inline void ValidateHeap()
{
#if defined(WIN64) && defined(_DEBUG) // on AMD64, heap validation is extremely slow
if (g_nValidateHeapCounter > 1000*1000 || !((++g_nValidateHeapCounter)&0xFF))
#endif
assert(IsHeapValid());
}
*/
//-------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------
bool CheckIfNAN( const Vec3d& vPos )
{
if (_isnan(vPos.x) || _isnan(vPos.y) || _isnan(vPos.z))
{
GameWarning( "NotANumber tried to be set for position of CPlayer" );
return true;
}
return false;
}
//////////////////////////////////////////////////////////////////////////////////////////////
//! CPlayer implemenation.
///////////////////////////////////////////////
CPlayer::CPlayer(CXGame *pGame) :
m_ssoHitPosVec(pGame->GetScriptSystem()),
m_ssoHitDirVec(pGame->GetScriptSystem()),
m_ssoHitNormVec(pGame->GetScriptSystem()),
m_vColor(1,0,1),
m_vShake(0,0,0),
m_pDynLight( NULL ),
m_vCharacterAngles( 0,0,0 ),
m_JumpStage(0),
m_JumpAniLenght(0),
m_bInertiaOverride(false),
m_bIsFish(false),
m_AutoCenter(0),
m_fNoChangeangleTime(0.0f),
m_fProcessTime(0.0f),
m_fCameraTime(0.0f),
m_vEyeAnglesBaseOffset(0,0,0),
m_bLastDeltaEyeVehicle( false ),
m_vSafeAngAtMountedWeapon(0,0,0),
m_MntWeaponStandTime(0.0f),
m_vProneEnvNormal(0,0,0),
m_vCurEntAngle(0,0,0),
m_bGrenadeAnimation(false)
{
m_pLastUsedCharacter = NULL;
m_weaponPositionState = WEAPON_POS_UNDEFINED;
m_vEyePos.Set(0,0,0);
m_bWeaponJustFired = false;
m_pLightTarget = 0;
float tm=.3f;
m_pBoneHead = NULL;
m_pBoneNeck = NULL;
m_pBoneSpine = NULL;
m_pBoneSpine1 = NULL;
m_pBoneSpine2 = NULL;
m_pGame = pGame;
m_pTimer = pGame->GetSystem()->GetITimer();
m_pScriptSystem = pGame->GetScriptSystem();
m_p3DEngine = pGame->GetSystem()->GetI3DEngine();
m_pPhysicalWorld=pGame->GetSystem()->GetIPhysicalWorld();
m_stmScriptStream.Create(m_pScriptSystem);
m_nSelectedWeaponID = -1;
m_PrevWeaponID = -1;
ZeroStruct( m_stats );
m_stats.weapon = -1;
m_stats.inVehicleState = PVS_OUT;
// m_stats.inVehicleActive = false;
ZeroStruct( m_walkParams );
// Init Walk params.
m_walkParams.runRoll = 0.2f;
m_walkParams.runPitch = 0.5f;
m_walkParams.curLength = 0.0f;
m_walkParams.stepLength = 3.5f;
m_walkParams.flyCoeff = 15.0f;
m_walkParams.prevF = 0.0f;
m_walkParams.weaponCycle = 0.006f;
m_walkParams.weaponCycleSpeed = 8;
m_walkParams.swayAmp=0.0f;
m_walkParams.swayFreq=0.0f;
m_walkParams.swayOfs=0.0f;
m_walkParams.shakeDegree=0.0f;
m_walkParams.leanAmount = 0.0f;
m_walkParams.leanStart = 0.0f;
m_walkParams.leanEnd = 0.0f;
m_walkParams.leanFactor = 0.0f;
m_walkParams.fWaterPitchPhase=0.0f;
m_walkParams.fWaterRollPhase=0.0f;
m_walkParams.fLeanTarget=0;
m_walkParams.fCurrLean=0;
m_pVehicle = NULL;
//@FIXME Give player some life
m_stats.health = 100;
m_stats.armor = 0;
m_stats.maxHealth = 100;
m_stats.maxArmor = 100;
m_stats.legHealth = 100;
m_stats.maxLegHealth = 100;
m_stats.armHealth = 100;
m_stats.maxArmHealth = 100;
m_stats.dmgFireAccuracy = 100;
m_stats.dmgSpeedCoeff = 100;
m_stats.FiringType = m_stats.LastFiringType = eNotFiring;
m_stats.cancelFireFlag = false;
m_stats.weapon = 0;
m_stats.score=0;
m_stats.deaths=0;
m_stats.firing_grenade = false;
m_stats.firemode = 0;
m_stats.canfire = true;
m_stats.crosshairOnScreen = true;
m_stats.fSpeedScale = 1.0f;
m_stats.climbing = false;
m_stats.holding_breath=false;
m_stats.concentration=false;
m_stats.firing=false;
m_stats.reloading=false;
m_stats.weapon_busy=0;
m_stats.grenadetype = 1;
m_stats.numofgrenades = 0;
m_stats.drawfpweapon=true;
m_stats.aiming=false;
m_stats.fire_rate_busy=false;
m_stats.fVel=1.0f;
m_stats.melee_distance = 0.0f;
m_stats.has_flashlight = false;
m_stats.has_binoculars = false;
m_stats.fInWater = 0.0f;
m_stats.swimTime = 0.0f;
m_staminaClient = m_stats.stamina = 100;
// m_breathClient = m_stats.breath = 100;
SetDimNormal();
SetDimCrouch();
SetDimProne();
SetDimStealth();
m_currDimensions = eDimNone;
ZeroStruct( m_AngleLimitBase );
m_AngleLimitVFlag = false;
m_AngleLimitHFlag = false;
m_fGravityOverride=1E10;
m_pScriptObject=NULL;
m_pRedirected = NULL;
m_nStanding = -1;
m_nMode = -1;
m_nStrafe = -1;
m_nForward = -1;
m_bFirstPerson = false;
m_bFirstPersonLoaded = true;
m_bLightOn = false;
m_LegAngle = 0;
m_LegAngleDesired = 0;
m_LegDeltaAngle = 0;
m_LegAngleIdleTime = 0;
m_LegADeltaLimit = 110;
m_LegADeltaLimitForce = 120;
m_LegAIdleTimeLimit = 2;
m_LegAngleVelMoving = 350;
m_LegAngleVelTimed = 320;
m_LegAngleVel = m_LegAngleVelMoving;
m_FlyTime = 0;
m_NotRunTime = 0;
m_RunSpeed = 4;
m_WalkSpeed = 3;
m_CrouchSpeed = 2;
m_ProneSpeed = 1;
m_SwimSpeed = 3.5f;
m_Sprinting = false;
m_CameraMode=PCM_OUTVEHICLE;
m_bCameraTransitionOnlyZ = false;
// SetAnimationRefSpeed();
SetAnimationRefSpeedRun( );
SetAnimationRefSpeedWalk( );
SetAnimationRefSpeedXWalk( );
SetAnimationRefSpeedCrouch( );
m_JumpForce = 4.0f;
m_LeanDegree = 9.0f;
m_Dynamics.gravity = 9.81f;
m_Dynamics.swimming_gravity = 2.0f;
m_Dynamics.inertia = 10.0f;
m_Dynamics.swimming_inertia = 1.0f;
m_Dynamics.air_control = 0.1f;
m_CurStance = eNone;
m_PrevStance = m_CurStance;
m_aimLook = true;
m_bIsAI = false;
//m_PrevAniName = "NoAni";
m_AnimationSystemEnabled = 1;
m_bAlwaysRun = true;
m_bSwimming=false;
m_bEyesInWater=false; // not in water at the beginning
m_stats.underwater = 0.0f;
// standing jump
m_JumpDist[0] = 3.0f;
m_JumpHeight[0] = 1.3f;
// walk jump
m_JumpDist[1] = 3.0f;
m_JumpHeight[1] = 1.3f;
// run jump
m_JumpDist[2] = 4.0f;
m_JumpHeight[2] = 1.3f;
m_fRecoilXDelta=0;
m_fRecoilZDelta=0;
m_fRecoilXUp=0;
m_fRecoilZUp=0;
m_fRecoilX=0;
m_fRecoilZ=0;
m_fAccuracy=0;
m_fAccuracyMod=0;
memset(m_vWeaponSlots,0,sizeof(m_vWeaponSlots));
m_stats.lock_weapon=false;
m_fHeatBodyFadingSpeed=m_fHeatWeaponsFadingSpeed=-1; // switch immediately
m_fHeatBodyDesiredValue=m_fHeatWeaponsDesiredValue=-1; // not set
m_fHeatBodyCurrValue=m_fHeatWeaponsCurrValue=0;
m_LastUsed = m_vBlindingList.end();
m_RunSpeedScale = 3.63f;
m_CrouchSpeedScale = .8f;
m_ProneSpeedScale = .5f;
m_XRunSpeedScale = 1.5f; // stealthth
m_XWalkSpeedScale = .81f;
m_RRunSpeedScale = 3.63f; // relaxed
m_RWalkSpeedScale = .81f;
m_stats.bIsBlinded = false;
m_stats.curBlindingValue = 0.0f;
m_pMountedWeapon = NULL;
m_stats.bIsLimping = false;
m_pPrevDmgCollider = 0;
m_timeDmgCollision = 0;
m_prevCollDamage = 0;
m_sPrevAniName = "";
m_sPrevAniNameLayer1 = "";
m_sPrevAniNameLayer2 = "";
m_fShootAniLength = 0.0f;
SetBlendTime("aidle_jump_air", .2f);
m_fDeathTimer = -1;
m_stats.onLadder = false;
m_RunningTime = m_RunningTimeClient = 0;
m_WalkingTime = m_WalkingTimeClient = 0;
m_NotRunTime = m_NotRunTimeClient = 0;
m_JTWalk = .2f;
m_JTRun = .4f;
m_fLastCamUpdateTime = 0;
m_vDeltaCamAngles.Set(0,0,0);
m_vDeltaCamPos.Set(0,0,0);
m_vPrevCamAngles.Set(0,0,0);
m_vPrevCamPos.Set(0,0,0);
m_vWeaponAngles.Set(0,0,0);
m_AniSpeedXRun[0] = -1.0f;
m_AniSpeedXRun[1] = -1.0f;
m_AniSpeedXRun[2] = -1.0f;
m_sVehicleEyeHelper.clear();
m_bWaitForFireRelease = false;
m_vLastMotionDir.Set(0,0,0);
m_input_accel = 0;//default is no input acceleration.
m_input_stop_accel = 0;
m_input_accel_indoor = 0;//default is no input acceleration.
m_input_stop_accel_indoor = 0;
m_bWriteOccured = false;
m_bStayCrouch = false;
m_SynchedRandomSeed.SetParent(this);
m_vLadderPosition.Set(0,0,0);
m_vLadderAngles.Set(0,0,0);
m_vHeadAngles.Set(0,0,0);
m_AreaUser.SetGame( pGame );
m_AreaUser.SetEntity( GetEntity() );
m_fLastProneTime = 0;
m_pLastAiming=NULL;
}
///////////////////////////////////////////////
CPlayer::~CPlayer()
{
SwitchFlashLight( false );
ListOfPlayers::iterator self = std::find(m_pGame->m_DeadPlayers.begin(), m_pGame->m_DeadPlayers.end(), this);
if(self!=m_pGame->m_DeadPlayers.end())
m_pGame->m_DeadPlayers.erase(self);
m_pGame->m_XAreaMgr.ExitAllAreas( m_AreaUser );
// remove shared weapon
GetEntity()->GetCharInterface()->SetCharacter(1, 0);
// if(m_pSelectedWeapon){
// m_pSelectedWeapon->GetEntity()->DrawCharacter(0,0);
// }
SetEntity(0);
if(m_pScriptObject)
m_pScriptObject->Release();
m_pScriptObject=NULL;
m_mapPlayerWeapons.clear();
if (m_pDynLight)
{
delete m_pDynLight;
m_pDynLight=NULL;
}
}
///////////////////////////////////////////////
/*! Initializes the player-container.
@return true if succeeded, false otherwise
*/
bool CPlayer::Init()
{
//@FIXME probably should be created in script.
m_pGame->m_pLog->Log("XEntityPlayer %d initialised\n", m_pEntity->GetId() );
m_pEntity->GetScriptObject()->SetValue("type", "Player");
IAIObject *pObject = m_pEntity->GetAI();
if (pObject)
{
IPuppet *pPuppet;
if (pObject->CanBeConvertedTo(AIOBJECT_PUPPET, (void **) &pPuppet))
m_bIsAI = true;
}
if (!m_bIsAI)
// if(m_pEntity->GetAI()->GetType() == AIOBJECT_PLAYER)
m_pEntity->SetNeedUpdate(true);
// else
// m_pEntity->SetDestroyable( true );
/*
// if (!m_bIsAI)
if(m_pEntity->GetAI()->GetType() == AIOBJECT_PLAYER)
{
m_pEntity->SetNeedUpdate(true);
m_pGame->p_speed_run->Set(m_RunSpeed);
m_pGame->p_speed_walk->Set(m_WalkSpeed);
m_pGame->p_speed_crouch->Set(m_CrouchSpeed);
m_pGame->p_speed_prone->Set(m_ProneSpeed);
}
*/
// create the camera
// <<FIXME>> create only for client which do the rendering
ICryCharInstance* pCharacter = m_pEntity->GetCharInterface()->GetCharacter(0);
if (pCharacter)
{
pCharacter->EnableLastIdleAnimationRestart(0,true);
if (m_bIsAI)
pCharacter->EnableLastIdleAnimationRestart(3,true);
}
//////////////////////////////////////////////////////////////////////////
// Initialize Player Camera Fov.
//////////////////////////////////////////////////////////////////////////
IEntityCamera *pEntCamera = m_pGame->GetSystem()->GetIEntitySystem()->CreateEntityCamera();
m_pEntity->SetCamera(pEntCamera);
int rw = m_pGame->GetSystem()->GetIRenderer()->GetWidth();
int rh = m_pGame->GetSystem()->GetIRenderer()->GetHeight();
float fFOV = DEG2RAD(90.0f); // Initialize with 90 degree fov.
pEntCamera->SetFov(fFOV,rw,rh);
pEntCamera->GetCamera().Init(rw,rh,fFOV);
pEntCamera->GetCamera().Update();
//////////////////////////////////////////////////////////////////////////
Vec3d default_offset;
default_offset(0,m_pGame->cl_ThirdPersonRange->GetFVal(),4);
m_pEntity->GetCamera()->SetCameraOffset(default_offset);
// [kirill] need this to use only z component of entity angles (same as for drawing)
// when calculating BBox
GetEntity()->SetFlags( ETY_FLAG_CALCBBOX_ZROTATE );
GoStand();
return true;
}
/*!Called by the entity when the angles are changed.
This notification is used to force the orientation of the player.
*/
void CPlayer::OnSetAngles( const Vec3d &ang )
{
// say to Vladimir if you want to comment this code again
// if(m_pGame->m_pClient && !m_pVehicle)
//[kirill] need it in cars for autocentering
if(m_pGame->m_pClient)
{
// if(m_pGame->m_pClient->GetPlayerId()==m_pEntity->GetId() || m_pGame->m_pClient->m_bLocalHost)
if(m_pGame->m_pClient->GetPlayerId()==m_pEntity->GetId())
m_pGame->m_pClient->m_PlayerProcessingCmd.SetDeltaAngles(ang);
}
}
// set a certain shader for the current selected weapon
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetHeatVisionValues(int dwFlags,const char *szName,float fValue,float fFadingValue)
{
if (dwFlags & BITMASK_WEAPON)
{
m_fHeatWeaponsDesiredValue=fValue;
m_fHeatWeaponsFadingSpeed=fFadingValue;
}
if (dwFlags & BITMASK_PLAYER)
{
m_fHeatBodyDesiredValue=fValue;
m_fHeatBodyFadingSpeed=fFadingValue;
}
}
/*! Initializes the weapon-information stored in the player-container.
*/
void CPlayer::InitWeapons()
{
// ValidateHeap();
IEntitySystem *pEntitySystem = (IEntitySystem *) m_pGame->GetSystem()->GetIEntitySystem();
SetWeapon(-1);
m_mapPlayerWeapons.clear();
for (int i=0;i<PLAYER_MAX_WEAPONS;i++)
m_vWeaponSlots[i]=0;
// init weapon instances
unsigned int weaponCount = GetGame()->GetWeaponSystemEx()->GetNumWeaponClasses();
for (unsigned int i = 0; i < weaponCount; ++i)
{
CWeaponClass *pWC = GetGame()->GetWeaponSystemEx()->GetWeaponClass(i);
assert(pWC);
WeaponInfo wi;
wi.fireTime = m_pTimer->GetCurrTime();
wi.fireLastShot = 0;
wi.reloading = false;
wi.iFireMode = 0;
assert(m_mapPlayerWeapons.count(pWC->GetID())==0); // otherwise we produce memory leaks
wi.owns = false;
m_mapPlayerWeapons[pWC->GetID()] = wi;
}
}
void CPlayer::SelectFirstWeapon()
{
if (!m_pGame->IsServer())
return;
int slot=0;
while(slot<PLAYER_MAX_WEAPONS && m_vWeaponSlots[slot]==0)
slot++;
if(m_vWeaponSlots[slot]!=0)
SelectWeapon(m_vWeaponSlots[slot]);
}
///////////////////////////////////////////////
/*! Updates the player torso/head angles. Should be called every frame. CAlled from Update()
*/
//////////////////////////////////////////////////////////////////////////////
//UPDATE HEAD ROTATION
void CPlayer::UpdateRotateHead()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
m_LegAngleVelMoving = m_pGame->pa_leg_velmoving->GetFVal();
m_LegAngleVelTimed = m_pGame->pa_leg_velidle->GetFVal();
m_LegAIdleTimeLimit = m_pGame->pa_leg_idletime->GetFVal();
if( !m_bRotateHead )
{
if( m_pEntity->GetCurrentAnimation(0, 3)>=0
|| m_pEntity->IsBound()
|| m_stats.onLadder // no rotatehead on ladders
// || m_stats.landing || m_stats.flying // no rotatehead while jumping
)
m_LegNeedsForceAngle = true;
m_LegRotation = false;
return;
}
Vec3d angles = GetActualAngles();
if(m_LegNeedsForceAngle || m_pMountedWeapon) // some animation was played - need to reset all rotations
{
m_LegAngle = angles.z;
m_LegAngleDesired = m_LegAngle;
m_LegDeltaAngle = 0.0f;
m_LegNeedsForceAngle = false;
}
m_LegRotation = true;
float legDeltaAngle = m_LegAngleVel*m_pTimer->GetFrameTime();
float legDiff = Ffabs(Snap_s180(m_LegAngleDesired - m_LegAngle));
if(legDiff<legDeltaAngle)
m_LegAngle = m_LegAngleDesired;
else
{
if(legDiff>160)
{
if(Ffabs(Snap_s180(m_LegAngle+legDeltaAngle-angles.z))<Ffabs(Snap_s180(m_LegAngle-legDeltaAngle-angles.z)))
m_LegAngle += legDeltaAngle;
else
m_LegAngle -= legDeltaAngle;
}
else
m_LegAngle += (Snap_s180(m_LegAngleDesired-m_LegAngle))>0?m_LegAngleVel*m_pTimer->GetFrameTime():-m_LegAngleVel*m_pTimer->GetFrameTime();
m_LegAngle = Snap_s180(m_LegAngle);
}
if( m_stats.moving )
{
m_LegDeltaAngle = Snap_s180(m_LegAngle - angles.z);
/*
if(Ffabs(m_LegDeltaAngle) > m_LegADeltaLimitForce)
{
if(m_LegDeltaAngle<0)
{
m_LegAngleDesired = Snap180(angles.z-m_LegADeltaLimit);
m_LegAngle = m_LegAngleDesired;
}
else
{
m_LegAngleDesired = Snap180(angles.z+m_LegADeltaLimit);
m_LegAngle = m_LegAngleDesired;
}
}
*/
return;
}
if( m_bRotateHead && IsAlive())
{
float prevDelta = m_LegDeltaAngle;
m_LegDeltaAngle = Snap_s180(m_LegAngle - angles.z);
if(Ffabs(m_LegDeltaAngle) > m_LegADeltaLimit)
{
if(m_LegDeltaAngle<0)
{
m_LegAngleDesired = Snap_s180(angles.z-m_LegADeltaLimit);
}
else
{
m_LegAngleDesired = Snap_s180(angles.z+m_LegADeltaLimit);
}
m_LegAngleVel = m_LegAngleVelMoving;
if(Ffabs(m_LegDeltaAngle) > m_LegADeltaLimit*2 && !m_bIsAI) // to prevent player's from twisting legs/upper_body
m_LegAngleVel *= 100;
}
if(Ffabs(m_LegDeltaAngle) > m_LegADeltaLimit-5 )
{
m_LegAngleIdleTime += m_pTimer->GetFrameTime();
if( m_LegAngleIdleTime>m_LegAIdleTimeLimit )
{
m_LegAngleDesired = angles.z;
m_LegAngleVel = m_LegAngleVelTimed;
}
}
else
m_LegAngleIdleTime = 0;
/*
// if less than 5 degrees - don't autorotate.
if(Ffabs(prevDelta)< 5 )
prevDelta = 0;
if(m_LegDeltaAngle!=0 && Ffabs(m_LegDeltaAngle - prevDelta)<1.0f)
{
m_LegAngleIdleTime += m_pTimer->GetFrameTime();
if( m_LegAngleIdleTime>m_LegAIdleTimeLimit )
{
m_LegAngleDesired = angles.z;
m_LegAngleVel = m_LegAngleVelTimed;
}
}
else
m_LegAngleIdleTime = 0;
*/
}
else
{
m_LegAngle = angles.z;
m_LegAngleDesired = m_LegAngle;
m_LegDeltaAngle = 0.0f;
}
}
///////////////////////////////////////////////
/*! Updates the player-container. Should be called every frame.
*/
void CPlayer::UpdateDead( SPlayerUpdateContext &ctx )
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
if (m_bIsAI && m_fDeathTimer>=0.0f )
{
m_fDeathTimer -= m_pTimer->GetFrameTime();
if(m_fDeathTimer <= 0.0f)
{
m_fDeathTimer = 0.0f;
int nRendererFrameID = m_pGame->GetSystem()->GetIRenderer()->GetFrameID();
if( nRendererFrameID - m_pEntity->GetDrawFrame() > 60*2 )
{
m_pEntity->Remove();
return;
}
// restart the timer
m_fDeathTimer=m_pGame->p_deathtime->GetFVal();
}
}
// don't check/update areas for AI's
if( !m_bIsAI )
{
// m_pGame->m_XAreaMgr.UpdatePlayer( this );
//////////////////////////////////////////////////////////////////////////////
//UPDATE THE CAMERA
SetEyePosDead();
UpdateCamera();
}
// UpdateDrawAngles( );
if (m_bFirstPerson)
{
m_pEntity->SetRegisterInSectors(false);
UpdateFirstPersonView();
}
else
{
m_pEntity->SetRegisterInSectors(true);
UpdateThirdPersonView();
}
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::AutoAiming()
{
const char *pszBoneName="Bip01 Spine1\0";
//const char *pszBoneName=NULL;
Vec3 Center;
Vec3 bestPoint3D;
float fBestDist=99999;
IEntity *pBest=NULL;
IEntityItPtr It=m_pGame->GetSystem()->GetIEntitySystem()->GetEntityInFrustrumIterator( true );
CCamera Cam=m_pGame->GetSystem()->GetViewCamera();
IEntity *pEnt;
//ray_hit RayHit;
IEntity *pLocal=m_pGame->GetMyPlayer();
Vec3 m_vWpnPos=pLocal->GetPos();
while (pEnt=It->Next())
{
if (pEnt==m_pEntity)
continue;
if (!pEnt->IsTrackable())
continue;
CPlayer *pPlayer;
if( pEnt->GetContainer() &&
pEnt->GetContainer()->QueryContainerInterface(CIT_IPLAYER,(void**)&pPlayer) &&
!pPlayer->IsAlive() )
continue;
IPhysicalEntity *pPE=pEnt->GetPhysics();
if (!pPE)
continue;
if (pszBoneName) // if we want a bone instead of bbox-center lets do so...
{
IEntityCharacter *pIChar=pEnt->GetCharInterface();
if (pIChar)
{
ICryCharInstance *cmodel=pIChar->GetCharacter(0);
if (cmodel)
{
ICryBone *pBone = cmodel->GetBoneByName(pszBoneName);
if (pBone)
{
Center=pBone->GetBonePosition();
Matrix44 m;
m.SetIdentity();
m=GetTranslationMat(pEnt->GetPos())*m;
m=Matrix44::CreateRotationZYX(-pEnt->GetAngles()*gf_DEGTORAD)*m; //NOTE: angles in radians and negated
Center=m.TransformPointOLD(Center);
}
}
}
else
{
Center=pEnt->GetPos();
}
}
Vec3 diff(Center-m_vWpnPos);
float length2=GetLengthSquared(diff);
if(length2>15*15 || length2<1.5*1.5)
continue;
// pick the closest
float fDist=(float)sqrt(length2);
if (fDist<fBestDist)
{
pBest=pEnt;
fBestDist=fDist;
bestPoint3D=Center;
}
}
float fCurrTime=m_pGame->GetSystem()->GetITimer()->GetCurrTime();
//ICVar *pCvar=m_pGame->GetSystem()->GetIConsole()->GetCVar("fixed_time_step");
if (!pBest)
{
m_pLastAiming=NULL;
return;
}
if (m_pLastAiming)
{
CPlayer *pPlayer;
if(m_pLastAiming->GetContainer() &&
m_pLastAiming->GetContainer()->QueryContainerInterface(CIT_IPLAYER,(void**)&pPlayer) &&
!pPlayer->IsAlive() )
m_pLastAiming=NULL;
}
if (m_pLastAiming && m_pLastAiming!=pBest)
{
if (fCurrTime-m_fLastTime<2.0f)
return;
m_fLastTime=fCurrTime;
}
else
m_fLastTime=m_pGame->GetSystem()->GetITimer()->GetCurrTime();
m_pLastAiming=pBest;
bestPoint3D.z-=1.5f;
Vec3 diff(bestPoint3D-m_vWpnPos);
Vec3 vCurrAng=pLocal->GetAngles();
Vec3 vNewAng=ConvertVectorToCameraAngles(diff);
//vCurrAng.z+=1.0f;
pLocal->SetAngles(vNewAng);
}
///////////////////////////////////////////////
/*! Updates the player-container. Should be called every frame.
*/
void CPlayer::Update()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
bool bMyPlayer = IsMyPlayer();
bool bPlayerVisible = bMyPlayer || IsVisible();
SPlayerUpdateContext ctx;
ctx.bPlayerVisible = bPlayerVisible;
if (bMyPlayer)
{
// force physics proxy being updated in first person view, if somebody has a better idea
// I'm open to suggestions
m_pEntity->SetNeedUpdate(true);
}
if( !IsAlive() )
{
UpdateDead(ctx);
// [marco] even after the player dies, he can slide and fall into water -
// this call will create the splash sounds
UpdateSwimState(false);
return;
}
// fixme - remove this after artists done with animation params tweaking
if(m_pGame->pa_forcerelax->GetIVal())
{
GoRelaxed();
m_pEntity->StartAnimation(0, NULL, 1, .15f); // to stop all the fire animations
}
// fixme end
if(m_pGame->p_limp->GetIVal() == 0) // no limping
m_stats.bIsLimping = false;
else if(m_pGame->p_limp->GetIVal() == 1) // limp if wounded
{
if(m_stats.health<50&&(!m_stats.bIsLimping))
m_stats.bIsLimping = true;
}
else if(m_pGame->p_limp->GetIVal() == 2) // limp always
m_stats.bIsLimping = true;
if(bMyPlayer && m_pGame->m_bHideLocalPlayer)
{
FRAME_PROFILER( "CPlayerUpdate::UpdateCamera",GetISystem(),PROFILE_GAME );
m_AreaUser.SetEntity( GetEntity());
m_pGame->m_XAreaMgr.UpdatePlayer( m_AreaUser );
UpdateCamera();
///m_pEntity->DrawCharacter(0, ETY_DRAW_NONE);
//m_bFirstPerson = false;
//UpdateThirdPersonView();
return;
}
//if (bMyPlayer)
// AutoAiming();
m_bRotateHead = m_pEntity->GetCurrentAnimation(0, 3)<0 && m_pGame->p_RotateHead->GetIVal()!=0 &&
IsAlive() && !m_pEntity->IsBound()
&& !m_stats.onLadder // no rotatehead on ladders
&& !m_bIsFish // it's not a fish
// && m_pEntity->WasVisible() //Removed to fix BUG6238 (you always hear Valeries footsteps when she is behind you)
;
//if (!m_bIsAI) [Anton] moved to UpdatePhysics
// UpdateStamina();
// ladder stuff
// if(m_stats.onLadder)
// {
// SetGravityOverride(0.0f);
// }
// update and store player's current velocity
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
pe_status_living &status = ctx.status;
if (!physEnt || !physEnt->GetStatus(&status))
{
GameWarning( "Bad Phyics Entity for Player %s",m_pEntity->GetName() );
return;
}
Vec3d vel = (Vec3d)status.vel;
if (status.pGroundCollider)
vel -= status.velGround;
m_stats.fVel = vel.Length();
//fixme - remove this after done with lights tweaking
if(m_pGame->pl_force->GetIVal() && m_bIsAI && IsAlive())
SwitchFlashLight(true);
//fixme - this has to be done once - when model is loaded
UpdateBonesPtrs();
// Only updates when player have flash light on.
ProceedFLight();
UpdateLightBlinding();
//UpdateCollisionDamage(); [Anton] moved to UpdatePhysics
CounterUpdateAll( m_pTimer->GetFrameTime() );
//---------------------------------------------------------------
//Removed to fix BUG6238 (you always hear Valeries footsteps when she is behind you)
//As long as the character is NOT visible, the angles were not updated and that is the reason
// why the "aidle" animation doesn't start!
// if (bPlayerVisible)
UpdateRotateHead();
if (bPlayerVisible && !m_pVehicle)
{
FRAME_PROFILER( "CPlayerUpdate::RotateHead",GetISystem(),PROFILE_GAME );
if( m_CurStance != eProne )
{
//@FIXME remove this
pe_params_pos pp;
// if (m_pVehicle)
// {
// Vec3d angles = GetActualAngles();
// pp.q = GetRotationAA(angles.z*(gf_PI/180.0f),vectorf(0,0,1));
// }
if (m_bRotateHead)
pp.q = GetRotationAA(m_LegAngle*(gf_PI/180.0f),vectorf(0,0,1));
else
pp.q = GetRotationAA(m_pEntity->GetAngles().z*(gf_PI/180.0f),vectorf(0,0,1));
pp.bRecalcBounds = 0;
m_pEntity->GetPhysics()->SetParams(&pp);
}
}
//work in progress
//do this to prevent sliding when prone
if( m_CurStance == eProne )
{
// if( !m_stats.flying && !CanProne() )
if( !CanProne() )
GoStand();
else
{
m_EnvTangent = CalcTangentOnEnviroment( m_pEntity->GetAngles() );
m_pEntity->SetPhysAngles( m_EnvTangent ); // set angels for phisics (body is flat on surfece tangent space)
}
}
if (!m_bIsAI)
UpdateLean();
if (bPlayerVisible)
UpdateBonesRotation();
SetEyePos();
if (physEnt && physEnt->GetType()==PE_LIVING)
{
FRAME_PROFILER( "CPlayerUpdate::PostStep",GetISystem(),PROFILE_GAME );
pe_params_flags pf;
pf.flagsOR = pef_custom_poststep;
if (m_bIsAI)
pf.flagsOR |= lef_loosen_stuck_checks;
physEnt->SetParams(&pf);
}
//
// in water checks, swimming states updates
bool bPrevSweem = m_bSwimming;
UpdateSwimState(true);
if( m_bSwimming )
m_stats.swimTime +=m_pTimer->GetFrameTime();
else
m_stats.swimTime = 0.0f;
// update stances
if( !m_pVehicle )
{
if( m_bSwimming && m_CurStance!=eSwim )
GoSwim();
else if(bPrevSweem != m_bSwimming && !m_bSwimming)
{
if(!RestorePrevStence())
if(!GoCrouch())
GoProne();
}
}
// if(!m_bIsAI) // don't check/update areas for AI's
if(bMyPlayer) // areas are only used for the local player (they will not trigger things on the server)
{
FRAME_PROFILER( "CPlayerUpdate::XAreaMgrUpdatePlayer",GetISystem(),PROFILE_GAME );
m_AreaUser.SetEntity( GetEntity());
m_pGame->m_XAreaMgr.UpdatePlayer( m_AreaUser );
// used for camera transitions e.g. when entering a vehicle
UpdateAutoCenter();
// update the camera
UpdateCamera();
}
if (bPlayerVisible)
UpdateDrawAngles();
if (!m_bIsAI)
{
// Only for local player.
if (m_bFirstPerson)
{
m_pEntity->SetRegisterInSectors(false);
UpdateFirstPersonView();
}
else
{
m_pEntity->SetRegisterInSectors(true);
UpdateThirdPersonView();
}
}
//////////////////////////////////////////////////////////////////////////////
//UPDATE THE WEAPON
if(m_stats.health>0)
{
if(m_stats.weapon_busy>0)
m_stats.weapon_busy-=m_pTimer->GetFrameTime();
UpdateMelee();
UpdateWeapon();
}
if(m_CurStance == eProne || m_bSwimming) // disable IK in prone mode and when swimming
{
FRAME_PROFILER( "CPlayerUpdate::DisableIK",GetISystem(),PROFILE_GAME );
pe_params_sensors ps;
ps.nSensors = 0;
physEnt->SetParams(&ps);
}
//////////////////////////////////////////////////////////////////////////////
//UPDATE THE ANIMATION
// layer 0 is used for movement/stance animations (lower body)
// layer 1 is used for aiming/shooting animations
// layer 2 is used for jump/land animations
UpdateCharacterAnimations( ctx );
UpdateFireAnimations();
// UpdateJumpAnimations();
}
void CPlayer::UpdatePhysics(float fDeltaTime)
{
m_fLastDeltaTime = fDeltaTime;
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
float MIN_WALK_SPEED = m_WalkSpeed*.15f;
pe_status_living sl;
physEnt->GetStatus(&sl);
if (!m_bIsAI)
UpdateStamina(fDeltaTime);
UpdateCollisionDamage();
//keep count of the last groudheight
if (!sl.bFlying)
{
m_fLastGroundHeight = m_pEntity->GetPos(true).z;
m_bHasJumped = false;
}
// when on ladder - no gravity
// when using mounted weapon - no gravity
if(m_stats.onLadder || m_pMountedWeapon )
{
SetGravityOverride(0.0f);
}
// [Anton] - moved from ProcessMovements, since it should be called for remote clients in multiplayer
// float kwater;
// int bSwimming = IsSwimming( kwater );
pe_player_dynamics movedyn;
movedyn.kInertia = m_Dynamics.inertia*(1-m_stats.fKWater) + m_Dynamics.swimming_inertia*m_stats.fKWater;
movedyn.kAirControl = m_Dynamics.air_control*(1-m_stats.fKWater);
movedyn.bSwimming = m_bSwimming;
if (m_fGravityOverride!=1E10)
{
movedyn.gravity = m_fGravityOverride;
if (!m_fGravityOverride)
{
movedyn.kAirControl=1.0f;
movedyn.bSwimming=true;
}
m_fGravityOverride = 1E10;
}
else
{
float fgravity = m_Dynamics.gravity;
//if we are jumping and there is a special gravity for jump use it.
if (sl.bFlying && m_bHasJumped && m_Dynamics.jump_gravity!=1E10)
{
//use jump gravity only if we are over the jump starting pos.
if (m_pEntity->GetPos(true).z > m_fLastGroundHeight)
fgravity = m_Dynamics.jump_gravity;
}
//we land, in any case use standard gravity.
/*if (!sl.bFlying)
{
fgravity = m_Dynamics.gravity;
m_bHasJumped = false;
}*/
//GetISystem()->GetILog()->Log("%f",fgravity);
movedyn.gravity = fgravity*(1-m_stats.fKWater)*m_pGame->p_gravity_modifier->GetFVal()+m_Dynamics.swimming_gravity*m_stats.fKWater;
}
// 0 gravity behaves like swimming (up and down movement is possible)
if(movedyn.gravity==0.0f)
{
movedyn.bSwimming=true; // allow not only movements in ground plane
movedyn.kAirControl=m_Dynamics.air_control; // water should not affect control
}
Vec3 vAngles = ConvertToRad(m_pEntity->GetAngles()),
vDir(-cry_sinf(vAngles[YAW])*cry_sinf(vAngles[PITCH]),cry_cosf(vAngles[YAW])*cry_sinf(vAngles[PITCH]),-cry_cosf(vAngles[PITCH]));
// make underwater movement smoother
if (m_stats.fKWater>=1.0f && sl.velRequested.len2()>0 && sqr(sl.velRequested*vDir)>sl.velRequested.len2()*0.5f
&& m_stats.swimTime>1.0f)
movedyn.kAirControl = 1.0f;
if(m_bInertiaOverride)
{
if(movedyn.bSwimming)
movedyn.kAirControl = 1.0f;
else
movedyn.kInertia = 0; // the bigger value - the faster we can change speed (0 is special case, not warking in water)
}
physEnt->SetParams(&movedyn);
// if(movedyn.bSwimming && m_bSwimming)
// GoSwim();
// else if(m_bSwimming && !movedyn.bSwimming)
// RestorePrevStence();
// m_bSwimming = movedyn.bSwimming && (m_stats.fInWater>0.0f);
m_stats.moving = false;
m_stats.running = false;
// Calculate our current speed
Vec3 vel = sl.vel;
if (sl.pGroundCollider)
vel -= sl.velGround;
float speed = vel.Length();
m_walkParams.speed = speed;
m_walkParams.vertSpeed = vel.z;
// Calculate projected current speed
vel.z = 0.0f;
float speed2d = vel.Length();
if ((speed2d > .0f && m_NotRunTime>1.5f) || (speed2d > MIN_WALK_SPEED) )
{
// Have the player continue moving
m_stats.moving = true;
m_NotRunTime = 0;
}
//else
if (speed>0)
m_NotRunTime += fDeltaTime;
else
m_NotRunTime = 0;
if (m_stats.moving && (speed2d-m_WalkSpeed>0.1f || ((m_stats.flying||m_stats.landing)&&m_RunningTime>.5f)) ) // if jumping in air - slows down, not to change snimation
{
// Have the player start/continue running
m_stats.running = true;
}
if( m_stats.running )
m_RunningTime += fDeltaTime;
else
m_RunningTime = 0;
if( m_stats.moving )
m_WalkingTime += fDeltaTime;
else
m_WalkingTime = 0;
m_pGame->ConstrainToSandbox(GetEntity());
}
///////////////////////////////////////////////
/*! Sets and loads the player-model.
@param model filename of the player-model
*/
void CPlayer::SetPlayerModel( const string &model )
{
//@FIXME: enable this later.
//if (m_pEntity->GetCharInterface()->LoadCharacter(PLAYER_MODEL_IDX,model.c_str()))
// m_strModel = model;
m_strModel = model;
if (m_nSelectedWeaponID == -1)
SelectWeapon(m_stats.weapon);
UpdateBonesPtrs();
}
///////////////////////////////////////////////
/*! Retrieves a weapon-info-structure for a certain weapon
@param nWeaponIndex weapon-id to retrieve from (negative value will return info of current weapon)
@return WeaponInfo if the function succeeds, NULL otherwise
*/
WeaponInfo & CPlayer::GetWeaponInfo(int nWeaponIndex /* = -1 */)
{
if(nWeaponIndex == -1)
nWeaponIndex = m_nSelectedWeaponID;
PlayerWeaponsItor wi = m_mapPlayerWeapons.find(nWeaponIndex);
if (wi != m_mapPlayerWeapons.end())
{
return wi->second;
}
// this should NEVER EVER be reached
assert(false);
return m_mapPlayerWeapons.begin()->second;
}
void CPlayer::GetCurrentWeaponParams(WeaponParams& wp)
{
WeaponInfo wi = GetWeaponInfo();
GetSelectedWeapon()->GetModeParams(wi.iFireMode, wp);
}
/*! Executes the processing commands
@param ProcessingCmd structure of commands to process
*/
void CPlayer::ProcessCmd(unsigned int nPing,CXEntityProcessingCmd &ProcessingCmd)
{
ProcessMovements(ProcessingCmd);
// client in MP processes fire event differently
// here the server relays the fire event to the client, but due to
// heavier client-side simulation of firing (see XClient.cpp) we
// keep the state of our client-side calculation
bool bClientFire = false;
bool bPrevFiring = ProcessingCmd.CheckAction(ACTION_FIRE0);
bool bPrevFireGrenade = ProcessingCmd.CheckAction(ACTION_FIRE_GRENADE);
if (m_pGame->IsMultiplayer() && m_pGame->IsClient() && !m_pGame->IsServer() && IsMyPlayer())
{
bClientFire = true;
ProcessingCmd.RemoveAction(ACTION_FIRE0);
if (m_stats.firing)
ProcessingCmd.AddAction(ACTION_FIRE0);
ProcessingCmd.RemoveAction(ACTION_FIRE_GRENADE);
if (m_stats.firing_grenade)
ProcessingCmd.AddAction(ACTION_FIRE_GRENADE);
}
ProcessWeapons(ProcessingCmd);
if (bClientFire)
{
ProcessingCmd.RemoveAction(ACTION_FIRE0);
if (bPrevFiring)
ProcessingCmd.AddAction(ACTION_FIRE0);
ProcessingCmd.RemoveAction(ACTION_FIRE_GRENADE);
if (bPrevFireGrenade)
ProcessingCmd.AddAction(ACTION_FIRE_GRENADE);
}
}
//
//claps angl to be within min-max range. Check fro special case when min>max -- for example min=350 max=40
inline float ClampAngle180( float min, float max, float angl )
{
if( angl>0 && angl<min )
return min;
else if( angl<0 && angl>max )
return max;
return angl;
}
///////////////////////////////////////////////
/*! Updates the orientation of the player
@param ProcessingCmd structure of commands to process
*/
void CPlayer::ProcessAngles(CXEntityProcessingCmd &ProcessingCmd)
{
if (IsMyPlayer() && !IsAlive())
return;
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
Vec3d Angles=ProcessingCmd.GetDeltaAngles();
if (IsMyPlayer() && m_pVehicle && !m_bFirstPerson && !m_pMountedWeapon)
{
// [marco] if this is the localplayer, and we are driving the vehicle,
// and we are in third person mode, AND we are not at mounted weapon
// then do not allow the player
// to mess around with the camera - he can switch
// to first person mode to shoot from inside the vehicle
// Angles.Set(0,0,180);
}
if(m_AngleLimitVFlag)
//check vertical limits
{
Angles.x = ClampAngle( Snap_s360(m_AngleLimitBase.x + m_MinVAngle),
Snap_s360(m_AngleLimitBase.x + m_MaxVAngle),
Snap_s360(Angles.x));
Angles.x = Snap_s180(Angles.x);
}
//
//probably not the best way. If we will have angle restriction (like mounted weapon) in prone - have to chage it
if( m_CurStance == eProne )
m_AngleLimitBase = m_EnvTangent;
if(m_AngleLimitHFlag)
{
//check horizontal limits
bool bClamped = false;
Angles.z = Snap_s180(Angles.z);
Angles.z = ClampAngle( Snap_s360(m_AngleLimitBase.z + m_MinHAngle),
Snap_s360(m_AngleLimitBase.z + m_MaxHAngle),
Snap_s360(Angles.z),bClamped);
if (m_bIsAI && bClamped)
m_pEntity->GetAI()->SetSignal(1,"RETURN_TO_NORMAL");
Angles.z = Snap_s180(Angles.z);
}
// if at the mounted weapon - check for collisions coz player position is forced bu the weapon
if( m_pMountedWeapon )
{
Vec3d pos2check = m_pEntity->GetPos();
if(!CanStand( pos2check ) )
{
// this position is bad (collides with something) - restore prev pos/angles
// float diff = Snap_s360(m_vSafeAngAtMountedWeapon.z) - Snap_s360(Angles.z);
float diff = Snap_s180(Snap_s180(m_vSafeAngAtMountedWeapon.z) - Snap_s180(Angles.z));
Angles.z += diff*.31f;
//GetISystem()->GetILog()->Log(">>> %.2f ", m_vSafeAngAtMountedWeapon.z);
}
else if(CanStand( pos2check ) )
{
// this position is good (no intersetion/collisions) - remember it
m_vSafeAngAtMountedWeapon = m_pEntity->GetAngles();
//GetISystem()->GetILog()->Log("<<<GD %.2f ", m_vSafeAngAtMountedWeapon.z);
}
}
ProcessingCmd.SetDeltaAngles(Angles);
if(IsMyPlayer())
{
float stanceRecoilModifier = 1.0f;
// process weapon specific recoil modifier based on stance
if (m_nSelectedWeaponID != -1)
{
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
WeaponParams wp;
GetCurrentWeaponParams(wp);
stanceRecoilModifier = wp.fRecoilModifierStanding;
if (m_CurStance == eCrouch)
{
stanceRecoilModifier = wp.fRecoilModifierCrouch;
}
else if (m_CurStance == eProne)
{
stanceRecoilModifier = wp.fRecoilModifierProne;
}
}
Vec3d vA=Angles;
//GetISystem()->GetILog()->Log("RECOIL: %f %f %f", m_fRecoilXUp, m_fRecoilZUp, m_fRecoilXDelta);
if((m_fRecoilXUp==0 && (m_fRecoilZUp==0)) && (m_fRecoilXDelta!=0) )//blend back recoil
{
//TRACE("RETURNING m_fRecoilXDelta=%f",m_fRecoilXDelta);
float multiplier=m_stats.firing?m_pGame->w_recoil_speed_down*0.2f:m_pGame->w_recoil_speed_down;
float m=min(1,m_pTimer->GetFrameTime()*multiplier);
float xdiff=m_fRecoilXDelta>m_fRecoilX*m?m_fRecoilX*m:m_fRecoilXDelta;
//float zdiff=m_fRecoilZDelta>0?min(m_fRecoilZDelta,m_fRecoilZ*m):-m_fRecoilZDelta;
xdiff *= stanceRecoilModifier;
if(m_fRecoilXDelta-xdiff<=0){
xdiff=m_fRecoilXDelta;
}
vA.x+=xdiff;
m_fRecoilXDelta-=xdiff;
//TRACE("m_fRecoilXDelta=%f xdiff=%f m_fRecoilZDelta=%f \n",m_fRecoilXDelta,xdiff,m_fRecoilZDelta);
ProcessingCmd.SetDeltaAngles(vA);
//TRACE("RETURNING ENDm_fRecoilXDelta=%f",m_fRecoilXDelta);
}
//APPLY RECOIL
if((m_fRecoilXUp!=0 || m_fRecoilZUp!=0) )//apply recoil
{
//GetISystem()->GetILog()->Log("APPLYING m_fRecoilXDelta=%f",m_fRecoilXDelta);
float deltatime=m_pTimer->GetFrameTime()*m_pGame->w_recoil_speed_up;
//GetISystem()->GetILog()->Log("deltatime=%f",deltatime);
float dx=m_fRecoilXUp>0?min(m_fRecoilXUp,m_fRecoilX*deltatime):max(m_fRecoilXUp,m_fRecoilX*deltatime);
float dz=m_fRecoilZUp>0?(float)min(m_fRecoilZUp,m_fRecoilZ*deltatime):(float)max(m_fRecoilZUp,-fabs(m_fRecoilZ*deltatime));
if(m_fRecoilXDelta+dx>=m_pGame->w_recoil_max_degree){
//GetISystem()->GetILog()->Log("w_recoil_max_degree=%f",m_pGame->w_recoil_max_degree);
dx=m_fRecoilXUp;
}
//GetISystem()->GetILog()->Log("m_fRecoilXDelta=%f dx=%f dz=%f m_fRecoilXUp=%f m_fRecoilZUp=%f\n",m_fRecoilXDelta,dx,dz,m_fRecoilXUp,m_fRecoilZUp);
m_fRecoilXUp-=dx;
if(m_fRecoilXUp<0)m_fRecoilXUp=0;
m_fRecoilZUp-=dz;
dx *= stanceRecoilModifier;
dz *= stanceRecoilModifier;
vA.x-=dx;
if(!m_pGame->w_recoil_vertical_only)
{
vA.z-=dz;
}
m_fRecoilXDelta+=dx;
ProcessingCmd.SetDeltaAngles(vA);
//TRACE("APPLYING END m_fRecoilXDelta=%f",m_fRecoilXDelta);
}
//////////////////////////////////////////////////////////////////////////
float fWaterPitch=m_pGame->p_waterbob_pitch->GetFVal();
float fWaterPitchSpeed=m_pGame->p_waterbob_pitchspeed->GetFVal();
float fWaterRoll=m_pGame->p_waterbob_roll->GetFVal();
float fWaterRollSpeed=m_pGame->p_waterbob_rollspeed->GetFVal();
float fWaterDepthWobble=m_pGame->p_waterbob_mindepth->GetFVal();
if (m_bEyesInWater) // wobble camera if in water
{
float fWobbleScale=(m_stats.fInWater-fWaterDepthWobble);
if (fWobbleScale<0.0f)
fWobbleScale=0.0f;
if (fWobbleScale>1.0f)
fWobbleScale=1.0f;
float fFrameTime=m_pTimer->GetFrameTime();
m_walkParams.fWaterPitchPhase+=fWaterPitchSpeed*fFrameTime;
if (m_walkParams.fWaterPitchPhase>=1.0f)
m_walkParams.fWaterPitchPhase-=1.0f;
m_walkParams.fWaterRollPhase+=fWaterRollSpeed*fFrameTime;
if (m_walkParams.fWaterRollPhase>=1.0f)
m_walkParams.fWaterRollPhase-=1.0f;
//Vec3d cangles = Angles;
vA.x += fWobbleScale*fWaterPitch*cry_sinf(m_walkParams.fWaterPitchPhase*gf_PI*2.0f);
vA.y = (fWaterRoll *cry_sinf(m_walkParams.fWaterRollPhase *gf_PI*2.0f))*fWobbleScale;
}else
{
//Vec3d cangles = vA;
vA.y=0.0f;
//ProcessingCmd.SetDeltaAngles(vA);
m_walkParams.fWaterPitchPhase=0.0f;
m_walkParams.fWaterRollPhase=0.0f;
}
ProcessingCmd.SetDeltaAngles(vA);
//////////////////////////////////////////////////////////////////////////
}
///
if (!m_pRedirected)
{
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//if (!m_pVehicle)
m_pEntity->SetAngles( Angles,false, false );
m_vShake=Vec3d(0,0,0);
//
// so here goes wapon sway
if(m_Dynamics.gravity!=0.0f) // only if there is gravity
{
// add some swaying to the angles
m_vShake.x+=(cry_cosf(m_walkParams.swayOfs*15.9f+0.3f)*m_walkParams.swayAmp*0.1f+cry_sinf(m_walkParams.swayOfs*5.9f+0.0f)*m_walkParams.swayAmp*0.45f+cry_cosf(m_walkParams.swayOfs*0.95f+0.5f)*m_walkParams.swayAmp)*0.33333f;
m_vShake.z+=(cry_cosf(m_walkParams.swayOfs*14.9f+0.7f)*m_walkParams.swayAmp*0.12f+cry_sinf(m_walkParams.swayOfs*5.05f+0.6f)*m_walkParams.swayAmp*0.5f+cry_cosf(m_walkParams.swayOfs*1.0f+0.2f)*m_walkParams.swayAmp)*0.33333f;
m_walkParams.swayOfs+=m_walkParams.swayFreq*m_pTimer->GetFrameTime();
}
//
// after explosion camera shacking - not when in vehicle
// when proning - aligne on terrain
if (IsAlive() && !m_pEntity->IsBound() )
{
// add shaking
if (IsMyPlayer())
{
if((fabsf(m_walkParams.shakeDegree)>0.1f) && (m_walkParams.shakeTime>0.0f))
{
m_walkParams.shakeOffset += m_walkParams.shakeFreq * m_pTimer->GetFrameTime();
m_walkParams.shakeElapsedTime += m_pTimer->GetFrameTime();
if (m_walkParams.shakeElapsedTime>m_walkParams.shakeTime)
{
m_walkParams.shakeDegree=0.0f;
}else
{
float fDeg = m_walkParams.shakeDegree * ( 1 - ( m_walkParams.shakeElapsedTime / m_walkParams.shakeTime ) );
float fSinOfs = cry_sinf(m_walkParams.shakeOffset * 6.283185307179586476925286766559f);
// m_vShake.x += m_walkParams.shakeAxis.x * fSinOfs * fDeg;
// m_vShake.y += m_walkParams.shakeAxis.y * fSinOfs * fDeg;
// m_vShake.z += m_walkParams.shakeAxis.z * fSinOfs * fDeg;
// make it shake on camera roll axis
// create the matrix here
Matrix44 matWorld;
matWorld.SetIdentity();
matWorld=Matrix44::CreateRotationZYX(-gf_DEGTORAD*m_vEyeAngles)*matWorld; //NOTE: angles in radians and negated
CryQuat cxquat = Quat( GetTransposed44(matWorld) );
CryQuat rxquat;
Vec3d shake( 0, fSinOfs * fDeg, 0 );
rxquat.SetRotationXYZ(DEG2RAD(shake));
CryQuat result = cxquat*rxquat;
Vec3d finalangles = RAD2DEG(Ang3::GetAnglesXYZ(Matrix33(result)));
m_vShake += m_vEyeAngles - finalangles;
}
}
}
}
}
else
{
ProcessingCmd.SetDeltaAngles(Angles);
// m_pEntity->SetAngles( Angles );//,false, false );
if (m_pRedirected) // [marco] Kirill does this check make sense -
// this should never happens but it crashes with the helicopter
m_pRedirected->SetAngles(Angles);
// ProcessingCmd.Reset();
}
}
//#define UNDERWATER_SPEED 0.19f/8.0f
///////////////////////////////////////////////
/*! Updates the position and stats of the player
@param ProcessingCmd structure of commands to process
*/
void CPlayer::ProcessMovements(CXEntityProcessingCmd &cmd, bool bScheduled)
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
IPhysicalEntity *pPhysEnt = (IPhysicalEntity *)m_pEntity->GetPhysics();
if(!pPhysEnt)
return;
//[kirill] need this to process autocentering
// no autocentering when moving mouse or fiering
m_bMouseMoved = cmd.CheckAction(ACTION_TURNLR) || cmd.CheckAction(ACTION_TURNUD) || cmd.CheckAction(ACTION_FIRE0);
PhysicsVars *physvars = m_pGame->GetSystem()->GetIPhysicalWorld()->GetPhysVars();
// [Anton] setting dynprops for the physics is moved to ::Update
pe_player_dynamics pd;
pPhysEnt->GetParams(&pd);
bool bSuperDesignerMode = pd.gravity==0 && pd.kInertia==0;
bool bNoGravity = !bSuperDesignerMode && (physvars->bFlyMode || IsSwimming() || m_stats.onLadder);
//return;
/* this blick would be needed only when designers tweak player's speeds
//FixME fix me FIXME!!!
//if(IsMyPlayer())
{
// m_RunSprintDecoyScale = m_pGame->p_sprint_decoy->GetFVal();
// m_RunSprintRestoreScaleRun = m_pGame->p_sprint_restore_run->GetFVal();
// m_RunSprintRestoreScaleIdle = m_pGame->p_sprint_restore_idle->GetFVal();
// m_RunSprintScale = m_pGame->p_sprint_scale->GetFVal();
m_RunSpeed = m_pGame->p_speed_run->GetFVal();
m_WalkSpeed = m_pGame->p_speed_walk->GetFVal();
m_CrouchSpeed = m_pGame->p_speed_crouch->GetFVal();
m_ProneSpeed = m_pGame->p_speed_prone->GetFVal();
m_JumpForce = m_pGame->p_jump_force->GetFVal();
m_LeanDegree = m_pGame->p_lean->GetFVal();
m_JTWalk = m_pGame->p_jump_walk_time->GetFVal();
m_JTRun = m_pGame->p_jump_run_time->GetFVal();
}
*/
m_StealthSpeed = (m_CrouchSpeed + m_WalkSpeed)*.5f;
IPhysicalWorld *pW=pPhysEnt->GetWorld();
float fTimeDelta=0;
CXClient *pClient=m_pGame->GetClient();
if(!pClient || pClient->GetPlayerId()!=m_pEntity->GetId())
fTimeDelta=cmd.GetServerPhysDelta();
if (!m_pVehicle && !m_pMountedWeapon && fTimeDelta>0)
{
pPhysEnt->StepBack(fTimeDelta);
m_NotRunTime = m_NotRunTimeClient;
m_RunningTime = m_RunningTimeClient;
m_WalkingTime = m_WalkingTimeClient;
m_stats.stamina = m_staminaClient;
// m_stats.breath = m_breathClient;
}
if (!IsAlive())
return;
if (cmd.CheckAction(ACTION_FLASHLIGHT))
{
if (m_pVehicle && m_stats.inVehicleState == PVS_DRIVER)
m_pVehicle->SwitchLights(5); // switch car's lights
else if (m_stats.has_flashlight)
SwitchFlashLight(!m_bLightOn);
// cmd.RemoveAction(ACTION_FLASHLIGHT);
}
// when in vehicle - use crouch key to toggle camera autocentering
if ((cmd.CheckAction(ACTION_MOVEMODE) || cmd.CheckAction(ACTION_MOVEMODE_TOGGLE)) && m_pVehicle)
{
StartAutoCenter( false );
cmd.RemoveAction(ACTION_MOVEMODE);
cmd.CheckAction(ACTION_MOVEMODE_TOGGLE);
}
// use button has been removed
m_stats.melee_attack=false;
if(cmd.CheckAction(ACTION_USE))
{
bool bUsed=false;
m_pEntity->SendScriptEvent(ScriptEvent_Use,0,&bUsed);
if (bUsed==false)
{
m_stats.use_pressed=true;
}
}
else
{
m_stats.use_pressed=false;
}
if (cmd.CheckAction(ACTION_CHANGE_VIEW))
{
//if (m_pGame->IsDevModeEnable())
{
m_pGame->SetViewMode(m_bFirstPerson);
}
cmd.RemoveAction(ACTION_CHANGE_VIEW);
}
if ( m_pVehicle )
{
//if (!m_pGame->IsMultiplayer() || !m_pGame->UseFixedStep() || bScheduled)
ProcessVehicleMovements(cmd); // so that we dont need any reference to vechile in this file
// can't sprint in vehicle
m_Sprinting = false;
return;
}
// if using mounted weapon - can't move
if(m_pMountedWeapon)
{
// can't sprint when useing mounted weapon
m_Sprinting = false;
return;
}
if (m_nSelectedWeaponID != -1)
{
WeaponParams wp;
GetCurrentWeaponParams(wp);
m_stats.holding_breath=false;
if (wp.bAllowHoldBreath && cmd.CheckAction(ACTION_HOLDBREATH) && m_stats.stamina>m_StaminaTable.BreathDecoyAim*.5f)
{
m_stats.holding_breath = true;
}
}
//lets remove the action flag every frame if in crouching mode.
if(m_pGame->IsServer())
{
//crouch toggle
if (cmd.CheckAction(ACTION_MOVEMODE_TOGGLE))
{
//apply the toggle crouch only if we are outside a vehicle
if (!m_pVehicle)
m_bStayCrouch = (m_bStayCrouch)?false:true;
cmd.RemoveAction(ACTION_MOVEMODE_TOGGLE);
}
bool bGoCrouch = cmd.CheckAction(ACTION_MOVEMODE) || m_bStayCrouch;
bool bGoProne = cmd.CheckAction(ACTION_MOVEMODE2);
if (m_stats.crouch && !m_bSwimming && !m_stats.onLadder)
{
//if it was crouching lets remove it otherwise the "onhold" will not work
if (!bGoCrouch)
RestorePrevStence();
// GoStand();
}
if (bGoCrouch || bGoProne)
{
if (!m_stats.onLadder)
{
if (m_stats.crouch)
{
if (bGoProne)
{
if (m_PrevStance == eProne)
GoStand(false);
else
GoProne( );
}
}
else
if (m_CurStance == eProne)
{
if (bGoProne)
// RestorePrevStence();
GoStand(false);
else
GoCrouch( );
}
else
if (m_CurStance == eSwim)
{
if (bGoProne)
// RestorePrevStence();
GoStand(false);
}
else
{
if (bGoProne)
GoProne( );
else
GoCrouch( );
}
}
cmd.RemoveAction(ACTION_MOVEMODE);
cmd.RemoveAction(ACTION_MOVEMODE2);
}
}
int bJump = 0;
if ( ( cmd.CheckAction(ACTION_WALK)^m_bAlwaysRun)&&
( cmd.CheckAction(ACTION_MOVE_RIGHT)||cmd.CheckAction(ACTION_MOVE_LEFT) ||
cmd.CheckAction(ACTION_MOVE_FORWARD)||cmd.CheckAction(ACTION_MOVE_BACKWARD) ) &&
!m_stats.bForceWalk )
{
if (!m_Running)
{
// cannot run if in crouch mode
if (!m_stats.crouch&&!m_stats.prone&&!m_bSwimming)
{
GoStand();
m_Running = true;
}
}
}
else
{
if( m_Running )
{
RestorePrevStence();
}
m_Running = false;
}
if (m_Running)
{
if ( cmd.CheckAction(ACTION_RUNSPRINT) && m_stats.stamina>m_StaminaTable.DecoyRun*.5f
|| cmd.CheckAction(ACTION_RUNSPRINT) && m_Sprinting && m_stats.stamina>1)
m_Sprinting = true;
else
m_Sprinting = false;
m_stats.running = true;
}
else
{
m_stats.running = false;
m_Sprinting = false;
}
m_walkParams.fLeanTarget=0;
// calculate leaning (if not proning and not at mounted weapon)
if (cmd.CheckAction(ACTION_LEANLEFT) && (!m_stats.lock_weapon) && (m_CurStance != eProne))
{
if(IsMyPlayer())
{
if (m_walkParams.leanEnd!=1.0f)
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=1.0f;
m_walkParams.leanFactor=0.0f;
m_walkParams.leanDegree=m_LeanDegree;
}
m_walkParams.fLeanTarget=.5;
m_walkParams.leanSpeed=1.5f;
}
}else
if (cmd.CheckAction(ACTION_LEANRIGHT) && (!m_stats.lock_weapon) && (m_CurStance != eProne))
{
if(IsMyPlayer())
{
if (m_walkParams.leanEnd!=-1.0f)
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=-1.0f;
m_walkParams.leanFactor=0.0f;
m_walkParams.leanDegree=m_LeanDegree;
}
m_walkParams.fLeanTarget=-1;
m_walkParams.leanSpeed=1.5f;
}
}else if (cmd.CheckAction(ACTION_MOVE_LEFT) )
{
if( !m_stats.onLadder )
{
if (m_walkParams.leanEnd!=0.1f)
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=0.1f;
m_walkParams.leanFactor=0.0f;
m_walkParams.leanDegree=m_LeanDegree;
}
if ((m_walkParams.leanAmount>=0.0f) && (m_walkParams.leanAmount<=0.1f))
m_walkParams.leanSpeed=0.1f;
m_walkParams.fLeanTarget=0.05f;
if(m_walkParams.fCurrLean==0)
m_walkParams.leanSpeed=0.2f;
}
}else if (cmd.CheckAction(ACTION_MOVE_RIGHT) )
{
if( !m_stats.onLadder )
{
if (m_walkParams.leanEnd!=-0.1f)
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=-0.1f;
m_walkParams.leanFactor=0.0f;
m_walkParams.leanDegree=m_LeanDegree;
}
if ((m_walkParams.leanAmount<=0.0f) && (m_walkParams.leanAmount>=-0.1f))
m_walkParams.leanSpeed=0.1f;
m_walkParams.fLeanTarget=-0.05f;
if(m_walkParams.fCurrLean==0)
m_walkParams.leanSpeed=0.2f;
}
}else if (m_walkParams.leanEnd!=0.0f)
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=0.0f;
m_walkParams.leanFactor=0.0f;
}
//////////////////
//convert in the format used by physics
Vec3d tempangle = cmd.GetDeltaAngles();
Vec3d dirangle = tempangle;
dirangle=ConvertToRad(dirangle);
float m_pcos = cry_cosf(dirangle[YAW]);//*inputspeed;
float m_psin = cry_sinf(dirangle[YAW]);//*inputspeed;
float m_pcos2 = cry_cosf(dirangle[PITCH]);
float m_psin2 = cry_sinf(dirangle[PITCH]);
m_walkParams.dir.x = -m_psin;
m_walkParams.dir.y = m_pcos;
m_walkParams.dir.z = 0.0f;
Vec3d speedxyz(0.0f, 0.0f, 0.0f);
pe_status_dynamics dynStatus;
pPhysEnt->GetStatus((pe_status*)&dynStatus);
float fWaterMoveScale = m_SwimSpeed*0.5f*m_stats.fKWater + (1.0f-m_stats.fKWater);
if (cmd.CheckAction(ACTION_MOVE_FORWARD))
{
if(m_stats.onLadder) // when on ladder - move mostly UP/DOWN
{
speedxyz[0] += -m_psin*.3f;
speedxyz[1] += m_pcos*.3f;
}
else
{
speedxyz[0] += -m_psin;
speedxyz[1] += m_pcos;
}
if (bNoGravity)
{
speedxyz[0] *= m_psin2;
speedxyz[1] *= m_psin2;
//
//if swimming up - make sure not to go too fast to prevent jumping out of water
if(m_bSwimming && m_pcos2<0)
{
if( (m_stats.fInWater < m_PlayerDimSwim.heightEye &&
// m_walkParams.vertSpeed > .02f &&
!m_stats.onLadder) || dynStatus.v.z<-7.0f)
speedxyz[2] = -m_pcos2*fWaterMoveScale*m_stats.fKWater*.02f; // if close to surface - don't go up too fast - not to jump out of water
// or big vertical vel - falling down
else
speedxyz[2] = -m_pcos2*fWaterMoveScale; // deep enoght - can go up
}
else
speedxyz[2] = -m_pcos2;//*inputspeed;
}
else if(bSuperDesignerMode)
{
speedxyz[2] = -m_pcos2;//*inputspeed;
}
}
if (cmd.CheckAction(ACTION_MOVE_BACKWARD))
{
m_stats.back_pressed = true;
//FIXME: would be nice if backward key detach us from the ladder when we approach the ground (instead use the jump button), but for this
//more info about the ladder are needed, like the center position, to know if we are going up or down.
// if(m_stats.onLadder /*&& (m_fLastGroundHeight+1.0 <m_pEntity->GetPos(true).z)*/)// when on ladder - move mostly UP/DOWN
// {
// speedxyz[0] += -m_psin*.3f;
// speedxyz[1] -= m_pcos*.3f;
// }
// else
{
speedxyz[0] -= -m_psin;
speedxyz[1] -= m_pcos;
}
if ( bNoGravity )
{
speedxyz[0] *= m_psin2;
speedxyz[1] *= m_psin2;
//
//if swimming up - make sure not to go too fast to prevent jumping out of water
if(m_bSwimming && m_pcos2>0)
{
if( (m_stats.fInWater < m_PlayerDimSwim.heightEye &&
// m_walkParams.vertSpeed > .02f &&
!m_stats.onLadder) || dynStatus.v.z<-7.0f)
speedxyz[2] = m_pcos2*fWaterMoveScale*m_stats.fKWater*.02f; // if close to surface - don't go up too fast - not to jump out of water
else
speedxyz[2] = m_pcos2*fWaterMoveScale; // deep enoght - can go up
}
else
speedxyz[2] = m_pcos2;//*inputspeed;
}
else if(bSuperDesignerMode)
{
speedxyz[2] = m_pcos2;//*inputspeed;
}
}
else
m_stats.back_pressed = false;
bool bStrafe = false;
if (cmd.CheckAction(ACTION_MOVE_LEFT)) //&& !m_stats.onLadder)
{
/*if (m_stats.onLadder)
{
speedxyz[0] -= m_pcos*0.1f;
speedxyz[1] -= m_psin*0.1f;
}
else*/
{
speedxyz[0] -= m_pcos;
speedxyz[1] -= m_psin;
}
bStrafe = true;
}
if (cmd.CheckAction(ACTION_MOVE_RIGHT)) //&& !m_stats.onLadder)
{
/*if (m_stats.onLadder)
{
speedxyz[0] += m_pcos*0.1f;
speedxyz[1] += m_psin*0.1f;
}
else*/
{
speedxyz[0] += m_pcos;
speedxyz[1] += m_psin;
}
bStrafe = true;
}
if (GetLengthSquared(speedxyz)>0)
{
float fSpeedScale = m_stats.fSpeedScale*m_stats.dmgSpeedCoeff/100.0f;
float inputspeed;
if(m_stats.back_pressed && !m_stats.onLadder)
{
switch(m_CurStance)
{
case eStealth:
inputspeed = m_StealthSpeedBack;
break;
case eCrouch:
inputspeed = m_CrouchSpeedBack;
break;
case eProne:
inputspeed = m_ProneSpeedBack;
break;
case eSwim:
inputspeed = m_SwimSpeedBack;
break;
default:
inputspeed = m_WalkSpeedBack;
break;
}
if(m_Sprinting)
inputspeed = m_RunSpeedBack*m_StaminaTable.RunSprintScale;
else if(m_stats.running)
inputspeed = m_RunSpeedBack;
}
else if(!bStrafe || m_stats.onLadder)
{
switch(m_CurStance)
{
case eStealth:
inputspeed = m_StealthSpeed;
break;
case eCrouch:
inputspeed = m_CrouchSpeed;
break;
case eProne:
inputspeed = m_ProneSpeed;
break;
case eSwim:
inputspeed = m_SwimSpeed;
break;
default:
inputspeed = m_WalkSpeed;
break;
}
if(m_Sprinting)
inputspeed = m_RunSpeed*m_StaminaTable.RunSprintScale;
else if(m_stats.running)
inputspeed = m_RunSpeed;
}
else
{
switch(m_CurStance)
{
case eStealth:
inputspeed = m_StealthSpeedStrafe;
break;
case eCrouch:
inputspeed = m_CrouchSpeedStrafe;
break;
case eProne:
inputspeed = m_ProneSpeedStrafe;
break;
case eSwim:
inputspeed = m_SwimSpeedStrafe;
break;
default:
inputspeed = m_WalkSpeedStrafe;
break;
}
if(m_Sprinting)
inputspeed = m_RunSpeedStrafe*m_StaminaTable.RunSprintScale;
else if(m_stats.running)
inputspeed = m_RunSpeedStrafe;
}
if(bSuperDesignerMode)
{
if (m_Running)
inputspeed = m_pGame->p_speed_run->GetFVal();
else
inputspeed = m_pGame->p_speed_walk->GetFVal();
}
inputspeed *= fSpeedScale;
speedxyz.Normalize();
speedxyz*=inputspeed;
}
//Vec3 ppos=m_pEntity->GetPos(true);
// if player wants to jump AND proning - stand up
// otherwice if not crouching AND has enough stamina for jump
// AND not in air right now OR in water deep enough (go up then)
// AND not in landing animation
// do jump
if ((cmd.CheckAction(ACTION_JUMP)))
{
//if player is jumping when on ladder throw him back, to detach from the ladder.
if (m_stats.onLadder)
{
speedxyz[0] -= -m_psin;
speedxyz[1] -= m_pcos;
}
else if(m_CurStance == eProne)
{
GoStand(false);
cmd.RemoveAction(ACTION_JUMP);
}
else
if (m_CurStance != eCrouch
// && m_CurStance != eProne
&& ((!m_stats.flying) || IsSwimming())
&& ((m_stats.stamina>m_StaminaTable.DecoyJump&&!m_stats.flying) || IsSwimming())
&& m_JumpAniLenght<=0
)
{
m_JumpHeight[0] = m_pGame->p_jump_walk_h->GetFVal();
m_JumpHeight[1] = m_pGame->p_jump_walk_h->GetFVal();
m_JumpHeight[2] = m_pGame->p_jump_run_h->GetFVal();
m_JumpDist[0] = m_pGame->p_jump_walk_d->GetFVal();
m_JumpDist[1] = m_pGame->p_jump_walk_d->GetFVal();
m_JumpDist[2] = m_pGame->p_jump_run_d->GetFVal();
float jumpSpeedH, jumpSpeedV;
bJump = 1;
Vec3d horSpeed = speedxyz;
if(!IsSwimming())
{
if( m_RunningTime >= m_JTRun ) // if runs long enough - long jump
CalcJumpSpeed( m_JumpDist[2], m_JumpHeight[2], jumpSpeedH, jumpSpeedV );
else if( m_WalkingTime >= m_JTWalk ) // if runs long enough - long jump
CalcJumpSpeed( m_JumpDist[1], m_JumpHeight[1], jumpSpeedH, jumpSpeedV );
else
CalcJumpSpeed( m_JumpDist[0], m_JumpHeight[0], jumpSpeedH, jumpSpeedV );
horSpeed.z = 0;
horSpeed.Normalize();
speedxyz[0] = horSpeed.x*jumpSpeedH;
speedxyz[1] = horSpeed.y*jumpSpeedH;
speedxyz[2] = jumpSpeedV;
// decrease stamina - jumping is not for free!
if((m_stats.stamina-=m_StaminaTable.DecoyJump)<0)
m_stats.stamina = 0;
m_bHasJumped = true;
}
else
{
float depth = m_p3DEngine->GetWaterLevel(m_pEntity) - m_p3DEngine->GetTerrainElevation(m_pEntity->GetPos().x, m_pEntity->GetPos().y);
// if not deep and pressed jupm key - stand up, if can't stand (too deep) - push player up
if( depth<1.5f )
{
GoStand(false);
cmd.RemoveAction(ACTION_JUMP);
}
else
{
// if pressing jump in water - just push playet up
speedxyz[2] = 4.0f;
// when swimming underwater and goung up by press JUMP
// if too close to surface - don't aplpy much UP impulse
// to prevent jumping out of water
if(m_stats.fInWater<.75f)
speedxyz[2] = 0;
else if(m_stats.fInWater<2.25f)
speedxyz[2] *= (m_stats.fInWater/2.25f)*.2f;
}
}
}
}
pe_status_living status;
pPhysEnt->GetStatus((pe_status*)&status);
m_stats.jumping = (bJump)?true:false;
pe_action_move hike;
hike.iJump = bJump && !bNoGravity;
hike.dir=speedxyz;
DampInputVector(hike.dir,m_input_accel,m_input_stop_accel,true,false);
pPhysEnt->Action(&hike);
float moveVel = speedxyz[0]*speedxyz[0] + speedxyz[1]*speedxyz[1];
// if the velosity is too low - not sprinting then
if(moveVel<2.0f)//|| (m_CurStance!=eStand && m_CurStance!=eRelaxed && m_CurStance!=eSwim))
m_Sprinting = false;
/*if(pPhysEnt) do
{
pPhysEnt->Step(min(fTimeDelta,0.02f));
fTimeDelta -= 0.02f;
} while(fTimeDelta>1E-4f);*/
float *pfSlices,sumSlice;
int i,nSlices = cmd.GetTimeSlices(pfSlices);
for(i=0,sumSlice=0; i<nSlices; i++)
sumSlice += pfSlices[i];
pPhysEnt->StartStep(sumSlice);
for(i=0; i<nSlices-1 && pPhysEnt; i++)
{
pPhysEnt->Step(pfSlices[i]);
pPhysEnt = m_pEntity->GetPhysics(); // update pPhysEnt since Step callback might change it (destroy/create new)
}
m_NotRunTimeClient = m_NotRunTime;
m_RunningTimeClient = m_RunningTime;
m_WalkingTimeClient = m_WalkingTime;
m_staminaClient = m_stats.stamina;
// m_breathClient = m_stats.breath;
if (nSlices>0 && pPhysEnt) // the last slice is teh 'server catch-up' slice, client doesn't have it
pPhysEnt->Step(pfSlices[nSlices-1]);
}
///////////////////////////////////////////////
/*! Retrieves the currently selected weapon
@return selected weapon
*/
CWeaponClass* CPlayer::GetSelectedWeapon() const
{
CWeaponClass *pSelectedWeapon = m_pGame->GetWeaponSystemEx()->GetWeaponClassByID(m_nSelectedWeaponID);
// make sure the weapon class (models, scripts, etc..) is loaded ...
if (pSelectedWeapon && !pSelectedWeapon->IsLoaded())
{
pSelectedWeapon->Load();
}
return pSelectedWeapon;
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::SelectNextWeapon()
{
int curr=0;
if(m_nSelectedWeaponID != -1)
curr = m_nSelectedWeaponID;
int slot=0;
while(slot<PLAYER_MAX_WEAPONS && m_vWeaponSlots[slot]!=curr)
slot++;
slot=(slot+1)%PLAYER_MAX_WEAPONS;
int iteration=0;
while(iteration<PLAYER_MAX_WEAPONS && (m_vWeaponSlots[slot]==0 || m_vWeaponSlots[slot]==curr))
{
iteration++;
slot=(slot+1)%PLAYER_MAX_WEAPONS;
}
if(m_vWeaponSlots[slot]!=0 && m_vWeaponSlots[slot]!=curr)
SelectWeapon(m_vWeaponSlots[slot]);
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::SelectPrevWeapon()
{
int curr=0;
if(m_nSelectedWeaponID != -1)
curr=m_nSelectedWeaponID;
int slot=0;
while(slot<PLAYER_MAX_WEAPONS && m_vWeaponSlots[slot]!=curr)
slot++;
slot=(slot-1);
int iteration=0;
while(iteration<PLAYER_MAX_WEAPONS && (m_vWeaponSlots[slot]==0 || m_vWeaponSlots[slot]==curr))
{
iteration++;
slot=slot-1;
if(slot<0)
{
slot = PLAYER_MAX_WEAPONS-1;
while(slot>=0 && (m_vWeaponSlots[slot]==0))slot--;
if(slot<0)slot=0;
}
}
if(m_vWeaponSlots[slot]!=0 && m_vWeaponSlots[slot]!=curr)
SelectWeapon(m_vWeaponSlots[slot]);
}
/*! Updates the weapons of the player
@param ProcessingCmd structure of commands to process
*/
//////////////////////////////////////////////////////////////////////////
void CPlayer::ProcessWeapons(CXEntityProcessingCmd &cmd)
{
// do not allow to use weapons and move when underwater or in a wtaer volume, and
// he is actively swimming
if(!IsMyPlayer())
m_walkParams.fCurrLean=cmd.GetLeaning();
if (cmd.CheckAction(ACTION_NEXT_WEAPON) && (!m_stats.lock_weapon))
{
SelectNextWeapon();
}
else if (cmd.CheckAction(ACTION_PREV_WEAPON) && (!m_stats.lock_weapon))
{
SelectPrevWeapon();
}
else
{
if(!m_stats.lock_weapon)
{
bool bSkip = false;
int w = 0;
int WeaponGroup=0;
if (cmd.CheckAction(ACTION_WEAPON_0))
{
WeaponGroup = 10;
cmd.RemoveAction(ACTION_WEAPON_0);
}
else if (cmd.CheckAction(ACTION_WEAPON_1))
{
WeaponGroup = 1;
cmd.RemoveAction(ACTION_WEAPON_1);
}
else if (cmd.CheckAction(ACTION_WEAPON_2))
{
WeaponGroup = 2;
cmd.RemoveAction(ACTION_WEAPON_2);
}
else if (cmd.CheckAction(ACTION_WEAPON_3))
{
WeaponGroup = 3;
cmd.RemoveAction(ACTION_WEAPON_3);
}
else if (cmd.CheckAction(ACTION_WEAPON_4))
{
WeaponGroup = 4;
cmd.RemoveAction(ACTION_WEAPON_4);
}
/* else if (cmd.CheckAction(ACTION_WEAPON_5))
{
WeaponGroup = 5;
cmd.RemoveAction(ACTION_WEAPON_5);
}
else if (cmd.CheckAction(ACTION_WEAPON_6))
{
WeaponGroup = 6;
cmd.RemoveAction(ACTION_WEAPON_6);
}
else if (cmd.CheckAction(ACTION_WEAPON_7))
{
WeaponGroup = 7;
cmd.RemoveAction(ACTION_WEAPON_7);
}
else if (cmd.CheckAction(ACTION_WEAPON_8))
{
WeaponGroup = 8;
cmd.RemoveAction(ACTION_WEAPON_8);
}
*/ else
bSkip = true;
if (!bSkip)
{
w = m_nSelectedWeaponID;
bool bFirstWeapon = true;
int iFirstID=-1;
WeaponGroup-=1;
if(WeaponGroup<PLAYER_MAX_WEAPONS)
{
if(m_vWeaponSlots[WeaponGroup])
{
SelectWeapon(m_vWeaponSlots[WeaponGroup]);
}
}
}
}
}
// get the selected weapon
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
//uses this flag to affect the accuracy
if(!m_bFirstPerson)
m_stats.aiming=cmd.CheckAction(ACTION_ZOOM_TOGGLE);
if (cmd.CheckAction(ACTION_CYCLE_GRENADE))
{
m_pEntity->SendScriptEvent(ScriptEvent_CycleGrenade,0);
cmd.RemoveAction(ACTION_CYCLE_GRENADE);
}
if (cmd.CheckAction(ACTION_FIREMODE))
{
SwitchFiremode();
cmd.RemoveAction(ACTION_FIREMODE);
}
if (cmd.CheckAction(ACTION_RELOAD) && (!m_stats.lock_weapon) &&
(m_stats.underwater==0.0f) && !m_bSwimming)
{
if (pSelectedWeapon)
{
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
pSelectedWeapon->ScriptReload(m_pEntity);
}
cmd.RemoveAction(ACTION_RELOAD);
}
// Check if the player is dropping his weapon
if(cmd.CheckAction(ACTION_DROPWEAPON) && (!m_stats.lock_weapon))
{
if (pSelectedWeapon && (CountAvaliableWeapons()>1))
{
// Remove the current weapon from the player's inventory
PlayerWeaponsItor WeaponIterator = m_mapPlayerWeapons.find(m_nSelectedWeaponID);
if (WeaponIterator == m_mapPlayerWeapons.end())
{
// This should not ever happen
TRACE("Could not find dropped weapon in weapon list");
return;
}
// Notify the weapon that it has been dropped
_SmartScriptObject pTable(m_pScriptSystem);
pTable->SetValue("Player", m_pEntity->GetScriptObject());
pTable->SetValue("WeaponID", m_nSelectedWeaponID);
pSelectedWeapon->ScriptDrop(pTable);
}
// Remove the command
cmd.RemoveAction(ACTION_DROPWEAPON);
}
if (m_bWaitForFireRelease && !cmd.CheckAction(ACTION_FIRE0))
{
m_bWaitForFireRelease = false;
}
if (!m_bWaitForFireRelease)
{
m_stats.firing = (cmd.CheckAction(ACTION_FIRE0)) != 0;
}
else
m_stats.firing = false;
if(cmd.CheckAction(ACTION_FIRECANCEL))
m_stats.cancelFireFlag = true;
else
m_stats.cancelFireFlag = false;
if (!GetGame()->IsMultiplayer() || m_bWriteOccured)
m_stats.firing_grenade = false;
if ((cmd.CheckAction(ACTION_FIRE_GRENADE)))
{
if(m_stats.weapon_busy<=0)
{
m_stats.firing_grenade = true;
}
}
if (m_bWriteOccured) m_bWriteOccured = false;
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::FireGrenade(const Vec3d &origin, const Vec3d &angles, IEntity *pIShooter)
{
_SmartScriptObject pTable(m_pScriptSystem);
m_ssoHitPosVec=origin;
m_ssoHitNormVec=angles;//angles;
Vec3d dir=angles;
dir=ConvertToRadAngles(dir);
// projectiles (grenades, for ex) should inherit player's velocity
m_ssoHitDirVec=dir; //+(m_walkParams.dir.normalize()*(m_stats.fVel*0.125f));
//m_pGame->GetSystem()->GetILog()->LogToConsole("vel=%f,dir=%f,%f,%f",m_stats.fVel,m_walkParams.dir.x,m_walkParams.dir.y,m_walkParams.dir.z);
float fWaterLevel=m_p3DEngine->GetWaterLevel(m_pEntity);
pTable->SetValue("pos",m_ssoHitPosVec);
pTable->SetValue("angles",m_ssoHitNormVec);
pTable->SetValue("dir",m_ssoHitDirVec);
pTable->SetValue("lifetime",3000);
if(m_nSelectedWeaponID != -1 && m_stats.firing && !(m_stats.grenadetype!= 1 && m_stats.numofgrenades <= 0))
GetSelectedWeapon()->ScriptOnStopFiring(m_pEntity);
if (fWaterLevel>origin.z)
pTable->SetValue("underwater",0);
else
pTable->SetToNull("underwater");
m_pEntity->SendScriptEvent(ScriptEvent_FireGrenade, *pTable);
if(m_pMountedWeapon) // stop fire animation on mounted weapon
m_pMountedWeapon->SendScriptEvent(ScriptEvent_Fire,0);
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetFiring(bool bIsFiring)
{
eFireType lastft=m_stats.FiringType;
if (/*m_pSelectedWeapon &&*/ bIsFiring && IsAlive() && !m_stats.onLadder)
{
switch (m_stats.FiringType)
{
case ePressing: m_stats.FiringType=eHolding; break;
case eHolding: m_stats.FiringType=eHolding; break;
case eReleasing: m_stats.FiringType=ePressing; break;
case eNotFiring: m_stats.FiringType=ePressing; break;
default: m_stats.FiringType=eNotFiring;
}
}
else
{
switch (m_stats.FiringType)
{
case ePressing: m_stats.FiringType=eNotFiring; break;
case eHolding: m_stats.FiringType=eReleasing; break;
case eReleasing: m_stats.FiringType=eNotFiring; break;
case eNotFiring: m_stats.FiringType=eNotFiring; break;
default: m_stats.FiringType=eNotFiring;
}
}
m_stats.LastFiringType=lastft;
/*if (m_stats.FiringType == PlayerStats::eFireType::ePressing)
m_stats.FiringType = PlayerStats::eFireType::eHolding;
else if (m_stats.FiringType == PlayerStats::eFireType::eReleasing)
m_stats.FiringType = PlayerStats::eFireType::eNotFiring;*/
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::DrawThirdPersonWeapon(bool bDraw)
{
ICryCharInstance *character = m_pEntity->GetCharInterface()->GetCharacter(PLAYER_MODEL_IDX);
if (character && m_nSelectedWeaponID != -1)
{
WeaponInfo &wi = GetWeaponInfo();
if(bDraw)
{
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
string sBone = pSelectedWeapon->GetBindBone();
if (!sBone.empty())
{
wi.hBindInfo = character->AttachObjectToBone( pSelectedWeapon->GetObject(), sBone.c_str() );
}
}
else
{
wi.DetachBindingHandles(character);
character->AttachObjectToBone(NULL,NULL);
}
}
}
///////////////////////////////////////////////
/*! Selects a weapon the player should hold
@param weapon id of weapon to set
*/
bool CPlayer::SelectWeapon( int weapon, bool bCheckForAvailability )
{
PlayerWeaponsItor wi;
// if it's shooter from the vehicle - can't select weapons
if (m_nSelectedWeaponID>0 && m_pVehicle && m_pVehicle->GetWeaponUser()==this)
return false;
if (m_stats.onLadder)
return false;
if ((wi = m_mapPlayerWeapons.find(weapon)) == m_mapPlayerWeapons.end() && weapon != -1)
return false;
if (bCheckForAvailability && weapon != -1)
{
if ((* wi).second.owns == false)
return false;
}
m_pEntity->SendScriptEvent(ScriptEvent_SelectWeapon,0);
// deselect old weapon, if selected
if (m_nSelectedWeaponID != -1 && (weapon!=m_stats.weapon))
{
// unbind the entity from the player
WeaponInfo &info=GetWeaponInfo();
info.iFireMode=m_stats.firemode;
_SmartScriptObject cOnUpdateParam(m_pScriptSystem);
cOnUpdateParam->SetValue("shooter", m_pEntity->GetScriptObject());
GetSelectedWeapon()->ScriptOnDeactivate(m_pEntity);
}
SetWeapon(weapon);
// call OnActivate when the weapon changes
if (m_nSelectedWeaponID != -1 && (weapon != m_stats.weapon))
{
WeaponInfo &info=GetWeaponInfo();
m_stats.firemode=info.iFireMode;
m_bWaitForFireRelease = true;
GetSelectedWeapon()->ScriptOnActivate(m_pEntity);
// make sure that the firemode is correct on script side
_SmartScriptObject pObj(m_pScriptSystem);
pObj->SetValue( "firemode", m_stats.firemode);
pObj->SetValue( "ignoreammo", true);
bool bCanSwitch;
m_pEntity->SendScriptEvent(ScriptEvent_FireModeChange, *pObj, &bCanSwitch);
// force animation update on first person weapon
if (GetSelectedWeapon()->GetCharacter())
GetSelectedWeapon()->GetCharacter()->ForceUpdate();
}
m_stats.weapon = m_nSelectedWeaponID;
return true;
}
void CPlayer::SetWeapon(int iClsID)
{
// ValidateHeap();
// check if we want to select the weapon we are holding
if(iClsID == m_nSelectedWeaponID)
return;
// we want to hide the currently selected weapon
if(m_nSelectedWeaponID != -1)
{
if (m_stats.LastFiringType!=eNotFiring)
GetSelectedWeapon()->ScriptOnStopFiring(m_pEntity);
SetWeaponPositionState(WEAPON_POS_UNDEFINED);
if (IsMyPlayer())
{
ICryCharInstance *pChar = GetEntity()->GetCharInterface()->GetCharacter(1);
if (pChar)
pChar->DetachAll();
GetEntity()->DrawCharacter(1,0);
GetEntity()->ResetAnimations(1);
}
}
// here we actually set the new weapon
m_nSelectedWeaponID = iClsID;
// returns the newly selected weapon!!!
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
if(pSelectedWeapon)
{
// attach to bone for third person view
HoldWeapon();
// set first person weapon
if (IsMyPlayer() || m_pGame->IsMultiplayer())
GetEntity()->GetCharInterface()->SetCharacter(1, pSelectedWeapon->GetCharacter());
m_pScriptObject->SetValue("weapon", pSelectedWeapon->GetScriptObject());
m_pScriptObject->SetValue("weaponid", m_nSelectedWeaponID);
} else {
GetEntity()->GetCharInterface()->SetCharacter(1, 0);
m_pScriptObject->SetToNull("weapon");
m_pScriptObject->SetToNull("weaponid");
m_stats.fSpeedScale = 1.0f;
m_nSelectedWeaponID = -1;
}
}
/*! return the position and orientation of the firepoint of a player
@param firePos position
@param fireAngles orientation(in degrees)
*/
void CPlayer::GetFirePosAngles(Vec3d& firePos, Vec3d& fireAngles)
{
if (!m_bIsAI)
{
//we must always take leaning into account!
fireAngles = m_vEyeAngles+m_vShake;
//fireAngles = m_pEntity->GetAngles()+m_vShake;
firePos = m_vEyePos;
/*
if (m_pMountedWeapon)
{
IEntityCharacter *pIChar = m_pMountedWeapon->GetCharInterface();
ICryCharInstance * cmodel = pIChar->GetCharacter(0);
if (!cmodel)
return;
ICryBone * pBone = cmodel->GetBoneByName("spitfire");
if(!pBone)
return;
Vec3 vBonePos = pBone->GetBonePosition();
Vec3 angles = m_pMountedWeapon->GetAngles();
Matrix44 m=Matrix34::GetRotationXYZ34( Deg2Rad(angles), m_pMountedWeapon->GetPos() ); //set rotation and translation in one function call
m = GetTransposed44(m); //TODO: remove this after E3 and use Matrix34 instead of Matrix44
// get result
firePos = m.TransformPointOLD(vBonePos);
}
else
*/
if (m_pVehicle)
{
// if we are in vehicle, the cam offset seems to be wrong -
// move to the exact camera position
//[kirill] - coz camera is offseted a bit for gunner - away from weapon
// if gunner's camera moved - add same offset here - now it's eyePos
// firePos=m_pEntity->GetCamera()->GetPos();
// if driver - using vehicle's autoveapon
// - just get current weapon pos/angles from the vehicle
// if (m_stats.inVehicleState==PVS_DRIVER && m_pVehicle->GetWeaponUser()==this )
if (m_stats.inVehicleState==PVS_DRIVER )
{
string vehicleWeaponName = m_pVehicle->GetWeaponName( m_stats.inVehicleState );
if(!vehicleWeaponName.empty() && vehicleWeaponName != m_pVehicle->m_sNoWeaponName)
m_pVehicle->GetFirePosAngles( firePos, fireAngles );
else if(IsMyPlayer()) // use vehicle camera position only for local player
firePos = m_pVehicle->GetCamPos();
else
firePos += Vec3(0.0f, 0.0f, -1.04f); // UGLY FIX FOR THE INFLATABLE BOAT!
// firePos on the server was 0.6 meters less than the client
}
// if passenger - get camera position from vehicle, it's smoothed with some spring simulation
else if (m_stats.inVehicleState == PVS_PASSENGER)
{
if(IsMyPlayer()) // use vehicle camera position only for local player
firePos = m_pVehicle->GetCamPos();
else // in MP on server use eye helper position
m_pVehicle->GetEntity()->GetHelperPosition(m_sVehicleEyeHelper.c_str(), firePos);
}
return;
}
}
else
{
if (m_pEntity->GetAI())
{
//<<FIXME>> this code will go - testing purposes
firePos = m_pEntity->GetAI()->GetPos();
// Vec3d angles = m_pEntity->GetAI()->GetState()->vFireDir;
// angles=ConvertVectorToCameraAngles(angles);
if(!m_pMountedWeapon) // normal weapon - shoot wherever
fireAngles = m_vDEBUGAIFIREANGLES;
// fireAngles = angles;
else // if using mounted weapon - angles are restricted
fireAngles = m_pEntity->GetAngles();
}
}
}
float CPlayer::CalculateAccuracyFactor(float accuracy)
{
if(m_nSelectedWeaponID == -1) return 0.0f;
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
WeaponParams wp;
GetCurrentWeaponParams(wp);
float factor = (wp.fMaxAccuracy - wp.fMinAccuracy) * (1.0f-accuracy) + wp.fMinAccuracy;
// factor 0 = bad, 1 = good
if (m_stats.aiming)
{
factor = factor + wp.fAimImprovement;
}
// apply sprinting if the sprint button is pressed and the player is moving
if (m_Sprinting && m_stats.moving)
{
factor = factor - wp.fSprintPenalty;
}
factor = 1 - factor;
factor = __max(factor, 0.000f);
float stanceAccuracyModifier = 1.0f;
// process weapon specific accuracy modifier based on stance
stanceAccuracyModifier = wp.fAccuracyModifierStanding;
if (m_CurStance == eCrouch)
{
stanceAccuracyModifier = wp.fAccuracyModifierCrouch;
}
else if (m_CurStance == eProne)
{
stanceAccuracyModifier = wp.fAccuracyModifierProne;
}
return factor * stanceAccuracyModifier;
}
void CPlayer::UpdateMelee()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
//MELEE ATTACK/////////////////////////////////////
if(m_stats.melee_attack && (m_stats.weapon_busy<=0) && (m_stats.melee_distance > 0.0f))
{
//TRACE("UATTATATATATATATATA!");
_SmartScriptObject so(m_pScriptSystem);
Vec3d firePos;
Vec3d fireAngles;
GetFirePosAngles(firePos, fireAngles);
Vec3d dir(0,-1,0);
Matrix44 tm = Matrix44::CreateRotationZYX(-fireAngles*gf_DEGTORAD); //NOTE: angles in radians and negated ;
dir = GetTransposed44(tm)*(dir);
m_ssoHitPosVec = firePos;
m_ssoHitDirVec = dir;
so->BeginSetGetChain();
so->SetValueChain("pos",m_ssoHitPosVec);
so->SetValueChain("dir",m_ssoHitDirVec);
so->SetValueChain("distance", m_stats.melee_distance);
so->SetValueChain("shooter",m_pEntity->GetScriptObject());
_SmartScriptObject soTarget(m_pScriptSystem,true);
if (GetScriptObject()->GetValue("melee_target", soTarget))
{
so->SetValueChain("melee_target", *soTarget);
}
so->EndSetGetChain();
m_pEntity->SendScriptEvent(ScriptEvent_MeleeAttack,so);
m_stats.melee_attack = false;
m_pEntity->GetScriptObject()->SetToNull("melee_target");
}
}
///////////////////////////////////////////////
/*! Updates the selected weapon
*/
void CPlayer::UpdateWeapon()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
float frametime=m_pTimer->GetFrameTime();
if(m_stats.firing_grenade)
{
FRAME_PROFILER( "UpdateWeapon::Grenade",GetISystem(),PROFILE_GAME );
Vec3d firePos;
Vec3d fireAngles;
GetFirePosAngles(firePos, fireAngles);
if(m_stats.weapon_busy<=0)
FireGrenade(firePos, fireAngles, m_pEntity);
if (!GetGame()->IsMultiplayer())
m_stats.firing_grenade = false;
}
if(m_nSelectedWeaponID == -1) return;
WeaponParams wp;
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
GetCurrentWeaponParams(wp);
m_fAccuracyMod=1;
if(m_pGame->IsServer())
{
// make sure that the AI is always using the right firemode
if(m_bIsAI)
{
FRAME_PROFILER( "UpdateWeapon::SwitchFiremode",GetISystem(),PROFILE_GAME );
SwitchFiremode(pSelectedWeapon->GetAIFireMode());
}
if(m_stats.firing){
m_fAccuracy=m_fAccuracy-(frametime);
}else{
m_fAccuracy=m_fAccuracy-(m_pGame->w_accuracy_gain_scale*frametime);
}
m_fAccuracy=__max(m_fAccuracy, 0.1f);
if(!m_pMountedWeapon && !m_pVehicle)
{
if(m_stats.running)
{
if(m_fAccuracy<wp.accuracy_decay_on_run)
{
m_fAccuracy=min(wp.accuracy_decay_on_run,m_fAccuracy+(frametime*6));
}
}
else if(m_stats.moving)
{
if(m_fAccuracy<(wp.accuracy_decay_on_run))
{
m_fAccuracy=min(wp.accuracy_decay_on_run,m_fAccuracy+(frametime*3));
}
}
}
if(m_stats.crouch || m_stats.prone){
m_fAccuracyMod-=0.2f;
}
if(m_stats.aiming)
{
m_fAccuracyMod-=0.3f;
}
//TRACE("m_stats.accuracy=%f",m_stats.accuracy);
//clamp accuracy to 1 byte
BYTE acc=(BYTE)((m_fAccuracy*m_fAccuracyMod)/(1.f/255));
m_stats.accuracy=(float)((acc)*(1.f/255));
}
WeaponInfo &wi=GetWeaponInfo();
if(m_stats.weapon_busy>0)
{
m_stats.firing=false;
}
else{
if(m_stats.weapon_busy!=0)
{
FRAME_PROFILER( "UpdateWeapon::ScriptWeaponReady",GetISystem(),PROFILE_GAME );
wi.fireTime=m_pTimer->GetCurrTime();
//wi->fireFirstBulletTime=0;
pSelectedWeapon->ScriptWeaponReady(m_pEntity);
}
m_stats.weapon_busy=0;
}
//Update the weapon entity
if (IsMyPlayer() || (m_pGame->cl_scope_flare->GetIVal() == 1 && m_weaponPositionState == WEAPON_POS_HOLD ))
pSelectedWeapon->Update(this);
if (m_stats.cancelFireFlag)
pSelectedWeapon->CancelFire();
if((m_stats.ammo_in_clip<=0 && m_stats.ammo>0 && (!m_stats.reloading) && (m_stats.weapon_busy<=0)) && (!m_stats.firing) &&
(m_stats.underwater==0.0f) && !m_bSwimming)
{
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
pSelectedWeapon->ScriptReload(m_pEntity);
wi.fireTime=m_pTimer->GetCurrTime();
}
else if(!m_stats.reloading && m_stats.weapon_busy<=0)
{
if(m_stats.ammo_in_clip>0 || wp.no_ammo)
{
if ((m_pTimer->GetCurrTime() - wi.fireLastShot) < pSelectedWeapon->GetFireRate(m_stats.FiringType))
m_stats.fire_rate_busy = true;
else
m_stats.fire_rate_busy = false;
m_stats.canfire = true;
}
else
{
if(m_stats.canfire)
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
m_stats.canfire=false;
}
SetFiring(m_stats.firing);
if (m_stats.FiringType != eNotFiring)
{
float fFireRate = pSelectedWeapon->GetFireRate(m_stats.FiringType);
//is in the right state for firing
if( wp.fire_activation&m_stats.FiringType)
{
Vec3d firePos;
Vec3d fireAngles;
GetFirePosAngles(firePos, fireAngles);
if(!(m_stats.LastFiringType&wp.fire_activation))
{
wi.fireTime=m_pTimer->GetCurrTime();
wi.fireFirstBulletTime=wi.fireTime;
m_fRecoilXDelta=0;
}
float deltatime=max(0.001f,m_pTimer->GetCurrTime()-wi.fireFirstBulletTime);
int bullets=0;
//[kirill] - can't shoot if using mounted vehicle weapon and weapon is off of angle limits
if (m_pGame->m_nDEBUG_TIMING==1)
{
m_pGame->m_nDEBUG_TIMING = 2;
//[Michael Glueck] has nothing to do with AI
if(m_bIsAI)
{
float fTime = m_pGame->GetSystem()->GetITimer()->GetAsyncCurTime();
m_pGame->m_pLog->Log(" Time between loading and having AI shooting is %.3f seconds",fTime-m_pGame->m_fDEBUG_STARTTIMER);
}
}
if(m_stats.crosshairOnScreen)
if(bullets = pSelectedWeapon->Fire( firePos,fireAngles, this, wi, GetRedirected() ? GetRedirected()->GetPhysics() : NULL))
{
FRAME_PROFILER( "UpdateWeapon::ScriptEvent_Fire",GetISystem(),PROFILE_GAME );
if(m_pMountedWeapon) // start fire animation on mounted weapon
m_pMountedWeapon->SendScriptEvent(ScriptEvent_Fire,1);
else if( m_pVehicle )
{
WeaponInfo &wi = GetWeaponInfo();
m_pVehicle->WeaponState( m_pEntity->GetId(), true, wi.iFireMode);
}
if(m_pGame->IsServer())
{
m_stats.last_accuracy=(BYTE)(m_stats.accuracy/(1.f/255));
m_fAccuracy=min(1,m_fAccuracy+((deltatime*(m_pGame->w_accuracy_decay_speed*fFireRate)*bullets)));
BYTE acc=(BYTE)((m_fAccuracy*m_fAccuracyMod)/(1.f/255));
m_stats.accuracy=(float)((acc)*(1.f/255));
}
//add recoil
if(!IsAI()) //IsMyPlayer()) // every player should have recoil
{
//pseudo realistic recoil
if((m_fRecoilXDelta+1)<m_pGame->w_recoil_max_degree)
{
float delta=min(1, (m_pTimer->GetCurrTime()-wi.fireFirstBulletTime)+wp.fFireRate);
float recoilx=wp.max_recoil*((delta*2)*2);
float recoilz=recoilx;
uint8 ucSeed = m_SynchedRandomSeed.GetRandomSeedC();
m_SynchedRandomSeed.IncreaseRandomSeedC();
// GetISystem()->GetILog()->Log(">> Recoil Recoil %d %d",(int)GetEntity()->GetId(),(int)(ucSeed)); // debug
float fRandA = m_SynchedRandomSeed.GetRandTable(ucSeed);
float fRandB = m_SynchedRandomSeed.GetRandTable(ucSeed+13);
m_fRecoilXUp=m_fRecoilX=(min(wp.max_recoil,wp.min_recoil+recoilx+(recoilx*fRandA)))*bullets;
m_fRecoilZUp=m_fRecoilZ=((m_fRecoilXUp)-(m_fRecoilXUp*fRandA)*2)*bullets;
if (m_stats.aiming)
{
m_fRecoilX *= wp.fAimRecoilModifier;
m_fRecoilXUp *= wp.fAimRecoilModifier;
m_fRecoilZ *= wp.fAimRecoilModifier;
m_fRecoilZUp *= wp.fAimRecoilModifier;
}
}
else
{
//m_fRecoilXUp=0;
}
}
}
}
//
}
else if(m_stats.LastFiringType!=eNotFiring)
{
FRAME_PROFILER( "UpdateWeapon::ScriptOnStopFiring",GetISystem(),PROFILE_GAME );
//was firing and now stoppped
//sending an event for stooping various effects
wi.fireFirstBulletTime=0;
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
if(m_pMountedWeapon) // stop fire animation on mounted weapon
m_pMountedWeapon->SendScriptEvent(ScriptEvent_Fire,0);
else if( m_pVehicle ) // stop fire animation on weapon on wehicle
m_pVehicle->WeaponState( m_pEntity->GetId(), false );
}
}
}
// returns ACTUAL plaerys direction angle - the one it's shooting/looking at
Vec3d CPlayer::GetActualAngles()
{
Vec3d angles;
if( m_pGame->p_EyeFire->GetIVal()==0)
{
if(m_aimLook)
{
Vec3d pos;
GetFirePosAngles( pos, angles );
}
else
angles = m_pEntity->GetAngles();
}
else
angles = m_pEntity->GetAngles();
angles.x = Snap_s180(angles.x);
angles.y = Snap_s180(angles.y);
angles.z = Snap_s180(angles.z);
return angles;
}
///////////////////////////////////////////////
/*! Updates procedural animation of character
*/
void CPlayer::UpdateBonesRotation( )
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
//m_pGame->m_pLog->LogToConsole("\003 %.2f %.2f ",m_LegAngle,m_LegDeltaAngle);
//also when on ladder we have to rotate some bones (head)
if (m_LegRotation || m_stats.onLadder)
{
// apply lean angles to player character
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
Vec3d angles = GetActualAngles();
if (pChar)
{
CryQuat qtH;
CryQuat qtV;
CryQuat qtR;
CryQuat qtTotal;
CryQuat qtParent;
CryQuat qtParentCnj;
float xAngle = -angles.x;
// float xAngle = Snap180(-angles.x);
/*
if( xAngle>180 )
xAngle = xAngle - 360.0f;
else if( xAngle<-180 )
xAngle = 360.0f+xAngle;
*/
// float leanBodyAngle = -(180.0f - (180 - m_walkParams.fCurrLean*m_pGame->p_lean->GetFVal()*2.0f));
float leanBodyAngle = -(180.0f - (180 - m_walkParams.fCurrLean*m_LeanDegree*2.0f));
// leanBodyAngle = 0;
leanBodyAngle *= 2.0f;
// leanBodyAngle *= 5.0f;
// float zAngle = m_LegDeltaAngle + m_LegMovingAngle;
float zAngle = m_LegDeltaAngle;
/*
if(m_pBoneSpine1)
qtParent = m_pBoneSpine1->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtH.SetRotationAA( DEG2RAD(m_LegDeltaAngle), Vec3(0.0f, 0.0f, 1.0f) );
//qtH.SetRotationAA( DEG2RAD(45), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle), Vec3(1.0f, 0.0f, 0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle), Vec3(0.0f, 1.0f, 0.0f) );
qtTotal = qtR*qtV*qtH;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
if(m_pBoneSpine1)
m_pBoneSpine1->SetPlusRotation( qtTotal );
return;
//*/
//on ladder we rotate just the head bone to follow the player view.
if (m_stats.onLadder)
{
if(m_pBoneNeck)
m_pBoneNeck->ResetPlusRotation();
if(m_pBoneSpine1)
m_pBoneSpine1->ResetPlusRotation();
if(m_pBoneSpine2)
m_pBoneSpine2->ResetPlusRotation();
if (m_stats.onLadder)
{
zAngle = Snap_s180(m_vLadderAngles.z - m_pEntity->GetAngles().z);
//m_pGame->GetSystem()->GetILog()->Log("head:%.1f,body:%.1f",zAngle,m_vLadderAngles.z);
}
//limit the head angle in a 120 degree range.
if (zAngle > 60.0f)
zAngle = 60.0f;
if (zAngle < -60.0f)
zAngle = -60.0f;
//smooth the head rotation.
Ang3 delta = Ang3(xAngle*0.5f,0,zAngle) - m_vHeadAngles;
m_vHeadAngles = m_vHeadAngles + delta*min(1.0f,m_pTimer->GetFrameTime()*10.0f);
m_vHeadAngles.Snap180();
//apply rotation
qtH.SetRotationAA( DEG2RAD(m_vHeadAngles.z), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(m_vHeadAngles.x), Vec3(1.0f, 0.0f, 0.0f) );
qtParent = m_pBoneHead->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtV*qtH*qtParentCnj;
m_pBoneHead->SetPlusRotation( qtTotal );
}
else if(m_CurStance == eProne)
{
m_LegADeltaLimit = 0;
if(m_pBoneHead)
m_pBoneHead->SetPlusRotation(0,0,angles.x);
if(m_pBoneNeck)
m_pBoneNeck->ResetPlusRotation();
if(m_pBoneSpine1)
m_pBoneSpine1->ResetPlusRotation();
if(m_pBoneSpine2)
m_pBoneSpine2->ResetPlusRotation();
}
// else if(m_aimLook) //aiming
else if(m_CurStance == eCrouch || m_CurStance == eStealth || m_CurStance == eStand)
{
//force weapon (shoulders) be same direction as ent direstion
//m_LegADeltaLimit = 60;
m_LegADeltaLimit = m_pGame->pa_leg_limitaim->GetFVal();// 60;
if(m_pBoneHead)
m_pBoneHead->ResetPlusRotation();
if(m_pBoneNeck)
m_pBoneNeck->ResetPlusRotation();
float amountSpine = m_pGame->pa_spine->GetFVal();
float amountSpine1 = m_pGame->pa_spine1->GetFVal();
float amountSpine2;
amountSpine2 = 1.0f - (amountSpine1 + amountSpine);
if(m_pBoneSpine)
{
qtH.SetRotationAA( DEG2RAD(zAngle*amountSpine), Vec3(0.0f,0.0f,1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.2f), Vec3(1.0f,0.0f,0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.2f), Vec3(0.0f,1.0f,0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine->SetPlusRotation( qtTotal );
}
if(m_pBoneSpine1)
{
qtH.SetRotationAA( DEG2RAD(zAngle*amountSpine1), Vec3(0.0f,0.0f,1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.4f), Vec3(1.0f,0.0f,0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.4f), Vec3(0.0f,1.0f,0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine1->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine1->SetPlusRotation( qtTotal );
}
if(m_pBoneSpine2)
{
qtH.SetRotationAA( DEG2RAD(zAngle*amountSpine2), Vec3(0.0f,0.0f,1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.4f), Vec3(1.0f,0.0f,0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.4f), Vec3(0.0f,1.0f,0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine2->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine2->SetPlusRotation( qtTotal );
}
}
else
{
//m_LegADeltaLimit = 110;
m_LegADeltaLimit = m_pGame->pa_leg_limitidle->GetFVal();
if(m_pBoneHead)
{
qtH.SetRotationAA( DEG2RAD(zAngle*.3f), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.5f), Vec3(1.0f, 0.0f, 0.0f) );
// qtTotal = qtV*qtH;
qtParent = m_pBoneHead->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtV*qtH*qtParentCnj;
m_pBoneHead->SetPlusRotation( qtTotal );
}
if(m_pBoneNeck)
{
qtH.SetRotationAA( DEG2RAD(zAngle*.3f), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.2f), Vec3(1.0f, 0.0f, 0.0f) );
// qtTotal = qtV*qtH;
qtParent = m_pBoneNeck->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtV*qtH*qtParentCnj;
m_pBoneNeck->SetPlusRotation( qtTotal );
}
if(m_pBoneSpine)
{
qtH.SetRotationAA( DEG2RAD(zAngle*.1f), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.1f), Vec3(1.0f, 0.0f, 0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.1f), Vec3(0.0f, 1.0f, 0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine->SetPlusRotation( qtTotal );
}
if(m_pBoneSpine1)
{
qtH.SetRotationAA( DEG2RAD(zAngle*.1f), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.1f), Vec3(1.0f, 0.0f, 0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.5f), Vec3(0.0f, 1.0f, 0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine1->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine1->SetPlusRotation( qtTotal );
}
if(m_pBoneSpine2)
{
qtH.SetRotationAA( DEG2RAD(zAngle*.2f), Vec3(0.0f, 0.0f, 1.0f) );
qtV.SetRotationAA( DEG2RAD(xAngle*.1f), Vec3(1.0f, 0.0f, 0.0f) );
qtR.SetRotationAA( DEG2RAD(leanBodyAngle*.4f), Vec3(0.0f, 1.0f, 0.0f) );
// qtTotal = qtR*qtV*qtH;
qtParent = m_pBoneSpine2->GetParentWQuat();
qtParentCnj = qtParent;
qtParentCnj.w = -qtParentCnj.w;
qtTotal = qtParent*qtR*qtV*qtH*qtParentCnj;
m_pBoneSpine2->SetPlusRotation( qtTotal );
}
//m_pBoneSpine1->SetPlusRotation(-m_LegDeltaAngle*.10f, -leanBodyAngle*.5f,
// -xAngle*.1f);//GetAngleDifference360(0, -angles.x)*.5f);
}
}
}
else
{
ResetRotateHead();
}
}
///////////////////////////////////////////////
///////////////////////////////////////////////
/*!
*/
void CPlayer::ResetRotateHead()
{
if(m_pBoneHead)
m_pBoneHead->ResetPlusRotation();
if(m_pBoneNeck)
m_pBoneNeck->ResetPlusRotation();
if(m_pBoneSpine)
m_pBoneSpine->ResetPlusRotation();
if(m_pBoneSpine1)
m_pBoneSpine1->ResetPlusRotation();
if(m_pBoneSpine2)
m_pBoneSpine2->ResetPlusRotation();
}
///////////////////////////////////////////////
///////////////////////////////////////////////
/*!
*/
void CPlayer::UpdateFireAnimations()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
//fixme - when dead - needs different update
if(!IsAlive())
return;
if( m_pGame->pa_blend1->GetFVal()<0.0f )
return;
// stop fire animation when
// in relaxed stance
// swimming
// on ladder
if(!m_AnimationSystemEnabled || m_CurStance == eRelaxed || m_bSwimming || m_stats.onLadder)
{
// m_pEntity->GetCurrentAnimation(0, 1)
m_sPrevAniNameLayer1.clear();
m_pEntity->StartAnimation(0, NULL, 1, .15f);
return;
}
const char *weaponShoot = "_utshoot"; // two hands animations
const char *weaponAim = "_utaim";
char aniName[64];
if (!GenerateAnimationName( aniName ))
{
return;
}
char aniName0[64]; // store the base layer0 animation name
memcpy( aniName0, aniName, strlen(aniName) );
// fixme - has to be changed for multyplayer
//m_stats.weapon_busy<=0
//check for melee attack/reloading/whatever
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
if(m_JumpStage==1)
{
m_pEntity->StartAnimation(0, NULL, 1, .15f);
//m_pEntity->StartAnimation(0, "aidle", 1, .15f);
m_sPrevAniNameLayer1 = "";
return;
}
if(m_JumpStage!=0)
return;
if(!pSelectedWeapon ) // no weapon in hands - use machete animations
{
weaponShoot = "_umshoot";
weaponAim = "_umaim";
}
else if(pSelectedWeapon->m_HoldingType == 2) // pistol animations
{
weaponShoot = "_upshoot";
weaponAim = "_upaim";
}
else if(pSelectedWeapon->m_HoldingType == 3) // machete animations
{
weaponShoot = "_umshoot";
weaponAim = "_umaim";
}
else if(pSelectedWeapon->m_HoldingType == 4) // building tool animations
{
weaponShoot = "_ubshoot";
weaponAim = "_ubaim";
}
else if(pSelectedWeapon->m_HoldingType == 5) // scouttool/healthpack animations
{
weaponShoot = "_usshoot";
weaponAim = "_usaim";
}
if ( m_stats.firing_grenade)
m_bGrenadeAnimation = true;
if ( m_bGrenadeAnimation )
{
if(m_stats.weapon_busy<=0)
m_bGrenadeAnimation = false;
else
{
const char *grenadeAim = "grenade_mp";
if(m_sPrevAniNameLayer1 != grenadeAim)
if(m_pEntity->StartAnimation(0, grenadeAim, 1, .2f, true)) //.2f
m_sPrevAniNameLayer1 = grenadeAim;
}
}
else
if( m_aimLook && m_stats.canfire )
{
m_fShootAniLength -= m_pTimer->GetFrameTime();
if(m_bWeaponJustFired) // do fire animation
{
m_bWeaponJustFired = false;
strcat( aniName,weaponShoot );
m_fShootAniLength = m_pEntity->GetAnimationLength( aniName );
}
else if( m_fShootAniLength<=0 ) // fire animation over - do aim animation
{
strcat( aniName,weaponAim );
}
else
{
// still playing fire animation
strcat( aniName,weaponShoot );
//return;
}
if(m_sPrevAniNameLayer1 == aniName)
return;
// float blendTime = m_pGame->pa_blend1->GetFVal();
// GetBlendTime( aniName, blendTime );
// blend time has to be the same as for base animation in layer 0
// float blendTime = m_pGame->pa_blend1->GetFVal();
// GetBlendTime( aniName0, blendTime );
float blendTime = m_pGame->pa_blend0->GetFVal();
// if animation is shorter than blend time - it blands to base animation ( which is bad )
float aniLenght = m_pEntity->GetAnimationLength(aniName);
if( blendTime>aniLenght )
blendTime = aniLenght; //0;
if(m_pEntity->StartAnimation(0, aniName, 1, blendTime, true)) //.2f
m_sPrevAniNameLayer1 = aniName;
}
else // not shooting/aiming - weapon down animation
{
if(pSelectedWeapon && pSelectedWeapon->m_HoldingType == 2) // pistol animations
{
strcat( aniName,"_upidle" );
// PETAR no animations for all stances - temporary HACK
strcpy(aniName,"aidle_upidle");
//--------------------
if(m_sPrevAniNameLayer1 == aniName)
return;
// float blendTime = m_pGame->pa_blend1->GetFVal();
// GetBlendTime( aniName, blendTime );
// blend time has to be the same as for base animation in layer 0
float blendTime = m_pGame->pa_blend0->GetFVal();
GetBlendTime( aniName0, blendTime );
// if animation is shorter than blend time - it blands to base animation ( which is bad )
float aniLenght = m_pEntity->GetAnimationLength(aniName);
if( blendTime>aniLenght )
blendTime = aniLenght; //0;
// try to start pistol idle for current stance/movement
if(m_pEntity->StartAnimation(0, aniName, 1, blendTime, true))
{
m_sPrevAniNameLayer1 = aniName;
return;
}
strcpy( aniName,"aidle_upidle" );
if(m_sPrevAniNameLayer1 == aniName)
return;
// if animation is shorter than blend time - it blands to base animation ( which is bad )
aniLenght = m_pEntity->GetAnimationLength(aniName);
if( blendTime>aniLenght )
blendTime = aniLenght; //0;
// use aim aidle stance
if(m_pEntity->StartAnimation(0, aniName, 1, blendTime, true))
{
m_sPrevAniNameLayer1 = aniName;
return;
}
}
if(m_sPrevAniNameLayer1.empty())
return;
m_pEntity->StartAnimation(0, NULL, 1, .15f);
m_sPrevAniNameLayer1 = "";
m_fShootAniLength = 0.0f;
}
}
///////////////////////////////////////////////
///////////////////////////////////////////////
/*!
*/
void CPlayer::UpdateJumpAnimations()
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
if( m_pGame->pa_blend2->GetFVal()<0.0f )
return;
if(!m_AnimationSystemEnabled)
return;
const char *aniName;
// if(m_FlyTime<.15f && !m_stats.landing)
if( m_FlyTime<.35f )
{
if( m_sPrevAniNameLayer2 == "jump_air" )
{
m_pEntity->StartAnimation(0, NULL, 2, .1f);
m_sPrevAniNameLayer2.clear();
}
return;
}
if( m_stats.flying )
aniName = "jump_air";
if(m_stats.landing)
aniName = "jump_land";
if(m_pEntity->GetCurrentAnimation(0, 2)<0)
m_sPrevAniNameLayer2.clear();
if (strlen(aniName) == 0 || m_sPrevAniNameLayer2 == aniName )
return;
float blendTime = m_pGame->pa_blend2->GetFVal();
GetBlendTime( aniName, blendTime );
if(m_pEntity->StartAnimation(0, aniName, 2, blendTime))
m_sPrevAniNameLayer2 = aniName;
}
///////////////////////////////////////////////
///////////////////////////////////////////////
/*! Updates walking-flags for the player so the correct animation can be played back
*/
void CPlayer::UpdateCharacterAnimations( SPlayerUpdateContext &ctx )
{
if(!IsAlive()) // if dead - deadBodyPhysics takes over
return;
if(m_pMountedWeapon)
{
UpdateCharacterAnimationsMounted( ctx );
return;
}
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
//float MIN_WALK_SPEED = m_WalkSpeed*.15f;
// float LEFT_RIGHT_COS = .8f;
// float LEFT_RIGHT_COS_TRH = 0.91f;
float MIN_CROUCH_SPEED = m_CrouchSpeed*.17f;
float MIN_PRONE_SPEED = m_ProneSpeed*.17f;
//bool moving = false;
bool flying = false;
//bool running = false;
bool forward = false;
// New variables for script based version
int nStanding = 0; // 0 = Standing( combat ), 1 = Crouching, 2 = Prone, 3 = Stealth, 4 = Standing( relaxed )
int nStrafe = 0;
int nForward = 0;
int nMode = 0; // 0 = Idle, 1 = Walking, 2 = Running, 3 = Jump, 4 = Flying, 6 = Turning, 7 = sprinting
// Create a new status object. The fields are initialized for us
pe_status_living &status = ctx.status;
// Get a pointer to the physics engine
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
PhysicsVars *physvars = m_pGame->GetSystem()->GetIPhysicalWorld()->GetPhysVars();
m_stats.landing = false;
// If the physics says the player is flying, set the flag
if (status.bFlying)
{
flying = true;
m_FlyTime += m_pTimer->GetFrameTime();
m_LandTime = 0;
// Calculate our current Vertical speed - to use for falling damage
Vec3 vel = status.vel;
if (status.pGroundCollider)
vel -= status.velGround;
m_walkParams.vertSpeedFalling = vel.z;
}
else
{
// If we were flying previously, but have stopped, set the flag
if (m_stats.flying)
{
if(m_FlyTime>.5f) // if more than .5 sec in air - play land animation
m_stats.landing = true;
// m_pEntity->SendScriptEvent(ScriptEvent_AnimationKey,1);
if(m_Dynamics.gravity!=0.0f) // in 0 gravity landing is not possible
if(m_walkParams.vertSpeedFalling<0.0f ) // falling down
m_pEntity->SendScriptEvent(ScriptEvent_Land, (int)(-m_walkParams.vertSpeedFalling*100));
}
m_FlyTime = 0;
m_LandTime += m_pTimer->GetFrameTime();
}
// Store the current flying and landing states
m_stats.flying = flying;
// [Anton] a piece of code moved to UpdatePhysics
// here goes stance determination -stuff
// Check if the player is stealth
if (m_CurStance == eStealth)
{
nStanding = 3;
// Check if the player is moving
// This is true if the player is running, moving left, moving right, or moving at all
if (m_stats.fVel > MIN_CROUCH_SPEED)
{
if (m_stats.running)
nMode = 2;
else
nMode = 1;
}
}
// Check if the player is crouching
else if (m_CurStance == eCrouch)
{
nStanding = 1;
// Check if the player is moving
// This is true if the player is running, moving left, moving right, or moving at all
if (m_stats.fVel > MIN_CROUCH_SPEED)
{
// Crouching movement.
nMode = 1;
}
}
else if(m_CurStance == eProne)
{
if (m_stats.fVel > MIN_PRONE_SPEED)
nMode = 1;
nStanding = 2;
}
else // must be standing
{
if (m_CurStance == eRelaxed) //Standing( relaxed ), otherwise - standing combat
nStanding = 4;
// Check if the player is moving
// This is true if the player is running, moving left, moving right, or moving at all
if (m_stats.moving)
{
// Check if the player is running
if (m_stats.running)
{
nMode = 2;
if( m_Sprinting )
nMode = 7;
}
else
{
// Walking
nMode = 1;
}
}
else
{
nMode = 0;
}
}
// stance stuff over
// here goes movement direction/type determination -stuff
if(m_stats.moving)
{
Ang3 playerLookAngles = GetActualAngles();
Ang3 playerMoveAngles = (Ang3)status.vel;
playerMoveAngles.normalize();
playerMoveAngles=ConvertUnitVectorToCameraAngles(playerMoveAngles);
playerMoveAngles.Snap180();
// float moveDeltaAngle = playerLookAngles.DifferenceZ( playerMoveAngles );
float moveDeltaAngle = Snap_s180(playerLookAngles.z-playerMoveAngles.z);
if(m_bSwimming)
{
// if( moveDeltaAngle<120 && moveDeltaAngle>-80 )
if( Ffabs(moveDeltaAngle)<120 )
{
// forward
nForward = 1;
forward = true;
m_LegAngleDesired = Snap_s180(playerMoveAngles.z);
m_LegAngleVel = m_LegAngleVelMoving;
}
else
{
// backwards
m_LegAngleDesired = Snap_s180(playerMoveAngles.z-180);
m_LegAngleVel = m_LegAngleVelMoving;
}
}
else
{
if( moveDeltaAngle<120 && moveDeltaAngle>-80 )
// if( Ffabs(moveDeltaAngle)<120 )
{
// forward
nForward = 1;
forward = true;
m_LegAngleDesired = Snap_s180(playerMoveAngles.z);
m_LegAngleVel = m_LegAngleVelMoving;
}
else
{
// backwards
m_LegAngleDesired = Snap_s180(playerMoveAngles.z-180);
m_LegAngleVel = m_LegAngleVelMoving;
}
}
}
else
{
if(m_stats.moving) // if was moving - just stopped stop rotating legs in movement direction
m_LegAngleDesired = m_LegAngle;
}
// [Anton] a piece of code moved to UpdatePhysics
if(nMode==0) // do rotation if needed
{
float aDir = Snap_s180(m_LegAngle - m_LegAngleDesired);
if( Ffabs(aDir)>.2 )
{
nMode = 6;
if( aDir<0 )
nStrafe = 1; // rotate left
else
nStrafe = 2; // rotate right
}
}
//if(speed>0.0f)
//m_pGame->m_pLog->LogToConsole("\001 %.2f %.2f ",speed, m_WalkSpeed);
m_nStanding = nStanding;
m_nMode = nMode;
m_nStrafe = nStrafe;
m_nForward = nForward;
Vec3 vel = status.vel;
if (status.pGroundCollider)
vel -= status.velGround;
float speed2d = Vec2(vel).len();
if(m_AnimationSystemEnabled ) // if enabled
{
if( m_stats.moving )
{
ScaleAnimationSpeed( speed2d );
}
else
{
m_pEntity->SetAnimationSpeed( 1.0f );
}
StartAnimation( ctx );
}
return;
}
/////////////////////////////////////////////////////////////////////////////////////
void CPlayer::ScaleAnimationSpeed( const float speed2d )
{
float curAniRefSpeed = -1;
//if is jumping/flying use a normal anim speed
if (m_stats.flying || m_JumpAniLenght>0)
{
curAniRefSpeed = -1;
}
else if(m_stats.bIsLimping )
{
curAniRefSpeed = -1;
}
else if(m_nMode==7) // run sprint - don't scale it now
{
curAniRefSpeed = -1;
}
else if(m_nMode==3) // jump
{
curAniRefSpeed = -1;
}
else if(m_nMode==2) // run
{
if( m_nStanding==3 ) // stealth
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedXRun[0];
else
curAniRefSpeed = m_AniSpeedXRun[2];
}
else
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedRun[0];
else
curAniRefSpeed = m_AniSpeedRun[2];
}
}
else if( m_nStanding==0 ) // walking
{
if( m_CurStance == eRelaxed )
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedWalkRelaxed[0];
else
curAniRefSpeed = m_AniSpeedWalkRelaxed[2];
}
else
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedWalk[0];
else
curAniRefSpeed = m_AniSpeedWalk[2];
}
}
else if( m_nStanding==3 ) // stealth
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedXWalk[0];
else
curAniRefSpeed = m_AniSpeedXWalk[2];
}
else if( m_nStanding==1 ) //crouch
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedCrouch[0];
else
curAniRefSpeed = m_AniSpeedCrouch[2];
}
else if( m_nStanding==4 ) // walking relaxed
{
if( m_nForward )
curAniRefSpeed = m_AniSpeedWalkRelaxed[0];
else
curAniRefSpeed = m_AniSpeedWalkRelaxed[2];
}
if(curAniRefSpeed>0.0f)
m_pEntity->SetAnimationSpeed( speed2d/curAniRefSpeed );
else
m_pEntity->SetAnimationSpeed( 1.0f );
}
/////////////////////////////////////////////////////////////////////////////////////
void CPlayer::StartAnimation( const SPlayerUpdateContext &ctx )
{
if( m_pGame->pa_blend0->GetFVal()<0.0f )
return;
if (!IsAlive())
return;
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
char aniName[32];
if( m_stats.onLadder)
{
strcpy( aniName,"ladder_loop" );
m_JumpStage=0;
m_JumpAniLenght=0;
//play ladder animation at a speed between 0.001 and 1, depending on the palyer velocity.
//we cant use a speed = 0 because it would be impossible to rotate the head bone, fix this in the anim sys?
float aspeed = max(0.001f,min(1.0f,fabs(ctx.status.vel.z)));
m_pEntity->SetAnimationSpeed( aspeed );
/*if( fabs(ctx.status.vel.z) > .1f )
m_pEntity->SetAnimationSpeed( 1.0f );
else
m_pEntity->SetAnimationSpeed( 0.0f );*/
}
else if(m_bSwimming)
// m_stats.fInWater>1.0f)
{
// the idle animation should depend on current depth
float depth = m_p3DEngine->GetWaterLevel(m_pEntity) - m_p3DEngine->GetTerrainElevation(m_pEntity->GetPos().x, m_pEntity->GetPos().y);
ray_hit hit;
Vec3 pos = m_pEntity->GetPos();
pos.z = m_p3DEngine->GetWaterLevel(m_pEntity);
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f), ent_all,
rwi_stop_at_pierceable,&hit,1, GetEntity()->GetPhysics()))
depth = hit.dist;
if( ctx.status.vel.len2()>.3f || depth<1.5f)
{
if(GetSelectedWeapon())
strcpy( aniName,"swim_weapon" );
else
strcpy( aniName,"swim" );
}
else
{
if(GetSelectedWeapon())
strcpy( aniName,"swim_weapon_idle" );
else
strcpy( aniName,"swim_idle" );
}
m_JumpStage=0;
m_JumpAniLenght=0;
m_pEntity->SetAnimationSpeed( 1.0f );
}
else
{
GenerateAnimationName( aniName );
if (!m_bIsAI)
{
if(m_JumpStage==2 && !m_stats.flying)
m_JumpStage=0;
if(m_JumpAniLenght>0)
{
m_JumpAniLenght-=m_pTimer->GetFrameTime();
if(m_JumpStage==2)
{
return;
}
if(m_JumpAniLenght<=0)
{
if(m_JumpStage==1)
{
m_JumpStage=2;
}
}
else if (m_JumpStage==1 || m_JumpStage==3)
return;
}
if( m_stats.flying )
{
if(m_JumpStage==0 || m_JumpStage==1
|| m_JumpStage==3 ) // if jumping immidiately after prev jump - still in landing state
{
//strcat( aniName,"_jump_start" );
if (m_nForward /*|| m_stats.fVel<0.1f*/)
strcpy( aniName,"jump_forward" );
else
strcpy( aniName,"jump_back" );
m_JumpStage=1;
}
else//flying? dont play anything but the jump start animation. So return.
{
return;
//strcat( aniName,"_jump_air" );
}
}
if(m_stats.landing)
{
strcat( aniName,"_jump_land" );
if (m_JumpStage!=3)
{
m_JumpStage=3;
m_JumpAniLenght = 0;
}
}
}
// else
// m_JumpStage=0;
}
if(m_sPrevAniName == aniName)
return;
if(m_stats.landing && !m_bIsAI)
{
if(m_JumpAniLenght>0)
return;
m_JumpAniLenght = m_pEntity->GetAnimationLength( aniName );
}
else if(m_JumpStage==1)
{
//we dont care anymore about the length of jumpin animations, because after this we keep the last frame until land.
m_JumpAniLenght = 0;
//m_JumpAniLenght = m_pEntity->GetAnimationLength( aniName );
}
else if(m_JumpAniLenght>0)
return; // don't start other anims before jump landing animation is over
// float blendTime = m_pGame->pa_blend0->GetFVal();
// GetBlendTime( aniName, blendTime );
float blendTime = m_pGame->pa_blend0->GetFVal();
//use a different bleding for the jump start anim
if (m_JumpStage==1)
{
//when jump start reset current animations, so when the jump anim will finish player will keep its the last frame.
m_pEntity->ResetAnimations(0);
//blendTime = 0.15f;
//set jumpstage directly to 2 (inair)
m_JumpStage = 2;
}
if(m_JumpStage==3 && m_JumpAniLenght<=0)
{
// m_sPrevAniNameLayer1 = "";
m_JumpStage=0;
blendTime = 0.15f;
//blendTime = 0.05f;
}
m_pEntity->StartAnimation(0, aniName, 0, blendTime );//.3f);
m_sPrevAniName = aniName;
/*
if(m_pEntity->StartAnimation(0, aniName, 0, blendTime ))//.3f))
{
m_sPrevAniName = aniName;
//m_pGame->m_pLog->LogToConsole("\002 %s ",aniName.c_str());
}
*/
}
/////////////////////////////////////////////////////////////////////////////////////
/*
-- generates string with appropriate animation name, according to naming convention
-- depending on parametrs
--
-- m_nForward: 0 = Backward, 1 = Forward
-- m_nStrafe: 0 = None, 1 = Left, 2 = Right
-- m_nStanding: 0 = Standing, 1 = Crouching, 2 = Prone, 3 = Stealth,
-- m_nMode: 0 = Idle, 1 = Walking, 2 = Running, 3 = Jump, 4 = Flying, 5 = Dead, 6 = Turning,
*/
bool CPlayer::GenerateAnimationName( char *aniName )
{
strcpy( aniName,"" );
//aniName = "aidle";
//return;
if(m_stats.bIsLimping)
strcpy( aniName,"l" );
else
switch(m_nStanding)
{
case 0: // standing combat
strcpy( aniName,"a" );
break;
case 1: // crouching combat
strcpy( aniName,"c" );
break;
case 2: // proning combat
strcpy( aniName,"p" );
break;
case 3: // stealth combat
strcpy( aniName,"x" );
break;
case 4: // standing relaxed
strcpy( aniName,"s" );
break;
default:
return false;
}
switch(m_nMode)
{
case 0:
strcat( aniName,"idle" );
return true;
case 1:
strcat( aniName,"walk" );
break;
case 2:
strcat( aniName,"run" );
break;
case 6:
strcat( aniName,"rotate" );
break;
case 7:
strcat( aniName,"sprint" );
break;
default:
return true;
}
if(m_nStrafe)
{
if(m_nStrafe == 1)
strcat( aniName,"left" );
else
strcat( aniName,"right" );
}
else if(m_nForward)
strcat( aniName,"fwd" );
else
strcat( aniName,"back" );
return true;
}
///////////////////////////////////////////////
/*! Let the player die by playing the animation and disabling physics
*/
/*
void CPlayer::Die()
{
m_pEntity->KillTimer();
// m_deathTime = GetCurrTime();
IEntityCharacter *ichar = m_pEntity->GetCharInterface();
// UpdateCharacterAnimations();
ICryCharInstance *character = ichar->GetCharacter(PLAYER_MODEL_IDX);
if (character)
{
// Hide weapon.
character->EnableLastIdleAnimationRestart(0,false);
character->EnableLastIdleAnimationRestart(1,false);
character->AttachObjectToBone(NULL,NULL);
if (m_bIsAI)
character->ResetAnimations();
}
m_pEntity->EnableAI(false);
if (m_pEntity->GetPhysics()->GetType()==PE_ARTICULATED)
return;
// Disable physics on this player.
m_pEntity->EnablePhysics(false);
}
*/
///////////////////////////////////////////////
/*! Respawns the player by enabling physics and calling the script
*/
void CPlayer::Respawn()
{
// Exit all areas to turn off water sound.
//m_pGame->m_XAreaMgr.ExitAllAreas( this );
m_walkParams.shakeDegree=0.0f;
m_walkParams.leanAmount = 0.0f;
m_walkParams.leanStart = 0.0f;
m_walkParams.leanEnd = 0.0f;
m_walkParams.leanFactor = 0.0f;
// Call game rules and try to revive this player.
CXServerRules *rules = m_pGame->GetRules();
// If no server rules, ignore this function.
if (rules)
{
rules->OnPlayerRespawn( m_pEntity );
}
// m_physicsEnabled = true;
m_pEntity->EnablePhysics(true);
m_pEntity->EnableAI(true);
// SetTime2Respawn( -1 );
m_bStayCrouch = false;
}
///////////////////////////////////////////////
/*! Retrieves if this player is mine
@return returns true if it is my player, false otherwise
*/
bool CPlayer::IsMyPlayer() const
{
if(!m_pGame->m_pClient) return false;
return (m_pEntity->GetId()==m_pGame->m_pClient->GetPlayerId());
}
///////////////////////////////////////////////
/*! Retrieves if we are in 1st person view
@return returns true if we are in 1st person view, false otherwise
*/
bool CPlayer::IsFirstPerson() const
{
return m_bFirstPerson;
}
///////////////////////////////////////////////
/*! Writes all data which needs to be synchronized to the network-stream
@param stream stream to write to
@param cs state of the entity per serverslot
@return true if the function succeeds, false otherwise
*/
bool CPlayer::Write( CStream &stream,EntityCloneState *cs)
{
bool bLocalHostEntity=true;
if(cs)
bLocalHostEntity=cs->m_bLocalplayer;
WRITE_COOKIE(stream);
stream.Write(bLocalHostEntity);
if(bLocalHostEntity)
{
assert(m_stats.health>=0);
if(m_stats.health>255)
{
GameWarning(" Player health=%d is bigger than 255 (name %s). Change properties", m_stats.health,m_pEntity->GetName());
m_stats.health = 255;
}
// assert(m_stats.health<=255);
assert(m_stats.armor>=0);
assert(m_stats.armor<=255);
if(m_stats.numofgrenades<0)
{
GameWarning(" Player numofgrenades=%d is less than 0 (name %s). Change properties", m_stats.numofgrenades,m_pEntity->GetName());
m_stats.numofgrenades = 0;
}
if(m_stats.numofgrenades>255)
{
GameWarning(" Player numofgrenades=%d is bigger than 255 (name %s). Change properties", m_stats.numofgrenades,m_pEntity->GetName());
m_stats.numofgrenades = 255;
}
assert(m_stats.stamina>=0 && m_stats.stamina<255);
stream.WritePkd( (BYTE)m_stats.stamina );
// assert(m_stats.breath>=0 && m_stats.breath<255);
// stream.WritePkd( (BYTE)m_stats.breath );
stream.WritePkd( (BYTE)m_stats.health );
stream.WritePkd( (BYTE)m_stats.armor );
if((unsigned int)(m_stats.ammo_in_clip)>1023)
{
m_pGame->GetSystem()->GetILog()->LogError("Ammo in clip (%d) is more than 1023, Value will not be restored correctly",m_stats.ammo_in_clip);
if(m_stats.ammo_in_clip>0)
m_stats.ammo_in_clip=1023;
}
stream.WriteNumberInBits(m_stats.ammo_in_clip,10);
if((unsigned int)(m_stats.ammo)>1023)
{
m_pGame->GetSystem()->GetILog()->LogError("Ammo (%d) is more than 1023, Value will not be restored correctly",m_stats.ammo);
if(m_stats.ammo>0)
m_stats.ammo=1023;
}
stream.WriteNumberInBits(m_stats.ammo,10);
stream.WritePkd((BYTE)m_stats.numofgrenades);
stream.WriteNumberInBits(m_stats.grenadetype, 4);
stream.Write(m_stats.holding_breath);
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stream.Write(m_vWeaponSlots[i]!=0);
if(m_vWeaponSlots[i]!=0)
{
assert(m_vWeaponSlots[i]>=0);
assert(m_vWeaponSlots[i]<=255);
stream.WritePkd((BYTE)m_vWeaponSlots[i]);
}
}
}
else
{
stream.Write((bool)(m_stats.ammo_in_clip!=0));
stream.Write((bool)(m_stats.ammo!=0));
stream.Write( m_stats.firing );
stream.Write(m_walkParams.fCurrLean!=0);
if(m_walkParams.fCurrLean!=0)
{
stream.Write(m_walkParams.fCurrLean>0); //sign
stream.WritePkd(((BYTE)(fabs(m_walkParams.fCurrLean)/(1.0f/255))));
}
}
WRITE_COOKIE(stream);
bool bSendFireGrenade = m_stats.firing_grenade;
if((m_stats.grenadetype != 1 && m_stats.numofgrenades<=0))
bSendFireGrenade = false;
stream.Write(bSendFireGrenade);
// [kirill]
// this is needed to be able to keep PrevWeapon when doing quicksave/quickload
// while on ladder - so when player gets out of ladder after QuickLoad he has
// correct weapon
//[filippo]
//in MP we need to send always the right "m_stats.weapon" value, otherwise the ladders would not works correctly.
if( m_stats.onLadder && !m_pGame->IsMultiplayer())
stream.WritePkd((BYTE)m_PrevWeaponID);
else
stream.WritePkd((BYTE)m_stats.weapon);
stream.WritePkd((BYTE)m_stats.firemode);
// stream.Write( m_stats.onLadder );
stream.WriteNumberInBits((unsigned int)m_CurStance,3);
stream.Write( m_stats.jumping );
// sync player random seed value to the clients
{
bool bSyncToClients=m_SynchedRandomSeed.GetSynchToClientsS();
stream.Write(bSyncToClients);
if(bSyncToClients)
stream.Write(m_SynchedRandomSeed.GetStartRandomSeedS());
}
stream.Write( m_stats.reloading );
BYTE acc=(BYTE)(m_stats.firing?m_stats.last_accuracy:m_stats.accuracy/(1.f/255.f));
stream.WritePkd(acc);
WRITE_COOKIE(stream);
if (m_pRedirected && m_pRedirected->GetId()<50000)
{
stream.Write(true);
stream.Write(m_pRedirected->GetId());
}
else
stream.Write(false);
stream.Write(m_bFirstPerson);
m_bWriteOccured = true;
return true;
}
///////////////////////////////////////////////
/*! Reads all data which needs to be synchronized from the network-stream
@param stream stream to read from
@return true if the function succeeds, false otherwise
*/
bool CPlayer::Read( CStream &stream )
{
unsigned short dirty = 0;
PlayerStats &stats=m_stats;
// GetPlayerStats( stats );
BYTE health,armor,weapon,firemode,staminaBuff;
//int weaponid = stats.weaponid;
bool bLocalHostEntity;
VERIFY_COOKIE(stream);
stream.Read(bLocalHostEntity);
if(bLocalHostEntity)
{
stream.ReadPkd( staminaBuff );
m_stats.stamina = staminaBuff;
// stream.ReadPkd( staminaBuff );
// m_stats.breath = staminaBuff;
stream.ReadPkd( health );
stats.health=health;
stream.ReadPkd( armor );
stats.armor=armor;
unsigned int ammo_in_clip;
stream.ReadNumberInBits(ammo_in_clip,10);
stats.ammo_in_clip=ammo_in_clip;
unsigned int ammo;
stream.ReadNumberInBits(ammo,10);
stats.ammo=ammo;
BYTE b;
stream.ReadPkd(b);
stats.numofgrenades=b;
stream.ReadNumberInBits(stats.grenadetype, 4);
stream.Read(stats.holding_breath);
bool isnotzero;
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stream.Read(isnotzero);
if(isnotzero)
{
stream.ReadPkd(b);
m_vWeaponSlots[i]=b;
}else
{
m_vWeaponSlots[i]=0;
}
}
}
else
{
bool val;
stream.Read(val);
stats.ammo_in_clip = val;
stream.Read(val);
stats.ammo = val;
stream.Read(val);
stats.firing = val;
bool t;
stream.Read(t);
if(t)
{
bool sign;
BYTE lean;
stream.Read(sign);
stream.ReadPkd(lean);
m_walkParams.fCurrLean=sign?(lean*(1.0f/255)):-(lean*(1.0f/255));
}
else
{
m_walkParams.fCurrLean=0;
}
}
VERIFY_COOKIE(stream);
stream.Read(stats.firing_grenade);
stream.ReadPkd(weapon);
if (weapon!=stats.weapon)
{
SelectWeapon(weapon, false);
stats.weapon = weapon;
stats.firing = false;
}
stream.ReadPkd(firemode);
if(firemode!=stats.firemode)
{
stats.firemode=firemode;
SwitchFiremode(stats.firemode);
}
//stream.Read(stats.firing);
// stream.Read(stats.onLadder);
eStance stance;
stream.ReadNumberInBits(*((unsigned int *)&stance),3);
// no stances in vehicle
if(stance!=m_CurStance && !m_pVehicle)
{
switch(stance)
{
case eRelaxed:
GoRelaxed();
break;
case eStand:
GoStand();
break;
// case eAimLook:
// GoAim();
// break;
case eStealth:
GoStealth();
break;
case eCrouch:
GoCrouch();
break;
case eProne:
GoProne();
break;
case eSwim:
GoSwim();
break;
default:
//DEBUG_BREAK;
::OutputDebugString("INVALID STANCE\n");
m_CurStance=(eStance)stance;
break;
}
}
stream.Read(stats.jumping);
if(stream.GetStreamVersion()>=PATCH1_SAVEVERSION) // to be backward compatible with old samegames
{
bool bSyncToAllClients;
stream.Read(bSyncToAllClients);
if(bSyncToAllClients)
{
uint8 ucStartRandomSeedCS;
stream.Read(ucStartRandomSeedCS);
m_SynchedRandomSeed.SetStartRandomSeedC(ucStartRandomSeedCS);
}
}
//TRIGGER REALOAD ON CLIENT ONLY (think if can be done better)
bool bReloading;
stream.Read(bReloading);
if(bReloading && (stats.reloading==false) && m_nSelectedWeaponID != -1)
{
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
pSelectedWeapon->ScriptReload(m_pEntity);
}
stats.reloading=bReloading;
BYTE acc;
stream.ReadPkd(acc);
stats.accuracy=acc*(1.f/255.f);
VERIFY_COOKIE(stream);
if(stats.firing_grenade)
{
//invoke script event (client)
m_bGrenadeAnimation = true;
m_pEntity->SendScriptEvent(ScriptEvent_FireGrenade,0,NULL);
}
bool bRedirected;
EntityId nID;
stream.Read(bRedirected);
if (bRedirected)
stream.Read(nID);
if ((m_pRedirected!=0)!=bRedirected || m_pRedirected && m_pRedirected->GetId()!=nID)
{
if (m_pRedirected)
{
m_pRedirected->OnUnBind(m_pEntity,0);
m_pRedirected = 0;
}
if (bRedirected && (m_pRedirected=m_pGame->GetSystem()->GetIEntitySystem()->GetEntity(nID)))
m_pRedirected->OnBind(m_pEntity,0);
}
if (m_pRedirected && !bLocalHostEntity)
m_pRedirected->SetAngles(m_pEntity->GetAngles());
stream.Read(m_bFirstPersonLoaded);
return true;
}
bool CPlayer::Save( CStream &stream)
{
EntityCloneState cs;
cs.m_bSyncYAngle = false;
cs.m_bOffSync = false;
cs.m_bLocalplayer = true;
//[PETAR] Serialize flashlight for singleplayer
stream.Write(m_bLightOn);
bool bRet=Write(stream,&cs);
ASSERT(bRet);
return true;
}
bool CPlayer::Load( CStream &stream)
{
bool bPrevLightStatus;
stream.Read(bPrevLightStatus);
if (bPrevLightStatus!=m_bLightOn)
SwitchFlashLight(bPrevLightStatus);
return Read(stream);
}
// these two functions save and load the player state which is NOT already saved using read/write
bool CPlayer::SaveGame(CStream &stm)
{
for(PlayerWeaponsItor itor=m_mapPlayerWeapons.begin(); itor!=m_mapPlayerWeapons.end(); ++itor)
{
WeaponInfo &wi = itor->second;
if(wi.owns)
{
stm.Write(itor->first);
ASSERT(itor->first>=0 && itor->first<50);
stm.Write(wi.iFireMode);
}
}
stm.Write((int)0);
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stm.Write(m_vWeaponSlots[i]);
}
Save(stm);
return true;
};
bool CPlayer::LoadGame(CStream &stm)
{
RemoveAllWeapons();
// [Petar] preserve the original health in case we need to use it
// to restore the health of special AI on a checkpoint
int nStartHealth = m_stats.health;
if (!m_bIsAI)
DeselectWeapon();
for(int cl = 0; (stm.Read(cl),cl); )
{
WeaponInfo &wi = m_mapPlayerWeapons[cl];
wi.owns = true;
stm.Read(wi.iFireMode);
}
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stm.Read(m_vWeaponSlots[i]);
}
Load(stm);
SelectWeapon(m_stats.weapon);
if (m_nSelectedWeaponID != -1)
{
WeaponInfo &wi = GetWeaponInfo();
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
_SmartScriptObject pObj(m_pScriptSystem);
pObj->SetValue( "firemode", m_stats.firemode);
pObj->SetValue( "ignoreammo", true);
bool bCanSwitch;
m_pEntity->SendScriptEvent(ScriptEvent_FireModeChange, *pObj, &bCanSwitch);
wi.iFireMode = m_stats.firemode;
}
if (m_bIsAI)
{
IPuppet *pPuppet=0;
if (m_pEntity->GetAI()->CanBeConvertedTo(AIOBJECT_PUPPET,(void**)&pPuppet))
{
if (pPuppet->GetPuppetParameters().m_bSpecial)
m_stats.health = nStartHealth;
}
}
return true;
};
void CPlayer::SetScriptObject(IScriptObject *pObject)
{
m_pScriptObject=pObject;
m_pUpdateAnimation=NULL;
}
/*! Retrieves the ScriptObject of this container
@return pointer to the ScriptObject
*/
IScriptObject *CPlayer::GetScriptObject()
{
return m_pScriptObject;
}
int CPlayer::MakeWeaponAvailable(int nWeaponID, bool bAvailable)
{
//make sure that we don't remove the currently selected weapon
if (nWeaponID == m_nSelectedWeaponID && !bAvailable)
{
DeselectWeapon();
SelectFirstWeapon();
}
CWeaponClass* pWC = GetGame()->GetWeaponSystemEx()->GetWeaponClassByID(nWeaponID);
if (pWC && !pWC->IsLoaded())
{
pWC->Load();
}
PlayerWeaponsItor it;
if ((it = m_mapPlayerWeapons.find(nWeaponID)) == m_mapPlayerWeapons.end())
{
TRACE("ERROR: Trying to make invalid weapon ID %i available", nWeaponID);
return -1;
}
bool bWasOwning=(* it).second.owns;
(* it).second.owns = bAvailable;
int slot=0;
if(bAvailable && (!bWasOwning))
{
(* it).second.iFireMode = 0;
slot=0;
while(slot<PLAYER_MAX_WEAPONS){if(m_vWeaponSlots[slot]==nWeaponID)return slot;slot++;}
slot=0;
while(slot<PLAYER_MAX_WEAPONS && m_vWeaponSlots[slot]!=0) slot++;
if(slot<PLAYER_MAX_WEAPONS && m_vWeaponSlots[slot]==0)
{
m_vWeaponSlots[slot]=nWeaponID;
return slot;
}
}else if(!bAvailable && (bWasOwning))
{
while(slot<PLAYER_MAX_WEAPONS){if(m_vWeaponSlots[slot]==nWeaponID){m_vWeaponSlots[slot]=0;return -1;} slot;slot++;}
}
return -1;
}
CWeaponClass *CPlayer::DeselectWeapon()
{
if (m_nSelectedWeaponID != -1)
{
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
//this script event is called only for the local client
if(IsMyPlayer() || m_pGame->IsMultiplayer())
{
pSelectedWeapon->ScriptOnDeactivate(m_pEntity);
}
// detach from bone ?
if (!pSelectedWeapon->GetBindBone().empty())
m_pEntity->DetachObjectToBone(pSelectedWeapon->GetBindBone().c_str());
SetWeapon(-1);
return pSelectedWeapon;
}
return 0;
}
/*ridirect the input of a player to another entity
@param id the id of the entity that will receive the input
@param angleDelta
*/
void CPlayer::RedirectInputToEntity(EntityId id, int angleDelta)
{
if (!id)
{
if (m_pRedirected)
m_pRedirected = NULL;
if(IsMyPlayer())
m_pGame->m_pClient->m_PlayerProcessingCmd.SetDeltaAngles(Vec3d(0.0f, 0.0f, 0.0f));
}
else
{
IEntity *pEntity = m_pGame->GetSystem()->GetIEntitySystem()->GetEntity(id);
if (pEntity)
{
m_pRedirected = pEntity;
//[PETAR]
// m_pGame->m_pClient->m_PlayerProcessingCmd.SetDeltaAngles(pEntity->GetAngles());
//[KIRILL] make turret point in right direction /statmounted - ONLY for local player
if(IsMyPlayer())
{
if(angleDelta>=0)
m_pGame->m_pClient->m_PlayerProcessingCmd.SetDeltaAngles(Vec3d(0.0f, 0.0f, (float)angleDelta));
else
m_pGame->m_pClient->m_PlayerProcessingCmd.SetDeltaAngles(pEntity->GetAngles(1));
}
}
}
}
bool CPlayer::QueryContainerInterface(ContainerInterfaceType desired_interface, void **ppInterface )
{
if (desired_interface == CIT_IPLAYER)
{
*ppInterface = (void *) this;
return true;
}
else
{
*ppInterface = 0;
return false;
}
}
IEntity * CPlayer::GetRedirected()
{
return m_pRedirected;
}
/*! set the offset of the camera from the player position.
usually is the height of the player
*/
void CPlayer::SetCameraOffset(const Vec3d& Offset)
{
m_pEntity->GetCamera()->SetCameraOffset(Offset);
}
/*! retreive the offset of the camera relative to the player position
@param Offset the offset in meters
*/
void CPlayer::GetCameraOffset(Vec3d& Offset)
{
m_pEntity->GetCamera()->GetCameraOffset(Offset);
}
void CPlayer::UpdateDrawAngles( )
{
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
if (!pChar)
return;
float timeScale = 20.1f*m_pTimer->GetFrameTime();
if (timeScale>1.0f)
timeScale = 1.0f;
Vec3d angles = GetActualAngles();
Vec3d vAngles;
//on ladder orient the player so he always look at the center of the ladder.
if (m_stats.onLadder)
{
m_vLadderAngles = m_pEntity->GetPos() - m_vLadderPosition;
m_vLadderAngles.z = 0;
m_vLadderAngles.Normalize();
m_vLadderAngles.z = -atan2(m_vLadderAngles.x,m_vLadderAngles.y)*(180.0f/gf_PI);
m_vLadderAngles.x = 0;
m_vLadderAngles.y = 0;
vAngles = m_vLadderAngles;
}
else if (m_pEntity->IsBound())
vAngles = angles;
else if (m_CurStance == eProne )
vAngles = m_EnvTangent;
else
{
if(m_LegRotation)
vAngles = Vec3d(0, 0, m_LegAngle);
else
vAngles = Vec3d(0,0,angles.z);
}
//[kirill] smooth here Character angles (all but Z)
// to make it not jurk when proning on some bumpy enviroment
vAngles.x = Snap_s180(vAngles.x);
vAngles.y = Snap_s180(vAngles.y);
m_vCurEntAngle.x = Snap_s180(m_vCurEntAngle.x);
m_vCurEntAngle.y = Snap_s180(m_vCurEntAngle.y);
Vec3d delta = (vAngles - m_vCurEntAngle);
delta.x = Snap_s180(delta.x);
delta.y = Snap_s180(delta.y);
m_vCurEntAngle += (delta*timeScale);
m_vCurEntAngle.z = vAngles.z;
m_vCharacterAngles = m_vCurEntAngle;
// CheckIfNAN( vAngles );
// m_vCharacterAngles = vAngles;
}
/*!drawn the player
called by the engine when the player has to be drawn
*/
void CPlayer::OnDraw(const SRendParams & _RendParams)
{
//return;
OnDrawMountedWeapon( _RendParams );
// if nRecursionLevel is not 0 - use only 3tp person view ( for reflections )
int nRecursionLevel = (int)m_pGame->GetSystem()->GetIRenderer()->EF_Query(EFQ_RecurseLevel) - 1;
// draw first person weapon
if(m_bFirstPerson && !nRecursionLevel && m_stats.drawfpweapon && m_nSelectedWeaponID != -1)
{
CWeaponClass* pWeapon = GetSelectedWeapon();
ICryCharInstance *pInst = pWeapon->GetCharacter();
if (pInst && pInst->GetFlags()&CS_FLAG_DRAW_MODEL)
{
SRendParams RendParams = _RendParams;
RendParams.vPos = pWeapon->GetPos();
RendParams.vAngles = pWeapon->GetAngles();
if (RendParams.pShadowVolumeLightSource)
{
if(m_pEntity->GetRndFlags()&ERF_CASTSHADOWVOLUME && !IsMyPlayer())
pInst->RenderShadowVolumes(&RendParams);
}
else {
pInst->Draw(RendParams,m_pEntity->GetPos());
}
}
return;
}
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
if (!pChar)
return;
if (!(pChar->GetFlags() & CS_FLAG_DRAW_MODEL) && !nRecursionLevel)
return;
SRendParams RendParams = _RendParams;
// RendParams.vPos = m_pEntity->GetPos(); // position is not always entity position
if(m_pVehicle ) // it' gunner in vehicle
{
// create the matrix here
Matrix44 matParent;
matParent.SetIdentity();
matParent=Matrix44::CreateRotationZYX(-gf_DEGTORAD*m_pVehicle->GetEntity()->GetAngles())*matParent; //NOTE: angles in radians and negated
CryQuat cxquat = Quat( GetTransposed44(matParent) );
CryQuat rxquat;
Vec3d gunnerAngle;
// if(m_pMountedWeapon) // it' gunner in vehicle
if(m_stats.inVehicleState == PVS_GUNNER) // it' gunner in vehicle
gunnerAngle = GetEntity()->GetAngles(1);
else // it' driver/passenger
gunnerAngle.Set(0,0,180);
gunnerAngle.x=0;
gunnerAngle.y=0;
rxquat.SetRotationXYZ(DEG2RAD(gunnerAngle));
CryQuat result = cxquat*rxquat;
Vec3d finalangles = Ang3::GetAnglesXYZ(Matrix33(result));
RendParams.vAngles = RAD2DEG(finalangles);
m_pEntity->SetPhysAngles( RendParams.vAngles );
}
else
// if (!m_pVehicle || m_bIsAI )
{
if( IsAlive())
RendParams.vAngles = m_vCharacterAngles;
else
RendParams.vAngles.Set(0, 0, m_pEntity->GetAngles().z);
}
/*
else
{
// if the player is bound to the vehicle and in 3rd person mode,
// force the character's angles to the correct direction
RendParams.vAngles = m_pVehicle->GetEntity()->GetAngles();
// RendParams.vAngles.z+=180;
// RendParams.vAngles.x=-RendParams.vAngles.x;
}
*/
if (_RendParams.pShadowVolumeLightSource)
{
if(m_pEntity->GetRndFlags()&ERF_CASTSHADOWVOLUME)
pChar->RenderShadowVolumes(&RendParams, (m_pEntity->GetRndFlags()&ERF_SELFSHADOW) ? 0 : 10);
}
else
pChar->Draw(RendParams,m_pEntity->GetPos());
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedRunRelaxed(const float fwd, const float side, const float back )
{
m_AniSpeedRunRelaxed[0] = fwd;
m_AniSpeedRunRelaxed[1] = side;
m_AniSpeedRunRelaxed[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedWalkRelaxed(const float fwd, const float side, const float back )
{
m_AniSpeedWalkRelaxed[0] = fwd;
m_AniSpeedWalkRelaxed[1] = side;
m_AniSpeedWalkRelaxed[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedWalk(const float fwd, const float side, const float back )
{
m_AniSpeedWalk[0] = fwd;
m_AniSpeedWalk[1] = side;
m_AniSpeedWalk[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedXRun(const float fwd, const float side, const float back )
{
m_AniSpeedXRun[0] = fwd;
m_AniSpeedXRun[1] = side;
m_AniSpeedXRun[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedRun(const float fwd, const float side, const float back )
{
m_AniSpeedRun[0] = fwd;
m_AniSpeedRun[1] = side;
m_AniSpeedRun[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedXWalk(const float fwd, const float side, const float back )
{
m_AniSpeedXWalk[0] = fwd;
m_AniSpeedXWalk[1] = side;
m_AniSpeedXWalk[2] = back;
}
/*!sets the animation speed of the player - used to scale animation playback speed
depending on actuall movement speed (to awoid skeiting)
*/
void CPlayer::SetAnimationRefSpeedCrouch(const float fwd, const float side, const float back )
{
m_AniSpeedCrouch[0] = fwd;
m_AniSpeedCrouch[1] = side;
m_AniSpeedCrouch[2] = back;
}
/*!sets the running speed of the player
@param speed the running speed
*/
void CPlayer::SetRunSpeed(const float speed)
{
m_RunSpeed = speed;
if(!m_bIsAI)
// if(IsMyPlayer())
m_pGame->p_speed_run->Set(m_RunSpeed);
}
/*!sets the walk speed of the player
@param speed the walk speed
*/
void CPlayer::SetWalkSpeed(const float speed)
{
m_WalkSpeed = speed;
if(!m_bIsAI)
// if(IsMyPlayer())
m_pGame->p_speed_walk->Set(m_WalkSpeed);
}
/*!sets the walk speed of the player when is croching
@param speed the croching speed
*/
void CPlayer::SetCrouchSpeed(const float speed)
{
m_CrouchSpeed = speed;
if(!m_bIsAI)
// if(IsMyPlayer())
m_pGame->p_speed_crouch->Set(m_CrouchSpeed);
}
/*!sets the walk speed of the player when is proning
@param speed the proning speed
*/
void CPlayer::SetProneSpeed(const float speed)
{
m_ProneSpeed = speed;
if(!m_bIsAI)
// if(IsMyPlayer())
m_pGame->p_speed_prone->Set(m_ProneSpeed);
}
/*!sets the walk speed of the player when is proning
@param speed the proning speed
*/
void CPlayer::SetSwimSpeed(const float speed)
{
m_SwimSpeed = speed;
}
//----------------------------------------------------------------------------------------------------
/*!sets the camera bob
@param pitch
@param roll
@param length
*/
void CPlayer::SetCameraBob(const float pitch, const float roll, const float length)
{
m_walkParams.runRoll = roll;
m_walkParams.runPitch = pitch;
m_walkParams.stepLength = length;
if (!m_bIsAI)
{
m_pGame->p_bob_pitch->Set(m_walkParams.runPitch);
m_pGame->p_bob_roll->Set(m_walkParams.runRoll);
m_pGame->p_bob_length->Set(m_walkParams.stepLength);
}
}
//----------------------------------------------------------------------------------------------------
//
/*!sets the weapon bob
*/
void CPlayer::SetWeaponBob(const float ampl)
{
m_walkParams.weaponCycle = ampl;
if (!m_bIsAI)
m_pGame->p_bob_weapon->Set(m_walkParams.weaponCycle);
}
//----------------------------------------------------------------------------------------------------
/*!sets the amount of force applied to the player when he jump
@param force the amount of force
*/
void CPlayer::SetJumpForce(const float force)
{
m_JumpForce = force;
if (!m_bIsAI)
m_pGame->p_jump_force->Set(m_JumpForce);
}
//----------------------------------------------------------------------------------------------------
//
/*!set the player's lean angle
@param lean angle in degrees
*/
void CPlayer::SetLean(const float lean)
{
m_LeanDegree = lean;
//[KIRILL] this console variable makes lean global - it has to be player's per-instance property
// to fix bug in MP with leaning
// if (!m_bIsAI)
// m_pGame->p_lean->Set(m_LeanDegree);
}
//----------------------------------------------------------------------------------------------------
/*!sets the player dimension in stealth mode
@param pDim struct containing the player dimensions
@see pe_player_dimensions
*/
void CPlayer::SetDimStealth(const pe_player_dimensions* const pDim)
{
if(!pDim)
{
m_PlayerDimStealth.heightEye = (m_PlayerDimNormal.heightEye + m_PlayerDimCrouch.heightEye)*.5f;
m_PlayerDimStealth.heightCollider = (m_PlayerDimNormal.heightCollider + m_PlayerDimCrouch.heightCollider)*.5f;
m_PlayerDimStealth.sizeCollider = (m_PlayerDimNormal.sizeCollider+m_PlayerDimCrouch.sizeCollider)*.5f;
return;
}
m_PlayerDimStealth = *pDim;
m_CurStance = eNone;
GoStand( );
}
//----------------------------------------------------------------------------------------------------
/*!sets the player dimension in normal(standing) mode
@param pDim struct containing the player dimensions
@see pe_player_dimensions
*/
void CPlayer::SetDimNormal(const pe_player_dimensions* const pDim)
{
if(!pDim)
{
m_PlayerDimNormal.heightEye = 1.7f;
m_PlayerDimNormal.heightCollider = 1.1f;
m_PlayerDimNormal.sizeCollider.Set(0.4f,0.4f,0.7f);
return;
}
m_PlayerDimNormal = *pDim;
SetDimStealth();
m_CurStance = eNone;
GoStand( );
// m_PlayerDimSwim = m_PlayerDimNormal;
// m_PlayerDimSwim.sizeCollider.z = .55f;
// m_PlayerDimSwim.heightEye = .65f;
// m_PlayerDimSwim = m_PlayerDimNo;
// m_PlayerDimSwim.sizeCollider.z = .55f;
// m_PlayerDimSwim.heightEye = .65f;
}
//----------------------------------------------------------------------------------------------------
/*!sets the player dimension in crouch mode
@param pDim struct containing the player dimensions
@see pe_player_dimensions
*/
void CPlayer::SetDimCrouch(const pe_player_dimensions* const pDim)
{
if(!pDim)
{
m_PlayerDimCrouch.heightEye = 1.0f;
m_PlayerDimCrouch.heightCollider = 0.6f;
m_PlayerDimCrouch.sizeCollider.Set(0.4f,0.4f,0.5f);
return;
}
m_PlayerDimCrouch = *pDim;
SetDimStealth();
m_CurStance = eNone;
GoStand( );
}
//----------------------------------------------------------------------------------------------------
/*!sets the player dimension in prone mode
@param pDim struct containing the player dimensions
@see pe_player_dimensions
*/
void CPlayer::SetDimProne(const pe_player_dimensions* const pDim)
{
if(!pDim)
{
m_PlayerDimProne.heightEye = 0.5f;
m_PlayerDimProne.heightCollider = 0.3f;
m_PlayerDimProne.sizeCollider.Set(0.4f,0.4f,0.2f);
return;
}
m_PlayerDimProne = *pDim;
m_PlayerDimSwim = m_PlayerDimProne;
m_PlayerDimSwim.sizeCollider.z = .55f;
m_PlayerDimSwim.heightCollider = .75f;
m_PlayerDimSwim.heightEye = .70f;
m_CurStance = eNone;
GoStand( );
}
//////////////////////////////////////////////////////////////////////////
int CPlayer::GetBoneHitZone( int boneIdx ) const
{
return m_pEntity->GetBoneHitZone(boneIdx);
}
//////////////////////////////////////////////////////////////////////////
Vec3d CPlayer::CalcTangentOnEnviroment( const Vec3d &angle )
{
Vec3d forward = angle;
Vec3d tangent=forward;
if(!m_pEntity->GetPhysics())
return tangent;
pe_status_living pStat;
m_pEntity->GetPhysics()->GetStatus(&pStat);
// Vec3d forward = m_pEntity->GetAngles();
// Vec3d normal = (Vec3d)pStat.groundSlope;
Vec3d normal = m_vProneEnvNormal;
forward=ConvertToRadAngles(forward);
forward = normal.Cross( forward );
forward = forward.Cross( normal );
forward.Normalize();
normal.Normalize();
Vec3d vA[3];
vA[1] = -forward;
vA[0] = normal.Cross(forward);
vA[2] = normal;
matrix3x3RMf &mtrx((matrix3x3RMf&)(*(float*)vA));
mtrx.Transpose();
tangent = Ang3::GetAnglesXYZ(mtrx);
Ang3 angles=tangent;
angles.Rad2Deg();
tangent=angles;
return tangent;
}
//----------------------------------------------------------------------------------------------------
//
//! returns arm damage in percent 100 - (arm_health/max_arm_health)*100
int CPlayer::GetArmDamage(void) const
{
//TRACE("ARM damage %d", 100 - ((float)m_stats.armHealth/(float)m_stats.maxArmHealth)*100.0f);
return 100 - (int)(((float)m_stats.armHealth/(float)m_stats.maxArmHealth)*100.0f);
}
//! returns leg damage in percent 100 - (leg_health/max_leg_health)*100
int CPlayer::GetLegDamage(void) const
{
return 100 - (int)((m_stats.legHealth/m_stats.maxLegHealth)*100.0f);
}
//
//!return true if the player is colliding with something
bool CPlayer::HasCollided( )
{
IPhysicalEntity *pent = m_pEntity->GetPhysics();
if(!pent)
return false;
if (pent->GetType()==PE_LIVING)
{
// Create a new status object. The fields are initialized for us
pe_status_living status;
// Get new player status from physics engine
pent->GetStatus(&status);
if (!status.bFlying)
return true;
return false;
}
else
{
pe_status_dynamics sd;
pent->GetStatus(&sd);
float fMassTot=sd.mass, fMassColl=0;
int nColls,i,j;
coll_history_item item[8];
pe_status_collisions sc;
sc.pHistory = item;
sc.len = 8;
sc.age = 0.5f;
nColls = pent->GetStatus(&sc);
for(i=0; i<nColls; i++)
{
for(j=0;j<i && item[j].partid[0]!=item[i].partid[0];j++);
if (j==i)
{
sd.partid = item[i].partid[0];
pent->GetStatus(&sd);
fMassColl += sd.mass;
}
}
return fMassColl>fMassTot*0.3f;
}
}
//-----------------------------------------------------------------------------
void CPlayer::StartDie( const Vec3d& hitImpuls, const Vec3d hitPoint, int hitpartid, const int deathType )
{
//
if(!m_pGame->IsMultiplayer())
{
float deathTimer=m_pGame->p_deathtime->GetFVal();
m_fDeathTimer = deathTimer;
} else
m_pGame->m_DeadPlayers.push_back(this);
//*/
if(IsMyPlayer())
{
/*
// if it was first person view - go to third person
if(m_bFirstPerson)
m_pGame->SetViewMode(true);
Vec3d camPos = m_pEntity->GetCamera()->GetPos();
float fWaterLevel=m_p3DEngine->GetWaterLevel(&camPos);
if( fWaterLevel>m_pEntity->GetCamera()->GetPos().z )
{
camPos.z = fWaterLevel + 1;
m_pEntity->GetCamera()->SetPos( camPos );
}
*/
InitCameraTransition( PCM_CASUAL );
IAISystem *pAISystem =m_pGame->GetSystem()->GetAISystem();
if (pAISystem)
{
if (pAISystem->GetAutoBalanceInterface())
pAISystem->GetAutoBalanceInterface()->RegisterPlayerDeath();
}
}
m_sPrevAniName.clear();
m_sPrevAniNameLayer1.clear();
m_sPrevAniNameLayer2.clear();
m_pEntity->ResetAnimations( 0 );
SwitchFlashLight( false ); // turn off flashlight
IPhysicalEntity *pent = m_pEntity->GetPhysics();
IEntityCharacter *ichar = m_pEntity->GetCharInterface();
ICryCharInstance *character = ichar->GetCharacter(PLAYER_MODEL_IDX);
// Hide weapon.
DeselectWeapon();
if (character)
{
hitpartid = character->TranslatePartIdToDeadBody(hitpartid);
}
if (pent)
{
if (pent->GetType()==PE_LIVING)
{
pe_action_move am;
am.dir = hitImpuls/100.0f;
am.iJump = 2;
pent->Action(&am);
}
else if (hitpartid>=0)
{
pe_action_impulse ai;
ai.partid = hitpartid;
if (hitPoint.len2()>0)
ai.point = hitPoint;
ai.impulse = hitImpuls;
pent->Action(&ai);
}
}
// m_deathTime = GetCurrTime();
// UpdateCharacterAnimations();
m_pEntity->EnableAI(false);
m_pEntity->KillTimer();
/*
// m_deathTime = GetCurrTime();
IEntityCharacter *ichar = m_pEntity->GetCharInterface();
// UpdateCharacterAnimations();
ICryCharInstance *character = ichar->GetCharacter(PLAYER_MODEL_IDX);
if (character)
{
// Hide weapon.
character->EnableLastIdleAnimationRestart(0,false);
character->EnableLastIdleAnimationRestart(1,false);
character->AttachObjectToBone(NULL,NULL);
if (m_bIsAI)
character->ResetAnimations();
}
if (m_pEntity->GetPhysics()->GetType()==PE_ARTICULATED)
return;
// Disable physics on this player.
m_pEntity->EnablePhysics(false);
*/
}
/*! sets the player dynamics parameters
@param pDyn a structure containing the dynamics parameters
air_control
gravity
swimming_gravity
inertia
swimming_inertia
*/
void CPlayer::SetDynamics(const PlayerDynamics *pDyn)
{
if (pDyn->air_control!=1E10f) m_Dynamics.air_control = pDyn->air_control;
if (pDyn->gravity!=1E10f) m_Dynamics.gravity = pDyn->gravity;
if (pDyn->swimming_gravity!=1E10f) m_Dynamics.swimming_gravity = pDyn->swimming_gravity;
if (pDyn->inertia!=1E10f) m_Dynamics.inertia = pDyn->inertia;
if (pDyn->swimming_inertia!=1E10f) m_Dynamics.swimming_inertia = pDyn->swimming_inertia;
if (pDyn->jump_gravity!=1E10f) m_Dynamics.jump_gravity = pDyn->jump_gravity;
}
void CPlayer::RemoveAllWeapons()
{
// Takes away the owns flag of all weapons in the player's weapon map
PlayerWeaponsItor it;
for (it=m_mapPlayerWeapons.begin(); it!=m_mapPlayerWeapons.end(); it++)
(* it).second.owns = false;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if can stand in given position
bool CPlayer::CanStand( const Vec3& pos)
{
bool result=true;
IPhysicalEntity* phys = m_pEntity->GetPhysics();
pe_player_dynamics pd;
phys->GetParams(&pd);
bool bActive = pd.bActive;
m_pEntity->ActivatePhysics( true );
Vec3 curPos=m_pEntity->GetPos();
pe_params_pos ppos;
ppos.pos = pos;
phys->SetParams(&ppos);
if(!phys->SetParams( &m_PlayerDimCrouch ))
result=false;
if(result && !phys->SetParams( &m_PlayerDimNormal ))
result=false;
// restore active/position
m_pEntity->ActivatePhysics( bActive );
ppos.pos = curPos;
phys->SetParams(&ppos);
phys->SetParams( &m_PlayerDimNormal );
// m_CurStance = eNone;
// GoStand( );
return result;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise return false
bool CPlayer::GoStand(bool ignoreSpam)
{
//prevent prone-standing position spamming
if (!ignoreSpam && m_fLastProneTime > m_pTimer->GetCurrTime())
return false;
IPhysicalEntity* phys = m_pEntity->GetPhysics();
if ( phys && m_CurStance != eStand ) //m_currDimensions!=eDimNormal)
{
// Use normal physics dimensions.
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( Vec3(0,0,0) ); // reset angle if proning
if(phys->SetParams( &m_PlayerDimNormal ))
{
//InitCameraTransition( PCM_CASUAL ,true );
m_AngleLimitBase.Set(0,0,0);
if(m_pEntity->GetAI())
{
m_pEntity->GetAI()->SetEyeHeight(m_PlayerDimNormal.heightEye);
}
m_currDimensions = eDimNormal;
m_PrevStance = m_CurStance;
m_CurStance = eStand;
m_stats.aim = false;
m_stats.crouch = false;
m_stats.prone = false;
// [kirill] need this to use only z component of entity angles (same as for drawing)
// when calculating BBox
GetEntity()->SetFlags( ETY_FLAG_CALCBBOX_ZROTATE );
#if defined(LINUX64)
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, 0);
#else
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, NULL);
#endif
m_bStayCrouch = false;
m_fLastProneTime = m_pTimer->GetCurrTime() + 0.5f;
return true;
}
// could not change - restore angle
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( m_EnvTangent );
return false;
}
else // was standing already
m_PrevStance = eStand;
m_bStayCrouch = false;
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise return false
bool CPlayer::GoStealth( )
{
IPhysicalEntity* phys = m_pEntity->GetPhysics();
if ( phys && m_CurStance != eStealth ) //m_currDimensions!=eDimStealth)
{
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( Vec3(0,0,0) ); // reset angle if proning
// Use stealth physics dimensions.
if(phys->SetParams( &m_PlayerDimStealth )) //if can stealth here
{
//InitCameraTransition( PCM_CASUAL );
m_AngleLimitBase.Set(0,0,0);
if(m_pEntity->GetAI())
{
m_pEntity->GetAI()->SetEyeHeight(m_PlayerDimStealth.heightEye);
}
m_currDimensions = eDimStealth;
m_PrevStance = m_CurStance;
m_CurStance = eStealth;
m_stats.aim = false;
m_stats.crouch = false;
m_stats.prone = false;
// [kirill] need this to use only z component of entity angles (same as for drawing)
// when calculating BBox
GetEntity()->SetFlags( ETY_FLAG_CALCBBOX_ZROTATE );
m_Running = false;
#if defined(LINUX64)
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, 0);
#else
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, NULL);
#endif
return true;
}
// could not change - restore angle if proning
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( m_EnvTangent );
return false;
}
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise return false
bool CPlayer::GoCrouch( )
{
// don't go to crouch mode if using mounted weapon
if(m_pMountedWeapon)
return false;
// don't change stance in water
if( m_bSwimming )
return false;
IPhysicalEntity* phys = m_pEntity->GetPhysics();
if ( phys && m_CurStance != eCrouch ) //m_currDimensions!=eDimCrouch)
{
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( Vec3(0,0,0) ); // reset angle if proning
// Use crouching physics dimensions.
if(phys->SetParams( &m_PlayerDimCrouch ))
{
//InitCameraTransition( PCM_CASUAL, true );
m_AngleLimitBase.Set(0,0,0);
if(m_pEntity->GetAI())
{
m_pEntity->GetAI()->SetEyeHeight(m_PlayerDimCrouch.heightEye);
}
m_currDimensions = eDimCrouch;
m_PrevStance = m_CurStance;
m_CurStance = eCrouch;
m_stats.aim = false;
m_stats.crouch = true;
m_stats.prone = false;
// [kirill] need this to use only z component of entity angles (same as for drawing)
// when calculating BBox
GetEntity()->SetFlags( ETY_FLAG_CALCBBOX_ZROTATE );
m_Running = false;
#if defined(LINUX64)
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, 0);
#else
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, NULL);
#endif
return true;
}
// could not change - restore angle if proning
if( m_CurStance == eProne )
m_pEntity->SetPhysAngles( m_EnvTangent );
return false;
}
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise returns false
bool CPlayer::GoProne( )
{
IPhysicalEntity* phys = m_pEntity->GetPhysics();
if(!CanProne(false))
return false;
if ( phys && m_CurStance != eProne) //!=eDimProne)
{
// Use proning physics dimensions.
// if can't change dimentions at current position - put player little up
// and try again
if(!phys->SetParams( &m_PlayerDimProne ))
{
Vec3d pos = m_pEntity->GetPos();
pos.z += .5f;
m_pEntity->SetPos( pos );
if(!phys->SetParams( &m_PlayerDimProne ))
{
// restore position
pos.z -= .5f;
m_pEntity->SetPos( pos );
return false;
}
}
//
Vec3d ang = m_pEntity->GetAngles();
m_EnvTangent = CalcTangentOnEnviroment( m_pEntity->GetAngles() );
m_pEntity->SetPhysAngles( m_EnvTangent ); // set angels for phisics (body is flat on surfece tangent space)
//InitCameraTransition( PCM_CASUAL, true );
if(m_pEntity->GetAI())
{
m_pEntity->GetAI()->SetEyeHeight(m_PlayerDimProne.heightEye);
}
m_currDimensions = eDimProne;
m_PrevStance = m_CurStance;
m_CurStance = eProne;
m_stats.aim = false;
m_stats.crouch = false;
m_stats.prone = true;
// [kirill] when in prone - use all the rotations (same as for drawing)
// when calculating BBox
GetEntity()->ClearFlags( ETY_FLAG_CALCBBOX_ZROTATE );
m_Running = false;
#if defined(LINUX64)
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, 0);
#else
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, NULL);
#endif
}
m_bStayCrouch = false;
m_fLastProneTime = m_pTimer->GetCurrTime() + 0.5f;
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise returns false
bool CPlayer::GoSwim( )
{
IPhysicalEntity* phys = m_pEntity->GetPhysics();
if ( phys && m_CurStance != eSwim) //!=eDimProne)
{
//
// Vec3d ang = m_pEntity->GetAngles();
// m_EnvTangent = CalcTangentOnEnviroment( m_pEntity->GetAngles() );
// m_pEntity->SetPhysAngles( m_EnvTangent ); // set angels for phisics (body is flat on surfece tangent space)
// Use proning physics dimensions for swimming.
if(phys->SetParams( &m_PlayerDimSwim ))
{
InitCameraTransition( PCM_CASUAL, true );
m_AngleLimitBase.Set(0,0,0);
if(m_pEntity->GetAI())
{
m_pEntity->GetAI()->SetEyeHeight(m_PlayerDimProne.heightEye);
}
m_currDimensions = eDimProne;
m_PrevStance = m_CurStance;
m_CurStance = eSwim;
// m_stats.aim = false;
// m_stats.crouch = false;
// m_stats.prone = true;
m_stats.aim = false;
m_stats.crouch = false;
m_stats.prone = false;
m_stats.prone = false;
// [kirill] need this to use only z component of entity angles (same as for drawing)
// when calculating BBox
GetEntity()->SetFlags( ETY_FLAG_CALCBBOX_ZROTATE );
m_Running = false;
#if defined(LINUX64)
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, 0);
#else
m_pEntity->SendScriptEvent(ScriptEvent_StanceChange, NULL);
#endif
m_bStayCrouch = false;
return true;
}
return false;
}
m_bStayCrouch = false;
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if slope angle is ok to be in prone (not too steep) AND not falling/jumping
bool CPlayer::CanProne(bool ignoreSpam)
{
float slopeProneLimit=.7f;
// don't go to prone mode if using mounted weapon
if(m_pMountedWeapon)
return false;
//prevent prone-standing position spamming
if (!ignoreSpam && m_fLastProneTime > m_pTimer->GetCurrTime())
return false;
// don't go to prone mode if falling/jumping
if(m_FlyTime>.5f && m_CurStance!=eSwim)
return false;
if(!m_pEntity->GetPhysics())
return false;
pe_status_living pStat;
m_pEntity->GetPhysics()->GetStatus(&pStat);
m_vProneEnvNormal = (Vec3d)pStat.groundSlope;
ray_hit hit;
Vec3d pos=m_pEntity->GetPos();
int hitCount=0;
float fHitCount=1.0f;
if( m_vProneEnvNormal.z>slopeProneLimit )
++hitCount;
pos.z += .3f;
pos.x += .1f;
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f),
ent_all-ent_independent, rwi_stop_at_pierceable | geom_colltype_player<<rwi_colltype_bit,&hit,
1, GetEntity()->GetPhysics()))
{
m_vProneEnvNormal += hit.n;
++fHitCount;
if( hit.n.z>slopeProneLimit )
++hitCount;
}
pos.x -= .2f;
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f),
ent_all-ent_independent, rwi_stop_at_pierceable | geom_colltype_player<<rwi_colltype_bit,&hit,
1, GetEntity()->GetPhysics()))
{
m_vProneEnvNormal += hit.n;
++fHitCount;
if( hit.n.z>slopeProneLimit )
++hitCount;
}
pos.x += .1f;
pos.y += .1f;
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f),
ent_all-ent_independent, rwi_stop_at_pierceable | geom_colltype_player<<rwi_colltype_bit,&hit,
1, GetEntity()->GetPhysics()))
{
m_vProneEnvNormal += hit.n;
++fHitCount;
if( hit.n.z>slopeProneLimit )
++hitCount;
}
pos.y -= .2f;
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f),
ent_all-ent_independent, rwi_stop_at_pierceable | geom_colltype_player<<rwi_colltype_bit,&hit,
1, GetEntity()->GetPhysics()))
{
m_vProneEnvNormal += hit.n;
++fHitCount;
if( hit.n.z>slopeProneLimit )
++hitCount;
}
// there are no points with allowed slope around - can't prone here
if( hitCount<1 )
return false;
m_vProneEnvNormal = m_vProneEnvNormal/fHitCount;
// can't prone when standing on boat/car
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (physEnt)
{
pe_status_living status;
if (physEnt->GetStatus(&status))
{
if(status.pGroundCollider)
{
IEntity* pEnt=(IEntity*)status.pGroundCollider->GetForeignData();
if(pEnt && pEnt->GetContainer())
{
CVehicle* pVehicleBelow;
if(pEnt->GetContainer()->QueryContainerInterface(CIT_IVEHICLE,(void**)&pVehicleBelow))
{
return false;
}
}
}
}
}
return true;
}
//
//-----------------------------------------------------------------------------------------------
// returns true if switch to stance or already in stance, otherwise return false
bool CPlayer::GoRelaxed( )
{
if(!GoStand())
{
return false;
}
m_PrevStance = m_CurStance;
m_CurStance = eRelaxed;
return true;
}
//
//-----------------------------------------------------------------------------------------------
bool CPlayer::RestorePrevStence()
{
switch( m_PrevStance )
{
case eStand:
case eSwim:
return GoStand();
case eStealth:
return GoStealth();
case eCrouch:
return GoCrouch();
case eProne:
return GoProne();
}
return false;
}
//
//-----------------------------------------------------------------------------------------------
// for debug/test purposes -
//////////////////////////////////////////////////////////////////////////
void CPlayer::StartFire()
{
Vec3d pos = m_pEntity->GetPos();
}
//////////////////////////////////////////////////////////////////////////
/*void CPlayer::PlaySound(ISound * pSound, float fSoundScale, Vec3d &Offset)
{
if(IsMyPlayer())
{
m_lstAttachedSounds.push_back(SAttachedSound(pSound, Offset));
pSound->SetPosition(CalcSoundPos());
}
else
{
pSound->SetPosition(m_pEntity->GetPos());
}
pSound->Play(fSoundScale);
}*/
Vec3d CPlayer::CalcSoundPos()
{
IEntityCamera *pEC;
if (IsMyPlayer() && (pEC=m_pEntity->GetCamera()))
{
CCamera &cam=pEC->GetCamera();
Vec3d vPos=cam.GetPos();
vPos+=cam.m_vOffset;
Vec3d vAngles=cam.GetAngles();
Vec3d vTrans=vPos-cam.GetPos();
Matrix44 vRot;
vRot.SetIdentity();
//rotate the matrix ingnoring the Y rotation
//vRot.RotateMatrix(Vec3d(vAngles.x,0,vAngles.z));
vRot=Matrix44::CreateRotationZYX(-Vec3d(vAngles.x,0,vAngles.z)*gf_DEGTORAD)*vRot; //NOTE: angles in radians and negated
vPos=vRot.TransformPointOLD(vTrans);
//translate back
vPos+=cam.GetPos();
return vPos;
}
return m_pEntity->GetPos();
}
// calculates vertical and horizontal speed to make player jump on dist and height
void CPlayer::CalcJumpSpeed( float dist, float height, float &horV, float &vertV )
{
assert(height>=0.0f);
// vz = srtq(2*g*h)
// vx = len*g/(2*vz)
float fGravity;
//we are using a different gravity for jump? use it to calculate jump speeds.
if (m_Dynamics.jump_gravity!=1E10)
fGravity = m_Dynamics.jump_gravity;
else
fGravity = m_Dynamics.gravity;
fGravity *= m_pGame->p_gravity_modifier->GetFVal();
vertV = cry_sqrtf( 2.0f*fGravity*height );
// horV = dist*m_Dynamics.gravity/( 2.0f*vertV );
if(height!=0.0f) horV=(dist*cry_sqrtf(fGravity)) / (2*cry_sqrtf(2*height));
else horV=0.0f;
}
void CPlayer::SetViewMode(bool bThirdPerson)
{
if(!IsMyPlayer())
return;
if( !bThirdPerson )
{
m_pEntity->DrawCharacter(0, 0);
m_pEntity->NeedsUpdateCharacter(0, true);
}
else
{
if (m_stats.bModelHidden)
m_pEntity->DrawCharacter(0, 0);
else
m_pEntity->DrawCharacter(0, 1);
}
// if( !bThirdPerson && IsMyPlayer() )
// {
// m_pEntity->DrawCharacter(0, 0);
// m_pEntity->NeedsUpdateCharacter(0, true);
// }
}
/*
// calcualtes aproximate point of lending for granade on terrain
// firePos - start point
// dir - normolized direction
// vel - velocity
// timeStep - time interval for iteration
// timeLimit - time to stop iterations if no collision with terrain is detected
Vec3d CPlayer::TraceGrenade( const Vec3d& firePos, const Vec3d& dir, const float vel,
const float timeStep, const float timeLimit)
{
Vec3d curPos;
float time = 0.0f;
curPos = firePos;
while( curPos.z > m_p3DEngine->GetTerrainElevation(curPos.x, curPos.y) && time<timeLimit)
{
curPos.x = time*dir.x*vel + firePos.x;
curPos.y = time*dir.y*vel + firePos.y;
curPos.z = m_Dynamics.gravity*time*time/2.0f + dir.z*vel*time + firePos.z;
time += timeStep;
}
curPos.z = m_p3DEngine->GetTerrainElevation(curPos.x, curPos.y);
return curPos;
}
*/
void CPlayer::SwitchFiremode(int nforce)
{
if (m_nSelectedWeaponID != -1)
{
WeaponParams temp;
bool bChanged = true, bCanSwitch;
int iNewFireMode;
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
WeaponInfo &wi = GetWeaponInfo();
if(nforce==-1)
{
// Check what the next firemode would be, bChanged will be false in case
// we can't switch to another mode
iNewFireMode = pSelectedWeapon->GetNextFireMode(wi.iFireMode, m_bIsAI);
}
else
{
iNewFireMode=nforce;
}
bChanged = (wi.iFireMode != iNewFireMode);
if (bChanged && (!m_stats.reloading) && (!m_stats.weapon_busy))
{
// Call the script to find out if we can switch
_SmartScriptObject pObj(m_pScriptSystem);
pObj->SetValue( "firemode",iNewFireMode);
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
m_stats.firemode=iNewFireMode;
m_pEntity->SendScriptEvent(ScriptEvent_FireModeChange, *pObj, &bCanSwitch);
// Apply the change to the C++ state
wi.iFireMode = iNewFireMode;
}
}
}
void CPlayer::CounterAdd( const string name, const float timeScale )
{
CountersMap::iterator counter = m_UpdatedCounters.find( name );
if( counter == m_UpdatedCounters.end() )
{
couterEntry newEntry;
newEntry.scale = timeScale;
m_UpdatedCounters[name] = newEntry;
}
else
{
(counter->second).scale = timeScale;
}
}
void CPlayer::CounterIncrement( const string name, const float value )
{
CountersMap::iterator counter = m_UpdatedCounters.find( name );
if( counter == m_UpdatedCounters.end() )
return;
(counter->second).value += value;
}
float CPlayer::CounterGetValue( const string name )
{
CountersMap::iterator counter = m_UpdatedCounters.find( name );
if( counter == m_UpdatedCounters.end() )
return 0.0f;
return (counter->second).value;
}
void CPlayer::CounterUpdateAll( const float dt )
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
CountersMap::iterator counter = m_UpdatedCounters.begin( );
for(; counter!=m_UpdatedCounters.end(); counter++ )
{
float prevValue = (counter->second).value;
(counter->second).value += (counter->second).scale*dt;
if( prevValue<(counter->second).eventTrhld && (counter->second).value>(counter->second).eventTrhld )
{
IAIObject *pObject = m_pEntity->GetAI();
if (pObject)
{
pObject->SetSignal(1, (counter->second).eventToCall.c_str());
}
}
if((counter->second).value < 0.0f)
(counter->second).value = 0.0f;
}
}
void CPlayer::CounterSetValue( const string name, const float value )
{
CountersMap::iterator counter = m_UpdatedCounters.find( name );
if( counter == m_UpdatedCounters.end() )
return;
(counter->second).value = value;
}
void CPlayer::CounterSetEvent( const string name, const float thrhld, const string eventName )
{
CountersMap::iterator counter = m_UpdatedCounters.find( name );
if( counter == m_UpdatedCounters.end() )
return;
(counter->second).eventToCall = eventName;
(counter->second).eventTrhld = thrhld;
}
// attaches weapon to weapon bone on character's back
void CPlayer::HolsterWeapon(void)
{
SetWeaponPositionState(WEAPON_POS_HOLSTER);
}
// rebinds weapon to be bound to the weapon bone in the characters hands
void CPlayer::HoldWeapon(void)
{
SetWeaponPositionState(WEAPON_POS_HOLD);
}
void CPlayer::SetWeaponPositionState(EWeaponPositionState weaponPositionState)
{
assert (IsHeapValid());
// attach to bone ?
if (m_nSelectedWeaponID != -1 && m_weaponPositionState != weaponPositionState)
{
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
m_weaponPositionState = weaponPositionState;
ICryCharInstance *character = m_pEntity->GetCharInterface()->GetCharacter(PLAYER_MODEL_IDX);
WeaponInfo &wi = GetWeaponInfo();
assert (IsHeapValid());
if (character)
{
wi.DetachBindingHandles(character);
if (weaponPositionState == WEAPON_POS_UNDEFINED)
return;
// ValidateHeap();
string sBone = pSelectedWeapon->GetBindBone();
// ValidateHeap();
if (!sBone.empty())
{
// ValidateHeap();
if (weaponPositionState == WEAPON_POS_HOLSTER)
sBone+="02";
// ValidateHeap();
wi.hBindInfo = character->AttachObjectToBone( pSelectedWeapon->GetObject(), sBone.c_str() );
// ValidateHeap();
// if there is an auxilary weapon bone, attach to that as well
string sAuxBone = "aux_" + sBone;
if (character->GetModel()->GetBoneByName(sAuxBone.c_str())>=0)
{
wi.hAuxBindInfo = character->AttachObjectToBone( pSelectedWeapon->GetObject(), sAuxBone.c_str() );
}
}
else
{
character->DetachAll();
}
}
}
}
//
//
void CPlayer::SetBlendTime(const char *sAniName, float fBlendTime)
{
if(strlen(sAniName)<3) // it has to be some name
return;
m_AniBlendTimes[sAniName] = fBlendTime;
}
void CPlayer::GetBlendTime(const char *sAniName, float&fBlendTime)
{
BlendTimesMap::iterator curAni=m_AniBlendTimes.find(sAniName);
if( curAni == m_AniBlendTimes.end() )
return;
fBlendTime = (curAni->second);
}
void CPlayer::UpdateCollisionDamage( )
{
// Get a pointer to the physics engine
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (!physEnt)
return;
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
// Create a new status object.
pe_status_collisions status;
coll_history_item history[4];
memset( history, 0, sizeof(history) );
status.pHistory = history;
status.len = 4;
status.bClearHistory = true;
status.age = .1f;
int colN=0,imax;
float massLimitMin=50.0f;
float massLimitMax=80.0f;
float velLimit=3;//10;//6.5f;
if ((m_timeDmgCollision+=m_pTimer->GetFrameTime())>2.0f)
{
m_timeDmgCollision = 0; m_pPrevDmgCollider = 0;
}
// Get new player status from physics engine
if (colN=physEnt->GetStatus(&status))
{
float damageValue = 0.0f;
//find the most damaging collision in history
for(imax=-1 ; colN>0; colN--)
{
float curVel = max(0.0f,history[colN-1].v[1]*history[colN-1].n);
if(history[colN-1].mass[1]<=massLimitMin || curVel<velLimit)
continue;
float curDamage = (history[colN-1].mass[1]<massLimitMax ? history[colN-1].mass[1] : massLimitMax)*curVel;
IPhysicalEntity *pCollider = m_pPhysicalWorld->GetPhysicalEntityById(history[colN-1].idCollider);
if (pCollider==m_pPrevDmgCollider && curDamage<m_prevCollDamage*1.2f)
continue;
if(damageValue < curDamage)
damageValue = curDamage, imax = colN-1;
}
//m_pGame->GetSystem()->GetILog()->Log( "\002 %d collision %s %.2f %.2f ", colN, GetName(), history[0].collMass, history[0].vrel.len() );
if(damageValue>=1.0f)
{
_SmartScriptObject pTable(m_pScriptSystem,false);
CScriptObjectVector oDir(m_pScriptSystem); oDir=history[imax].n;
pTable->SetValue("dir",*oDir);
pTable->SetValue("damage",damageValue);
pTable->SetValue("collider_mass",history[imax].mass[1]);
pTable->SetValue("collider_velocity",-history[imax].v[1]*history[imax].n);
IPhysicalEntity *pCollider = m_pPhysicalWorld->GetPhysicalEntityById(history[imax].idCollider);
if (pCollider)
{
IEntity *pEntCollider = (IEntity*)pCollider->GetForeignData();
if (pEntCollider)
pTable->SetValue("collider",pEntCollider->GetScriptObject());
}
m_pEntity->SendScriptEvent( ScriptEvent_PhysCollision , pTable);
//m_pGame->GetSystem()->GetILog()->Log( "\002 collision %s %.1f %d %.1f ", GetName(), damageValue, m_stats.health, maxVel);
m_pPrevDmgCollider = pCollider;
m_prevCollDamage = damageValue;
m_timeDmgCollision = 0;
}
}
}
void CPlayer::SetSpeedMult( float run, float crouch, float prone, float xrun, float xwalk, float rrun, float rwalk )
{
m_RunSpeedScale = run;
m_CrouchSpeedScale = crouch;
m_ProneSpeedScale = prone;
m_XRunSpeedScale = xrun; // stealth
m_XWalkSpeedScale = xwalk;
m_RRunSpeedScale = rrun; // relaxed
m_RWalkSpeedScale = rwalk;
}
//
//-----------------------------------------------------------------
void CPlayer::OnDrawMountedWeapon( const SRendParams & RendParams )
{
if(m_nSelectedWeaponID == -1)
return;
// if the localplayer is using the mounted weapon, only then do we disable the first person weapon drawing
if( m_pMountedWeapon && IsMyPlayer())
{
m_pMountedWeapon->DrawObject(0,ETY_DRAW_NORMAL);
m_pMountedWeapon->DrawCharacter(0,ETY_DRAW_NORMAL);
Vec3d apos, aang;
GetFirePosAngles( apos, aang );
apos = m_pMountedWeapon->GetAngles(1);
// if(IsMyPlayer())
m_pMountedWeapon->SetAngles( aang, false, false, true );
// else
// m_pMountedWeapon->SetAngles( m_pEntity->GetAngles(), false, false, true );
m_pMountedWeapon->ForceCharacterUpdate(0);
m_pMountedWeapon->DrawEntity(RendParams);
m_pMountedWeapon->SetAngles( apos );
m_pMountedWeapon->DrawObject(0,ETY_DRAW_NONE); // we don't want to draw it (already drawn by player)
m_pMountedWeapon->DrawCharacter(0,ETY_DRAW_NONE);
m_pMountedWeapon->NeedsUpdateCharacter( 0, true); // but we want to update animation for it
GetEntity()->DrawCharacter(1, ETY_DRAW_NONE);
}
return;
}
void CPlayer::UpdateCharacterAnimationsMounted( SPlayerUpdateContext &ctx )
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
m_pEntity->SetAnimationSpeed( 1.0f );
if( m_pVehicle ) // mounted weapon on vehicle - don't do any animation
return;
float diff = m_pEntity->GetAngles().z - m_vPrevMntPos.z;
float vel = diff/m_pTimer->GetFrameTime();
//if(diff!=0)
//m_pGame->m_pLog->Log(" %.2f %.2f %.2f\n", diff, vel, m_pEntity->GetAngles().z );
string aniName;
/*
if(fabsf(vel)>50.6f) // too slow - no animations
{
m_RunningTime += m_pTimer->GetFrameTime();
}
else
{
m_RunningTime = 0;
}
*/
// if( m_RunningTime<.1f )
if( fabsf(vel)<60.6f )
aniName = "mount_fwd";
else
{
if( diff<0 )
aniName = "mount_left";//"arotateright";
else
// aniName = "srotateleft";
aniName = "mount_right";//"arotateleft";
// float speedScale = 1 + (fabsf(vel)-60)*.5f;
// m_pEntity->SetAnimationSpeed( speedScale );
}
m_RunningTime += m_pTimer->GetFrameTime();
if(m_sPrevAniName != aniName)
{
if(aniName == "mount_fwd")
{
if( m_MntWeaponStandTime>.3f )
{
if(m_pEntity->StartAnimation(0, aniName.c_str(), 0, .25f ))
m_sPrevAniName = aniName;
// m_RunningTime = 0;
}
m_MntWeaponStandTime += m_pTimer->GetFrameTime();
}
else
{
if(m_pEntity->StartAnimation(0, aniName.c_str(), 0, .25f ))
m_sPrevAniName = aniName;
m_MntWeaponStandTime = 0.0f;
}
}
m_vPrevMntPos = m_pEntity->GetAngles();
return;
/*
//m_pEntity->StartAnimation(0, "awalkback", 0, .1 );
//return;
Vec3d diff = m_pEntity->GetPos() - m_vPrevMntPos;
//Ang3 playerDir = GetActualAngles();
Vec3d playerDir = m_pEntity->GetAngles();
playerDir = ConvertToRadAngles(playerDir);
playerDir.z=0;
playerDir.normalize();
diff.z=0;
float dist = diff.len();
float vel = dist/m_pTimer->GetFrameTime();
diff.normalize();
float dotz = playerDir.x*diff.x + playerDir.y*diff.y;
float crossz = playerDir.x * diff.y - playerDir.y * diff.x;
string aniName;
if(vel<.6f) // too slow - no animations
{
m_NotRunTime += m_pTimer->GetFrameTime();
}
else
{
m_NotRunTime = 0;
}
if( m_NotRunTime>.2f )//|| fabsf(crossz)<.3 )
aniName = "sidle";
else if( crossz<0 )
aniName = "awalkfwd";//"arotateright";
else
aniName = "srotateleft";
// aniName = "swalkback";//"arotateleft";
if(m_sPrevAniNameLayer1 != aniName)
if(m_pEntity->StartAnimation(0, aniName.c_str(), 0, .1 ))
m_sPrevAniNameLayer1 = aniName;
m_vPrevMntPos = m_pEntity->GetPos();
return;
*/
}
void CPlayer::GiveBinoculars(bool val)
{
if (m_stats.has_binoculars == val)
return;
m_stats.has_binoculars = val;
// FIXME ... if the binoculars are take away, then we should reset the viewlayer (must be done
// on the script side
}
void CPlayer::PreloadInstanceResources(Vec3d vPrevPortalPos, float fPrevPortalDistance, float fTime)
{
int nRecursionLevel = (int)m_pGame->GetSystem()->GetIRenderer()->EF_Query(EFQ_RecurseLevel) - 1;
if(m_bFirstPerson && !nRecursionLevel && m_stats.drawfpweapon && m_nSelectedWeaponID != -1)
return;
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
if (!pChar)
return;
if (!(pChar->GetFlags() & CS_FLAG_DRAW_MODEL) && !nRecursionLevel)
return;
float fDist = fPrevPortalDistance + vPrevPortalPos.GetDistance(m_pEntity->GetPos());
pChar->PreloadResources(fDist, 1.f, 0);
}
void CPlayer::SetStaminaTable( const StaminaTable& stTable )
{
m_StaminaTable = stTable;
}
void CPlayer::UpdateStamina( float dTime )
{
// stamina (for sprint run) update
// update breath (blue bar)
if(m_stats.underwater>0.0f) //we are under water - decrease breath level
{
if(m_stats.stamina>0) // if there is some stamina -
{
if((m_stats.stamina-=dTime*m_StaminaTable.BreathDecoyUnderwater)<0)
m_stats.stamina = 0;
}
}
else if( m_stats.holding_breath ) // we are sniping/holding breath - decrease breath level
{
if((m_stats.stamina-=dTime*m_StaminaTable.BreathDecoyAim)<1.0f)
m_stats.stamina = 1.0f;
}
// update stamina (yellow bar)
else if( m_Sprinting )
{
if((m_stats.stamina -= dTime*m_StaminaTable.DecoyRun)<1.0f)
m_stats.stamina = 1.0f;
}
// restore stamina - player is resting
else if(m_stats.stamina<100 && (!m_stats.flying || m_bSwimming&&m_stats.underwater<=0.0f ))
{
if(m_Running)
m_stats.stamina += dTime*m_StaminaTable.RestoreRun;
else
m_stats.stamina += dTime*m_StaminaTable.RestoreWalk;
if(m_stats.stamina>100)
m_stats.stamina = 100;
}
// to indicate stamina on HUD
m_StaminaTable.StaminaHUD = m_stats.stamina*0.01f;
}
//////////////////////////////////////////////////////////////////////////
bool CPlayer::IsVisible() const
{
if(m_pGame->IsServer() && m_pGame->IsMultiplayer())
return true;
if (m_pEntity)
{
// If was rendered recently.
int nCurrRenderFrame = (int)m_pGame->GetSystem()->GetIRenderer()->GetFrameID();
if (abs(nCurrRenderFrame-m_pEntity->GetDrawFrame(0)) < 3)
return true;
}
return false;
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::UpdateSwimState(bool bAlive)
{
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
// check if the player goes underwater.
//if (m_p3DEngine->GetWaterLevel(&m_vEyePos)>m_vEyePos.z)
float fWaterLevel=m_p3DEngine->GetWaterLevel(m_pEntity);
m_stats.fInWater=fWaterLevel-m_pEntity->GetPos().z;
if (m_stats.fInWater<0.0f)
m_stats.fInWater=0.0f;
Vec3 vPos=m_vEyePos;
if (!bAlive && !IsMyPlayer())
{
SetEyePosBone();
vPos=m_vEyePos;
//vPos=m_pEntity->GetPos();
}
if (fWaterLevel>vPos.z)
{
// if that is the case, start the EAX underwater effect
// plus increase the underwater time
m_stats.underwater+=m_pTimer->GetFrameTime();
if (!m_bIsAI)
if(m_pGame->GetSystem()->GetISoundSystem())
m_pGame->GetSystem()->GetISoundSystem()->SetEaxListenerEnvironment(EAX_PRESET_UNDERWATER);
// also call the script function to play the water splash sounds and
// other stuff it this is the first time it goes underwater
if (!m_bEyesInWater)
{
m_pEntity->SendScriptEvent(ScriptEvent_EnterWater,0);
m_bEyesInWater=true;
}
}
else
{
// remove EAX underwater, if he was in the water before
if ((m_stats.underwater>0.001f) && (!m_bIsAI)) // epsilon
if(m_pGame->GetSystem()->GetISoundSystem())
m_pGame->GetSystem()->GetISoundSystem()->SetEaxListenerEnvironment(EAX_PRESET_OFF);
m_stats.underwater=0.0f;
m_bEyesInWater=false;
}
m_stats.fKWater = 0;
// no need for anymore checks if dead - only eyesInWater updated
if(!IsAlive())
{
m_bSwimming = false;
return;
}
// ladder is priority to swim
if(m_stats.onLadder)
{
m_bSwimming = false;
return;
}
// in vehicle is priority to swim
if(m_pVehicle)
{
m_bSwimming = false;
return;
}
// not in water
if(fWaterLevel < -500)
{
m_bSwimming = false;
return;
}
// if(m_stats.fInWater<)
/*
//[kirill]
//fixme
//remove this
//the check is for cathching strange positon outorrange problem
//if( m_pGame->pa_blend2->GetFVal()>0.0f )
{
Vec3d pos = m_pEntity->GetPos();
if(pos.z<-100 || pos.z>500 ||
pos.x<=0 || pos.x>10000 ||
pos.y<=0 || pos.y>10000
)
{
if(IsAlive())
m_pGame->m_pLog->Log("\006 alive player < %s > position is invalid %.2f %.2f %.2f \n", m_pEntity->GetName(), pos.x, pos.y, pos.z );
else
m_pGame->m_pLog->Log("\006 dead player < %s > position is invalid %.2f %.2f %.2f \n", m_pEntity->GetName(), pos.x, pos.y, pos.z );
}
}
//remove this over
*/
// to use value depending on current stance
float depthOffset;// = GetEntity()->GetCamera()->GetCamOffset().z;
//AIs don't have camera offset - use fixed value (could use eyeHeight)
if( m_bIsAI )
depthOffset = 1.5f;
else
{
switch( m_CurStance )
{
case eProne:
case eSwim:
depthOffset = .45f;
break;
// case eStand:
default:
depthOffset = 1.5f;
break;
}
}
//check if we are standing on something
pe_status_living status;
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (!physEnt || !physEnt->GetStatus(&status))
{
GameWarning( "Bad Phyics Entity for Player %s",m_pEntity->GetName() );
return;
}
if (status.pGroundCollider)
{
if( status.groundHeight+depthOffset > fWaterLevel )
{
m_bSwimming = false;
return;
}
}
//
if(m_pEntity->GetEntityVisArea()==0) // if outdoors - check how deep we are
{
Vec3 rPos = m_pEntity->GetPos();
bool bChanged = false;
if(_isnan(rPos.x))
{
bChanged = true;
rPos.x = 0;
}
if(_isnan(rPos.y))
{
bChanged = true;
rPos.y = 0;
}
if(_isnan(rPos.z))
{
bChanged = true;
rPos.z = 0;
}
if(bChanged)
m_pEntity->SetPos(rPos);
float fTerrainLevel=m_p3DEngine->GetTerrainElevation(m_pEntity->GetPos().x, m_pEntity->GetPos().y);
if(fWaterLevel - fTerrainLevel < depthOffset )//1.5f)
{
m_bSwimming = false;
return;
}
}
// else
if(fWaterLevel - m_pEntity->GetPos().z < depthOffset )//1.5f) // check if it's deep enough to sweem
{
vectorf pos = m_pEntity->GetPos();
pos.z = fWaterLevel;
ray_hit hit;
if (m_pGame->GetSystem()->GetIPhysicalWorld()->RayWorldIntersection( pos, vectorf(0,0,-1.5f), ent_all,
rwi_stop_at_pierceable,&hit,1, GetEntity()->GetPhysics()))
{
m_bSwimming = false;
return;
}
}
m_stats.fKWater = min(1.0f,m_stats.fInWater*(1.0f/.60f));
m_bSwimming = m_stats.fKWater>0.0f;
m_stats.fKWater*=m_stats.fKWater;
}
//////////////////////////////////////////////////////////////////////////
void CPlayer::DampInputVector(vectorf &vec ,float speed ,float stopspeed ,bool only2d ,bool linear)
{
if (speed<=0.0f)
return;
float spd = speed;
float saveZ = vec.z;
if (only2d)
vec.z = 0;
float goallen = vec.len();
if (goallen<0.001f)
spd = stopspeed;
vectorf delta = vec - m_vLastMotionDir;
if (linear)//if linear cap the delta to "ai_smoothvel"
{
float deltalen = delta.len();
if (deltalen>spd)
delta = delta * (deltalen==0?0.001f:1.0f/deltalen) * spd;
}
float dt = m_fLastDeltaTime;//m_pTimer->GetFrameTime();//m_pGame->GetSystem()->GetITimer()->GetFrameTime();
vec = m_vLastMotionDir + delta*min(dt*spd,1.0f);
if (vec.len()<0.001f)
vec.Set(0,0,0);
m_vLastMotionDir = vec;
if (only2d)
vec.z = saveZ;
}
void CPlayer::SaveAIState(CStream & stm, CScriptObjectStream & scriptStream)
{
IScriptSystem *pScriptSystem = m_pGame->GetSystem()->GetIScriptSystem();
HSCRIPTFUNCTION saveOverallFunction=NULL;
if( m_pEntity->GetScriptObject() && m_pEntity->GetScriptObject()->GetValue("OnSaveOverall", saveOverallFunction) )
{
pScriptSystem->BeginCall(saveOverallFunction);
pScriptSystem->PushFuncParam(m_pEntity->GetScriptObject());
pScriptSystem->PushFuncParam(scriptStream.GetScriptObject());
pScriptSystem->EndCall();
}
if (!m_bIsAI)
return;
IAIObject *pObject = m_pEntity->GetAI();
pObject->Save(stm);
IPipeUser *pUser =0;
// save weapon state
int nGunOut = 0;
m_pEntity->GetScriptObject()->GetValue("AI_GunOut",nGunOut);
stm.Write(nGunOut);
ICryCharInstance *pCharacter = m_pEntity->GetCharInterface()->GetCharacter(0);
bool bAnimWritten = false;
if (pCharacter)
{
int nAnimID = pCharacter->GetCurrentAnimation(3);
if (nAnimID>=0)
{
ICryCharModel *pModel = pCharacter->GetModel();
if (pModel)
{
const char *szAnimName = pModel->GetAnimationSet()->GetName(nAnimID);
stm.Write(szAnimName);
bAnimWritten = true;
}
}
}
if (!bAnimWritten)
stm.Write("NA");
// save any conversation that this guy may be in
_SmartScriptObject pCurrentConversation(m_pScriptSystem,true);
if (m_pEntity->GetScriptObject()->GetValue("CurrentConversation",pCurrentConversation))
{
const char *szName;
pCurrentConversation->GetValue("NAME",szName);
stm.Write(szName);
int iProgress,conv_id;
pCurrentConversation->GetValue("CONV_ID",conv_id);
stm.Write(conv_id);
pCurrentConversation->GetValue("Progress",iProgress);
stm.Write(iProgress);
// save all the actors in the conversation
_SmartScriptObject pActors(m_pScriptSystem,true);
pCurrentConversation->GetValue("Actor",pActors);
int i=1;
stm.Write(pActors->Count());
while (i<=pActors->Count())
{
_SmartScriptObject pActorEntity(m_pScriptSystem,true);
if (pActors->GetAt(i,pActorEntity))
{
int Actor_ID;
pActorEntity->GetValue("id",Actor_ID);
stm.Write(Actor_ID);
}
i++;
}
}
else
stm.Write("NA");
}
void CPlayer::LoadAIState(CStream & stm, CScriptObjectStream & scriptStream)
{
IScriptSystem *pScriptSystem = m_pGame->GetSystem()->GetIScriptSystem();
HSCRIPTFUNCTION loadOverallFunction=NULL;
if( m_pEntity->GetScriptObject() && m_pEntity->GetScriptObject()->GetValue("OnLoadOverall", loadOverallFunction) )
{
pScriptSystem->BeginCall(loadOverallFunction);
pScriptSystem->PushFuncParam(m_pEntity->GetScriptObject());
pScriptSystem->PushFuncParam(scriptStream.GetScriptObject());
pScriptSystem->EndCall();
}
if (!m_bIsAI)
return;
IAIObject *pObject = m_pEntity->GetAI();
pObject->Load(stm);
int nGunOut=0;
stm.Read(nGunOut);
if (nGunOut)
{
SetWeaponPositionState(WEAPON_POS_HOLD);
m_pEntity->GetScriptObject()->SetValue("AI_GunOut",1);
m_pScriptSystem->BeginCall("BasicAI","MakeAlerted");
m_pScriptSystem->PushFuncParam(m_pEntity->GetScriptObject());
m_pScriptSystem->EndCall();
}
char str[255];
stm.Read(str,255);
if (stricmp(str,"NA"))
{
ICryCharInstance *pCharacter = m_pEntity->GetCharInterface()->GetCharacter(0);
if (pCharacter)
{
CryCharAnimationParams ccap;
ccap.fBlendInTime = 0;
ccap.fBlendOutTime = 0;
ccap.nLayerID = 3;
pCharacter->StartAnimation(str,ccap);
}
}
stm.Read(str,255);
if (stricmp(str,"NA"))
{
_SmartScriptObject pCurrentConversation(m_pScriptSystem,true);
if (!m_pEntity->GetScriptObject()->GetValue("CurrentConversation",pCurrentConversation))
{
// get the saved conversation
int conv_id;
stm.Read(conv_id);
_SmartScriptObject pNewConversation(m_pScriptSystem,true);
_SmartScriptObject pConvManager(m_pScriptSystem,true);
m_pScriptSystem->GetGlobalValue("AI_ConvManager",pConvManager);
m_pScriptSystem->BeginCall("AI_ConvManager","GetSpecificConversation");
m_pScriptSystem->PushFuncParam(pConvManager);
m_pScriptSystem->PushFuncParam(str);
m_pScriptSystem->PushFuncParam(conv_id);
m_pScriptSystem->EndCall(pNewConversation);
// remember how far we were
stm.Read(conv_id);
// go back one line
if (conv_id>0)
conv_id--;
pNewConversation->SetValue("Progress",conv_id);
// now loop through all the actors and make them join this conversation
int nrActors,curr_actor=0;
stm.Read(nrActors);
while (curr_actor<nrActors)
{
int ActorID;
stm.Read(ActorID);
// get the entity
IEntity *pActorEntity = m_pGame->GetSystem()->GetIEntitySystem()->GetEntity(ActorID);
if (pActorEntity)
{
IScriptObject *pActorScriptObject = pActorEntity->GetScriptObject();
pActorScriptObject->SetValue("CurrentConversation",pNewConversation);
unsigned int funcHandle;
pNewConversation->GetValue("Join",funcHandle);
m_pScriptSystem->BeginCall(funcHandle);
m_pScriptSystem->PushFuncParam(pNewConversation);
m_pScriptSystem->PushFuncParam(pActorEntity->GetScriptObject());
m_pScriptSystem->EndCall();
}
curr_actor++;
}
// if joined is equal to amount of participants, continue the conversation
int iJoined,iParticipants;
pNewConversation->GetValue("Joined",iJoined);
pNewConversation->GetValue("Participants",iParticipants);
if (iJoined == iParticipants)
{
unsigned int funcHandle;
pNewConversation->GetValue("Continue",funcHandle);
m_pScriptSystem->BeginCall(funcHandle);
m_pScriptSystem->PushFuncParam(pNewConversation);
m_pScriptSystem->EndCall();
}
}
else
{
int dummy;
stm.Read(dummy); //conv_id
stm.Read(dummy); //progress
int nrActors;
stm.Read(nrActors);
while (nrActors--)
stm.Read(dummy);
}
}
}
void CPlayer::LoadAIState_RELEASE(CStream & stm)
{
if (!m_bIsAI)
return;
IAIObject *pObject = m_pEntity->GetAI();
//AIObject Load is empty in release version
// pObject->Load(stm);
int nGunOut=0;
stm.Read(nGunOut);
if (nGunOut)
{
SetWeaponPositionState(WEAPON_POS_HOLD);
m_pEntity->GetScriptObject()->SetValue("AI_GunOut",1);
m_pScriptSystem->BeginCall("BasicAI","MakeAlerted");
m_pScriptSystem->PushFuncParam(m_pEntity->GetScriptObject());
m_pScriptSystem->EndCall();
}
/*
if (!m_bIsAI)
return;
IAIObject *pObject = m_pEntity->GetAI();
//pObject->Load(stm);
IPipeUser *pUser =0;
if (pObject->CanBeConvertedTo(AIOBJECT_PIPEUSER,(void**)&pUser))
{
int nId;
stm.Read(nId);
if (nId)
{
if (nId<0)
{
// player is the target
IEntity *pMyPlayer = m_pGame->GetMyPlayer();
if (pMyPlayer)
{
SAIEVENT event;
event.bFuzzySight = false;
event.fThreat = 1000000.f;
event.pSeen = pMyPlayer->GetAI();
pObject->Event(AIEVENT_ONVISUALSTIMULUS,&event);
}
}
else
{
// some puppet or vehicle is the target
IEntity *pMyTarget = m_pGame->GetSystem()->GetIEntitySystem()->GetEntity(nId);
if (pMyTarget)
{
SAIEVENT event;
event.bFuzzySight = false;
event.fThreat = 1000000.f;
event.pSeen = pMyTarget->GetAI();
pObject->Event(AIEVENT_ONVISUALSTIMULUS,&event);
}
}
SetWeaponPositionState(WEAPON_POS_HOLD);
m_pEntity->GetScriptObject()->SetValue("AI_GunOut",1);
}
}
*/
}
void CPlayer::LoadAIState_PATCH_1(CStream & stm)
{
if (!m_bIsAI)
return;
IAIObject *pObject = m_pEntity->GetAI();
pObject->Load_PATCH_1(stm);
int nGunOut=0;
stm.Read(nGunOut);
if (nGunOut)
{
SetWeaponPositionState(WEAPON_POS_HOLD);
m_pEntity->GetScriptObject()->SetValue("AI_GunOut",1);
m_pScriptSystem->BeginCall("BasicAI","MakeAlerted");
m_pScriptSystem->PushFuncParam(m_pEntity->GetScriptObject());
m_pScriptSystem->EndCall();
}
}
void CPlayer::OnEntityNetworkUpdate( const EntityId &idViewerEntity, const Vec3d &v3dViewer, uint32 &inoutPriority,
EntityCloneState &inoutCloneState) const
{
inoutPriority+=100000;
if(m_stats.moving)
inoutPriority+=10000;
if(m_stats.firing)
inoutPriority+=20000;
// if(m_stats.reloading)
// inoutPriority-=10000;
inoutCloneState.m_bSyncYAngle=false;
}
//
//
//-------------------------------------------------------------------------------------
bool CPlayer::LoadGame_PATCH_1(CStream &stm)
{
RemoveAllWeapons();
// [Petar] preserve the original health in case we need to use it
// to restore the health of special AI on a checkpoint
int nStartHealth = m_stats.health;
if (!m_bIsAI)
DeselectWeapon();
for(int cl = 0; (stm.Read(cl),cl); )
{
WeaponInfo &wi = m_mapPlayerWeapons[cl];
wi.owns = true;
stm.Read(wi.iFireMode);
}
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stm.Read(m_vWeaponSlots[i]);
}
Load_PATCH_1(stm);
SelectWeapon(m_stats.weapon);
if (m_nSelectedWeaponID != -1)
{
WeaponInfo &wi = GetWeaponInfo();
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
_SmartScriptObject pObj(m_pScriptSystem);
pObj->SetValue( "firemode", m_stats.firemode);
pObj->SetValue( "ignoreammo", true);
bool bCanSwitch;
m_pEntity->SendScriptEvent(ScriptEvent_FireModeChange, *pObj, &bCanSwitch);
wi.iFireMode = m_stats.firemode;
}
if (m_bIsAI)
{
IPuppet *pPuppet=0;
if (m_pEntity->GetAI()->CanBeConvertedTo(AIOBJECT_PUPPET,(void**)&pPuppet))
{
if (pPuppet->GetPuppetParameters().m_bSpecial)
m_stats.health = nStartHealth;
}
}
return true;
};
bool CPlayer::Load_PATCH_1( CStream &stream)
{
// bool bPrevLightStatus;
// stream.Read(bPrevLightStatus);
// if (bPrevLightStatus!=m_bLightOn)
// SwitchFlashLight(bPrevLightStatus);
return Read_PATCH_1(stream);
}
///////////////////////////////////////////////
/*! Reads all data which needs to be synchronized from the network-stream
@param stream stream to read from
@return true if the function succeeds, false otherwise
*/
bool CPlayer::Read_PATCH_1( CStream &stream )
{
unsigned short dirty = 0;
PlayerStats &stats=m_stats;
// GetPlayerStats( stats );
BYTE health,armor,weapon,firemode,staminaBuff;
//int weaponid = stats.weaponid;
bool bHostEntity;
VERIFY_COOKIE(stream);
stream.Read(bHostEntity);
if(bHostEntity)
{
stream.ReadPkd( staminaBuff );
m_stats.stamina = staminaBuff;
// stream.ReadPkd( staminaBuff );
// m_stats.breath = staminaBuff;
stream.ReadPkd( health );
stats.health=health;
stream.ReadPkd( armor );
stats.armor=armor;
unsigned int ammo_in_clip;
stream.ReadNumberInBits(ammo_in_clip,10);
stats.ammo_in_clip=ammo_in_clip;
unsigned int ammo;
stream.ReadNumberInBits(ammo,10);
stats.ammo=ammo;
BYTE b;
stream.ReadPkd(b);
stats.numofgrenades=b;
stream.ReadNumberInBits(stats.grenadetype, 4);
stream.Read(stats.holding_breath);
bool isnotzero;
for(int i=0;i<sizeof(m_vWeaponSlots)/sizeof(int);i++)
{
stream.Read(isnotzero);
if(isnotzero)
{
stream.ReadPkd(b);
m_vWeaponSlots[i]=b;
}else
{
m_vWeaponSlots[i]=0;
}
}
}
else
{
bool val;
stream.Read(val);
stats.ammo_in_clip = val;
stream.Read(val);
stats.ammo = val;
stream.Read(val);
stats.firing = val;
bool t;
stream.Read(t);
if(t)
{
bool sign;
BYTE lean;
stream.Read(sign);
stream.ReadPkd(lean);
m_walkParams.fCurrLean=sign?(lean*(1.0f/255)):-(lean*(1.0f/255));
}
else
{
m_walkParams.fCurrLean=0;
}
}
VERIFY_COOKIE(stream);
stream.Read(stats.firing_grenade);
stream.ReadPkd(weapon);
if (weapon!=stats.weapon)
{
SelectWeapon(weapon, false);
stats.weapon = weapon;
stats.firing = false;
}
stream.ReadPkd(firemode);
if(firemode!=stats.firemode)
{
stats.firemode=firemode;
SwitchFiremode(stats.firemode);
}
//stream.Read(stats.firing);
// stream.Read(stats.onLadder);
eStance stance;
stream.ReadNumberInBits(*((unsigned int *)&stance),3);
// no stances in vehicle
if(stance!=m_CurStance && !m_pVehicle)
{
switch(stance)
{
case eRelaxed:
GoRelaxed();
break;
case eStand:
GoStand();
break;
// case eAimLook:
// GoAim();
// break;
case eStealth:
GoStealth();
break;
case eCrouch:
GoCrouch();
break;
case eProne:
GoProne();
break;
case eSwim:
GoSwim();
break;
default:
//DEBUG_BREAK;
::OutputDebugString("INVALID STANCE\n");
m_CurStance=(eStance)stance;
break;
}
}
stream.Read(stats.jumping);
if(stream.GetStreamVersion()>=PATCH1_SAVEVERSION) // to be backward compatible with old samegames
{
bool bSyncToAllClients;
stream.Read(bSyncToAllClients);
if(bSyncToAllClients)
{
uint8 ucStartRandomSeedCS;
stream.Read(ucStartRandomSeedCS);
// if(!bHostEntity)
m_SynchedRandomSeed.SetStartRandomSeedC(ucStartRandomSeedCS);
// GetISystem()->GetILog()->Log(">> Player Read %d %d",(int)(this->GetEntity()->GetId()),(int)ucStartRandomSeedCS); // debug
}
}
//TRIGGER REALOAD ON CLIENT ONLY (think if can be done better)
bool bReloading;
stream.Read(bReloading);
if(bReloading && (stats.reloading==false) && m_nSelectedWeaponID != -1)
{
CWeaponClass *pSelectedWeapon = GetSelectedWeapon();
pSelectedWeapon->ScriptOnStopFiring(m_pEntity);
pSelectedWeapon->ScriptReload(m_pEntity);
}
stats.reloading=bReloading;
BYTE acc;
stream.ReadPkd(acc);
stats.accuracy=acc*(1.f/255.f);
VERIFY_COOKIE(stream);
if(stats.firing_grenade)
{
//invoke script event (client)
m_bGrenadeAnimation = true;
m_pEntity->SendScriptEvent(ScriptEvent_FireGrenade,0,NULL);
}
bool bRedirected;
EntityId nID;
stream.Read(bRedirected);
if (bRedirected)
stream.Read(nID);
if ((m_pRedirected!=0)!=bRedirected || m_pRedirected && m_pRedirected->GetId()!=nID)
{
if (m_pRedirected)
{
m_pRedirected->OnUnBind(m_pEntity,0);
m_pRedirected = 0;
}
if (bRedirected && (m_pRedirected=m_pGame->GetSystem()->GetIEntitySystem()->GetEntity(nID)))
m_pRedirected->OnBind(m_pEntity,0);
}
if (m_pRedirected && !bHostEntity)
m_pRedirected->SetAngles(m_pEntity->GetAngles());
stream.Read(m_bFirstPersonLoaded);
return true;
}
Reference in New Issue View Git Blame Copy Permalink