//-----------------------------------------------------------------------------
// Purpose: Recover stamina
//-----------------------------------------------------------------------------
void CSDKGameMovement::ReduceTimers( void )
{
Vector vecPlayerVelocity = m_pSDKPlayer->GetAbsVelocity();
#if defined ( SDK_USE_STAMINA ) || defined ( SDK_USE_SPRINTING )
float flStamina = m_pSDKPlayer->m_Shared.GetStamina();
#endif
#if defined ( SDK_USE_SPRINTING )
float fl2DVelocitySquared = vecPlayerVelocity.x * vecPlayerVelocity.x +
vecPlayerVelocity.y * vecPlayerVelocity.y;
if ( !( mv->m_nButtons & IN_SPEED ) )
{
m_pSDKPlayer->m_Shared.ResetSprintPenalty();
}
// Can only sprint in forward direction.
bool bSprinting = ( (mv->m_nButtons & IN_SPEED) && ( mv->m_nButtons & IN_FORWARD ) );
// If we're holding the sprint key and also actually moving, remove some stamina
Vector vel = m_pSDKPlayer->GetAbsVelocity();
if ( bSprinting && fl2DVelocitySquared > 10000 ) //speed > 100
{
flStamina -= 20 * gpGlobals->frametime;
m_pSDKPlayer->m_Shared.SetStamina( flStamina );
}
else
#endif // SDK_USE_SPRINTING
#if defined ( SDK_USE_STAMINA ) || defined ( SDK_USE_SPRINTING )
{
//gain some back
if ( fl2DVelocitySquared <= 0 )
{
flStamina += 60 * gpGlobals->frametime;
}
else if ( ( m_pSDKPlayer->GetFlags() & FL_ONGROUND ) &&
( mv->m_nButtons & IN_DUCK ) &&
( m_pSDKPlayer->GetFlags() & FL_DUCKING ) )
{
flStamina += 50 * gpGlobals->frametime;
}
else
{
flStamina += 10 * gpGlobals->frametime;
}
m_pSDKPlayer->m_Shared.SetStamina( flStamina );
}
#endif
BaseClass::ReduceTimers();
}
Activity CSDKPlayerAnimState::CalcMainActivity()
{
float flOuterSpeed = GetOuterXYSpeed();
CSDKPlayer *pPlayer = dynamic_cast<CSDKPlayer*>(GetBasePlayer());
Activity idealActivity = ACT_IDLE;
if (pPlayer->m_Shared.m_bIsShotCharging && mp_charging_animation_enabled.GetBool())
return ACT_IOS_RUNCELEB;
if ( HandleJumping(idealActivity) )
{
if (pPlayer->GetFlags() & FL_CELEB)
return ACT_IOS_JUMPCELEB; //cartwheel celeb
//else if (pPlayer->m_nBody > 0)
else if (pPlayer->m_Shared.GetAnimEvent() == PLAYERANIMEVENT_KEEPER_JUMP)
return ACT_IDLE;//FIXME: Buggy jump animation: ACT_LEAP; //keepers jump
else
return ACT_IDLE;//FIXME: Buggy jump animation: ACT_HOP; //normal jump
}
else
{
if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
{
if ( flOuterSpeed > (mp_runspeed.GetInt() + mp_sprintspeed.GetInt()) / 2.0f )
{
idealActivity = ACT_SPRINT;
}
else if ( flOuterSpeed > (mp_walkspeed.GetInt() + mp_runspeed.GetInt()) / 2.0f )
{
if (pPlayer->GetFlags() & FL_CELEB) //now on layer
idealActivity = ACT_IOS_RUNCELEB;
else
idealActivity = ACT_RUN;
}
else
{
idealActivity = ACT_WALK;
}
}
else
{
idealActivity = ACT_IDLE;
}
return idealActivity;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseSDKGrenade::SecondaryAttack()
{
if ( m_bRedraw )
return;
CSDKPlayer *pPlayer = GetPlayerOwner();
if ( pPlayer == NULL )
return;
//See if we're ducking
if ( pPlayer->GetFlags() & FL_DUCKING )
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
}
else
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_HAULBACK );
}
// Don't let weapon idle interfere in the middle of a throw!
SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
}
void CWeaponMP5::PrimaryAttack( void )
{
const CSDKWeaponInfo &pWeaponInfo = GetSDKWpnData();
CSDKPlayer *pPlayer = GetPlayerOwner();
float flCycleTime = pWeaponInfo.m_flCycleTime;
bool bPrimaryMode = true;
float flSpread = 0.01f;
// more spread when jumping
if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
flSpread = 0.05f;
pPlayer->m_iShotsFired++;
// Out of ammo?
if ( m_iClip1 <= 0 )
{
if (m_bFireOnEmpty)
{
PlayEmptySound();
m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
}
}
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
m_iClip1--;
// player "shoot" animation
pPlayer->SetAnimation( PLAYER_ATTACK1 );
FX_FireBullets(
pPlayer->entindex(),
pPlayer->Weapon_ShootPosition(),
pPlayer->EyeAngles() + pPlayer->GetPunchAngle(),
GetWeaponID(),
bPrimaryMode?Primary_Mode:Secondary_Mode,
CBaseEntity::GetPredictionRandomSeed() & 255,
flSpread );
pPlayer->DoMuzzleFlash();
m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
{
// HEV suit - indicate out of ammo condition
pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
}
// start idle animation in 5 seconds
SetWeaponIdleTime( gpGlobals->curtime + 5.0 );
}
//-----------------------------------------------------------------------------
// Purpose: Run through all the Bots in the game and let them think.
//-----------------------------------------------------------------------------
void Bot_RunAll(void)
{
/*if (g_iWaitingAmount && g_bServerReady) //Kind of a shitty hack. But this will allow people to spawn a certain amount of bots in
{ //the server.cfg. Anyway, the server is ready, so do it.
BotPutInServer(g_iWaitingAmount, false);
g_iWaitingAmount = 0; //Make sure we've reset the waiting count.
}*/
//bot manager handles bot population via the svars
CBotManager::Think();
//let the vcomm managers do their thing
g_BotAmerComms.Think();
g_BotBritComms.Think();
if (bot_pause.GetBool()) //If we're true, just don't run the thinking cycle. Effectively "pausing" the bots.
return;
BotDebugThink();
//we're testing something, don't let the AI interfere!
extern ConVar bot_mimic;
if (bot_mimic.GetBool())
return;
#ifdef PROFILE_BOT_PERFORMANCE
auto preThinkTime = std::chrono::system_clock::now();
#endif
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pPlayer = UTIL_PlayerByIndex(i);// );
if (pPlayer && (pPlayer->GetFlags() & FL_FAKECLIENT))
{
CSDKBot *pBot = CSDKBot::ToBot(pPlayer);
if (pBot) {//Do most of the "filtering" here.
pBot->Think();
}
}
}
#ifdef PROFILE_BOT_PERFORMANCE
auto postThinkTime = std::chrono::system_clock::now();
int deltaTime = std::chrono::duration_cast<std::chrono::milliseconds>(postThinkTime - preThinkTime).count();
static int counter = 0;
counter++;
if (counter == 500) {
counter = 0;
Msg("%i\n", deltaTime);
}
#endif
}
void CC_CreatePlayerBall(const CCommand &args)
{
if (!SDKGameRules()->IsIntermissionState() || SDKGameRules()->IsCeremony())
return;
CSDKPlayer *pPl = ToSDKPlayer(UTIL_GetCommandClient());
if (!CSDKPlayer::IsOnField(pPl))
return;
if (pPl->GetFlags() & FL_REMOTECONTROLLED)
return;
trace_t tr;
CTraceFilterSkipTwoEntities traceFilter(pPl, pPl->GetPlayerBall(), COLLISION_GROUP_NONE);
UTIL_TraceHull(
pPl->GetLocalOrigin() + VEC_VIEW,
pPl->GetLocalOrigin() + VEC_VIEW + pPl->EyeDirection3D() * 150,
-Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, BALL_PHYS_RADIUS),
Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, BALL_PHYS_RADIUS),
MASK_SOLID,
&traceFilter,
&tr);
Vector pos = tr.endpos;
if (pPl->GetPlayerBall())
{
if (pPl->GetPlayerBall()->GetHoldingPlayer())
{
//pPl->GetPlayerBall()->RemoveFromPlayerHands(pPl->GetPlayerBall()->GetHoldingPlayer());
pPl->GetPlayerBall()->State_Transition(BALL_STATE_NORMAL);
}
if (sv_ball_update_physics.GetBool())
pPl->GetPlayerBall()->CreateVPhysics();
pPl->GetPlayerBall()->SetPos(pos, false);
pPl->GetPlayerBall()->RemoveAllTouches();
}
else
pPl->SetPlayerBall(CreatePlayerBall(pos, pPl));
//pPl->GetPlayerBall()->m_nSkin = pPl->GetPlayerBallSkin() == -1 ? g_IOSRand.RandomInt(0, BALL_SKIN_COUNT - 1) : pPl->GetPlayerBallSkin();
pPl->GetPlayerBall()->SetSkinName(pPl->GetPlayerBallSkinName());
pPl->GetPlayerBall()->SetBallCannonMode(false);
pPl->GetPlayerBall()->SaveBallCannonSettings();
pPl->m_Shared.SetStamina(100);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CSDKGameMovement::CheckJumpButton( void )
{
if (!m_pSDKPlayer->IsAlive())
{
mv->m_nOldButtons |= IN_JUMP ; // don't jump again until released
return false;
}
#if defined ( SDK_USE_PRONE )
if( m_pSDKPlayer->m_Shared.IsProne() ||
m_pSDKPlayer->m_Shared.IsGettingUpFromProne() ||
m_pSDKPlayer->m_Shared.IsGoingProne() )
{
mv->m_nOldButtons |= IN_JUMP;
return false;
}
#endif
// See if we are waterjumping. If so, decrement count and return.
float flWaterJumpTime = player->GetWaterJumpTime();
if ( flWaterJumpTime > 0 )
{
flWaterJumpTime -= gpGlobals->frametime;
if (flWaterJumpTime < 0)
flWaterJumpTime = 0;
player->SetWaterJumpTime( flWaterJumpTime );
return false;
}
// If we are in the water most of the way...
if ( m_pSDKPlayer->GetWaterLevel() >= 2 )
{
// swimming, not jumping
SetGroundEntity( NULL );
if(m_pSDKPlayer->GetWaterType() == CONTENTS_WATER) // We move up a certain amount
mv->m_vecVelocity[2] = 100;
else if (m_pSDKPlayer->GetWaterType() == CONTENTS_SLIME)
mv->m_vecVelocity[2] = 80;
// play swiming sound
if ( player->GetSwimSoundTime() <= 0 )
{
// Don't play sound again for 1 second
player->SetSwimSoundTime( 1000 );
PlaySwimSound();
}
return false;
}
// No more effect
if (m_pSDKPlayer->GetGroundEntity() == NULL)
{
mv->m_nOldButtons |= IN_JUMP;
return false; // in air, so no effect
}
if ( mv->m_nOldButtons & IN_JUMP )
return false; // don't pogo stick
// In the air now.
SetGroundEntity( NULL );
m_pSDKPlayer->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->GetSurfaceData(), 1.0, true );
m_pSDKPlayer->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
//Tony; liek the landing sound, leaving this here if as an example for playing a jump sound.
// // make the jump sound
// CPASFilter filter( m_pSDKPlayer->GetAbsOrigin() );
// filter.UsePredictionRules();
// m_pSDKPlayer->EmitSound( filter, m_pSDKPlayer->entindex(), "Player.Jump" );
float flGroundFactor = 1.0f;
if ( player->GetSurfaceData() )
{
flGroundFactor = player->GetSurfaceData()->game.jumpFactor;
}
Assert( sv_gravity.GetFloat() == 800.0f );
float flJumpHeight = 268.3281572999747f;
//Warning("HERE team: %d", player->GetTeamNumber());
// Accelerate upward
// If we are ducking...
float startz = mv->m_vecVelocity[2];
if ( ( m_pSDKPlayer->m_Local.m_bDucking ) || ( m_pSDKPlayer->GetFlags() & FL_DUCKING ) )
{
// d = 0.5 * g * t^2 - distance traveled with linear accel
// t = sqrt(2.0 * 45 / g) - how long to fall 45 units
// v = g * t - velocity at the end (just invert it to jump up that high)
// v = g * sqrt(2.0 * 45 / g )
// v^2 = g * g * 2.0 * 45 / g
// v = sqrt( g * 2.0 * 45 )
if(player->GetTeamNumber() == 2){
mv->m_vecVelocity[2] = flGroundFactor * flJumpHeight ;
//mv->m_vecVelocity[1] *= 1.8;
//mv->m_vecVelocity[0] *= 1.8;
Vector vecForward;
AngleVectors( mv->m_vecViewAngles, &vecForward );
vecForward.z = 0;
VectorNormalize( vecForward );
VectorAdd( (vecForward*(fabs( mv->m_flForwardMove * 0.5f ))*2), mv->m_vecVelocity, mv->m_vecVelocity );
}
else mv->m_vecVelocity[2] = flGroundFactor * flJumpHeight; // flJumpSpeed of 45
}
else
{
if(player->GetTeamNumber() == 2)
mv->m_vecVelocity[2] += flGroundFactor * flJumpHeight * 2; // 2 * gravity * height
else
mv->m_vecVelocity[2] += flGroundFactor * flJumpHeight; // 2 * gravity * height
//mv->m_vecVelocity[2] += flGroundFactor * flJumpHeight; // flJumpSpeed of 45
}
FinishGravity();
mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
mv->m_outStepHeight += 0.1f;
// Flag that we jumped.
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
m_pSDKPlayer->m_Shared.SetJumping( true );
return true;
}
void CWeaponShotgun::PrimaryAttack()
{
CSDKPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
// don't fire underwater
if (pPlayer->GetWaterLevel() == 3)
{
PlayEmptySound( );
m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
return;
}
// Out of ammo?
if ( m_iClip1 <= 0 )
{
Reload();
if ( m_iClip1 == 0 )
{
PlayEmptySound();
m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
}
return;
}
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
m_iClip1--;
pPlayer->DoMuzzleFlash();
// player "shoot" animation
pPlayer->SetAnimation( PLAYER_ATTACK1 );
// Dispatch the FX right away with full accuracy.
FX_FireBullets(
pPlayer->entindex(),
pPlayer->Weapon_ShootPosition(),
pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
GetWeaponID(),
Primary_Mode,
CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
0.0675 );
if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
{
// HEV suit - indicate out of ammo condition
pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
}
if (m_iClip1 != 0)
m_flPumpTime = gpGlobals->curtime + 0.5;
m_flNextPrimaryAttack = gpGlobals->curtime + 0.875;
m_flNextSecondaryAttack = gpGlobals->curtime + 0.875;
if (m_iClip1 != 0)
SetWeaponIdleTime( gpGlobals->curtime + 2.5 );
else
SetWeaponIdleTime( gpGlobals->curtime + 0.875 );
m_fInSpecialReload = 0;
// Update punch angles.
QAngle angle = pPlayer->GetPunchAngle();
if ( pPlayer->GetFlags() & FL_ONGROUND )
{
angle.x -= SharedRandomInt( "ShotgunPunchAngleGround", 4, 6 );
}
else
{
angle.x -= SharedRandomInt( "ShotgunPunchAngleAir", 8, 11 );
}
pPlayer->SetPunchAngle( angle );
}