bool CHudProgressBar::ShouldDraw()
{
C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
if( pTarget && pTarget->IsPlayer() )
{
pPlayer = ToCSPlayer( pTarget );
if( !pPlayer->IsAlive() )
return false;
}
else
return false;
}
if( !pPlayer || pPlayer->m_iProgressBarDuration == 0 || pPlayer->m_lifeState == LIFE_DEAD )
{
return false;
}
return cl_c4progressbar.GetBool();
}
void CSmokeGrenadeProjectile::Think_Detonate()
{
if ( GetAbsVelocity().Length() > 0.1 )
{
// Still moving. Don't detonate yet.
SetNextThink( gpGlobals->curtime + 0.2 );
return;
}
TheBots->SetGrenadeRadius( this, SmokeGrenadeRadius );
// Ok, we've stopped rolling or whatever. Now detonate.
ParticleSmokeGrenade *pGren = (ParticleSmokeGrenade*)CBaseEntity::Create( PARTICLESMOKEGRENADE_ENTITYNAME, GetAbsOrigin(), QAngle(0,0,0), NULL );
if ( pGren )
{
pGren->FillVolume();
pGren->SetFadeTime( 17, 22 );
pGren->SetAbsOrigin( GetAbsOrigin() );
//tell the hostages about the smoke!
CBaseEntity *pEntity = NULL;
variant_t var; //send the location of the smoke?
var.SetVector3D( GetAbsOrigin() );
while ( ( pEntity = gEntList.FindEntityByClassname( pEntity, "hostage_entity" ) ) != NULL)
{
//send to hostages that have a resonable chance of being in it while its still smoking
if( (GetAbsOrigin() - pEntity->GetAbsOrigin()).Length() < 1000 )
pEntity->AcceptInput( "smokegrenade", this, this, var, 0 );
}
// tell the bots a smoke grenade has exploded
CCSPlayer *player = ToCSPlayer(GetThrower());
if ( player )
{
IGameEvent * event = gameeventmanager->CreateEvent( "smokegrenade_detonate" );
if ( event )
{
event->SetInt( "userid", player->GetUserID() );
event->SetFloat( "x", GetAbsOrigin().x );
event->SetFloat( "y", GetAbsOrigin().y );
event->SetFloat( "z", GetAbsOrigin().z );
gameeventmanager->FireEvent( event );
}
}
}
m_hSmokeEffect = pGren;
m_bDidSmokeEffect = true;
EmitSound( "BaseSmokeEffect.Sound" );
m_nRenderMode = kRenderTransColor;
SetNextThink( gpGlobals->curtime + 5 );
SetThink( &CSmokeGrenadeProjectile::Think_Fade );
}
void CCSPlayerMove::StartCommand( CBasePlayer *player, CUserCmd *cmd )
{
CCSPlayer *pPlayer = ToCSPlayer( player );
// Reset this.. it gets reset each frame that we're in a bomb zone.
pPlayer->m_bInBombZone = false;
pPlayer->m_bInBuyZone = false;
pPlayer->m_bInHostageRescueZone = false;
BaseClass::StartCommand( player, cmd );
}
void CCSPlayerAnimState::InitCS( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
{
CModAnimConfig config;
config.m_flMaxBodyYawDegrees = 90;
config.m_LegAnimType = legAnimType;
config.m_bUseAimSequences = bUseAimSequences;
m_pPlayer = ToCSPlayer( pEntity );
m_pHelpers = pHelpers;
BaseClass::Init( pEntity, config );
}
void CHudProgressBar::Paint()
{
C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
if( pTarget && pTarget->IsPlayer() )
{
pPlayer = ToCSPlayer( pTarget );
if( !pPlayer->IsAlive() )
return;
}
else
return;
}
if ( !pPlayer )
return;
int x, y, wide, tall;
GetBounds( x, y, wide, tall );
tall = 10;
int xOffset=0;
int yOffset=0;
Color clr = m_clrProgress;
clr[3] = 160;
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawOutlinedRect( xOffset, yOffset, xOffset+wide, yOffset+tall );
if( pPlayer->m_iProgressBarDuration > 0 )
{
// ProgressBarStartTime is now with respect to m_flSimulationTime rather than local time
float percent = (pPlayer->m_flSimulationTime - pPlayer->m_flProgressBarStartTime) / (float)pPlayer->m_iProgressBarDuration;
percent = clamp( percent, 0, 1 );
clr[3] = 240;
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawFilledRect( xOffset+2, yOffset+2, xOffset+(int)(percent*wide)-2, yOffset+tall-2 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CWeapon_SLAM::TripmineAttach( void )
{
CCSPlayer *pOwner = ToCSPlayer( GetOwner() );
if (!pOwner)
{
return;
}
m_bAttachTripmine = false;
Vector vecSrc, vecAiming;
// Take the eye position and direction
vecSrc = pOwner->EyePosition();
QAngle angles = pOwner->GetLocalAngles();
AngleVectors( angles, &vecAiming );
trace_t tr;
UTIL_TraceLine( vecSrc, vecSrc + (vecAiming * 128), MASK_SOLID, pOwner, COLLISION_GROUP_NONE, &tr );
if (tr.fraction < 1.0)
{
CBaseEntity *pEntity = tr.m_pEnt;
if (pEntity && !(pEntity->GetFlags() & FL_CONVEYOR))
{
#ifndef CLIENT_DLL
QAngle angles;
VectorAngles(tr.plane.normal, angles);
angles.x += 90;
CBaseEntity *pEnt = CBaseEntity::Create( "npc_tripmine", tr.endpos + tr.plane.normal * 3, angles, NULL );
CTripmineGrenade *pMine = (CTripmineGrenade *)pEnt;
pMine->m_hOwner = GetOwner();
#endif
pOwner->RemoveAmmo( 1, m_iSecondaryAmmoType );
}
}
}
bool operator()( CBasePlayer *player )
{
if ( !player->IsAlive() || player->GetTeamNumber() != m_team )
return true;
CCSPlayer *csPlayer = ToCSPlayer( player );
if ( !csPlayer )
return true;
if ( csPlayer->IsBlind() )
return true;
Vector eye, forward;
player->EyePositionAndVectors( &eye, &forward, NULL, NULL );
Vector path( m_target - eye );
float distance = path.Length();
path.NormalizeInPlace();
float dot = DotProduct( forward, path );
if( (dot > 0.995f )
|| (dot > 0.98f && distance < 900)
|| (dot > 0.8f && distance < 250)
)
{
trace_t tr;
CTraceFilterSkipTwoEntities filter( player, m_targetEntity, COLLISION_GROUP_DEBRIS );
UTIL_TraceLine( eye, m_target,
(CONTENTS_OPAQUE|CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_DEBRIS), &filter, &tr );
if( tr.fraction == 1.0f )
{
//if ( TheCSBots()->IsLineBlockedBySmoke( eye, m_target ) )
//{
// return true;
//}
m_spotted = true;
return false; // spotted already, so no reason to check for other players spotting the same thing.
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CWeapon_SLAM::CanAttachSLAM( void )
{
CCSPlayer *pOwner = ToCSPlayer( GetOwner() );
if (!pOwner)
{
return false;
}
Vector vecSrc, vecAiming;
// Take the eye position and direction
vecSrc = pOwner->EyePosition();
QAngle angles = pOwner->GetLocalAngles();
AngleVectors( angles, &vecAiming );
trace_t tr;
Vector vecEnd = vecSrc + (vecAiming * 42);
UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pOwner, COLLISION_GROUP_NONE, &tr );
if (tr.fraction < 1.0)
{
// Don't attach to a living creature
if (tr.m_pEnt)
{
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
if (pBCC)
{
return false;
}
}
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when the player falls onto a surface fast enough to take
// damage, according to the rules in CGameMovement::CheckFalling.
// Output : Returns true if the player survived the fall, false if they died.
//-----------------------------------------------------------------------------
bool CMoveHelperServer::PlayerFallingDamage( void )
{
float flFallDamage = g_pGameRules->FlPlayerFallDamage( m_pHostPlayer );
if ( flFallDamage > 0 )
{
m_pHostPlayer->TakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), flFallDamage, DMG_FALL ) );
StartSound( m_pHostPlayer->GetAbsOrigin(), "Player.FallDamage" );
//=============================================================================
// HPE_BEGIN:
// [dwenger] Needed for fun-fact implementation
//=============================================================================
#ifdef CSTRIKE_DLL
// Increment the stat for fall damage
CCSPlayer* pPlayer = ToCSPlayer(m_pHostPlayer);
if ( pPlayer )
{
CCS_GameStats.IncrementStat( pPlayer, CSSTAT_FALL_DAMAGE, (int)flFallDamage );
}
#endif
//=============================================================================
// HPE_END
//=============================================================================
}
if ( m_pHostPlayer->m_iHealth <= 0 )
{
if ( g_pGameRules->FlPlayerFallDeathDoesScreenFade( m_pHostPlayer ) )
{
color32 black = {0, 0, 0, 255};
UTIL_ScreenFade( m_pHostPlayer, black, 0, 9999, FFADE_OUT | FFADE_STAYOUT );
}
return(false);
}
return(true);
}
bool CWeaponElite::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
{
if( event == 5001 )
{
C_CSPlayer *pPlayer = ToCSPlayer( GetOwner() );
if( pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed() )
return true;
CEffectData data;
data.m_fFlags = 0;
data.m_hEntity = pViewModel->GetRefEHandle();
data.m_nAttachmentIndex = m_bFireRight?2:1; // toggle muzzle flash
data.m_flScale = GetCSWpnData().m_flMuzzleScale;
DispatchEffect( "CS_MuzzleFlash", data );
return true;
}
return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCSPlayerResource::UpdatePlayerData( void )
{
int i;
m_iPlayerC4 = 0;
m_iPlayerVIP = 0;
for ( i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
if ( pPlayer && pPlayer->IsConnected() )
{
if ( pPlayer->IsVIP() )
{
// we should only have one VIP
Assert( m_iPlayerVIP == 0 );
m_iPlayerVIP = i;
}
if ( pPlayer->HasC4() )
{
// we should only have one bomb
m_iPlayerC4 = i;
}
}
}
CBaseEntity *c4 = NULL;
if ( m_iPlayerC4 == 0 )
{
// no player has C4, update C4 position
if ( g_C4s.Count() > 0 )
{
c4 = g_C4s[0];
m_vecC4 = c4->GetAbsOrigin();
}
else
{
m_vecC4.Init();
}
}
//int numHostages = g_Hostages.Count();
for ( i = 0; i < MAX_HOSTAGES; i++ )
{
/*if ( i >= numHostages )
{
// engine->Con_NPrintf( i, "Dead" );
m_bHostageAlive.Set( i, false );
m_isHostageFollowingSomeone.Set( i, false );
continue;
}
// CHostage* pHostage = g_Hostages[i];
//m_bHostageAlive.Set( i, pHostage->IsRescuable() );
/*if ( pHostage->IsValid() )
{
m_iHostageX.Set( i, (int) pHostage->GetAbsOrigin().x );
m_iHostageY.Set( i, (int) pHostage->GetAbsOrigin().y );
m_iHostageZ.Set( i, (int) pHostage->GetAbsOrigin().z );
m_iHostageEntityIDs.Set( i, pHostage->entindex() );
//m_isHostageFollowingSomeone.Set( i, pHostage->IsFollowingSomeone() );
// engine->Con_NPrintf( i, "ID:%d Pos:(%.0f,%.0f,%.0f)", pHostage->entindex(), pHostage->GetAbsOrigin().x, pHostage->GetAbsOrigin().y, pHostage->GetAbsOrigin().z );
}
else
{
// engine->Con_NPrintf( i, "Invalid" );
}*/
}
if( !m_foundGoalPositions )
{
// We only need to update these once a map, but we need the client to know about them.
CBaseEntity* ent = NULL;
while ( ( ent = gEntList.FindEntityByClassname( ent, "func_bomb_target" ) ) != NULL )
{
const Vector &pos = ent->WorldSpaceCenter();
CNavArea *area = TheNavMesh->GetNearestNavArea( pos, true );
const char *placeName = (area) ? TheNavMesh->PlaceToName( area->GetPlace() ) : NULL;
if ( placeName == NULL )
{
// The bomb site has no area or place name, so just choose A then B
if ( m_bombsiteCenterA.Get().IsZero() )
{
m_bombsiteCenterA = pos;
}
else
{
m_bombsiteCenterB = pos;
}
}
else
{
// The bomb site has a place name, so choose accordingly
if( FStrEq( placeName, "BombsiteA" ) )
{
m_bombsiteCenterA = pos;
}
else
{
m_bombsiteCenterB = pos;
}
}
m_foundGoalPositions = true;
}
int hostageRescue = 0;
while ( (( ent = gEntList.FindEntityByClassname( ent, "func_hostage_rescue" ) ) != NULL) && (hostageRescue < MAX_HOSTAGE_RESCUES) )
{
const Vector &pos = ent->WorldSpaceCenter();
m_hostageRescueX.Set( hostageRescue, (int) pos.x );
m_hostageRescueY.Set( hostageRescue, (int) pos.y );
m_hostageRescueZ.Set( hostageRescue, (int) pos.z );
hostageRescue++;
m_foundGoalPositions = true;
}
}
bool bombSpotted = false;
if ( c4 )
{
Spotter spotter( c4, m_vecC4, TEAM_CT );
ForEachPlayer( spotter );
if ( spotter.Spotted() )
{
bombSpotted = true;
}
}
for ( int i=0; i < MAX_PLAYERS+1; i++ )
{
CCSPlayer *target = ToCSPlayer( UTIL_PlayerByIndex( i ) );
if ( !target || !target->IsAlive() )
{
m_bPlayerSpotted.Set( i, 0 );
continue;
}
Spotter spotter( target, target->EyePosition(), (target->GetTeamNumber()==TEAM_CT) ? TEAM_TERRORIST : TEAM_CT );
ForEachPlayer( spotter );
if ( spotter.Spotted() )
{
if ( target->HasC4() )
{
bombSpotted = true;
}
m_bPlayerSpotted.Set( i, 1 );
}
else
{
m_bPlayerSpotted.Set( i, 0 );
}
}
if ( bombSpotted )
{
m_bBombSpotted = true;
}
else
{
m_bBombSpotted = false;
}
BaseClass::UpdatePlayerData();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBaseGrenadeProj::ResolveFlyCollisionCustom( trace_t &trace, Vector &vecVelocity )
{
//Assume all surfaces have the same elasticity
float flSurfaceElasticity = 1.0;
//Don't bounce off of players with perfect elasticity
if( trace.m_pEnt && trace.m_pEnt->IsPlayer() )
{
flSurfaceElasticity = 0.3;
}
#if 0
// if its breakable glass and we kill it, don't bounce.
// give some damage to the glass, and if it breaks, pass
// through it.
bool breakthrough = false;
if( trace.m_pEnt && FClassnameIs( trace.m_pEnt, "func_breakable" ) )
{
breakthrough = true;
}
if( trace.m_pEnt && FClassnameIs( trace.m_pEnt, "func_breakable_surf" ) )
{
breakthrough = true;
}
if (breakthrough)
{
CTakeDamageInfo info( this, this, 10, DMG_CLUB );
trace.m_pEnt->DispatchTraceAttack( info, GetAbsVelocity(), &trace );
ApplyMultiDamage();
if( trace.m_pEnt->m_iHealth <= 0 )
{
// slow our flight a little bit
Vector vel = GetAbsVelocity();
vel *= 0.4;
SetAbsVelocity( vel );
return;
}
}
#endif
float flTotalElasticity = GetElasticity() * flSurfaceElasticity;
flTotalElasticity = clamp( flTotalElasticity, 0.0f, 0.9f );
// NOTE: A backoff of 2.0f is a reflection
Vector vecAbsVelocity;
PhysicsClipVelocity( GetAbsVelocity(), trace.plane.normal, vecAbsVelocity, 2.0f );
vecAbsVelocity *= flTotalElasticity;
// Get the total velocity (player + conveyors, etc.)
VectorAdd( vecAbsVelocity, GetBaseVelocity(), vecVelocity );
float flSpeedSqr = DotProduct( vecVelocity, vecVelocity );
// Stop if on ground.
if ( trace.plane.normal.z > 0.7f ) // Floor
{
// Verify that we have an entity.
CBaseEntity *pEntity = trace.m_pEnt;
Assert( pEntity );
SetAbsVelocity( vecAbsVelocity );
if ( flSpeedSqr < ( 30 * 30 ) )
{
if ( pEntity->IsStandable() )
{
SetGroundEntity( pEntity );
}
// Reset velocities.
SetAbsVelocity( vec3_origin );
SetLocalAngularVelocity( vec3_angle );
//align to the ground so we're not standing on end
QAngle angle;
VectorAngles( trace.plane.normal, angle );
// rotate randomly in yaw
angle[1] = random->RandomFloat( 0, 360 );
// TFTODO: rotate around trace.plane.normal
SetAbsAngles( angle );
}
else
{
Vector vecDelta = GetBaseVelocity() - vecAbsVelocity;
Vector vecBaseDir = GetBaseVelocity();
VectorNormalize( vecBaseDir );
float flScale = vecDelta.Dot( vecBaseDir );
VectorScale( vecAbsVelocity, ( 1.0f - trace.fraction ) * gpGlobals->frametime, vecVelocity );
VectorMA( vecVelocity, ( 1.0f - trace.fraction ) * gpGlobals->frametime, GetBaseVelocity() * flScale, vecVelocity );
PhysicsPushEntity( vecVelocity, &trace );
}
}
else
{
// If we get *too* slow, we'll stick without ever coming to rest because
// we'll get pushed down by gravity faster than we can escape from the wall.
if ( flSpeedSqr < ( 30 * 30 ) )
{
// Reset velocities.
SetAbsVelocity( vec3_origin );
SetLocalAngularVelocity( vec3_angle );
}
else
{
SetAbsVelocity( vecAbsVelocity );
}
}
BounceSound();
#if 0
// tell the bots a grenade has bounced
CCSPlayer *player = ToCSPlayer(GetThrower());
if ( player )
{
KeyValues *event = new KeyValues( "grenade_bounce" );
event->SetInt( "userid", player->GetUserID() );
gameeventmanager->FireEventServerOnly( event );
}
#endif
}