void SendHelp( CGEPlayer *pPlayer )
{
if ( !pPlayer || pPlayer->IsBotPlayer() )
return;
CSingleUserRecipientFilter filter( pPlayer );
filter.MakeReliable();
// Send overall scenario help information
UserMessageBegin( filter, "ScenarioHelp" );
WRITE_STRING( GEGameplay()->GetScenario()->GetIdent() );
WRITE_STRING( m_szHelpTagLine );
WRITE_STRING( m_szHelpWebsite );
WRITE_BYTE( m_iDefaultPane );
MessageEnd();
// Output each help item from each pane
FOR_EACH_MAP( m_vHelpPanes, idx )
{
sHelpPane *pPane = m_vHelpPanes[idx];
if ( pPane->nHelpString == INVALID_STRING_INDEX )
{
bool save = engine->LockNetworkStringTables( false );
pPane->nHelpString = g_pStringTableGameplay->AddString( true, pPane->szHelpString );
engine->LockNetworkStringTables( save );
}
UserMessageBegin( filter, "ScenarioHelpPane" );
WRITE_BYTE( m_vHelpPanes.Key(idx) );
WRITE_STRING( pPane->szHelpId );
WRITE_SHORT( pPane->nHelpString );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Input handler for showing the message and/or playing the sound.
//-----------------------------------------------------------------------------
void CEnvHudHint::InputShowHudHint( inputdata_t &inputdata )
{
if ( AllPlayers() )
{
CReliableBroadcastRecipientFilter user;
UserMessageBegin( user, "KeyHintText" );
WRITE_BYTE( 1 ); // one message
WRITE_STRING( STRING(m_iszMessage) );
MessageEnd();
}
else
{
CBaseEntity *pPlayer = NULL;
if ( inputdata.pActivator && inputdata.pActivator->IsPlayer() )
{
pPlayer = inputdata.pActivator;
}
else
{
pPlayer = UTIL_GetNearestPlayer(GetAbsOrigin());
}
if ( !pPlayer || !pPlayer->IsNetClient() )
return;
CSingleUserRecipientFilter user( (CBasePlayer *)pPlayer );
user.MakeReliable();
UserMessageBegin( user, "KeyHintText" );
WRITE_BYTE( 1 ); // one message
WRITE_STRING( STRING(m_iszMessage) );
MessageEnd();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvHudHint::InputHideHudHint( inputdata_t &inputdata )
{
CBaseEntity *pPlayer = NULL;
if ( inputdata.pActivator && inputdata.pActivator->IsPlayer() )
{
pPlayer = inputdata.pActivator;
}
else
{
#ifdef HL2SB
pPlayer = UTIL_GetNearestPlayer( GetAbsOrigin() );
#else
pPlayer = UTIL_GetLocalPlayer();
#endif
}
if ( pPlayer )
{
if ( !pPlayer || !pPlayer->IsNetClient() )
return;
CSingleUserRecipientFilter user( (CBasePlayer *)pPlayer );
user.MakeReliable();
UserMessageBegin( user, "KeyHintText" );
WRITE_BYTE( 1 ); // one message
WRITE_STRING( STRING(NULL_STRING) );
MessageEnd();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *player -
// effect -
// params -
//-----------------------------------------------------------------------------
void CForceFeedback::StartEffect( CBasePlayer *player, FORCEFEEDBACK_t effect, const FFBaseParams_t& params )
{
if ( !player )
{
return;
}
CSingleUserRecipientFilter user( player );
UserMessageBegin( user, "ForceFeedback" );
WRITE_BYTE( FFMSG_START ); // Reset effects
WRITE_BYTE( effect );
// encode direction as a byte
int dir = (int)( ( params.m_flDirection / 360.0f ) * 255.0f );
WRITE_BYTE( dir );
// encode duration as a signed int
int duration = (int)params.m_flDuration * 1000.0f;
WRITE_LONG( duration );
// encode gain as a byte
byte gain = (byte)clamp( params.m_flGain * 255.0f, 0.0f, 255.0f );
WRITE_BYTE( gain );
WRITE_BYTE( params.m_nPriority );
WRITE_BYTE( params.m_bSolo ? 1 : 0 );
MessageEnd();
}
void HapticMsg_MeleeContact(CBasePlayer* pPlayer)
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user,"HapMeleeContact");
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGrubNugget::MyTouch( CBasePlayer *pPlayer )
{
//int nHealthToGive = sk_grubnugget_health.GetFloat() * m_nDenomination;
int nHealthToGive;
switch (m_nDenomination)
{
case NUGGET_SMALL:
nHealthToGive = sk_grubnugget_health_small.GetInt();
break;
case NUGGET_LARGE:
nHealthToGive = sk_grubnugget_health_large.GetInt();
break;
default:
nHealthToGive = sk_grubnugget_health_medium.GetInt();
}
// Attempt to give the player health
if ( pPlayer->TakeHealth( nHealthToGive, DMG_GENERIC ) == 0 )
return false;
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
CPASAttenuationFilter filter( pPlayer, "GrubNugget.Touch" );
EmitSound( filter, pPlayer->entindex(), "GrubNugget.Touch" );
UTIL_Remove( this );
return true;
}
void CLoot::SendLoot(CIN_Player *pPlayer)
{
// No es un jugador.
if ( !pPlayer )
return;
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
// Loot!!
for ( int i = 1; i < LootItems.Count(); i++ )
{
// Este slot no tiene ningún objeto.
if ( LootItems[i] == 0 || !LootItems[i] )
continue;
// Le enviamos la lista de objetos en este Loot.
UserMessageBegin(user, "Loot");
WRITE_SHORT(entindex()); // Se lo enviamos en cada objeto y nos evitamos hacer otro UserMessage
WRITE_SHORT(i); // ID en el array.
WRITE_SHORT(LootItems[i]); // ID del objeto.
MessageEnd();
}
// Actualizamos el panel de Loot.
pPlayer->ExecCommand("cl_update_loot 1");
}
//-----------------------------------------------------------------------------
// Purpose: Touch function
//-----------------------------------------------------------------------------
bool CTFBaseDMPowerup::MyTouch( CBasePlayer *pPlayer )
{
bool bSuccess = false;
CTFPlayer *pTFPlayer = dynamic_cast<CTFPlayer*>( pPlayer );
if ( pTFPlayer && ValidTouch( pPlayer ) )
{
// Add the condition and duration from derived classes
pTFPlayer->m_Shared.AddCond( GetCondition(), GetEffectDuration() );
// Give full health
SetHealth( GetMaxHealth() );
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
pPlayer->EmitSound( STRING( m_strPickupSound ) );
bSuccess = true;
}
return bSuccess;
}
void FullClientUpdatePyNetworkClsByFilter( IRecipientFilter &filter )
{
if( !SrcPySystem()->IsPythonRunning() )
return;
Assert(g_SetupNetworkTablesOnHold == false);
// Send messages about each server class
PyServerClass *p = g_pPyServerClassHead;
while( p )
{
if( p->m_bFree ) {
p = p->m_pPyNext;
continue;
}
// Send message
UserMessageBegin(filter, "PyNetworkCls");
WRITE_BYTE(p->m_iType);
WRITE_STRING(p->m_pNetworkName);
WRITE_STRING(p->m_pNetworkedClass->m_pNetworkName);
MessageEnd();
p = p->m_pPyNext;
}
}
//=========================================================
// Deathnotice.
//=========================================================
void CTeamplayRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
if ( m_DisableDeathMessages )
return;
CBaseEntity *pKiller = info.GetAttacker();
if ( pVictim && pKiller && pKiller->GetFlags() & FL_CLIENT )
{
CBasePlayer *pk = (CBasePlayer*)pKiller;
if ( pk )
{
if ( (pk != pVictim) && (PlayerRelationship( pVictim, pk ) == GR_TEAMMATE) )
{
CRelieableBroadcastRecipientFilter filter;
// TODO we are sending this message twice ?? in BaseClass::DeathNotice too.
UserMessageBegin( filter, "DeathMsg" );
WRITE_BYTE( pKiller->entindex() ); // the killer
WRITE_BYTE( pVictim->entindex() ); // the victim
WRITE_STRING( "teammate" ); // flag this as a teammate kill
MessageEnd();
return;
}
}
}
BaseClass::DeathNotice( pVictim, info );
}
//-----------------------------------------------------------------------------
// Purpose: If we're picked up by another pla`yer, give resources to that team
//-----------------------------------------------------------------------------
void CResourceChunk::ChunkTouch( CBaseEntity *pOther )
{
if ( pOther->IsPlayer() || pOther->GetServerVehicle() )
{
// Give the team the resources
int iAmountPerPlayer = ((CTFTeam *)pOther->GetTeam())->AddTeamResources( GetResourceValue(), TF_PLAYER_STAT_RESOURCES_ACQUIRED_FROM_CHUNKS );
TFStats()->IncrementTeamStat( pOther->GetTeamNumber(), TF_TEAM_STAT_RESOURCE_CHUNKS_COLLECTED, GetResourceValue() );
pOther->EmitSound( "ResourceChunk.Pickup" );
// Tell the player
CSingleUserRecipientFilter user( (CBasePlayer*)pOther );
UserMessageBegin( user, "PickupRes" );
WRITE_BYTE( iAmountPerPlayer );
MessageEnd();
// Tell our zone to remove this chunk from it's list
if ( m_hZone )
{
m_hZone->RemoveChunk( this, false );
m_hZone = NULL;
}
// Remove this chunk
SetTouch( NULL );
UTIL_Remove( this );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWarsWeapon::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
#if 0
const char* tracer = "ASWUTracer";
//if (GetActiveASWWeapon())
// tracer = GetActiveASWWeapon()->GetUTracerType();
#ifdef CLIENT_DLL
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_hEntity = this;
//data.m_nMaterial = m_iDamageAttributeEffects;
DispatchEffect( tracer, data );
#else
CRecipientFilter filter;
filter.AddAllPlayers();
if (gpGlobals->maxClients > 1 && GetCommander())
{
filter.RemoveRecipient(GetCommander());
}
UserMessageBegin( filter, tracer );
WRITE_SHORT( entindex() );
WRITE_FLOAT( tr.endpos.x );
WRITE_FLOAT( tr.endpos.y );
WRITE_FLOAT( tr.endpos.z );
//WRITE_SHORT( m_iDamageAttributeEffects );
MessageEnd();
#endif
#else
#ifdef CLIENT_DLL
ASWUTracer( GetOwner(), tr.endpos, m_vTracerColor );
#endif
#endif // 0
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameStats::SendStatsToPlayer( CTFPlayer *pPlayer, int iMsgType )
{
PlayerStats_t &stats = m_aPlayerStats[pPlayer->entindex()];
int iSendBits = stats.iStatsChangedBits;
switch ( iMsgType )
{
case STATMSG_PLAYERDEATH:
case STATMSG_PLAYERRESPAWN:
break;
case STATMSG_RESET:
// this is a reset message, no need to send any stat values with it
iSendBits = 0;
break;
case STATMSG_UPDATE:
// if nothing changed, no need to send a message
if ( iSendBits == 0 )
return;
break;
case STATMSG_PLAYERSPAWN:
// do a full update at player spawn
for ( int i = TFSTAT_FIRST; i < TFSTAT_MAX; i++ )
{
iSendBits |= ( 1 << ( i - TFSTAT_FIRST ) );
}
break;
default:
Assert( false );
}
int iStat = TFSTAT_FIRST;
CSingleUserRecipientFilter filter( pPlayer );
UserMessageBegin( filter, "PlayerStatsUpdate" );
WRITE_BYTE( pPlayer->GetPlayerClass()->GetClassIndex() ); // write the class
WRITE_BYTE( iMsgType ); // type of message
WRITE_LONG( iSendBits ); // write the bit mask of which stats follow in the message
// write all the stats specified in the bit mask
while ( iSendBits > 0 )
{
if ( iSendBits & 1 )
{
WRITE_LONG( stats.statsCurrentRound.m_iStat[iStat] );
}
iSendBits >>= 1;
iStat ++;
}
MessageEnd();
stats.iStatsChangedBits = 0;
stats.m_flTimeLastSend = gpGlobals->curtime;
if ( iMsgType == STATMSG_PLAYERDEATH )
{
// max sentry kills is different from other stats, it is a max value and can span player lives. Reset it to zero so
// it doesn't get re-reported in the next life unless the sentry stays alive and gets more kills.
pPlayer->SetMaxSentryKills( 0 );
Event_MaxSentryKills( pPlayer, 0 );
}
}
//=========================================================
// Se activa cuando el usuario toca el objeto.
//=========================================================
bool CSoda::MyTouch(CBasePlayer *pPlayer)
{
// En modo Survival esto solo se puede usar desde el inventario.
if ( g_pGameRules->IsMultiplayer() )
return false;
CIN_Player *pInPlayer = GetInPlayer(pPlayer);
if ( !pPlayer )
return false;
if ( pInPlayer->TakeThirst(sk_soda.GetFloat()) != 0 )
{
CSingleUserRecipientFilter user(pInPlayer);
user.MakeReliable();
UserMessageBegin(user, "ItemPickup");
WRITE_STRING(GetClassname());
MessageEnd();
CPASAttenuationFilter filter(pInPlayer, "Player.Drink");
EmitSound(filter, entindex(), "Player.Drink");
if ( g_pGameRules->ItemShouldRespawn(this) )
Respawn();
else
Remove();
return true;
}
return false;
}
void CTimer::DispatchResetMessage()
{
CSingleUserRecipientFilter user(UTIL_GetLocalPlayer());
user.MakeReliable();
UserMessageBegin(user, "Timer_Reset");
MessageEnd();
}
//=========================================================
// Se activa cuando el usuario toca el objeto.
//=========================================================
bool CHealthKit::MyTouch(CBasePlayer *pPlayer)
{
// En modo Survival esto solo se puede usar desde el inventario.
if ( InGameRules()->IsSurvival() )
return false;
if ( pPlayer->TakeHealth(sk_healthkit.GetFloat(), DMG_GENERIC) )
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user, "ItemPickup");
WRITE_STRING(GetClassname());
MessageEnd();
CPASAttenuationFilter filter(pPlayer, "HealthKit.Touch");
EmitSound(filter, pPlayer->entindex(), "HealthKit.Touch");
if ( g_pGameRules->ItemShouldRespawn(this) )
Respawn();
else
Remove();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// Output :
//-----------------------------------------------------------------------------
bool CHealthKit::MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->TakeHealth( sk_healthkit.GetFloat(), DMG_GENERIC ) )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
CPASAttenuationFilter filter( pPlayer, "HealthKit.Touch" );
EmitSound( filter, pPlayer->entindex(), "HealthKit.Touch" );
if ( g_pGameRules->ItemShouldRespawn( this ) )
{
Respawn();
}
else
{
UTIL_Remove(this);
}
return true;
}
return false;
}
void HapticMsg_SetDrag(CBasePlayer* pPlayer, float drag)
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "HapSetDrag" );
WRITE_FLOAT(drag);
MessageEnd();
}
void CASW_Intro_Control::InputShowCredits( inputdata_t &inputdata )
{
m_bShownCredits = true;
CReliableBroadcastRecipientFilter filter;
UserMessageBegin( filter, "LaunchCredits" );
MessageEnd();
}
void CTeamplayRules :: UpdateGameMode( CBasePlayer *pPlayer )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "GameMode" );
WRITE_BYTE( 1 ); // game mode teamplay
MessageEnd();
}
void CWeaponCombatCannon::ResetFreezing( bool finished )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( m_pFreezingBlock )
{
if ( !finished )
{
if ( m_pFreezingBlock->IsFrozen() && m_bTempFreeze )
{
if ( pPlayer )
{
DevMsg( "Unfreezing temp freeze\n" );
m_pFreezingBlock->UnFreeze( pPlayer );
}
else
{
DevMsg( "Unfreezing temp freeze\n" );
m_pFreezingBlock->UnFreeze( NULL, FROZEN_BY_WORLD );
}
}
}
m_pFreezingBlock->SetCurrentFreezer( NULL );
}
// lolu, wut?! - Hekar
m_flLastFreeze = -1.0f;
m_flLastTime = -1.0f;
m_flFreezeRatio = 0.0f;
m_flFreezeTime = 0.0f;
m_flElapsedTime = 0.0f;
m_bTempFreeze = false;
m_bFreezing = false;
m_pFreezingBlock = NULL;
if ( pPlayer )
{
m_nReloadDebounce |= pPlayer->m_nButtons;
}
if ( GetOwner() )
{
CSingleUserRecipientFilter user( ToBasePlayer( GetOwner() ) );
user.MakeReliable();
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 0 ); // Turn off the HUD
WRITE_LONG( 0 );
WRITE_FLOAT( 0 );
MessageEnd();
}
StopFreezeSound();
m_pLastBlock = NULL;
}
void HapticMsg_SendWeaponAnim( CBasePlayer *pPlayer, int iActivity )
{
//Send the haptics message
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "SPHapWeapEvent" );
WRITE_LONG(iActivity);
MessageEnd();
}
void CTimer::DispatchStateMessage()
{
CSingleUserRecipientFilter user(UTIL_GetLocalPlayer());
user.MakeReliable();
UserMessageBegin(user, "Timer_State");
WRITE_BOOL(m_bIsRunning);
WRITE_LONG(m_iStartTick);
MessageEnd();
}
void CBaseMultiplayerPlayer::AwardAchievement( int iAchievement )
{
Assert( iAchievement >= 0 && iAchievement < 0xFFFF ); // must fit in short
CSingleUserRecipientFilter filter( this );
UserMessageBegin( filter, "AchievementEvent" );
WRITE_SHORT( iAchievement );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Update a client who joined during the middle of an act
//-----------------------------------------------------------------------------
void CInfoAct::UpdateClient( CBaseTFPlayer *pPlayer )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ActBegin" );
WRITE_BYTE( (byte)m_iActNumber );
WRITE_FLOAT( m_flActStartedAt );
MessageEnd();
}
void CBaseMultiplayerPlayer::AwardAchievement( int iAchievement )
{
Assert( iAchievement >= 0 && iAchievement < 255 ); // must fit in byte
CSingleUserRecipientFilter filter( this );
UserMessageBegin( filter, "AchievementEvent" );
WRITE_BYTE( iAchievement );
MessageEnd();
}
void CCredits::InputRollCredits( inputdata_t &inputdata )
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "CreditsMsg" );
WRITE_BYTE( 2 );
MessageEnd();
}
void CCredits::InputShowLogo( inputdata_t &inputdata )
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
if ( m_flLogoLength )
{
UserMessageBegin( user, "LogoTimeMsg" );
WRITE_FLOAT( m_flLogoLength );
MessageEnd();
}
else
{
UserMessageBegin( user, "CreditsMsg" );
WRITE_BYTE( 1 );
MessageEnd();
}
}
void HapticMsg_SetConstantForce(CBasePlayer* pPlayer, Vector force)
{
// portal does not network this.
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "HapSetConst" );
WRITE_SHORT(force.x);
WRITE_SHORT(force.y);
WRITE_SHORT(force.z);
MessageEnd();
}
void HapticMsg_Punch(CBasePlayer* pPlayer, float x, float y, float z)
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user,"HapPunch");
WRITE_FLOAT(x);
WRITE_FLOAT(y);
WRITE_FLOAT(z);
MessageEnd();
}
