//-----------------------------------------------------------------------------
// 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();
}
void CDAViewModel::AddViewModelBob( CBasePlayer *owner, Vector& eyePosition, QAngle& eyeAngles )
{
CSDKPlayer* pOwner = ToSDKPlayer(owner);
if (!pOwner)
return;
CWeaponSDKBase* pWeapon = GetDAWeapon();
if (pWeapon && pWeapon->IsThrowingGrenade())
{
float flThrowStart = GetDAWeapon()->GetGrenadeThrowStart();
float flHolsterTime = GetDAWeapon()->GetGrenadeThrowWeaponHolsterTime();
float flDeployTime = GetDAWeapon()->GetGrenadeThrowWeaponDeployTime();
float flThrowEnd = GetDAWeapon()->GetGrenadeThrowEnd();
float flGain = 0.7f;
if (pOwner->GetCurrentTime() < flHolsterTime)
{
eyePosition -= Vector(0, 0, 1) * RemapGainedValClamped( pOwner->GetCurrentTime(), flGain, flThrowStart, flHolsterTime, 0, da_weapon_grenadethrow_drop.GetFloat());
eyeAngles.x += RemapGainedValClamped( pOwner->GetCurrentTime(), flGain, flThrowStart, flHolsterTime, 0, da_weapon_grenadethrow_tilt.GetFloat());
}
else if (pOwner->GetCurrentTime() > flDeployTime)
{
eyePosition -= Vector(0, 0, 1) * RemapGainedValClamped( pOwner->GetCurrentTime(), flGain, flDeployTime, flThrowEnd, da_weapon_grenadethrow_drop.GetFloat(), 0);
eyeAngles.x += RemapGainedValClamped( pOwner->GetCurrentTime(), flGain, flDeployTime, flThrowEnd, da_weapon_grenadethrow_tilt.GetFloat(), 0);
}
}
// Offset it a tad so that it moves while looking around.
eyePosition.x += da_weaponoffset.GetFloat();
// For mysterious reasons that I don't care to investigate, the eye angles
// are sometimes slammed to (0, 0, 0) for a frame or two. If this should
// happen, use the previous eye angles instead.
QAngle angEye = EyeAngles();
if (angEye.x == 0 && angEye.y == 0 && angEye.z == 0)
angEye = m_angLastPlayerEyeAngles;
else
m_angLastPlayerEyeAngles = angEye;
Vector vecViewForward, vecViewRight, vecViewUp;
AngleVectors(angEye, &vecViewForward, &vecViewRight, &vecViewUp);
Vector vecViewDirection(vecViewForward.x, vecViewForward.y, 0);
vecViewDirection.NormalizeInPlace();
float flMaxVelocity = 100;
Vector vecOwnerVelocity = pOwner->GetAbsVelocity();
if (vecOwnerVelocity.LengthSqr() > flMaxVelocity*flMaxVelocity)
vecOwnerVelocity = (vecOwnerVelocity / vecOwnerVelocity.Length()) * flMaxVelocity;
m_vecPlayerVelocityLerp.x = Approach(vecOwnerVelocity.x, m_vecPlayerVelocityLerp.x, 1000*gpGlobals->frametime);
m_vecPlayerVelocityLerp.y = Approach(vecOwnerVelocity.y, m_vecPlayerVelocityLerp.y, 1000*gpGlobals->frametime);
m_vecPlayerVelocityLerp.z = Approach(vecOwnerVelocity.z, m_vecPlayerVelocityLerp.z, 1000*gpGlobals->frametime);
Vector vecPlayerVelocityLerp = m_vecPlayerVelocityLerp;
vecPlayerVelocityLerp.NormalizeInPlace();
float flViewVelocityDot = fabs(vecPlayerVelocityLerp.Dot(vecViewRight));
eyePosition += m_vecPlayerVelocityLerp * da_weaponlag.GetFloat() * flViewVelocityDot;
if (pOwner->m_Shared.GetViewBobRamp() && pOwner->m_Shared.GetRunSpeed())
{
float flViewBobMagnitude = pOwner->m_Shared.GetViewBobRamp() * da_weaponbob.GetFloat();
float flRunPeriod = M_PI * 3;
float flRunUpBob = sin(pOwner->GetCurrentTime() * flRunPeriod * 2) * (flViewBobMagnitude / 2);
float flRunRightBob = sin(pOwner->GetCurrentTime() * flRunPeriod) * flViewBobMagnitude;
float flWalkPeriod = M_PI * 1.5f;
float flWalkUpBob = sin(pOwner->GetCurrentTime() * flWalkPeriod * 2) * (flViewBobMagnitude / 2);
float flWalkRightBob = sin(pOwner->GetCurrentTime() * flWalkPeriod) * flViewBobMagnitude;
// 0 is walk, 1 is run.
float flRunRamp = RemapValClamped(pOwner->m_Shared.GetViewBobRamp(), pOwner->m_Shared.GetAimInSpeed()/pOwner->m_Shared.GetRunSpeed(), 1.0f, 0.0f, 1.0f);
float flRightBob = RemapValClamped(flRunRamp, 0, 1, flWalkRightBob, flRunRightBob);
float flUpBob = RemapValClamped(flRunRamp, 0, 1, flWalkUpBob, flRunUpBob);
eyePosition += vecViewRight * flRightBob + vecViewUp * (flUpBob - pOwner->m_Shared.GetViewBobRamp() * da_weapondrop.GetFloat());
}
if (pOwner->m_Shared.GetViewTilt())
{
Vector vecDiveRight = Vector(0, 0, 1).Cross(pOwner->m_Shared.GetDiveDirection());
float flRightDot = vecViewDirection.Dot(vecDiveRight);
float flUpDot = vecViewDirection.Dot(pOwner->m_Shared.GetDiveDirection());
eyeAngles.z += flRightDot * pOwner->m_Shared.GetViewTilt() * da_weapontilt.GetFloat();;
eyePosition += (vecViewUp * (flUpDot * 0.5f) + vecViewDirection * (flUpDot * 0.5f)) * pOwner->m_Shared.GetViewTilt();
float flDiveBobMagnitude = 0.5f * pOwner->m_Shared.GetViewTilt();
float flDiveBobPeriod = M_PI * 0.5f;
float flDiveUpBob = sin(pOwner->GetCurrentTime() * flDiveBobPeriod * 2) * (flDiveBobMagnitude / 2);
float flDiveRightBob = cos(pOwner->GetCurrentTime() * flDiveBobPeriod * 2) * (flDiveBobMagnitude / 2);
eyePosition += vecViewRight * flDiveRightBob + vecViewUp * flDiveUpBob;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSDKGameMovement::CheckParameters( void )
{
QAngle v_angle;
SetPlayerSpeed();
if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
player->GetMoveType() != MOVETYPE_NOCLIP &&
player->GetMoveType() != MOVETYPE_OBSERVER )
{
float spd;
float maxspeed;
spd = ( mv->m_flForwardMove * mv->m_flForwardMove ) +
( mv->m_flSideMove * mv->m_flSideMove ) +
( mv->m_flUpMove * mv->m_flUpMove );
maxspeed = mv->m_flClientMaxSpeed;
if ( maxspeed != 0.0 )
{
mv->m_flMaxSpeed = min( maxspeed, mv->m_flMaxSpeed );
}
// Slow down by the speed factor
float flSpeedFactor = 1.0f;
if ( player->GetSurfaceData() )
{
flSpeedFactor = player->GetSurfaceData()->game.maxSpeedFactor;
}
// If we have a constraint, slow down because of that too.
float flConstraintSpeedFactor = ComputeConstraintSpeedFactor();
if (flConstraintSpeedFactor < flSpeedFactor)
flSpeedFactor = flConstraintSpeedFactor;
mv->m_flMaxSpeed *= flSpeedFactor;
if ( g_bMovementOptimizations )
{
// Same thing but only do the sqrt if we have to.
if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed*mv->m_flMaxSpeed ) )
{
float fRatio = mv->m_flMaxSpeed / sqrt( spd );
mv->m_flForwardMove *= fRatio;
mv->m_flSideMove *= fRatio;
mv->m_flUpMove *= fRatio;
}
}
else
{
spd = sqrt( spd );
if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed ) )
{
float fRatio = mv->m_flMaxSpeed / spd;
mv->m_flForwardMove *= fRatio;
mv->m_flSideMove *= fRatio;
mv->m_flUpMove *= fRatio;
}
}
}
if ( player->GetFlags() & FL_FROZEN ||
player->GetFlags() & FL_ONTRAIN ||
IsDead() )
{
mv->m_flForwardMove = 0;
mv->m_flSideMove = 0;
mv->m_flUpMove = 0;
}
DecayPunchAngle();
// Take angles from command.
if ( !IsDead() )
{
v_angle = mv->m_vecAngles;
v_angle = v_angle + player->m_Local.m_vecPunchAngle;
// Now adjust roll angle
if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
player->GetMoveType() != MOVETYPE_NOCLIP )
{
mv->m_vecAngles[ROLL] = CalcRoll( v_angle, mv->m_vecVelocity, sv_rollangle.GetFloat(), sv_rollspeed.GetFloat() );
}
else
{
mv->m_vecAngles[ROLL] = 0.0; // v_angle[ ROLL ];
}
mv->m_vecAngles[PITCH] = v_angle[PITCH];
mv->m_vecAngles[YAW] = v_angle[YAW];
}
else
{
mv->m_vecAngles = mv->m_vecOldAngles;
}
// Set dead player view_offset
if ( IsDead() )
{
player->SetViewOffset( VEC_DEAD_VIEWHEIGHT );
}
// Adjust client view angles to match values used on server.
if ( mv->m_vecAngles[YAW] > 180.0f )
{
mv->m_vecAngles[YAW] -= 360.0f;
}
if ( cl_show_speed.GetBool() )
{
Vector vel = m_pSDKPlayer->GetAbsVelocity();
float actual_speed = sqrt( vel.x * vel.x + vel.y * vel.y );
Msg( "player speed %.1f ( max: %f ) \n",actual_speed, mv->m_flClientMaxSpeed );
}
}
void CSDKGameMovement::WalkMove( void )
{
#if defined ( SDK_USE_SPRINTING )
float flSpeedCheck = m_pSDKPlayer->GetAbsVelocity().Length2D();
bool bSprintButtonPressed = ( mv->m_nButtons & IN_SPEED ) > 0;
if( bSprintButtonPressed &&
( mv->m_nButtons & IN_FORWARD ) &&
#if defined ( SDK_USE_PRONE )
!m_pSDKPlayer->m_Shared.IsProne() &&
#endif
!m_pSDKPlayer->m_Shared.IsDucking() &&
flSpeedCheck > 80 )
{
m_pSDKPlayer->SetSprinting( true );
}
else
{
m_pSDKPlayer->SetSprinting( false );
}
#endif // SDK_USE_SPRINTING
// Get the movement angles.
Vector vecForward, vecRight, vecUp;
AngleVectors( mv->m_vecViewAngles, &vecForward, &vecRight, &vecUp );
vecForward.z = 0.0f;
vecRight.z = 0.0f;
VectorNormalize( vecForward );
VectorNormalize( vecRight );
// Copy movement amounts
float flForwardMove = mv->m_flForwardMove;
float flSideMove = mv->m_flSideMove;
// Find the direction,velocity in the x,y plane.
Vector vecWishDirection( ( ( vecForward.x * flForwardMove ) + ( vecRight.x * flSideMove ) ),
( ( vecForward.y * flForwardMove ) + ( vecRight.y * flSideMove ) ),
0.0f );
// Calculate the speed and direction of movement, then clamp the speed.
float flWishSpeed = VectorNormalize( vecWishDirection );
flWishSpeed = clamp( flWishSpeed, 0.0f, mv->m_flMaxSpeed );
// Accelerate in the x,y plane.
mv->m_vecVelocity.z = 0;
Accelerate( vecWishDirection, flWishSpeed, sv_accelerate.GetFloat() );
Assert( mv->m_vecVelocity.z == 0.0f );
// Clamp the players speed in x,y.
float flNewSpeed = VectorLength( mv->m_vecVelocity );
if ( flNewSpeed > mv->m_flMaxSpeed )
{
float flScale = ( mv->m_flMaxSpeed / flNewSpeed );
mv->m_vecVelocity.x *= flScale;
mv->m_vecVelocity.y *= flScale;
}
// Now reduce their backwards speed to some percent of max, if they are travelling backwards unless they are under some minimum
if ( sdk_clamp_back_speed.GetFloat() < 1.0 && VectorLength( mv->m_vecVelocity ) > sdk_clamp_back_speed_min.GetFloat() )
{
float flDot = DotProduct( vecForward, mv->m_vecVelocity );
// are we moving backwards at all?
if ( flDot < 0 )
{
Vector vecBackMove = vecForward * flDot;
Vector vecRightMove = vecRight * DotProduct( vecRight, mv->m_vecVelocity );
// clamp the back move vector if it is faster than max
float flBackSpeed = VectorLength( vecBackMove );
float flMaxBackSpeed = ( mv->m_flMaxSpeed * sdk_clamp_back_speed.GetFloat() );
if ( flBackSpeed > flMaxBackSpeed )
{
vecBackMove *= flMaxBackSpeed / flBackSpeed;
}
// reassemble velocity
mv->m_vecVelocity = vecBackMove + vecRightMove;
}
}
// Add base velocity to the player's current velocity - base velocity = velocity from conveyors, etc.
VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
// Calculate the current speed and return if we are not really moving.
float flSpeed = VectorLength( mv->m_vecVelocity );
if ( flSpeed < 1.0f )
{
// I didn't remove the base velocity here since it wasn't moving us in the first place.
mv->m_vecVelocity.Init();
return;
}
// Calculate the destination.
Vector vecDestination;
vecDestination.x = mv->GetAbsOrigin().x + ( mv->m_vecVelocity.x * gpGlobals->frametime );
vecDestination.y = mv->GetAbsOrigin().y + ( mv->m_vecVelocity.y * gpGlobals->frametime );
vecDestination.z = mv->GetAbsOrigin().z;
// Try moving to the destination.
trace_t trace;
TracePlayerBBox( mv->GetAbsOrigin(), vecDestination, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
if ( trace.fraction == 1.0f )
{
// Made it to the destination (remove the base velocity).
mv->SetAbsOrigin( trace.endpos );
VectorSubtract( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
// Save the wish velocity.
mv->m_outWishVel += ( vecWishDirection * flWishSpeed );
// Try and keep the player on the ground.
// NOTE YWB 7/5/07: Don't do this here, our version of CategorizePosition encompasses this test
// StayOnGround();
return;
}
// Now try and do a step move.
StepMove( vecDestination, trace );
// Remove base velocity.
Vector baseVelocity = player->GetBaseVelocity();
VectorSubtract( mv->m_vecVelocity, baseVelocity, mv->m_vecVelocity );
// Save the wish velocity.
mv->m_outWishVel += ( vecWishDirection * flWishSpeed );
// Try and keep the player on the ground.
// NOTE YWB 7/5/07: Don't do this here, our version of CategorizePosition encompasses this test
// StayOnGround();
}
void CDABViewModel::AddViewModelBob( CBasePlayer *owner, Vector& eyePosition, QAngle& eyeAngles )
{
CSDKPlayer* pOwner = ToSDKPlayer(owner);
if (!pOwner)
return;
// Offset it a tad so that it moves while looking around.
eyePosition.x += da_weaponoffset.GetFloat();
Vector vecViewForward, vecViewRight, vecViewUp;
AngleVectors(EyeAngles(), &vecViewForward, &vecViewRight, &vecViewUp);
Vector vecViewDirection(vecViewForward.x, vecViewForward.y, 0);
vecViewDirection.NormalizeInPlace();
float flMaxVelocity = 100;
Vector vecOwnerVelocity = pOwner->GetAbsVelocity();
if (vecOwnerVelocity.LengthSqr() > flMaxVelocity*flMaxVelocity)
vecOwnerVelocity = (vecOwnerVelocity / vecOwnerVelocity.Length()) * flMaxVelocity;
m_vecPlayerVelocityLerp.x = Approach(vecOwnerVelocity.x, m_vecPlayerVelocityLerp.x, 1000*gpGlobals->frametime);
m_vecPlayerVelocityLerp.y = Approach(vecOwnerVelocity.y, m_vecPlayerVelocityLerp.y, 1000*gpGlobals->frametime);
m_vecPlayerVelocityLerp.z = Approach(vecOwnerVelocity.z, m_vecPlayerVelocityLerp.z, 1000*gpGlobals->frametime);
Vector vecPlayerVelocityLerp = m_vecPlayerVelocityLerp;
vecPlayerVelocityLerp.NormalizeInPlace();
float flViewVelocityDot = fabs(vecPlayerVelocityLerp.Dot(vecViewRight));
eyePosition += m_vecPlayerVelocityLerp * da_weaponlag.GetFloat() * flViewVelocityDot;
if (pOwner->m_Shared.GetViewBobRamp() && pOwner->m_Shared.GetRunSpeed())
{
float flViewBobMagnitude = pOwner->m_Shared.GetViewBobRamp() * da_weaponbob.GetFloat();
float flRunPeriod = M_PI * 3;
float flRunUpBob = sin(pOwner->GetCurrentTime() * flRunPeriod * 2) * (flViewBobMagnitude / 2);
float flRunRightBob = sin(pOwner->GetCurrentTime() * flRunPeriod) * flViewBobMagnitude;
float flWalkPeriod = M_PI * 1.5f;
float flWalkUpBob = sin(pOwner->GetCurrentTime() * flWalkPeriod * 2) * (flViewBobMagnitude / 2);
float flWalkRightBob = sin(pOwner->GetCurrentTime() * flWalkPeriod) * flViewBobMagnitude;
// 0 is walk, 1 is run.
float flRunRamp = RemapValClamped(pOwner->m_Shared.GetViewBobRamp(), pOwner->m_Shared.GetAimInSpeed()/pOwner->m_Shared.GetRunSpeed(), 1.0f, 0.0f, 1.0f);
float flRightBob = RemapValClamped(flRunRamp, 0, 1, flWalkRightBob, flRunRightBob);
float flUpBob = RemapValClamped(flRunRamp, 0, 1, flWalkUpBob, flRunUpBob);
eyePosition += vecViewRight * flRightBob + vecViewUp * (flUpBob - pOwner->m_Shared.GetViewBobRamp() * da_weapondrop.GetFloat());
}
if (pOwner->m_Shared.GetViewTilt())
{
Vector vecDiveRight = Vector(0, 0, 1).Cross(pOwner->m_Shared.GetDiveDirection());
float flRightDot = vecViewDirection.Dot(vecDiveRight);
float flUpDot = vecViewDirection.Dot(pOwner->m_Shared.GetDiveDirection());
eyeAngles.z -= flRightDot * pOwner->m_Shared.GetViewTilt() * 8;
eyePosition += (vecViewUp * (flUpDot * 0.5f) + vecViewDirection * (flUpDot * 0.5f)) * pOwner->m_Shared.GetViewTilt();
float flDiveBobMagnitude = 0.5f * pOwner->m_Shared.GetViewTilt();
float flDiveBobPeriod = M_PI * 0.5f;
float flDiveUpBob = sin(pOwner->GetCurrentTime() * flDiveBobPeriod * 2) * (flDiveBobMagnitude / 2);
float flDiveRightBob = cos(pOwner->GetCurrentTime() * flDiveBobPeriod * 2) * (flDiveBobMagnitude / 2);
eyePosition += vecViewRight * flDiveRightBob + vecViewUp * flDiveUpBob;
}
}