//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponFrag::ItemPostFrame( void )
{
if( m_fDrawbackFinished )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if (pOwner)
{
switch( m_AttackPaused )
{
case GRENADE_PAUSED_PRIMARY:
if( !(pOwner->m_nButtons & IN_ATTACK) )
{
SendWeaponAnim( ACT_VM_THROW );
ToSDKPlayer(pOwner)->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRIMARY );
//Tony; fire the sequence
m_fDrawbackFinished = false;
}
break;
case GRENADE_PAUSED_SECONDARY:
if( !(pOwner->m_nButtons & IN_ATTACK2) )
{
//See if we're ducking
if ( pOwner->m_nButtons & IN_DUCK )
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
}
else
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_HAULBACK );
}
//Tony; the grenade really should have a secondary anim. but it doesn't on the player.
ToSDKPlayer(pOwner)->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRIMARY );
m_fDrawbackFinished = false;
}
break;
default:
break;
}
}
}
BaseClass::ItemPostFrame();
if ( m_bRedraw )
{
if ( IsViewModelSequenceFinished() )
{
Reload();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets an animation in the player.
// Input : eAnim - Animation to set.
//-----------------------------------------------------------------------------
void CMoveHelperServer::PlayerSetAnimation( PLAYER_ANIM eAnim )
{
m_pHostPlayer->SetAnimation( eAnim );
#ifdef HL2MP
ToSDKPlayer(m_pHostPlayer)->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pVictim -
// *pKiller -
// *pInflictor -
//-----------------------------------------------------------------------------
void CSDKGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
int killer_ID = 0;
// Find the killer & the scorer
CSDKPlayer *pSDKPlayerVictim = ToSDKPlayer( pVictim );
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
// CSDKPlayer *pAssister = ToSDKPlayer( GetAssister( pVictim, pScorer, pInflictor ) );
// Work out what killed the player, and send a message to all clients about it
int iWeaponID;
const char *killer_weapon_name = GetKillingWeaponName( info, pSDKPlayerVictim, &iWeaponID );
if ( pScorer ) // Is the killer a client?
{
killer_ID = pScorer->GetUserID();
}
IGameEvent * event = gameeventmanager->CreateEvent( "player_death" );
if ( event )
{
event->SetInt( "userid", pVictim->GetUserID() );
event->SetInt( "attacker", killer_ID );
// event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 );
event->SetString( "weapon", killer_weapon_name );
event->SetInt( "weaponid", iWeaponID );
event->SetInt( "damagebits", info.GetDamageType() );
event->SetInt( "customkill", info.GetDamageCustom() );
event->SetInt( "priority", 7 ); // HLTV event priority, not transmitted
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose: TF2 Specific Client Commands
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CSDKGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
{
CSDKPlayer *pPlayer = ToSDKPlayer( pEdict );
#if 0
const char *pcmd = args[0];
if ( FStrEq( pcmd, "somecommand" ) )
{
if ( args.ArgC() < 2 )
return true;
// Do something here!
return true;
}
else
#endif
// Handle some player commands here as they relate more directly to gamerules state
if ( pPlayer->ClientCommand( args ) )
{
return true;
}
else if ( BaseClass::ClientCommand( pEdict, args ) )
{
return true;
}
return false;
}
CBall *GetNearestPlayerBall(const Vector &pos)
{
CBall *pNearestBall = GetMatchBall();
Vector ballPos = pNearestBall->GetPos();
float shortestDist = (ballPos - pos).Length2DSqr();
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pPl = ToSDKPlayer(UTIL_PlayerByIndex(i));
if (!pPl || !CSDKPlayer::IsOnField(pPl))
continue;
CBall *pBall = pPl->GetPlayerBall();
if (!pBall)
continue;
Vector ballPos = pBall->GetPos();
float dist = (ballPos - pos).Length2DSqr();
if (dist < shortestDist)
{
shortestDist = dist;
pNearestBall = pBall;
}
}
return pNearestBall;
}
void CSDKGameMovement::ProcessMovement( CBasePlayer *pBasePlayer, CMoveData *pMove )
{
//Store the player pointer
m_pSDKPlayer = ToSDKPlayer( pBasePlayer );
Assert( m_pSDKPlayer );
BaseClass::ProcessMovement( pBasePlayer, pMove );
}
void ClientActive( edict_t *pEdict, bool bLoadGame )
{
// Can't load games in CS!
Assert( !bLoadGame );
CSDKPlayer *pPlayer = ToSDKPlayer( CBaseEntity::Instance( pEdict ) );
FinishClientPutInServer( pPlayer );
}
void CSDKGameRules::CalculateSlowMoForPlayer(CSDKPlayer* pPlayer)
{
if (!pPlayer)
return;
if (!pPlayer->IsAlive())
{
pPlayer->SetSlowMoType(SLOWMO_NONE);
return;
}
// If I activated slow then I get to keep my slow level.
if (pPlayer->GetSlowMoType() == SLOWMO_ACTIVATED)
return;
if (pPlayer->GetSlowMoType() == SLOWMO_STYLESKILL)
return;
// Players who haven't activated anything are at the whims of those who have.
bool bOtherInSlow = false;
CUtlVector<CSDKPlayer*> apOthersInPVS;
CBaseEntity* pOther = NULL;
while ((pOther = UTIL_EntitiesInPVS(pPlayer, pOther)) != NULL)
{
CSDKPlayer* pOtherPlayer = ToSDKPlayer(pOther);
if (!pOtherPlayer)
continue;
if (pOtherPlayer == pPlayer)
continue;
apOthersInPVS.AddToTail(pOtherPlayer);
}
for (int i = 0; i < apOthersInPVS.Size(); i++)
{
CSDKPlayer* pOtherPlayer = apOthersInPVS[i];
if (!pOtherPlayer->IsAlive())
continue;
if (pOtherPlayer->GetSlowMoType() != SLOWMO_NONE)
{
bOtherInSlow = true;
break;
}
}
// If any of these players are in slow then I'm in slow too.
if (bOtherInSlow)
pPlayer->SetSlowMoType(SLOWMO_PASSIVE);
else
pPlayer->SetSlowMoType(SLOWMO_NONE);
}
void CTriggerKill::Touch( CBaseEntity *pOther )
{
if (pOther->IsPlayer())
{
CTakeDamageInfo info( this, this, 10000, m_bitsDamageInflict );
pOther->TakeDamage( info );
ToSDKPlayer(pOther)->PlayerDeathThink();
ToSDKPlayer(pOther)->SetKilledByString(m_sKillerPrintString);
}
else if (dynamic_cast<CBriefcase*>(pOther))
{
// This code doesn't work, the briefcase needs some sort of flag
// to be triggered and I can't be bothered to figure it out right now.
AssertMsg(false, "Untested code");
SDKGameRules()->CleanupMiniObjective_Briefcase();
SDKGameRules()->SetupMiniObjective_Briefcase();
}
}
void CWeaponSDKMelee::PrimaryAttack()
{
#ifndef CLIENT_DLL
CSDKPlayer *pPlayer = ToSDKPlayer( GetPlayerOwner() );
pPlayer->NoteWeaponFired();
#endif
StartSwing( false );
}
float CDAViewModel::GetSequenceCycleRate( CStudioHdr *pStudioHdr, int iSequence )
{
float flSlow = 1;
CSDKPlayer* pOwner = ToSDKPlayer(GetOwner());
if (pOwner)
flSlow *= pOwner->GetSlowMoMultiplier();
return BaseClass::GetSequenceCycleRate(pStudioHdr, iSequence) * flSlow;
}
void CC_ShootPlayerBall(const CCommand &args)
{
CSDKPlayer *pPl = ToSDKPlayer(UTIL_GetCommandClient());
if (!CSDKPlayer::IsOnField(pPl) || !pPl->GetPlayerBall())
return;
pPl->GetPlayerBall()->SetBallCannonMode(true);
pPl->GetPlayerBall()->RestoreBallCannonSettings();
pPl->m_Shared.SetStamina(100);
}
// checks if the spot is clear of players
bool CSDKGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer )
{
if ( !pSpot->IsTriggered( pPlayer ) )
{
return false;
}
// Check if it is disabled by Enable/Disable
CSpawnPoint *pSpawnPoint = dynamic_cast< CSpawnPoint * >( pSpot );
if ( pSpawnPoint )
{
if ( pSpawnPoint->IsDisabled() )
{
return false;
}
}
for (int i = 0; i < gpGlobals->maxClients; i++)
{
CBasePlayer *pOtherPlayer = UTIL_PlayerByIndex( i );
if (!pOtherPlayer)
continue;
if (PlayerRelationship(pPlayer, pOtherPlayer) == GR_TEAMMATE)
continue;
if ((pSpot->GetAbsOrigin() - pOtherPlayer->GetAbsOrigin()).LengthSqr() > 512*512)
continue;
CSDKPlayer* pOtherSDKPlayer = ToSDKPlayer(pOtherPlayer);
trace_t tr;
UTIL_TraceLine( pSpot->WorldSpaceCenter(), pOtherSDKPlayer->WorldSpaceCenter(), MASK_VISIBLE_AND_NPCS, pPlayer, COLLISION_GROUP_NONE, &tr );
if (tr.m_pEnt == pOtherPlayer)
return false;
}
CBaseEntity* pGrenade = gEntList.FindEntityByClassname( NULL, "weapon_grenade" );
while (pGrenade)
{
if ((pSpot->GetAbsOrigin() - pGrenade->GetAbsOrigin()).LengthSqr() < 500*500)
return false;
pGrenade = gEntList.FindEntityByClassname( pGrenade, "weapon_grenade" );
}
Vector mins = GetViewVectors()->m_vHullMin;
Vector maxs = GetViewVectors()->m_vHullMax;
Vector vTestMins = pSpot->GetAbsOrigin() + mins;
Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
// First test the starting origin.
return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CWeaponHL2Pistol::Reload( void )
{
bool fRet = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
if ( fRet )
{
WeaponSound( RELOAD );
ToSDKPlayer(GetOwner())->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
m_flAccuracyPenalty = 0.0f;
}
return fRet;
}
void CSDKGameRules::GiveSlowMoToNearbyPlayers(CSDKPlayer* pPlayer)
{
if (!pPlayer)
return;
if (!pPlayer->IsAlive())
{
pPlayer->SetSlowMoType(SLOWMO_NONE);
return;
}
if (pPlayer->GetSlowMoType() == SLOWMO_NONE)
return;
// I have some slowmo on me. Pass it to other players nearby.
CUtlVector<CSDKPlayer*> apOthersInPVS;
CBaseEntity* pOther = NULL;
while ((pOther = UTIL_EntitiesInPVS(pPlayer, pOther)) != NULL)
{
CSDKPlayer* pOtherPlayer = ToSDKPlayer(pOther);
if (!pOtherPlayer)
continue;
if (pOtherPlayer == pPlayer)
continue;
// If they already have slow mo, we don't need to pass it to them.
if (pOtherPlayer->GetSlowMoType() == SLOWMO_STYLESKILL)
continue;
if (pOtherPlayer->GetSlowMoType() == SLOWMO_ACTIVATED)
continue;
if (pOtherPlayer->GetSlowMoType() == SLOWMO_PASSIVE)
continue;
apOthersInPVS.AddToTail(pOtherPlayer);
}
for (int i = 0; i < apOthersInPVS.Size(); i++)
{
CSDKPlayer* pOtherPlayer = apOthersInPVS[i];
// It could have been already done by a previous iteration of the recursion below.
if (pOtherPlayer->GetSlowMoType() != SLOWMO_NONE)
continue;
pOtherPlayer->SetSlowMoType(SLOWMO_PASSIVE);
GiveSlowMoToNearbyPlayers(pOtherPlayer);
}
}
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 :
// Input :
// Output :
//------------------------------------------------------------------------------
void CWeaponSDKMelee::PrimaryAttack()
{
#ifndef CLIENT_DLL
CSDKPlayer *pPlayer = ToSDKPlayer( GetPlayerOwner() );
pPlayer->NoteWeaponFired();
// Move other players back to history positions based on local player's lag
lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
#endif
Swing( false );
#ifndef CLIENT_DLL
// Move other players back to history positions based on local player's lag
lagcompensation->FinishLagCompensation( pPlayer );
#endif
}
void CArmorRechargerClassic::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// if it's not a player, ignore
if ( !pActivator || !pActivator->IsPlayer())
{
return;
}
else if (GameRules()->GetGameMode() == GAMEMODE_CLASSIC)
{
if (ClassicGameRules()->GetCurrentPhaseID() == PHASE_BUILD)
{
if (m_flSoundTime <= gpGlobals->curtime)
{
m_flSoundTime = gpGlobals->curtime + 0.62;
EmitSound( "SuitRecharge.Deny" );
}
return;
}
else if (GetTeamNumber() != pActivator->GetTeamNumber() &&
GetTeamNumber() != TEAM_SPECTATOR)
{
if (m_flSoundTime <= gpGlobals->curtime)
{
CBasePlayer *pPlayer = ToBasePlayer( pActivator );
Assert( pPlayer );
ClientPrint( pPlayer, HUD_PRINTTALK, "#lf_armor_charger_deny" );
m_flSoundTime = gpGlobals->curtime + 0.62;
EmitSound( "SuitRecharge.Deny" );
}
return;
}
}
CSDKPlayer *pPlayer = ToSDKPlayer( pCaller );
AssertMsg( pPlayer, "Failure SDKPlayer Armor charger\n" );
CSDKTeam *pTeam = GetGlobalSDKTeam( pPlayer->GetTeamNumber() );
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( pPlayer->m_Shared.PlayerClass() );
SetMaxArmor( pClassInfo.m_iArmor );
BaseClass::Use( pActivator, pCaller, useType, value );
}
float CWeaponSDKMelee::GetMeleeDamage( bool bIsSecondary ) const
{
CSDKPlayer *pPlayer = ToSDKPlayer( GetOwner() );
float flDamage = GetSDKWpnData().m_iDamage;
if (bIsSecondary)
flDamage = GetSDKWpnData().m_iSecondaryDamage;
flDamage = pPlayer->m_Shared.ModifySkillValue(flDamage, 0.2f, SKILL_BOUNCER);
if (pPlayer->m_Shared.IsDiving())
flDamage *= 1.5f;
else if (!pPlayer->GetGroundEntity())
flDamage *= 1.2f;
return flDamage;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// &movementData -
//-----------------------------------------------------------------------------
CSDKPlayerAnimState::CSDKPlayerAnimState( CBasePlayer *pPlayer )
{
m_pSDKPlayer = ToSDKPlayer(pPlayer);
// Pose parameters.
m_bPoseParameterInit = false;
m_PoseParameterData.Init();
m_DebugAnimData.Init();
m_angRender.Init();
m_flEyeYaw = 0.0f;
m_flEyePitch = 0.0f;
m_flGoalFeetYaw = 0.0f;
m_flCurrentFeetYaw = 0.0f;
m_flLastAimTurnTime = 0.0f;
// Jumping.
m_bJumping = false;
m_flJumpStartTime = 0.0f;
m_bFirstJumpFrame = false;
// Swimming
m_bInSwim = false;
m_bFirstSwimFrame = true;
// Dying
m_bDying = false;
m_bFirstDyingFrame = true;
m_eCurrentMainSequenceActivity = ACT_INVALID;
// Ground speed interpolators.
#ifdef CLIENT_DLL
m_iv_flMaxGroundSpeed.Setup( &m_flMaxGroundSpeed, LATCH_ANIMATION_VAR | INTERPOLATE_LINEAR_ONLY );
m_flLastGroundSpeedUpdateTime = 0.0f;
#endif
m_flMaxGroundSpeed = 0.0f;
m_bForceAimYaw = true; //ios false;
//InitGestureSlots();
}
float CSDKGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
{
CSDKPlayer* pSDKPlayer = ToSDKPlayer(pPlayer);
float flFallVelocity = pSDKPlayer->m_Local.m_flFallVelocity;
float flDiveFallSpeed = 800;
float flExcessSpeed = flFallVelocity - PLAYER_MAX_SAFE_FALL_SPEED;
if (pSDKPlayer->m_Shared.IsDiving())
flExcessSpeed = flFallVelocity - flDiveFallSpeed;
float flDamage = RemapValClamped(flExcessSpeed, 0, 100, 0, 10);
if (pSDKPlayer->m_Shared.IsDiving())
flDamage /= 2;
return flDamage;
}
bool CWeaponSMG1::Reload( void )
{
bool fRet;
float fCacheTime = m_flNextSecondaryAttack;
fRet = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
if ( fRet )
{
// Undo whatever the reload process has done to our secondary
// attack timer. We allow you to interrupt reloading to fire
// a grenade.
m_flNextSecondaryAttack = GetOwner()->m_flNextAttack = fCacheTime;
WeaponSound( RELOAD );
ToSDKPlayer(GetOwner())->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
}
return fRet;
}
CBlockBase *CWeaponCombatCannon::FindTraceBlock( void )
{
CSDKPlayer *pPlayer = ToSDKPlayer( GetOwner() );
CBaseEntity *pEntity = NULL;
if ( m_grabController.GetAttached() )
{
pEntity = m_grabController.GetAttached();
}
else
{
Vector vecSrc, vecEnd, vecDir;
vecSrc = pPlayer->Weapon_ShootPosition();
pPlayer->EyeVectors( &vecDir );
// Calculate max distance as twice the radius of the block
float max_distance = pPlayer->CollisionProp()->BoundingRadius()
+ lf_freeze_distance_combat.GetFloat();
vecEnd = vecSrc + vecDir * max_distance;
UTIL_TraceLine( vecSrc, vecEnd, MASK_SHOT, GetOwner(), COLLISION_GROUP_NONE, &m_tr );
pEntity = m_tr.m_pEnt;
}
if ( !pEntity || !pEntity->IsBlock() )
{
ResetFreezing();
return NULL;
}
CBlockBase *pBlock = dynamic_cast < CBlockBase * > ( pEntity );
if( !pBlock )
{
DevMsg( "Not a block\n" );
return NULL;
}
return pBlock;
}
/*
==============================
ComputeSideMove
==============================
*/
void CInput::ComputeSideMove( CUserCmd *cmd )
{
// thirdperson platformer movement
if ( CAM_IsThirdPerson() && thirdperson_platformer.GetInt() )
{
// no sideways movement in this mode
return;
}
// thirdperson screenspace movement
if ( CAM_IsThirdPerson() && thirdperson_screenspace.GetInt() )
{
float ideal_yaw = m_aCamIdealAngles[YAW];
float ideal_sin = sin(DEG2RAD(ideal_yaw));
float ideal_cos = cos(DEG2RAD(ideal_yaw));
float movement = ideal_cos*KeyState(&in_moveright)
+ ideal_sin*KeyState(&in_back)
+ -ideal_cos*KeyState(&in_moveleft)
+ -ideal_sin*KeyState(&in_forward);
cmd->sidemove += cl_sidespeed.GetFloat() * movement;
return;
}
// If strafing, check left and right keys and act like moveleft and moveright keys
if ( in_strafe.state & 1 )
{
cmd->sidemove += cl_sidespeed.GetFloat() * KeyState (&in_right);
cmd->sidemove -= cl_sidespeed.GetFloat() * KeyState (&in_left);
}
// Otherwise, check strafe keys
C_SDKPlayer *pPlayer = ToSDKPlayer(C_BasePlayer::GetLocalPlayer());
cmd->sidemove += cl_sidespeed.GetFloat() * KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed.GetFloat() * KeyState (&in_moveleft);
}
CSDKPlayer *CKeeperBot::FindClosestPlayerToBall()
{
float shortestDist = FLT_MAX;
CSDKPlayer *pClosest = NULL;
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pPl = ToSDKPlayer(UTIL_PlayerByIndex(i));
if (!CSDKPlayer::IsOnField(pPl))
continue;
float dist = (m_vBallPos - pPl->GetLocalOrigin()).Length2D();
if (dist < shortestDist)
{
shortestDist = dist;
pClosest = pPl;
}
}
return pClosest;
}
void CDataManager::SavePositions()
{
if (IsSendingData())
return;
m_flNextPositionsUpdate = gpGlobals->curtime + da_data_positions_interval.GetFloat();
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pPlayer = ToSDKPlayer(UTIL_PlayerByIndex( i ));
if (!pPlayer)
continue;
if (pPlayer->IsBot())
continue;
if (!pPlayer->IsAlive())
continue;
m_avecPlayerPositions.AddToTail(pPlayer->GetAbsOrigin());
}
}
//------------------------------------------------------------------------------
// Purpose: Implement impact function
//------------------------------------------------------------------------------
void CWeaponSDKMelee::Hit( trace_t &traceHit, Activity nHitActivity )
{
CSDKPlayer *pPlayer = ToSDKPlayer( GetOwner() );
//Do view kick
// AddViewKick();
CBaseEntity *pHitEntity = traceHit.m_pEnt;
//Apply damage to a hit target
if ( pHitEntity != NULL )
{
Vector hitDirection;
pPlayer->EyeVectors( &hitDirection, NULL, NULL );
VectorNormalize( hitDirection );
#ifndef CLIENT_DLL
CTakeDamageInfo info( GetOwner(), GetOwner(), GetDamageForActivity( nHitActivity ), DMG_CLUB );
if( pPlayer && pHitEntity->IsNPC() )
{
// If bonking an NPC, adjust damage.
info.AdjustPlayerDamageInflictedForSkillLevel();
}
CalculateMeleeDamageForce( &info, hitDirection, traceHit.endpos );
pHitEntity->DispatchTraceAttack( info, hitDirection, &traceHit );
ApplyMultiDamage();
// Now hit all triggers along the ray that...
TraceAttackToTriggers( info, traceHit.startpos, traceHit.endpos, hitDirection );
#endif
WeaponSound( MELEE_HIT );
}
// Apply an impact effect
ImpactEffect( traceHit );
}
int CSDKGameRules::CountPlayerClass( int team, int cls )
{
int num = 0;
CSDKPlayer *pSDKPlayer;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pSDKPlayer = ToSDKPlayer( UTIL_PlayerByIndex( i ) );
if (pSDKPlayer == NULL)
continue;
if (FNullEnt( pSDKPlayer->edict() ))
continue;
if( pSDKPlayer->GetTeamNumber() != team )
continue;
if( pSDKPlayer->m_Shared.DesiredPlayerClass() == cls )
num++;
}
return num;
}
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;
}
}
void CDAViewModel::FireObsoleteEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
CSDKPlayer* pOwner = ToSDKPlayer(GetOwner());
if (!pOwner)
return;
Vector attachOrigin;
QAngle attachAngles;
switch( event )
{
// Obsolete. Use the AE_CL_CREATE_PARTICLE_EFFECT event instead, which uses the artist driven particle system & editor.
case AE_CLIENT_EFFECT_ATTACH:
{
int iAttachment = -1;
int iParam = 0;
char token[128];
char effectFunc[128];
const char *p = options;
p = nexttoken(token, p, ' ');
if( token )
Q_strncpy( effectFunc, token, sizeof(effectFunc) );
p = nexttoken(token, p, ' ');
bool bResult = false;
if( token )
{
if (pOwner->IsInThirdPerson() && pOwner->GetActiveSDKWeapon())
{
iAttachment = pOwner->GetActiveSDKWeapon()->LookupAttachment(token);
bResult = pOwner->GetActiveSDKWeapon()->GetAttachment( iAttachment, attachOrigin, attachAngles );
}
else
{
iAttachment = LookupAttachment(token);
bResult = GetAttachment( iAttachment, attachOrigin, attachAngles );
}
}
p = nexttoken(token, p, ' ');
if( token )
iParam = atoi(token);
if (bResult)
{
// Fill out the generic data
CEffectData data;
data.m_vOrigin = attachOrigin;
data.m_vAngles = attachAngles;
AngleVectors( attachAngles, &data.m_vNormal );
data.m_hEntity = GetRefEHandle();
data.m_nAttachmentIndex = iAttachment + 1;
data.m_fFlags = iParam;
DispatchEffect( effectFunc, data );
}
}
break;
}
}
