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 CHLTVDirector::StartFixedCameraShot(int iCamera, int iTarget)
{
CBaseEntity *pCamera = m_pFixedCameras[iCamera];
Vector vCamPos = pCamera->GetAbsOrigin();
QAngle aViewAngle = pCamera->GetAbsAngles();
m_iPVSEntity = 0; // don't use camera entity, since it may not been transmitted
m_vPVSOrigin = vCamPos;
IGameEvent *shot = gameeventmanager->CreateEvent( "hltv_fixed", true );
if ( shot )
{
shot->SetInt("posx", static_cast<int>(vCamPos.x) );
shot->SetInt("posy", static_cast<int>(vCamPos.y) );
shot->SetInt("posz", static_cast<int>(vCamPos.z) );
shot->SetInt("theta", static_cast<int>(aViewAngle.x) );
shot->SetInt("phi", static_cast<int>(aViewAngle.y) );
shot->SetInt("target", iTarget );
shot->SetFloat("fov", RandomFloat(50,110) );
// send spectators the HLTV director command as a game event
m_pHLTVServer->BroadcastEvent( shot );
gameeventmanager->FreeEvent( shot );
}
}
void CHintSystem::HintMessage( const char *pMessage, float duration )
{
Assert( m_pPlayer );
#ifdef GAME_DLL
// On the server, we send it down to the queue who sends it to the client
if ( !m_pPlayer->IsNetClient() || !m_pHintMessageQueue )
return;
if ( !m_bShowHints )
return;
m_pHintMessageQueue->AddMessage( pMessage, duration );
#else
// On the client, we just send it straight to the hint hud element
if ( cl_showhelp.GetBool() )
{
IGameEvent *event = gameeventmanager->CreateEvent( "player_hintmessage" );
if ( event )
{
event->SetString( "hintmessage", pMessage );
event->SetFloat( "duration", duration );
gameeventmanager->FireEventClientSide( event );
}
}
#endif
}
void CHEGrenadeProjectile::Detonate()
{
BaseClass::Detonate();
// tell the bots an HE grenade has exploded
CMomentumPlayer *player = static_cast<CMomentumPlayer*>(GetThrower());
if ( player )
{
IGameEvent * event = gameeventmanager->CreateEvent( "hegrenade_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 );
}
}
}
void CASW_Jukebox::InputMusicStop( inputdata_t &inputdata )
{
// Tell each client to stop the music
IGameEvent * event = gameeventmanager->CreateEvent( "jukebox_stop" );
if ( event )
{
event->SetFloat( "fadeouttime", m_fFadeOutTime );
gameeventmanager->FireEvent( event );
}
}
int DotaObjective::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
if ( m_bMet )
return 0;
if ( !(inputInfo.GetDamageType() & DMG_BULLET) )
{
CHL2MP_Player * playerAttacker = ToHL2MPPlayer( inputInfo.GetAttacker() );
CreepMaker * maker = (CreepMaker*)gEntList.FindEntityByName( NULL, m_creepMakerName );
if ( !maker )
AssertMsg( false, "Objective can't find its creepmaker!\n" );
CAI_BaseNPC * guardian = (CAI_BaseNPC*)gEntList.FindEntityByName( NULL, m_guardianName );
if( guardian && guardian->IsAlive() )
{
if( playerAttacker )
ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("The guradian is alive in this lane, you can't hurt the gate.\n") );
}
else
{
m_timesHit++;
m_timesHit = min(m_timesHit, OBJECTIVE_HEALTHI); // make sure times hit never goes above the maximum times an objective can be hit!
CRecipientFilter user;
user.AddRecipientsByTeam( this->GetTeam() );
user.MakeReliable();
char szText[200];
Q_snprintf( szText, sizeof(szText), "Your ally gate is under attack from an enemy!" );
UTIL_ClientPrintFilter( user, HUD_PRINTCENTER, szText );
if( playerAttacker )
ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("Gate has %i health left.\n", OBJECTIVE_HEALTHI - m_timesHit) );
if (m_timesHit >= OBJECTIVE_HEALTHI)
{
TakeAction(DOBJ_ACTION_CLOSE);
} else {
IGameEvent *pEvent = gameeventmanager->CreateEvent( "objectivegate_attacked" );
if ( pEvent )
{
pEvent->SetString( "lane", GetLane() );
pEvent->SetInt( "team", this->GetTeamNumber() );
pEvent->SetFloat( "health", (OBJECTIVE_HEALTHF - m_timesHit)/OBJECTIVE_HEALTHF );
gameeventmanager->FireEvent( pEvent );
}
}
}
}
return 0;
}
void CFlashbangProjectile::Detonate()
{
RadiusFlash(GetAbsOrigin(), this, GetThrower(), 4, CLASS_NONE, DMG_BLAST);
EmitSound("Flashbang.Explode");
// tell the bots a flashbang grenade has exploded
CMomentumPlayer *player = static_cast<CMomentumPlayer*>(GetThrower());
if (player)
{
IGameEvent * event = gameeventmanager->CreateEvent("flashbang_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);
}
}
UTIL_Remove(this);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TeamTrainWatcher::OnDataChanged( DataUpdateType_t updateType )
{
if ( m_iOldTrainSpeedLevel != m_iTrainSpeedLevel || m_nOldNumCappers != m_nNumCappers )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_speed" );
if ( event )
{
event->SetInt( "speed", m_iTrainSpeedLevel );
event->SetInt( "players", m_nNumCappers );
gameeventmanager->FireEventClientSide( event );
}
}
if ( m_flOldProgress != m_flTotalProgress )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_progress" );
if ( event )
{
event->SetFloat( "progress", m_flTotalProgress );
if ( m_flOldProgress <= -1 )
{
event->SetBool( "reset", true );
}
gameeventmanager->FireEventClientSide( event );
}
}
if ( m_flOldRecedeTime != m_flRecedeTime )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_recede" );
if ( event )
{
event->SetFloat( "recedetime", m_flRecedeTime );
gameeventmanager->FireEventClientSide( event );
}
}
}
void CASW_Jukebox::InputMusicStart( inputdata_t &inputdata )
{
// Send each client the music start event
IGameEvent * event = gameeventmanager->CreateEvent( "jukebox_play_random" );
if ( event )
{
event->SetFloat( "fadeintime", m_fFadeInTime );
event->SetString( "defaulttrack", m_szDefaultMusic );
gameeventmanager->FireEvent( event );
// Stop stim music if it's playing
ASWGameRules()->m_fPreventStimMusicTime = 5.0f;
}
}
static void GravityChanged_Callback(IConVar *var, const char *pOldString, float)
{
ConVarRef grav(var);
UpdatePhysicsGravity(grav.GetFloat());
if (gpGlobals->mapname != NULL_STRING)
{
IGameEvent *event = gameeventmanager->CreateEvent("gravity_change");
if (event)
{
event->SetFloat("newgravity", grav.GetFloat());
gameeventmanager->FireEvent(event);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureStart( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers )
{
int iNumCappers = iNumCappingPlayers;
float flLastOwnershipChangeTime = -1.f;
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, GetControlPointMasterName() );
while( pEnt )
{
CTeamControlPointMaster *pMaster = dynamic_cast<CTeamControlPointMaster *>( pEnt );
if ( pMaster && pMaster->IsActive() )
{
flLastOwnershipChangeTime = pMaster->GetLastOwnershipChangeTime();
}
pEnt = gEntList.FindEntityByClassname( pEnt, GetControlPointMasterName() );
}
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_startcapture" );
if ( event )
{
event->SetInt( "cp", m_iPointIndex );
event->SetString( "cpname", STRING( m_iszPrintName ) );
event->SetInt( "team", m_iTeam );
event->SetInt( "capteam", iCapTeam );
event->SetFloat( "captime", gpGlobals->curtime - flLastOwnershipChangeTime );
// safety check
if ( iNumCappers > 8 )
{
iNumCappers = 8;
}
char cappers[9]; // pCappingPlayers should be max length 8
int i;
for( i = 0 ; i < iNumCappers ; i++ )
{
cappers[i] = (char)pCappingPlayers[i];
}
cappers[i] = '\0';
// pCappingPlayers is a null terminated list of player indices
event->SetString( "cappers", cappers );
event->SetInt( "priority", 7 );
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::BreakCapture( bool bNotEnoughPlayers )
{
if( m_bCapturing )
{
// Remap team to get first game team = 1
switch ( m_nCapturingTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnBreakTeam1.FireOutput( this, this );
break;
case 2:
m_OnBreakTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
m_BreakOutput.FireOutput(this,this);
m_bCapturing = false;
m_nCapturingTeam = TEAM_UNASSIGNED;
UpdateCappingTeam( TEAM_UNASSIGNED );
if ( bNotEnoughPlayers )
{
IncrementCapAttemptNumber();
}
SetCapTimeRemaining( 0 );
if( m_hPoint )
{
m_hPoint->CaptureEnd();
// The point reverted to it's previous owner.
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_capture_broken" );
if ( event )
{
event->SetInt( "cp", m_hPoint->GetPointIndex() );
event->SetString( "cpname", m_hPoint->GetName() );
event->SetFloat( "time_remaining", m_fTimeRemaining );
gameeventmanager->FireEvent( event );
}
}
SetNumCappers( 0 );
// tell all touching players to stop racking up capture points
CTeam *pTeam = GetGlobalTeam( m_nCapturingTeam );
if ( pTeam )
{
for ( int i=0;i<pTeam->GetNumPlayers();i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( pTeam->GetPlayer(i) );
if ( pPlayer && IsTouching( pPlayer ) )
{
pPlayer->StopScoringEscortPoints();
}
}
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CObjectTeleporter::TeleporterThink( void )
{
SetContextThink( &CObjectTeleporter::TeleporterThink, gpGlobals->curtime + BUILD_TELEPORTER_NEXT_THINK, TELEPORTER_THINK_CONTEXT );
// At any point, if our match is not ready, revert to IDLE
if ( IsDisabled() || IsRedeploying() || IsMatchingTeleporterReady() == false )
{
ShowDirectionArrow( false );
if ( GetState() != TELEPORTER_STATE_IDLE && !IsUpgrading() )
{
SetState( TELEPORTER_STATE_IDLE );
CObjectTeleporter *pMatch = GetMatchingTeleporter();
if ( !pMatch )
{
// The other end has been destroyed. Revert back to L1.
m_iUpgradeLevel = 1;
// We need to adjust for any damage received if we downgraded
float flHealthPercentage = GetHealth() / GetMaxHealthForCurrentLevel();
SetMaxHealth( GetMaxHealthForCurrentLevel() );
SetHealth( (int)( GetMaxHealthForCurrentLevel() * flHealthPercentage ) );
m_iUpgradeMetal = 0;
}
}
return;
}
if ( m_flMyNextThink && m_flMyNextThink > gpGlobals->curtime )
return;
// pMatch is not NULL and is not building
CObjectTeleporter *pMatch = GetMatchingTeleporter();
Assert( pMatch );
Assert( pMatch->m_iState != TELEPORTER_STATE_BUILDING );
switch ( m_iState )
{
// Teleporter is not yet active, do nothing
case TELEPORTER_STATE_BUILDING:
case TELEPORTER_STATE_UPGRADING:
ShowDirectionArrow( false );
break;
default:
case TELEPORTER_STATE_IDLE:
// Do we have a match that is active?
// Make sure both ends wait through full recharge time in case they get upgraded while recharging.
if ( IsMatchingTeleporterReady() && !IsUpgrading() && gpGlobals->curtime > m_flRechargeTime )
{
SetState( TELEPORTER_STATE_READY );
EmitSound( "Building_Teleporter.Ready" );
if ( GetObjectMode() == TELEPORTER_TYPE_ENTRANCE )
{
ShowDirectionArrow( true );
}
}
break;
case TELEPORTER_STATE_READY:
break;
case TELEPORTER_STATE_SENDING:
{
pMatch->TeleporterReceive( m_hTeleportingPlayer, 1.0 );
m_flRechargeTime = gpGlobals->curtime + ( BUILD_TELEPORTER_FADEOUT_TIME + BUILD_TELEPORTER_FADEIN_TIME + g_flTeleporterRechargeTimes[ GetUpgradeLevel() - 1] );
// change state to recharging...
SetState( TELEPORTER_STATE_RECHARGING );
}
break;
case TELEPORTER_STATE_RECEIVING:
{
// get the position we'll move the player to
Vector newPosition = GetAbsOrigin();
newPosition.z += TELEPORTER_MAXS.z + 1;
// Telefrag anyone in the way
CBaseEntity *pEnts[256];
Vector mins, maxs;
Vector expand( 4, 4, 4 );
mins = newPosition + VEC_HULL_MIN - expand;
maxs = newPosition + VEC_HULL_MAX + expand;
CTFPlayer *pTeleportingPlayer = m_hTeleportingPlayer.Get();
// move the player
if ( pTeleportingPlayer )
{
CUtlVector<CBaseEntity*> hPlayersToKill;
bool bClear = true;
// Telefrag any players in the way
int numEnts = UTIL_EntitiesInBox( pEnts, 256, mins, maxs, 0 );
if ( numEnts )
{
//Iterate through the list and check the results
for ( int i = 0; i < numEnts && bClear; i++ )
{
if ( pEnts[i] == NULL )
continue;
if ( pEnts[i] == this )
continue;
// kill players
if ( pEnts[i]->IsPlayer() )
{
if ( !pTeleportingPlayer->InSameTeam(pEnts[i]) )
{
hPlayersToKill.AddToTail( pEnts[i] );
}
continue;
}
if ( pEnts[i]->IsBaseObject() )
continue;
// Solid entities will prevent a teleport
if ( pEnts[i]->IsSolid() && pEnts[i]->ShouldCollide( pTeleportingPlayer->GetCollisionGroup(), MASK_ALL ) &&
g_pGameRules->ShouldCollide( pTeleportingPlayer->GetCollisionGroup(), pEnts[i]->GetCollisionGroup() ) )
{
// We're going to teleport into something solid. Abort & destroy this exit.
bClear = false;
}
}
}
if ( bClear )
{
// Telefrag all enemy players we've found
for ( int player = 0; player < hPlayersToKill.Count(); player++ )
{
CTakeDamageInfo info( this, pTeleportingPlayer, 1000, DMG_CRUSH, TF_DMG_TELEFRAG );
hPlayersToKill[player]->TakeDamage( info );
}
pTeleportingPlayer->Teleport( &newPosition, &(GetAbsAngles()), &vec3_origin );
// Unzoom if we are a sniper zoomed!
if ( ( pTeleportingPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SNIPER ) &&
pTeleportingPlayer->m_Shared.InCond( TF_COND_AIMING ) )
{
CTFWeaponBase *pWpn = pTeleportingPlayer->GetActiveTFWeapon();
if ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_SNIPERRIFLE )
{
CTFSniperRifle *pRifle = static_cast<CTFSniperRifle*>( pWpn );
pRifle->ToggleZoom();
}
}
pTeleportingPlayer->SetFOV( pTeleportingPlayer, 0, tf_teleporter_fov_time.GetFloat(), tf_teleporter_fov_start.GetInt() );
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pTeleportingPlayer, fadeColor, 0.25, 0.4, FFADE_IN );
}
else
{
DetonateObject();
}
}
SetState( TELEPORTER_STATE_RECEIVING_RELEASE );
m_flMyNextThink = gpGlobals->curtime + ( BUILD_TELEPORTER_FADEIN_TIME );
}
break;
case TELEPORTER_STATE_RECEIVING_RELEASE:
{
CTFPlayer *pTeleportingPlayer = m_hTeleportingPlayer.Get();
if ( pTeleportingPlayer )
{
int iTeam = GetBuilder() ? GetBuilder()->GetTeamNumber() : GetTeamNumber();
pTeleportingPlayer->m_Shared.SetTeleporterEffectColor( iTeam );
pTeleportingPlayer->TeleportEffect();
pTeleportingPlayer->m_Shared.RemoveCond( TF_COND_SELECTED_TO_TELEPORT );
if ( !m_bWasMapPlaced && GetBuilder() )
CTF_GameStats.Event_PlayerUsedTeleport( GetBuilder(), pTeleportingPlayer );
IGameEvent * event = gameeventmanager->CreateEvent( "player_teleported" );
if ( event )
{
event->SetInt( "userid", pTeleportingPlayer->GetUserID() );
if ( GetBuilder() )
event->SetInt( "builderid", GetBuilder()->GetUserID() );
Vector vecOrigin = GetAbsOrigin();
Vector vecDestinationOrigin = GetMatchingTeleporter()->GetAbsOrigin();
Vector vecDifference = Vector( vecOrigin.x - vecDestinationOrigin.x, vecOrigin.y - vecDestinationOrigin.y, vecOrigin.z - vecDestinationOrigin.z );
float flDist = sqrtf( pow( vecDifference.x, 2 ) + pow( vecDifference.y, 2 ) + pow( vecDifference.z, 2 ) );
event->SetFloat( "dist", flDist );
gameeventmanager->FireEvent( event, true );
}
// Don't thank ourselves.
if ( pTeleportingPlayer != GetBuilder() )
pTeleportingPlayer->SpeakConceptIfAllowed( MP_CONCEPT_TELEPORTED );
}
// reset the pointers to the player now that we're done teleporting
SetTeleportingPlayer( NULL );
pMatch->SetTeleportingPlayer( NULL );
SetState( TELEPORTER_STATE_RECHARGING );
m_flMyNextThink = gpGlobals->curtime + ( g_flTeleporterRechargeTimes[ GetUpgradeLevel() - 1 ] );
}
break;
case TELEPORTER_STATE_RECHARGING:
// If we are finished recharging, go active
if ( gpGlobals->curtime > m_flRechargeTime )
{
SetState( TELEPORTER_STATE_READY );
EmitSound( "Building_Teleporter.Ready" );
}
break;
}
}
void CHLTVDirector::AnalyzeCameras()
{
InitRandomOrder( m_nNumFixedCameras );
for ( int i = 0; i<m_nNumFixedCameras; i++ )
{
int iCameraIndex = s_RndOrder[i];
CBaseEntity *pCamera = m_pFixedCameras[ iCameraIndex ];
float flRank = 0.0f;
int iClosestPlayer = 0;
float flClosestPlayerDist = 100000.0f;
int nCount = 0; // Number of visible targets
Vector vDistribution; vDistribution.Init(); // distribution of targets
Vector vCamPos = pCamera->GetAbsOrigin();
for ( int j=0; j<m_nNumActivePlayers; j++ )
{
CBasePlayer *pPlayer = m_pActivePlayers[j];
Vector vPlayerPos = pPlayer->GetAbsOrigin();
float dist = VectorLength( vPlayerPos - vCamPos );
if ( dist > 1024.0f || dist < 4.0f )
continue; // too colse or far away
// check visibility
trace_t tr;
UTIL_TraceLine( vCamPos, pPlayer->GetAbsOrigin(), MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0 )
continue; // not visible for camera
nCount++;
// remember closest player
if ( dist < flClosestPlayerDist )
{
iClosestPlayer = pPlayer->entindex();
flClosestPlayerDist = dist;
}
Vector v1; AngleVectors( pPlayer->EyeAngles(), &v1 );
// check players orientation towards camera
Vector v2 = vCamPos - vPlayerPos;
VectorNormalize( v2 );
// player/camera cost function:
flRank += ( 1.0f/sqrt(dist) ) * WeightedAngle( v1, v2 );
vDistribution += v2;
}
if ( nCount > 0 )
{
// normalize distribution
flRank *= VectorLength( vDistribution ) / nCount;
}
IGameEvent *event = gameeventmanager->CreateEvent("hltv_rank_camera");
if ( event )
{
event->SetFloat("rank", flRank );
event->SetInt("index", iCameraIndex ); // index in m_pFixedCameras
event->SetInt("target", iClosestPlayer ); // ent index
gameeventmanager->FireEvent( event );
}
}
}
void CCSHLTVDirector::CreateShotFromEvent( CHLTVGameEvent *event )
{
// show event at least for 2 more seconds after it occured
const char *name = event->m_Event->GetName();
IGameEvent *shot = NULL;
if ( !Q_strcmp( "hostage_rescued", name ) ||
!Q_strcmp( "hostage_hurt", name ) ||
!Q_strcmp( "hostage_follows", name ) ||
!Q_strcmp( "hostage_killed", name ) )
{
CBaseEntity *player = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
if ( !player )
return;
// shot player as primary, hostage as secondary target
shot = gameeventmanager->CreateEvent( "hltv_chase", true );
shot->SetInt( "target1", player->entindex() );
shot->SetInt( "target2", event->m_Event->GetInt("hostage") );
shot->SetFloat( "distance", 96.0f );
shot->SetInt( "theta", 40 );
shot->SetInt( "phi", 20 );
// shot 2 seconds after event
m_nNextShotTick = min( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
m_iPVSEntity = player->entindex();
}
else if ( !Q_strcmp( "bomb_pickup", name ) ||
!Q_strcmp( "bomb_dropped", name ) ||
!Q_strcmp( "bomb_planted", name ) ||
!Q_strcmp( "bomb_defused", name ) )
{
CBaseEntity *player = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
if ( !player )
return;
shot = gameeventmanager->CreateEvent( "hltv_chase", true );
shot->SetInt( "target1", player->entindex() );
shot->SetInt( "target2", 0 );
shot->SetFloat( "distance", 64.0f );
shot->SetInt( "theta", 200 );
shot->SetInt( "phi", 10 );
// shot 2 seconds after pickup
m_nNextShotTick = min( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
m_iPVSEntity = player->entindex();
}
else
{
// let baseclass create a shot
BaseClass::CreateShotFromEvent( event );
return;
}
if ( shot )
{
m_pHLTVServer->BroadcastEvent( shot );
gameeventmanager->FreeEvent( shot );
DevMsg("DrcCmd: %s\n", name );
}
}
void CHLTVDirector::AnalyzePlayers()
{
// build list of current active players
BuildActivePlayerList();
// analyzes every active player
InitRandomOrder( m_nNumActivePlayers );
for ( int i = 0; i<m_nNumActivePlayers; i++ )
{
int iPlayerIndex = s_RndOrder[i];
CBasePlayer *pPlayer = m_pActivePlayers[ iPlayerIndex ];
float flRank = 0.0f;
int iBestFacingPlayer = 0;
float flBestFacingPlayer = 0.0f;
int nCount = 0; // Number of visible targets
Vector vDistribution; vDistribution.Init(); // distribution of targets
Vector vCamPos = pPlayer->GetAbsOrigin();
Vector v1; AngleVectors( pPlayer->EyeAngles(), &v1 );
v1 *= -1; // inverted
for ( int j=0; j<m_nNumActivePlayers; j++ )
{
if ( iPlayerIndex == j )
continue; // don't check against itself
CBasePlayer *pOtherPlayer = m_pActivePlayers[j];
Vector vPlayerPos = pOtherPlayer->GetAbsOrigin();
float dist = VectorLength( vPlayerPos - vCamPos );
if ( dist > 1024.0f || dist < 4.0f )
continue; // too close or far away
// check visibility
trace_t tr;
UTIL_TraceLine( vCamPos, pOtherPlayer->GetAbsOrigin(), MASK_SOLID, pOtherPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0 )
continue; // not visible for camera
nCount++;
// check players orientation towards camera
Vector v2; AngleVectors( pOtherPlayer->EyeAngles(), &v2 );
float facing = WeightedAngle( v1, v2 );
// remember closest player
if ( facing > flBestFacingPlayer )
{
iBestFacingPlayer = pOtherPlayer->entindex();
flBestFacingPlayer = facing;
}
// player/camera cost function:
flRank += ( 1.0f/sqrt(dist) ) * facing;
vDistribution += v2;
}
if ( nCount > 0 )
{
float flDistribution = VectorLength( vDistribution ) / nCount; // normalize distribution
flRank *= flDistribution;
}
IGameEvent *event = gameeventmanager->CreateEvent("hltv_rank_entity");
if ( event )
{
event->SetInt("index", pPlayer->entindex() );
event->SetFloat("rank", flRank );
event->SetInt("target", iBestFacingPlayer ); // ent index
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TeamTrainWatcher::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
if ( m_iOldTrainSpeedLevel != m_iTrainSpeedLevel || m_nOldNumCappers != m_nNumCappers )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_speed" );
if ( event )
{
event->SetInt( "team", GetTeamNumber() );
event->SetInt( "speed", m_iTrainSpeedLevel );
event->SetInt( "players", m_nNumCappers );
gameeventmanager->FireEventClientSide( event );
}
}
if ( m_flOldProgress != m_flTotalProgress )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_progress" );
if ( event )
{
event->SetInt( "team", GetTeamNumber() );
event->SetFloat( "progress", m_flTotalProgress );
if ( m_flOldProgress <= -1 )
{
event->SetBool( "reset", true );
}
gameeventmanager->FireEventClientSide( event );
}
// check to see if the train is now on a hill
if ( ObjectiveResource() )
{
int nNumHills = ObjectiveResource()->GetNumNodeHillData( GetTeamNumber() );
if ( nNumHills > 0 )
{
float flStart = 0, flEnd = 0;
for ( int i = 0 ; i < nNumHills ; i++ )
{
ObjectiveResource()->GetHillData( GetTeamNumber(), i, flStart, flEnd );
bool state = ( m_flTotalProgress >= flStart && m_flTotalProgress <= flEnd );
ObjectiveResource()->SetTrainOnHill( GetTeamNumber(), i, state );
}
}
}
}
if ( m_flOldRecedeTime != m_flRecedeTime )
{
IGameEvent *event = gameeventmanager->CreateEvent( "escort_recede" );
if ( event )
{
event->SetInt( "team", GetTeamNumber() );
event->SetFloat( "recedetime", m_flRecedeTime );
gameeventmanager->FireEventClientSide( event );
}
}
#ifdef GLOWS_ENABLE
if ( m_hOldGlowEnt != m_hGlowEnt )
{
UpdateGlowEffect();
}
#endif // GLOWS_ENABLE
}
//-----------------------------------------------------------------------------
// Purpose: Input handler for showing the message and/or playing the sound.
//-----------------------------------------------------------------------------
void CEnvInstructorHint::InputShowHint( inputdata_t &inputdata )
{
static int s_InstructorServerHintEventCreate = 0;
IGameEvent * event = gameeventmanager->CreateEvent( "instructor_server_hint_create", false, &s_InstructorServerHintEventCreate );
if ( event )
{
CBaseEntity *pTargetEntity = gEntList.FindEntityByName( NULL, m_iszHintTargetEntity );
if( pTargetEntity == NULL && !m_bStatic )
pTargetEntity = inputdata.pActivator;
if( pTargetEntity == NULL )
pTargetEntity = GetWorldEntity();
char szColorString[128];
Q_snprintf( szColorString, sizeof( szColorString ), "%.3d,%.3d,%.3d", m_Color.r, m_Color.g, m_Color.b );
int iFlags = 0;
iFlags |= (m_iPulseOption == 0) ? 0 : (LOCATOR_ICON_FX_PULSE_SLOW << (m_iPulseOption - 1));
iFlags |= (m_iAlphaOption == 0) ? 0 : (LOCATOR_ICON_FX_ALPHA_SLOW << (m_iAlphaOption - 1));
iFlags |= (m_iShakeOption == 0) ? 0 : (LOCATOR_ICON_FX_SHAKE_NARROW << (m_iShakeOption - 1));
iFlags |= m_bStatic ? LOCATOR_ICON_FX_STATIC : 0;
CBasePlayer *pActivator = NULL;
bool bFilterByActivator = m_bLocalPlayerOnly;
#ifdef INFESTED_DLL
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>( inputdata.pActivator );
if ( pMarine )
{
pActivator = pMarine->GetCommander();
}
#else
if ( inputdata.value.StringID() != NULL_STRING )
{
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, inputdata.value.String() );
pActivator = dynamic_cast<CBasePlayer*>( pTarget );
if ( pActivator )
{
bFilterByActivator = true;
}
}
else
{
if ( GameRules()->IsMultiplayer() == false )
{
pActivator = UTIL_GetLocalPlayer();
}
else
{
Warning( "Failed to play server side instructor hint: no player specified for hint\n" );
Assert( 0 );
}
}
#endif
const char *pActivatorCaption = m_iszActivatorCaption.ToCStr();
if ( !pActivatorCaption || pActivatorCaption[ 0 ] == '\0' )
{
pActivatorCaption = m_iszCaption.ToCStr();
}
event->SetString( "hint_name", GetEntityName().ToCStr() );
event->SetString( "hint_replace_key", m_iszReplace_Key.ToCStr() );
event->SetInt( "hint_target", pTargetEntity->entindex() );
event->SetInt( "hint_activator_userid", ( pActivator ? pActivator->GetUserID() : 0 ) );
event->SetInt( "hint_timeout", m_iTimeout );
event->SetString( "hint_icon_onscreen", m_iszIcon_Onscreen.ToCStr() );
event->SetString( "hint_icon_offscreen", m_iszIcon_Offscreen.ToCStr() );
event->SetString( "hint_caption", m_iszCaption.ToCStr() );
event->SetString( "hint_activator_caption", pActivatorCaption );
event->SetString( "hint_color", szColorString );
event->SetFloat( "hint_icon_offset", m_fIconOffset );
event->SetFloat( "hint_range", m_fRange );
event->SetInt( "hint_flags", iFlags );
event->SetString( "hint_binding", m_iszBinding.ToCStr() );
event->SetBool( "hint_allow_nodraw_target", m_bAllowNoDrawTarget );
event->SetBool( "hint_nooffscreen", m_bNoOffscreen );
event->SetBool( "hint_forcecaption", m_bForceCaption );
event->SetBool( "hint_local_player_only", bFilterByActivator );
gameeventmanager->FireEvent( event );
}
}
void CHLTVDirector::CreateShotFromEvent( CGameEvent *event )
{
// show event at least for 2 more seconds after it occured
const char *name = event->m_Event->GetName();
IGameEvent *shot = NULL;
bool bPlayerHurt = Q_strcmp( "player_hurt", name ) == 0;
bool bPlayerKilled = Q_strcmp( "player_death", name ) == 0;
bool bRoundStart = Q_strcmp( "round_start", name ) == 0;
bool bRoundEnd = Q_strcmp( "round_end", name ) == 0;
if ( bPlayerHurt || bPlayerKilled )
{
CBaseEntity *victim = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
CBaseEntity *attacker = UTIL_PlayerByUserId( event->m_Event->GetInt("attacker") );
if ( !victim )
return;
if ( attacker == victim || attacker == NULL )
{
// player killed self or by WORLD
shot = gameeventmanager->CreateEvent( "hltv_chase", true );
shot->SetInt( "target1", victim->entindex() );
shot->SetInt( "target2", 0 );
shot->SetInt( "theta", 0 ); // view from behind over head
shot->SetInt( "phi", 20 ); // from above
shot->SetFloat( "distance", 96.0f );
}
else // attacker != NULL
{
// check if we would show it from ineye view
bool bInEye = (bPlayerKilled && RandomFloat(0,1) > 0.33) || (bPlayerHurt && RandomFloat(0,1) > 0.66);
// if we show ineye view, show it more likely from killer
if ( RandomFloat(0,1) > (bInEye?0.3f:0.7f) )
{
swap( attacker, victim );
}
// hurting a victim is shown as chase more often
shot = gameeventmanager->CreateEvent( "hltv_chase", true );
shot->SetInt( "target1", victim->entindex() );
shot->SetInt( "target2", attacker->entindex() );
// view from behind over head
shot->SetInt( "phi", -20 ); // lower view point, dramatic
shot->SetFloat( "distance", 96.0f );
shot->SetInt( "ineye", bInEye?1:0 );
// view over shoulder, randomly left or right
if ( RandomFloat(0,1) > 0.5 )
{
shot->SetInt( "theta", 30 ); // swing left
}
else
{
shot->SetInt( "theta", -30 ); // swing right
}
}
// shot 2 seconds after death/hurt
m_nNextShotTick = MIN( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
m_iPVSEntity = victim->entindex();
}
else if ( bRoundStart || bRoundEnd )
{
StartBestFixedCameraShot( false );
}
else
{
DevMsg( "No known TV shot for event %s\n", name );
}
if ( shot )
{
m_pHLTVServer->BroadcastEvent( shot );
gameeventmanager->FreeEvent( shot );
}
}