/* <2464e8> ../cstrike/dlls/wpn_shared/wpn_c4.cpp:152 */
void CC4::__MAKE_VHOOK(PrimaryAttack)(void)
{
BOOL PlaceBomb;
int inBombZone, onGround;
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
{
return;
}
inBombZone = (m_pPlayer->m_signals.GetState() & SIGNAL_BOMB) == SIGNAL_BOMB;
onGround = (m_pPlayer->pev->flags & FL_ONGROUND) == FL_ONGROUND;
PlaceBomb = (onGround && inBombZone);
if (!m_bStartedArming)
{
if (!inBombZone)
{
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_At_Bomb_Spot");
m_flNextPrimaryAttack = GetNextAttackDelay(1.0);
return;
}
if (!onGround)
{
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground");
m_flNextPrimaryAttack = GetNextAttackDelay(1);
return;
}
m_bStartedArming = true;
m_bBombPlacedAnimation = false;
m_fArmedTime = gpGlobals->time + C4_ARMING_ON_TIME;
SendWeaponAnim(C4_ARM, UseDecrement() != FALSE);
SET_CLIENT_MAXSPEED(m_pPlayer->edict(), 1.0);
m_pPlayer->SetAnimation(PLAYER_ATTACK1);
m_pPlayer->SetProgressBarTime(C4_ARMING_ON_TIME);
}
else
{
if (PlaceBomb)
{
CBaseEntity *pEntity = NULL;
CBasePlayer *pTempPlayer = NULL;
if (m_fArmedTime <= gpGlobals->time)
{
if (m_bStartedArming)
{
m_bStartedArming = false;
m_fArmedTime = 0;
Broadcast("BOMBPL");
m_pPlayer->m_bHasC4 = false;
if (pev->speed != 0 && g_pGameRules != NULL)
{
g_pGameRules->m_iC4Timer = (int)pev->speed;
}
CGrenade *pBomb = CGrenade::ShootSatchelCharge(m_pPlayer->pev, m_pPlayer->pev->origin, Vector(0, 0, 0));
MESSAGE_BEGIN(MSG_SPEC, SVC_DIRECTOR);
WRITE_BYTE(9);
WRITE_BYTE(DRC_CMD_EVENT);
WRITE_SHORT(m_pPlayer->entindex());
WRITE_SHORT(0);
WRITE_LONG(DRC_FLAG_FACEPLAYER | 11);
MESSAGE_END();
MESSAGE_BEGIN(MSG_ALL, gmsgBombDrop);
WRITE_COORD(pBomb->pev->origin.x);
WRITE_COORD(pBomb->pev->origin.y);
WRITE_COORD(pBomb->pev->origin.z);
WRITE_BYTE(1);
MESSAGE_END();
UTIL_ClientPrintAll(HUD_PRINTCENTER, "#Bomb_Planted");
TheBots->OnEvent(EVENT_BOMB_PLANTED, m_pPlayer, pBomb);
if (g_pGameRules->IsCareer() && !m_pPlayer->IsBot())
{
TheCareerTasks->HandleEvent(EVENT_BOMB_PLANTED, m_pPlayer);
}
UTIL_LogPrintf
(
"\"%s<%i><%s><TERRORIST>\" triggered \"Planted_The_Bomb\"\n",
STRING(m_pPlayer->pev->netname),
GETPLAYERUSERID(m_pPlayer->edict()),
GETPLAYERAUTHID(m_pPlayer->edict())
);
g_pGameRules->m_bBombDropped = FALSE;
EMIT_SOUND(edict(), CHAN_WEAPON, "weapons/c4_plant.wav", VOL_NORM, ATTN_NORM);
m_pPlayer->pev->body = 0;
m_pPlayer->ResetMaxSpeed();
m_pPlayer->SetBombIcon(FALSE);
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
if (!m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
{
RetireWeapon();
return;
}
}
}
else
{
if (m_fArmedTime - 0.75 <= gpGlobals->time && !m_bBombPlacedAnimation)
{
m_bBombPlacedAnimation = true;
SendWeaponAnim(C4_DROP, UseDecrement() != FALSE);
m_pPlayer->SetAnimation(PLAYER_HOLDBOMB);
}
}
}
else
{
if (inBombZone)
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground");
else
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Arming_Cancelled");
m_bStartedArming = false;
m_flNextPrimaryAttack = GetNextAttackDelay(1.5);
m_pPlayer->ResetMaxSpeed();
m_pPlayer->SetProgressBarTime(0);
m_pPlayer->SetAnimation(PLAYER_HOLDBOMB);
SendWeaponAnim(m_bBombPlacedAnimation ? C4_DRAW : C4_IDLE1, UseDecrement() != FALSE);
return;
}
}
m_flNextPrimaryAttack = GetNextAttackDelay(0.3);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + RANDOM_FLOAT(10, 15);
}
void m68k_write_memory_32(unsigned int address, unsigned int value)
{
WRITE_LONG(g_68kmem, address, value);
}
/*
=========================================================
UpdateClientData
resends any changed player HUD info to the client.
Called every frame by PlayerPreThink
Also called at start of demo recording and playback by
ForceClientDllUpdate to ensure the demo gets messages
reflecting all of the HUD state info.
=========================================================
*/
void CBasePlayer::UpdateClientData()
{
if( m_bNeedsNewConnectTime )
{
m_bNeedsNewConnectTime = false;
m_flConnectTime = gpGlobals->time;
}
if( !m_bWeaponValidationReceived && m_flConnectTime + WEAPON_VALIDATION_GRACE_TIME < gpGlobals->time )
{
//If the client didn't send the message in time, drop the client. - Solokiller
//Set it to true to avoid running this multiple times. - Solokiller
m_bWeaponValidationReceived = true;
UTIL_LogPrintf( "Player \"%s\" didn't send weapon validation in time, disconnecting\n", GetNetName() );
if( !IS_DEDICATED_SERVER() )
{
//Listen server hosts usually don't have logging enabled, so echo to console unconditionally for them. - Solokiller
UTIL_ServerPrintf( "Player \"%s\" didn't send weapon validation in time, disconnecting\n", GetNetName() );
}
if( IS_DEDICATED_SERVER() || entindex() != 1 )
{
SERVER_COMMAND( UTIL_VarArgs( "kick \"%s\" \"No weapon validation received\"\n", GetNetName() ) );
}
else
{
//The local player can't be kicked, so terminate the session instead - Solokiller
CLIENT_COMMAND( edict(), "disconnect\n" );
}
}
//The engine will not call ClientPutInServer after transitions, so we'll have to catch this event every map change. - Solokiller
if( !m_bSentInitData )
{
m_bSentInitData = true;
//Update Hud colors. - Solokiller
CMap::GetInstance()->SendHudColors( this, true );
}
if( m_fInitHUD )
{
m_fInitHUD = false;
gInitHUD = false;
MESSAGE_BEGIN( MSG_ONE, gmsgResetHUD, NULL, this );
WRITE_BYTE( 0 );
MESSAGE_END();
if( !m_fGameHUDInitialized )
{
MESSAGE_BEGIN( MSG_ONE, gmsgInitHUD, NULL, this );
MESSAGE_END();
g_pGameRules->InitHUD( this );
m_fGameHUDInitialized = true;
m_iObserverLastMode = OBS_ROAMING;
if( g_pGameRules->IsMultiplayer() )
{
FireTargets( "game_playerjoin", this, this, USE_TOGGLE, 0 );
}
}
FireTargets( "game_playerspawn", this, this, USE_TOGGLE, 0 );
InitStatusBar();
SendWeatherUpdate();
}
if( m_iHideHUD != m_iClientHideHUD )
{
MESSAGE_BEGIN( MSG_ONE, gmsgHideWeapon, NULL, this );
WRITE_BYTE( m_iHideHUD );
MESSAGE_END();
m_iClientHideHUD = m_iHideHUD;
}
if( m_iFOV != m_iClientFOV )
{
MESSAGE_BEGIN( MSG_ONE, gmsgSetFOV, NULL, this );
WRITE_BYTE( m_iFOV );
MESSAGE_END();
// cache FOV change at end of function, so weapon updates can see that FOV has changed
}
// HACKHACK -- send the message to display the game title
if( gDisplayTitle )
{
MESSAGE_BEGIN( MSG_ONE, gmsgShowGameTitle, NULL, this );
WRITE_BYTE( 0 );
MESSAGE_END();
gDisplayTitle = false;
}
if( pev->health != m_iClientHealth )
{
int iHealth = clamp( static_cast<int>( pev->health ), 0, 255 ); // make sure that no negative health values are sent
if( pev->health > 0.0f && pev->health <= 1.0f )
iHealth = 1;
// send "health" update message
MESSAGE_BEGIN( MSG_ONE, gmsgHealth, NULL, this );
WRITE_BYTE( iHealth );
MESSAGE_END();
m_iClientHealth = pev->health;
}
if( pev->armorvalue != m_iClientBattery )
{
m_iClientBattery = pev->armorvalue;
ASSERT( gmsgBattery > 0 );
// send "health" update message
MESSAGE_BEGIN( MSG_ONE, gmsgBattery, NULL, this );
WRITE_SHORT( ( int ) pev->armorvalue );
MESSAGE_END();
}
if( pev->dmg_take || pev->dmg_save || m_bitsHUDDamage != m_bitsDamageType )
{
// Comes from inside me if not set
Vector damageOrigin = GetAbsOrigin();
// send "damage" message
// causes screen to flash, and pain compass to show direction of damage
edict_t *other = pev->dmg_inflictor;
if( other )
{
CBaseEntity *pEntity = CBaseEntity::Instance( other );
if( pEntity )
damageOrigin = pEntity->Center();
}
// only send down damage type that have hud art
int visibleDamageBits = m_bitsDamageType & DMG_SHOWNHUD;
MESSAGE_BEGIN( MSG_ONE, gmsgDamage, NULL, this );
WRITE_BYTE( pev->dmg_save );
WRITE_BYTE( pev->dmg_take );
WRITE_LONG( visibleDamageBits );
WRITE_COORD( damageOrigin.x );
WRITE_COORD( damageOrigin.y );
WRITE_COORD( damageOrigin.z );
MESSAGE_END();
//TODO: both of these can probably be removed. - Solokiller
pev->dmg_take = 0;
pev->dmg_save = 0;
m_bitsHUDDamage = m_bitsDamageType;
// Clear off non-time-based damage indicators
m_bitsDamageType &= DMG_TIMEBASED;
}
// Update Flashlight
if( ( m_flFlashLightTime ) && ( m_flFlashLightTime <= gpGlobals->time ) )
{
if( FlashlightIsOn() )
{
if( m_iFlashBattery )
{
m_flFlashLightTime = FLASH_DRAIN_TIME + gpGlobals->time;
m_iFlashBattery--;
if( !m_iFlashBattery )
FlashlightTurnOff();
}
}
else
{
if( m_iFlashBattery < 100 )
{
m_flFlashLightTime = FLASH_CHARGE_TIME + gpGlobals->time;
m_iFlashBattery++;
}
else
m_flFlashLightTime = 0;
}
MESSAGE_BEGIN( MSG_ONE, gmsgFlashBattery, NULL, this );
WRITE_BYTE( m_iFlashBattery );
MESSAGE_END();
}
if( m_iTrain & TRAIN_NEW )
{
ASSERT( gmsgTrain > 0 );
// send "health" update message
MESSAGE_BEGIN( MSG_ONE, gmsgTrain, NULL, this );
WRITE_BYTE( m_iTrain & 0xF );
MESSAGE_END();
m_iTrain &= ~TRAIN_NEW;
}
SendAmmoUpdate();
// Update all the items
for( int i = 0; i < MAX_WEAPON_SLOTS; i++ )
{
if( m_rgpPlayerItems[ i ] ) // each item updates it's successors
m_rgpPlayerItems[ i ]->UpdateClientData( this );
}
// Cache and client weapon change
m_pClientActiveItem = m_pActiveItem;
m_iClientFOV = m_iFOV;
// Update Status Bar
if( m_flNextSBarUpdateTime < gpGlobals->time )
{
UpdateStatusBar();
m_flNextSBarUpdateTime = gpGlobals->time + 0.2;
}
}
void CWeaponCombatCannon::CombatHealIncrement( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
// Find and check the player's punch angle for
// a block in sight
CBlockBase *pBlock = FindTraceBlock();
if( !pBlock )
{
ResetHealing();
return;
}
if ( pBlock->GetHealth() + lf_heal_increment_combat.GetFloat() >= pBlock->GetMaxHealth() )
{
return;
}
else if ( pPlayer->GetTeamNumber() != pBlock->GetTeamNumber() )
{
// You may not heal a block not belonging to your team
return;
}
m_vecPlayerHealPosition = m_tr.endpos;
// Check if the player has moved too far back from the freezing point
float healDistance = fabs( ( pPlayer->GetAbsOrigin() - m_vecPlayerHealPosition ).Length() );
if ( healDistance > lf_heal_distance_combat.GetFloat() )
{
ResetHealing();
return;
}
// First time heaing, so start the sound
if ( m_flLastHeal <= 0.0f )
{
// Play our repairing noise
pBlock->EmitSound( "Luminousforts.Repair" );
m_pLastBlock = pBlock;
}
// Start healing the block
if ( m_flLastHeal + lf_heal_delay_combat.GetFloat() <= gpGlobals->curtime )
{
pBlock->SetHealth( pBlock->GetHealth() + lf_heal_increment_combat.GetFloat() );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
DoEffect( EFFECT_HOLDING );
float health = pBlock->GetHealth();
float maxHealth = pBlock->GetMaxHealth();
float percentage = ( health / maxHealth ) * 100;
// Send a message with information on the amount frozen.
CSingleUserRecipientFilter user( ToBasePlayer( GetOwner() ) );
// Send our stuff over the wire
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 1 ); // Letting the HUD know it's time to turn on
WRITE_LONG( SFH_FREEZEPROGRESS_HEALING );
WRITE_FLOAT( percentage );
MessageEnd();
m_bHealing = true;
m_flLastHeal = gpGlobals->curtime;
}
}
void CWeaponCombatCannon::CombatFreezeIncrement( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
// Find and check the player's punch angle for
// a block in sight
CBlockBase *pBlock = FindTraceBlock();
if( !pBlock )
{
ResetFreezing();
return;
}
if ( !pBlock->IsFreezeable() ||
( pBlock->IsBeingFrozen() && pBlock->GetCurrentFreezer() != pPlayer ) )
{
ResetFreezing();
return;
}
// Let's presume we're not unfreezing a block
bool IsUnFreezing = false;
// Are we looking at the same entity we started to freeze?
if ( pBlock != m_pFreezingBlock )
{
if ( m_flFreezeTime > 0.0f && m_flElapsedTime > 0.0 )
{
ResetFreezing();
}
m_pFreezingBlock = pBlock;
}
if ( !m_grabController.GetAttached() )
{
// Check if the player has moved too far back from the freezing point
float freezeDistance = fabs( ( pPlayer->Weapon_ShootPosition() - m_tr.endpos ).Length() );
if ( freezeDistance > lf_freeze_distance_combat.GetFloat() )
{
ResetFreezing();
return;
}
}
// The player has started freezing a block
if ( m_flLastFreeze <= 0.0f )
{
m_flStartTime = gpGlobals->curtime;
// Amount of time required to Freeze/UnFreeze a block in combat
float flFreezeTime = lf_combat_unfreeze_enemy.GetFloat();
// Check if the block is on our team
if ( pBlock->GetTeamNumber() == GetOwner()->GetTeamNumber() )
{
// Calculate our freeze time
if ( pBlock->IsFrozen() )
{
flFreezeTime = lf_combat_unfreeze_friendly.GetFloat();
}
else
{
flFreezeTime = lf_combat_freeze_friendly.GetFloat();
m_bTempFreeze = true;
pBlock->Freeze( pPlayer );
}
}
else
{
// Completely different values for unfreezing on enemy team
float flHealthRatio = (float)pBlock->GetHealth() / (float)pBlock->GetMaxHealth();
flFreezeTime = (float)lf_combat_unfreeze_enemy.GetFloat() * (float)flHealthRatio;
}
// Play our freezing noise
float duration = 10.0f;
pBlock->EmitSound( "Luminousforts.Freeze", 0.0f, &duration );
m_pLastBlock = pBlock;
m_flFreezeTime = flFreezeTime;
}
// Check if we're unfreezing (Block will be frozen if we're unfreezing)
if ( pBlock->IsFrozen() && !m_bTempFreeze )
{
IsUnFreezing = true;
}
// Calculate the freezing ratio
m_flFreezeRatio = 0.0f;
if ( m_flFreezeTime > 0.0f && m_flElapsedTime > 0.0 )
{
m_flFreezeRatio = ( m_flElapsedTime / m_flFreezeTime );
}
// Send a message with information on the amount frozen.
CSingleUserRecipientFilter user( ToBasePlayer(GetOwner( )) );
float percentage = m_flFreezeRatio * 100.0f;
// Make Reliable for first packet sent
if( percentage < 2.0f )
{
user.MakeReliable();
}
int iFreezingType = SFH_FREEZEPROGRESS_NONE;
// Do all our checks here and only send a single enum
// to save a little bit of our precious bandwidth
if ( IsUnFreezing )
{
if ( GetOwner()->GetTeamNumber() != m_pFreezingBlock->GetTeamNumber() )
{
iFreezingType = SFH_FREEZEPROGRESS_UNFREEZING_ENEMY;
}
else
{
iFreezingType = SFH_FREEZEPROGRESS_UNFREEZING;
}
m_bFreezing = false;
}
else
{
iFreezingType = SFH_FREEZEPROGRESS_FREEZING;
m_bFreezing = true;
}
// Send our stuff over the wire
UserMessageBegin( user, "UpdateFreezeProgress" );
WRITE_BYTE( 1 ); // Letting the HUD know it's time to turn on
WRITE_LONG( iFreezingType );
WRITE_FLOAT( percentage );
MessageEnd();
// Display the welding sparks
GenerateSparks( m_tr.endpos );
pBlock->SetCurrentFreezer( pPlayer );
m_flElapsedTime = gpGlobals->curtime - m_flStartTime;
m_flLastFreeze = gpGlobals->curtime;
}
void CVoiceGameMgr::UpdateMasks()
{
m_UpdateInterval = 0;
bool bAllTalk = !!(sv_alltalk.value);
for (int iClient = 0; iClient < m_nMaxPlayers; ++iClient)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iClient + 1);
if (!pEnt
#ifndef REGAMEDLL_FIXES
|| !pEnt->IsPlayer()
#endif
)
continue;
CBasePlayer *pPlayer = static_cast<CBasePlayer *>(pEnt);
CPlayerBitVec gameRulesMask;
// Request the state of their "VModEnable" cvar.
if (g_bWantModEnable[ iClient ])
{
MESSAGE_BEGIN(MSG_ONE, m_msgRequestState, NULL, pEnt->pev);
MESSAGE_END();
}
if (g_PlayerModEnable[ iClient ])
{
// Build a mask of who they can hear based on the game rules.
for (int iOtherClient = 0; iOtherClient < m_nMaxPlayers; ++iOtherClient)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iOtherClient + 1);
if (pEnt && (bAllTalk || m_pHelper->CanPlayerHearPlayer(pPlayer, (CBasePlayer *)pEnt)))
{
gameRulesMask[ iOtherClient ] = true;
}
}
}
// If this is different from what the client has, send an update.
if (gameRulesMask != g_SentGameRulesMasks[ iClient ] || g_BanMasks[ iClient ] != g_SentBanMasks[ iClient ])
{
g_SentGameRulesMasks[ iClient ] = gameRulesMask;
g_SentBanMasks[ iClient ] = g_BanMasks[ iClient ];
MESSAGE_BEGIN(MSG_ONE, m_msgPlayerVoiceMask, NULL, pPlayer->pev);
for (int dw = 0; dw < VOICE_MAX_PLAYERS_DW; ++dw)
{
WRITE_LONG(gameRulesMask.GetDWord(dw));
WRITE_LONG(g_BanMasks[ iClient ].GetDWord(dw));
}
// ServerModEnable +1 to buffer size
// WRITE_BYTE(1);
MESSAGE_END();
}
// Tell the engine.
for (int iOtherClient = 0; iOtherClient < m_nMaxPlayers; ++iOtherClient)
{
bool bCanHear = gameRulesMask[ iOtherClient ] && !g_BanMasks[ iClient ][ iOtherClient ];
SET_CLIENT_LISTENING(iClient + 1, iOtherClient + 1, bCanHear);
}
}
}
// Powerup Touch
BOOL CItemPowerup::MyTouch( CBasePlayer *pPlayer )
{
if (pPlayer->pev->health <= 0)
return FALSE;
EMIT_SOUND( ENT(pev), CHAN_ITEM, STRING(pev->noise), 1, ATTN_NORM );
pPlayer->m_iQuakeItems |= m_iPowerupBit;
int iPowerUp = 0;
// Invincibility
if (invincible_finished)
{
// Make them glow red
if ( pPlayer->m_iQuakeItems & IT_QUAD )
{
pPlayer->pev->renderfx = kRenderFxGlowShell;
pPlayer->pev->rendercolor = Vector( 255, 125, 255 ); // RGB
pPlayer->pev->renderamt = 100; // Shell size
iPowerUp = 3;
}
else
{
pPlayer->pev->renderfx = kRenderFxGlowShell;
pPlayer->pev->rendercolor = Vector( 255, 128, 0 ); // RGB
pPlayer->pev->renderamt = 100; // Shell size
iPowerUp = 2;
}
if ( pPlayer->m_iQuakeItems & IT_INVISIBILITY )
{
pPlayer->pev->rendermode = kRenderTransColor;
pPlayer->pev->renderamt = 1;
}
pPlayer->m_flInvincibleFinished = gpGlobals->time + invincible_finished;
}
// Quad Damage
if (super_damage_finished)
{
// Make them glow blue
if ( pPlayer->m_iQuakeItems & IT_INVULNERABILITY )
{
pPlayer->pev->renderfx = kRenderFxGlowShell;
pPlayer->pev->rendercolor = Vector( 255, 125, 255 ); // RGB
pPlayer->pev->renderamt = 100; // Shell size
iPowerUp = 3;
}
else
{
pPlayer->pev->renderfx = kRenderFxGlowShell;
pPlayer->pev->rendercolor = Vector( 128, 128, 255 ); // RGB
pPlayer->pev->renderamt = 100; // Shell size
iPowerUp = 1;
}
if ( pPlayer->m_iQuakeItems & IT_INVISIBILITY )
{
pPlayer->pev->rendermode = kRenderTransColor;
pPlayer->pev->renderamt = 1;
}
pPlayer->m_flSuperDamageFinished = gpGlobals->time + super_damage_finished;
// Remove armor and cells if DM==4
if (gpGlobals->deathmatch == 4)
{
pPlayer->pev->armortype = 0;
pPlayer->pev->armorvalue = 0;
pPlayer->m_iAmmoCells = 0;
}
}
// Radiation suit
if (radsuit_finished)
pPlayer->m_flRadsuitFinished = gpGlobals->time + radsuit_finished;
// Invisibility
if (invisible_finished)
{
pPlayer->m_flInvisibleFinished = gpGlobals->time + invisible_finished;
pPlayer->pev->renderfx = kRenderFxGlowShell;
pPlayer->pev->rendercolor = Vector( 128, 128, 128 ); // RGB
pPlayer->pev->renderamt = 5; // Shell size
}
// tell director about it
MESSAGE_BEGIN( MSG_SPEC, SVC_DIRECTOR );
WRITE_BYTE ( 9 ); // command length in bytes
WRITE_BYTE ( DRC_CMD_EVENT ); // powerup pickup
WRITE_SHORT( ENTINDEX(pPlayer->edict()) ); // player is primary target
WRITE_SHORT( ENTINDEX(this->edict()) ); // powerup as second target
WRITE_LONG( 9 ); // highst prio in game
MESSAGE_END();
pPlayer->W_SetCurrentAmmo();
PLAYBACK_EVENT_FULL( FEV_GLOBAL | FEV_RELIABLE,
pPlayer->edict(), g_usPowerUp, 0, (float *)&g_vecZero, (float *)&g_vecZero,
(float)iPowerUp, 0.0, pPlayer->entindex(), pPlayer->pev->team, 0, 0 );
return TRUE;
}
void CC4::PrimaryAttack(void)
{
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
return;
BOOL onBombZone = m_pPlayer->m_signals.GetState() & SIGNAL_BOMB;
BOOL onGround = m_pPlayer->pev->flags & FL_ONGROUND;
if (!m_bStartedArming)
{
if (!onBombZone)
{
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_At_Bomb_Spot");
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 1;
return;
}
if (!onGround)
{
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground");
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 1;
return;
}
m_bStartedArming = true;
m_bBombPlacedAnimation = false;
m_fArmedTime = gpGlobals->time + 3;
SendWeaponAnim(C4_ARM, UseDecrement() != FALSE);
g_engfuncs.pfnSetClientMaxspeed(ENT(m_pPlayer->pev), 1);
m_pPlayer->SetAnimation(PLAYER_ATTACK1);
m_pPlayer->SetProgressBarTime(3);
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + RANDOM_FLOAT(10, 15);
}
else
{
if (!onGround || !onBombZone)
{
if (onBombZone)
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground");
else
ClientPrint(m_pPlayer->pev, HUD_PRINTCENTER, "#C4_Arming_Cancelled");
m_bStartedArming = false;
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 1.5;
m_pPlayer->ResetMaxSpeed();
m_pPlayer->SetProgressBarTime(0);
m_pPlayer->SetAnimation(PLAYER_HOLDBOMB);
if (m_bBombPlacedAnimation == true)
SendWeaponAnim(C4_DRAW, UseDecrement() != FALSE);
else
SendWeaponAnim(C4_IDLE1, UseDecrement() != FALSE);
return;
}
if (gpGlobals->time > m_fArmedTime)
{
if (m_bStartedArming == true)
{
m_bStartedArming = false;
m_fArmedTime = 0;
Broadcast("BOMBPL");
m_pPlayer->m_bHasC4 = false;
#ifndef CLIENT_WEAPONS
if (pev->speed != 0 && g_pGameRules)
g_pGameRules->m_iC4Timer = (int)pev->speed;
#endif
CGrenade *pGrenade = CGrenade::ShootSatchelCharge(m_pPlayer->pev, m_pPlayer->pev->origin, Vector(0, 0, 0));
MESSAGE_BEGIN(MSG_SPEC, SVC_DIRECTOR);
WRITE_BYTE(9);
WRITE_BYTE(DRC_CMD_EVENT);
WRITE_SHORT(ENTINDEX(m_pPlayer->edict()));
WRITE_SHORT(0);
WRITE_LONG(11 | DRC_FLAG_FACEPLAYER);
MESSAGE_END();
#ifndef CLIENT_WEAPONS
MESSAGE_BEGIN(MSG_ALL, gmsgBombDrop);
WRITE_COORD(pGrenade->pev->origin.x);
WRITE_COORD(pGrenade->pev->origin.y);
WRITE_COORD(pGrenade->pev->origin.z);
WRITE_BYTE(1);
MESSAGE_END();
#endif
UTIL_ClientPrintAll(HUD_PRINTCENTER, "#Bomb_Planted");
#ifndef CLIENT_WEAPONS
if (g_pGameRules->IsCareer() && !m_pPlayer->IsBot())
{
}
#endif
UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Planted_The_Bomb\"\n", STRING(m_pPlayer->pev->netname), GETPLAYERUSERID(m_pPlayer->edict()), GETPLAYERAUTHID(m_pPlayer->edict()));
#ifndef CLIENT_WEAPONS
g_pGameRules->m_bBombDropped = false;
#endif
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/c4_plant.wav", VOL_NORM, ATTN_NORM);
m_pPlayer->pev->body = 0;
m_pPlayer->ResetMaxSpeed();
m_pPlayer->SetBombIcon(FALSE);
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
if (!m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
{
RetireWeapon();
return;
}
}
}
else
{
if (gpGlobals->time >= m_fArmedTime - 0.75)
{
if (m_bBombPlacedAnimation == false)
{
m_bBombPlacedAnimation = true;
SendWeaponAnim(C4_DROP, UseDecrement() != FALSE);
m_pPlayer->SetAnimation(PLAYER_HOLDBOMB);
}
}
}
}
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + RANDOM_FLOAT(10, 15);
}
//=========================================================
// Deathnotice.
//=========================================================
void CHalfLifeMultiplay::DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pevInflictor )
{
// Work out what killed the player, and send a message to all clients about it
CBaseEntity *Killer = CBaseEntity::Instance( pKiller );
const char *killer_weapon_name = "world"; // by default, the player is killed by the world
int killer_index = 0;
// Hack to fix name change
char *tau = "tau_cannon";
char *gluon = "gluon gun";
if ( pKiller->flags & FL_CLIENT )
{
killer_index = ENTINDEX(ENT(pKiller));
if ( pevInflictor )
{
if ( pevInflictor == pKiller )
{
// If the inflictor is the killer, then it must be their current weapon doing the damage
CBasePlayer *pPlayer = (CBasePlayer*)CBaseEntity::Instance( pKiller );
if ( pPlayer->m_pActiveItem )
{
killer_weapon_name = pPlayer->m_pActiveItem->pszName();
}
}
else
{
killer_weapon_name = STRING( pevInflictor->classname ); // it's just that easy
}
}
}
else
{
killer_weapon_name = STRING( pevInflictor->classname );
}
// strip the monster_* or weapon_* from the inflictor's classname
if ( strncmp( killer_weapon_name, "weapon_", 7 ) == 0 )
killer_weapon_name += 7;
else if ( strncmp( killer_weapon_name, "monster_", 8 ) == 0 )
killer_weapon_name += 8;
else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
killer_weapon_name += 5;
MESSAGE_BEGIN( MSG_ALL, gmsgDeathMsg );
WRITE_BYTE( killer_index ); // the killer
WRITE_BYTE( ENTINDEX(pVictim->edict()) ); // the victim
WRITE_STRING( killer_weapon_name ); // what they were killed by (should this be a string?)
MESSAGE_END();
// replace the code names with the 'real' names
if ( !strcmp( killer_weapon_name, "egon" ) )
killer_weapon_name = gluon;
else if ( !strcmp( killer_weapon_name, "gauss" ) )
killer_weapon_name = tau;
if ( pVictim->pev == pKiller )
{
// killed self
// team match?
if ( g_teamplay )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" committed suicide with \"%s\"\n",
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( pVictim->edict() ), "model" ),
killer_weapon_name );
}
else
{
UTIL_LogPrintf( "\"%s<%i><%s><%i>\" committed suicide with \"%s\"\n",
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
GETPLAYERUSERID( pVictim->edict() ),
killer_weapon_name );
}
}
else if ( pKiller->flags & FL_CLIENT )
{
// team match?
if ( g_teamplay )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" killed \"%s<%i><%s><%s>\" with \"%s\"\n",
STRING( pKiller->netname ),
GETPLAYERUSERID( ENT(pKiller) ),
GETPLAYERAUTHID( ENT(pKiller) ),
g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( ENT(pKiller) ), "model" ),
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( pVictim->edict() ), "model" ),
killer_weapon_name );
}
else
{
UTIL_LogPrintf( "\"%s<%i><%s><%i>\" killed \"%s<%i><%s><%i>\" with \"%s\"\n",
STRING( pKiller->netname ),
GETPLAYERUSERID( ENT(pKiller) ),
GETPLAYERAUTHID( ENT(pKiller) ),
GETPLAYERUSERID( ENT(pKiller) ),
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
GETPLAYERUSERID( pVictim->edict() ),
killer_weapon_name );
}
}
else
{
// killed by the world
// team match?
if ( g_teamplay )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" committed suicide with \"%s\" (world)\n",
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( pVictim->edict() ), "model" ),
killer_weapon_name );
}
else
{
UTIL_LogPrintf( "\"%s<%i><%s><%i>\" committed suicide with \"%s\" (world)\n",
STRING( pVictim->pev->netname ),
GETPLAYERUSERID( pVictim->edict() ),
GETPLAYERAUTHID( pVictim->edict() ),
GETPLAYERUSERID( pVictim->edict() ),
killer_weapon_name );
}
}
MESSAGE_BEGIN( MSG_SPEC, SVC_DIRECTOR );
WRITE_BYTE ( 9 ); // command length in bytes
WRITE_BYTE ( DRC_CMD_EVENT ); // player killed
WRITE_SHORT( ENTINDEX(pVictim->edict()) ); // index number of primary entity
if (pevInflictor)
WRITE_SHORT( ENTINDEX(ENT(pevInflictor)) ); // index number of secondary entity
else
WRITE_SHORT( ENTINDEX(ENT(pKiller)) ); // index number of secondary entity
WRITE_LONG( 7 | DRC_FLAG_DRAMATIC); // eventflags (priority and flags)
MESSAGE_END();
// Print a standard message
// TODO: make this go direct to console
return; // just remove for now
/*
char szText[ 128 ];
if ( pKiller->flags & FL_MONSTER )
{
// killed by a monster
strcpy ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, " was killed by a monster.\n" );
return;
}
if ( pKiller == pVictim->pev )
{
strcpy ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, " commited suicide.\n" );
}
else if ( pKiller->flags & FL_CLIENT )
{
strcpy ( szText, STRING( pKiller->netname ) );
strcat( szText, " : " );
strcat( szText, killer_weapon_name );
strcat( szText, " : " );
strcat ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, "\n" );
}
else if ( FClassnameIs ( pKiller, "worldspawn" ) )
{
strcpy ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, " fell or drowned or something.\n" );
}
else if ( pKiller->solid == SOLID_BSP )
{
strcpy ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, " was mooshed.\n" );
}
else
{
strcpy ( szText, STRING( pVictim->pev->netname ) );
strcat ( szText, " died mysteriously.\n" );
}
UTIL_ClientPrintAll( szText );
*/
}
void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
{
pev->model = 0;
pev->solid = SOLID_NOT;
pev->takedamage = DAMAGE_NO;
UTIL_ScreenShake(pTrace->vecEndPos, 25, 150, 1, 3000);
g_pGameRules->m_bTargetBombed = true;
if (g_pGameRules->IsCareer())
{
}
m_bJustBlew = true;
g_pGameRules->CheckWinConditions();
if (pTrace->flFraction != 1)
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6);
int iContents = UTIL_PointContents(pev->origin);
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_SPRITE);
WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z - 10);
WRITE_SHORT(g_sModelIndexFireball3);
WRITE_BYTE((pev->dmg - 275) * 0.6);
WRITE_BYTE(150);
MESSAGE_END();
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_SPRITE);
WRITE_COORD(pev->origin.x + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball2);
WRITE_BYTE((pev->dmg - 275) * 0.6);
WRITE_BYTE(150);
MESSAGE_END();
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_SPRITE);
WRITE_COORD(pev->origin.x + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball3);
WRITE_BYTE((pev->dmg - 275) * 0.6);
WRITE_BYTE(150);
MESSAGE_END();
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_SPRITE);
WRITE_COORD(pev->origin.x + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball);
WRITE_BYTE((pev->dmg - 275) * 0.6);
WRITE_BYTE(17);
MESSAGE_END();
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/c4_explode1.wav", VOL_NORM, 0.25);
CSoundEnt::InsertSound(bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3);
entvars_t *pevOwner;
if (pev->owner)
pevOwner = VARS(pev->owner);
else
pevOwner = NULL;
pev->owner = NULL;
RadiusDamage(pev, pevOwner, g_pGameRules->m_flBombRadius, CLASS_NONE, bitsDamageType);
if (g_pGameRules->IsCareer())
{
}
MESSAGE_BEGIN(MSG_SPEC, SVC_DIRECTOR);
WRITE_BYTE(9);
WRITE_BYTE(DRC_CMD_EVENT);
WRITE_SHORT(ENTINDEX(edict()));
WRITE_SHORT(0);
WRITE_LONG(15 | DRC_FLAG_FINAL);
MESSAGE_END();
if (RANDOM_FLOAT(0, 1) < 0.5)
UTIL_DecalTrace(pTrace, DECAL_SCORCH1);
else
UTIL_DecalTrace(pTrace, DECAL_SCORCH2);
float flRndSound = RANDOM_FLOAT(0, 1);
switch (RANDOM_LONG(0, 2))
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris1.wav", 0.55, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris2.wav", 0.55, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris3.wav", 0.55, ATTN_NORM); break;
}
pev->effects |= EF_NODRAW;
SetThink(&CGrenade::Smoke2);
pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.85;
if (iContents != CONTENTS_WATER)
{
int sparkCount = RANDOM_LONG(0, 3);
for (int i = 0; i < sparkCount; i++)
Create("spark_shower", pev->origin, pTrace->vecPlaneNormal, NULL);
}
}
void CHostage::IdleThink(void)
{
pev->nextthink = gpGlobals->time + (1.0 / 30);
DispatchAnimEvents(StudioFrameAdvance());
if (gpGlobals->time >= m_flNextFullThink)
{
m_flNextFullThink = gpGlobals->time + 0.1;
if (pev->deadflag == DEAD_DEAD)
{
UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0));
return;
}
if (m_hTargetEnt != NULL)
{
if ((m_bStuck != FALSE && gpGlobals->time - m_flStuckTime > 5) || m_hTargetEnt->pev->deadflag != DEAD_NO)
{
m_State = STAND;
m_hTargetEnt = NULL;
m_bStuck = FALSE;
}
}
if (m_hTargetEnt != 0 || m_improv)
{
CBasePlayer *pPlayer;
if (m_improv)
{
}
else
pPlayer = GetClassPtr((CBasePlayer *)m_hTargetEnt->pev);
if (!pPlayer || pPlayer->m_iTeam == TEAM_CT)
{
if (!g_pGameRules->m_bMapHasRescueZone)
{
BOOL hasRescueZone = FALSE;
if (UTIL_FindEntityByClassname(NULL, "info_hostage_rescue"))
hasRescueZone = TRUE;
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityByClassname(pEntity, "info_hostage_rescue")) != NULL)
{
if ((pEntity->pev->origin - pev->origin).Length() < 256)
{
m_bRescueMe = TRUE;
break;
}
}
if (!hasRescueZone)
{
pEntity = NULL;
while ((pEntity = UTIL_FindEntityByClassname(pEntity, "info_player_start")) != NULL)
{
if ((pEntity->pev->origin - pev->origin).Length() < 256)
{
m_bRescueMe = TRUE;
break;
}
}
}
}
if (m_bRescueMe)
{
if (g_pGameRules->IsCareer() && pPlayer && !pPlayer->IsBot())
{
}
if (pPlayer)
{
pev->deadflag = DEAD_RESPAWNABLE;
pPlayer->AddAccount(1000);
UTIL_LogPrintf("\"%s<%i><%s><CT>\" triggered \"Rescued_A_Hostage\"\n", STRING(pPlayer->pev->netname), GETPLAYERUSERID(pPlayer->edict()), GETPLAYERAUTHID(pPlayer->edict()));
}
SendHostageEventMsg();
MESSAGE_BEGIN(MSG_SPEC, SVC_DIRECTOR);
WRITE_BYTE(9);
WRITE_BYTE(DRC_CMD_EVENT);
WRITE_SHORT(pPlayer ? ENTINDEX(pPlayer->edict()) : 0);
WRITE_SHORT(ENTINDEX(edict()));
WRITE_LONG(15);
MESSAGE_END();
pev->effects |= EF_NODRAW;
Remove();
g_pGameRules->m_iHostagesRescued++;
g_pGameRules->CheckWinConditions();
if (pPlayer)
Broadcast("rescued");
else
Broadcast("escaped");
}
}
}
DoFollow();
if (pev->deadflag != DEAD_DEAD && !(pev->effects & EF_NODRAW))
{
if (m_flNextRadarTime <= gpGlobals->time)
{
if ((m_vOldPos - pev->origin).Length() > 1)
{
m_vOldPos = pev->origin;
if (!g_pGameRules->m_fTeamCount)
SendHostagePositionMsg();
}
m_flNextRadarTime = gpGlobals->time + 1;
}
}
if (m_flFlinchTime <= gpGlobals->time)
{
if (pev->velocity.Length() > 160)
SetActivity(ACT_RUN);
else if (pev->velocity.Length() > 15)
SetActivity(ACT_WALK);
else
SetActivity(ACT_IDLE);
}
}
}
void CGrenade::C4Think(void)
{
if (!IsInWorld())
{
UTIL_Remove(this);
return;
}
pev->nextthink = gpGlobals->time + 0.12;
if (gpGlobals->time >= m_flNextFreq)
{
m_flNextFreq = m_flNextFreqInterval + gpGlobals->time;
m_flNextFreqInterval *= 0.9;
switch (m_iCurWave)
{
case 0:
{
m_sBeepName = "weapons/c4_beep1.wav";
m_fAttenu = 1.5;
break;
}
case 1:
{
m_sBeepName = "weapons/c4_beep2.wav";
m_fAttenu = 1;
break;
}
case 2:
{
m_sBeepName = "weapons/c4_beep3.wav";
m_fAttenu = 0.8;
break;
}
case 3:
{
m_sBeepName = "weapons/c4_beep4.wav";
m_fAttenu = 0.5;
break;
}
case 4:
{
m_sBeepName = "weapons/c4_beep5.wav";
m_fAttenu = 0.2;
break;
}
}
m_iCurWave++;
}
if (gpGlobals->time >= m_flNextBeep)
{
m_flNextBeep = gpGlobals->time + 1.4;
EMIT_SOUND(ENT(pev), CHAN_VOICE, m_sBeepName, VOL_NORM, m_fAttenu);
}
if (gpGlobals->time >= m_flNextBlink)
{
m_flNextBlink = gpGlobals->time + 2;
MESSAGE_BEGIN(MSG_PVS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_GLOWSPRITE);
WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z + 5);
WRITE_SHORT(g_sModelIndexC4Glow);
WRITE_BYTE(1);
WRITE_BYTE(3);
WRITE_BYTE(255);
MESSAGE_END();
}
if (m_flC4Blow <= gpGlobals->time)
{
MESSAGE_BEGIN(MSG_ALL, gmsgScenarioIcon);
WRITE_BYTE(0);
MESSAGE_END();
if (m_pentCurBombTarget)
{
CBaseEntity *pEntity = CBaseEntity::Instance(m_pentCurBombTarget);
if (pEntity)
{
CBaseEntity *pOwner = CBaseEntity::Instance(pev->owner);
pEntity->Use(pOwner, this, USE_TOGGLE, 0);
}
}
CBaseEntity *pOwner = CBaseEntity::Instance(pev->owner);
pOwner->pev->frags += 3;
MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup);
MESSAGE_END();
g_pGameRules->m_bBombDropped = false;
if (pev->waterlevel != 0)
UTIL_Remove(this);
else
SetThink(&CGrenade::Detonate2);
}
if (m_bStartDefuse == true && m_pBombDefuser != NULL)
{
CBasePlayer *pDefuser = (CBasePlayer *)CBaseEntity::Instance(m_pBombDefuser);
if (m_flDefuseCountDown > gpGlobals->time)
{
int fOnGround = m_pBombDefuser->pev->flags & FL_ONGROUND;
if (m_fNextDefuse < gpGlobals->time || !fOnGround)
{
if (!fOnGround)
ClientPrint(m_pBombDefuser->pev, HUD_PRINTCENTER, "#C4_Defuse_Must_Be_On_Ground");
pDefuser->ResetMaxSpeed();
pDefuser->m_bIsDefusing = false;
pDefuser->SetProgressBarTime(0);
m_bStartDefuse = false;
m_pBombDefuser = NULL;
m_flDefuseCountDown = 0;
}
}
else
{
if (m_pBombDefuser->pev->deadflag == DEAD_NO)
{
Broadcast("BOMBDEF");
MESSAGE_BEGIN(MSG_SPEC, SVC_DIRECTOR);
WRITE_BYTE(9);
WRITE_BYTE(DRC_CMD_EVENT);
WRITE_SHORT(ENTINDEX(ENT(m_pBombDefuser->pev)));
WRITE_SHORT(0);
WRITE_LONG(15 | DRC_FLAG_FINAL | DRC_FLAG_FACEPLAYER | DRC_FLAG_DRAMATIC);
MESSAGE_END();
UTIL_LogPrintf("\"%s<%i><%s><CT>\" triggered \"Defused_The_Bomb\"\n", STRING(m_pBombDefuser->pev->netname), GETPLAYERUSERID(m_pBombDefuser->edict()), GETPLAYERAUTHID(m_pBombDefuser->edict()));
UTIL_EmitAmbientSound(ENT(pev), pev->origin, "weapons/c4_beep5.wav", 0, ATTN_NONE, SND_STOP, 0);
EMIT_SOUND(ENT(m_pBombDefuser->pev), CHAN_WEAPON, "weapons/c4_disarmed.wav", VOL_NORM, ATTN_NORM);
UTIL_Remove(this);
m_bJustBlew = true;
pDefuser->ResetMaxSpeed();
pDefuser->m_bIsDefusing = false;
MESSAGE_BEGIN(MSG_ALL, gmsgScenarioIcon);
WRITE_BYTE(0);
MESSAGE_END();
if (g_pGameRules->IsCareer())
{
if (!pDefuser->IsBot())
{
}
}
g_pGameRules->m_bBombDefused = true;
g_pGameRules->CheckWinConditions();
pDefuser->pev->frags += 3;
MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup);
MESSAGE_END();
g_pGameRules->m_bBombDropped = false;
m_bStartDefuse = false;
m_pBombDefuser = NULL;
}
else
{
pDefuser->ResetMaxSpeed();
pDefuser->m_bIsDefusing = false;
m_bStartDefuse = false;
m_pBombDefuser = NULL;
}
}
}
}
static cell AMX_NATIVE_CALL write_long(AMX *amx, cell *params) /* 1 param */
{
WRITE_LONG(params[1]);
return 1;
}
void CVoiceGameMgr::UpdateMasks()
{
m_UpdateInterval = 0;
bool bAllTalk = !!sv_alltalk.GetInt();
for(int iClient=0; iClient < m_nMaxPlayers; iClient++)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iClient+1);
if(!pEnt || !pEnt->IsPlayer())
continue;
CBasePlayer *pPlayer = (CBasePlayer*)pEnt;
CSingleUserRecipientFilter user( pPlayer );
// Request the state of their "VModEnable" cvar.
if(g_bWantModEnable[iClient])
{
UserMessageBegin( user, "RequestState" );
MessageEnd();
// Since this is reliable, only send it once
g_bWantModEnable[iClient] = false;
}
CPlayerBitVec gameRulesMask;
CPlayerBitVec ProximityMask;
bool bProximity = false;
if( g_PlayerModEnable[iClient] )
{
// Build a mask of who they can hear based on the game rules.
for(int iOtherClient=0; iOtherClient < m_nMaxPlayers; iOtherClient++)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iOtherClient+1);
if(pEnt && pEnt->IsPlayer() &&
(bAllTalk || m_pHelper->CanPlayerHearPlayer(pPlayer, (CBasePlayer*)pEnt, bProximity )) )
{
gameRulesMask[iOtherClient] = true;
ProximityMask[iOtherClient] = bProximity;
}
}
}
// If this is different from what the client has, send an update.
if(gameRulesMask != g_SentGameRulesMasks[iClient] ||
g_BanMasks[iClient] != g_SentBanMasks[iClient])
{
g_SentGameRulesMasks[iClient] = gameRulesMask;
g_SentBanMasks[iClient] = g_BanMasks[iClient];
UserMessageBegin( user, "VoiceMask" );
int dw;
for(dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
{
WRITE_LONG(gameRulesMask.GetDWord(dw));
WRITE_LONG(g_BanMasks[iClient].GetDWord(dw));
}
WRITE_BYTE( !!g_PlayerModEnable[iClient] );
MessageEnd();
}
// Tell the engine.
for(int iOtherClient=0; iOtherClient < m_nMaxPlayers; iOtherClient++)
{
bool bCanHear = gameRulesMask[iOtherClient] && !g_BanMasks[iClient][iOtherClient];
g_pVoiceServer->SetClientListening( iClient+1, iOtherClient+1, bCanHear );
if ( bCanHear )
{
g_pVoiceServer->SetClientProximity( iClient+1, iOtherClient+1, !!ProximityMask[iOtherClient] );
}
}
}
}
void CVoiceGameMgr::UpdateMasks()
{
m_UpdateInterval = 0;
bool bAllTalk = !!ns_cvar_float(&sv_alltalk);
for(int iClient=0; iClient < m_nMaxPlayers; iClient++)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iClient+1);
if(!pEnt || !pEnt->IsPlayer())
continue;
// Request the state of their "VModEnable" cvar.
if(g_bWantModEnable[iClient])
{
MESSAGE_BEGIN(MSG_ONE, m_msgRequestState, NULL, pEnt->pev);
MESSAGE_END();
}
CBasePlayer *pPlayer = (CBasePlayer*)pEnt;
CPlayerBitVec gameRulesMask;
if(g_PlayerModEnable[iClient])
{
// Build a mask of who they can hear based on the game rules.
for(int iOtherClient=0; iOtherClient < m_nMaxPlayers; iOtherClient++)
{
CBaseEntity *pEnt = UTIL_PlayerByIndex(iOtherClient+1);
if(pEnt && pEnt->IsPlayer() &&
(bAllTalk || m_pHelper->CanPlayerHearPlayer(pPlayer, (CBasePlayer*)pEnt)) )
{
gameRulesMask[iOtherClient] = true;
}
}
}
// If this is different from what the client has, send an update.
if(gameRulesMask != g_SentGameRulesMasks[iClient] ||
g_BanMasks[iClient] != g_SentBanMasks[iClient])
{
g_SentGameRulesMasks[iClient] = gameRulesMask;
g_SentBanMasks[iClient] = g_BanMasks[iClient];
MESSAGE_BEGIN(MSG_ONE, m_msgPlayerVoiceMask, NULL, pPlayer->pev);
int dw;
for(dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
{
WRITE_LONG(gameRulesMask.GetDWord(dw));
WRITE_LONG(g_BanMasks[iClient].GetDWord(dw));
}
MESSAGE_END();
}
// Tell the engine.
for(int iOtherClient=0; iOtherClient < m_nMaxPlayers; iOtherClient++)
{
bool bCanHear = gameRulesMask[iOtherClient] && !g_BanMasks[iClient][iOtherClient];
g_engfuncs.pfnVoice_SetClientListening(iClient+1, iOtherClient+1, bCanHear);
}
}
}
void CFuncMachinegun::PostFrame( CBasePlayer *pActivator )
{
Vector plAngles = pActivator->pev->angles;
while (plAngles.y < 0) plAngles.y += 360;
float yawAngle = plAngles.y - pev->angles.y;
float pitchAngle = pActivator->pev->angles.x * -3;
SetBoneController( 0, yawAngle );
SetBoneController( 1, pitchAngle );
StudioFrameAdvance();
// return to idle after fire anim
if (m_fSequenceFinished)
{
pev->sequence = TURRET_IDLE;
pev->frame = 0;
ResetSequenceInfo();
m_fSequenceLoops = TRUE;
}
if ( gpGlobals->time < m_flNextAttack )
return;
if ( pActivator->pev->button & IN_ATTACK && (m_iAmmo > 0 || m_iAmmo == -1))
{
// fire
Vector vecForward, vecSrc, vecAngles;
vecAngles = pActivator->pev->angles;
vecAngles.x = vecAngles.x * -3; // invert anf scale pitch
UTIL_MakeVectorsPrivate( vecAngles, vecForward, NULL, NULL );
GetAttachment(0, vecSrc, vecAngles);
pev->sequence = TURRET_SHOOT_SOLID; // sounds, muzzleflashes, and shells will go by anim event
pev->frame = 0;
ResetSequenceInfo();
m_fSequenceLoops = FALSE;
switch( m_projectileType )
{
default:
case TANK_BULLET_9MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_6DEGREES, 16384, BULLET_9MM, pActivator->pev);
break;
case TANK_BULLET_12MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_6DEGREES, 16384, BULLET_12MM, pActivator->pev);
break;
case TANK_BULLET_14MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_7DEGREES, 16384, BULLET_14MM, pActivator->pev);
break;
case TANK_BULLET_BUCKSHOT:
for ( i = 0; i < 8; i++ )
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_10DEGREES, 16384, BULLET_BUCKSHOT, pActivator->pev);
break;
case TANK_BULLET_12G:
for ( i = 0; i < 4; i++ )
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_15DEGREES, 16384, BULLET_12G, pActivator->pev);
break;
case TANK_BULLET_57MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_2DEGREES, 16384, BULLET_57mm, pActivator->pev);
break;
case TANK_BULLET_762NATO:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_3DEGREES, 16384, BULLET_762Nato, pActivator->pev);
break;
case TANK_BULLET_338MAGNUM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_0DEGREES, 16384, BULLET_338Magnum, pActivator->pev);
break;
case TANK_BULLET_762X54:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_4DEGREES, 16384, BULLET_762x54, pActivator->pev);
break;
case TANK_BULLET_86MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_8DEGREES, 16384, BULLET_86mm, pActivator->pev);
break;
case TANK_BULLET_32MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_5DEGREES, 16384, BULLET_32mm, pActivator->pev);
break;
case TANK_BULLET_127MM:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_1DEGREES, 16384, BULLET_127MM, pActivator->pev);
break;
case TANK_BULLET_BFG:
for ( i = 0; i < 8; i++ )
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_40DEGREES, 16384, BULLET_BFG, pActivator->pev);
break;
case TANK_BULLET_NAIL:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_0DEGREES, 16384, BULLET_NAILGUN, pActivator->pev);
break;
case TANK_BULLET_BOLT:
CBolt::ShootBolt(pActivator->pev, vecSrc + vecForward*16, vecForward * 5000, 0 );
break;
case TANK_ENERGY_HOMINGSHOCK:
CShock::ShootShock(pActivator->pev, vecSrc + vecForward*16, vecForward * 400, FALSE );
break;
case TANK_ENERGY_SHOCK:
CShock::ShootShock(pActivator->pev, vecSrc + vecForward*16, vecForward * 700, TRUE );
break;
case TANK_ENERGY_PLASMA:
CPlasma::ShootPlasma(pActivator->pev, vecSrc + vecForward*16, vecForward * 20000 );
break;
case TANK_ENERGY_PLASMALARGE:
CPlasma2::ShootPlasma2(pActivator->pev, vecSrc + vecForward*16, vecForward * 20000 );
break;
case TANK_ENERGY_FLAME:
CFlame::ShootFlame(pActivator->pev, vecSrc + vecForward*16, vecForward * 900 );
break;
case TANK_ENERGY_ECHARGE:
CEnergycharge::ShootEnergycharge(pActivator->pev, vecSrc + vecForward*16, vecForward * 8000);
break;
case TANK_ENERGY_FROSTBALL:
CFrostball::ShootFrostball(pActivator->pev, vecSrc + vecForward*16, vecForward * 5000);
break;
case TANK_ENERGY_GLUON:
CGluon::ShootGluon(pActivator->pev, vecSrc + vecForward*16, vecForward * 2500 );
break;
case TANK_ENERGY_GLUONLARGE:
CGluon2::ShootGluon2(pActivator->pev, vecSrc + vecForward*16, vecForward * 6800, 10);
break;
case TANK_ENERGY_DISPBALL_HALF:
CDispball::ShootDispball(pActivator->pev, vecSrc + vecForward*16, vecForward * 3000, 1);
break;
case TANK_ENERGY_DISPBALL_FULL:
CDispball::ShootDispball(pActivator->pev, vecSrc + vecForward*16, vecForward * 1500, 2);
break;
case TANK_ENERGY_PBOLT:
CPBolt::ShootPBolt(pActivator->pev, vecSrc + vecForward*16, vecForward * 15000 );
break;
case TANK_ROCKET_XBOLT:
CBolt::ShootBolt(pActivator->pev, vecSrc + vecForward*16, vecForward * 7500, 2);
break;
case TANK_ROCKET_CLUSTER:
CClMomma::ShootClusterMomma(pActivator->pev, vecSrc + vecForward*16, vecForward * 1250, 3 );
break;
case TANK_ROCKET_M203GREN:
CM203grenade::ShootM203grenade(pActivator->pev, vecSrc + vecForward*16, vecForward * 1800);
break;
case TANK_ROCKET_AK74GREN:
CAK74grenade::ShootAK74grenade(pActivator->pev, vecSrc + vecForward*16, vecForward * 4000);
break;
case TANK_ROCKET_HANDGREN:
CGrenade::ShootGrenade(pActivator->pev, vecSrc + vecForward*16, vecForward * 1500, 3.5);
break;
case TANK_ROCKET_NGGREN:
CNGgrenade::ShootNGgrenade(pActivator->pev, vecSrc + vecForward*16, vecForward * 2000, 3 );
break;
case TANK_ROCKET_U2:
CU2Momma::ShootU2Momma(pActivator->pev, vecSrc + vecForward*16, vecForward * 900, 1 );
break;
case TANK_ROCKET_TESLAGREN:
CTeslagren::ShootTeslagren(pActivator->pev, vecSrc + vecForward*16, vecForward * 3000);
break;
case TANK_ROCKET_MMISSILE:
CMmissile::ShootMmissile(pActivator->pev, vecSrc + vecForward*16, vecForward * 5250 );
break;
case TANK_ROCKET_DEMOLITION:
CWhlProjectile::ShootWhlProjectile(pActivator->pev, vecSrc + vecForward*16, vecForward * 2250, FALSE );
break;
case TANK_ROCKET_RPG:
CRpgRocket::ShootRpgRocket(pActivator->pev, vecSrc + vecForward*16, vecForward * 2500, FALSE, NULL);
break;
case TANK_ROCKET_DUMBFIRE:
CDumbfire::ShootDumbfire(pActivator->pev, vecSrc + vecForward*16, vecForward * 250);
break;
case TANK_ROCKET_HELLFIRE:
Chellfire::ShootHellfire(pActivator->pev, vecSrc + vecForward*16, vecForward * 300, TRUE);
break;
case TANK_MORTAR:
CTankProj::ShootTankProj(pActivator->pev, vecSrc + vecForward*16, vecForward * 100000);
break;
case TANK_ROCKET_NUKE:
CNuke::ShootNuke(pActivator->pev, vecSrc + vecForward*16, vecForward * 1500, FALSE);
break;
case TANK_ROCKET_NUKE_CONTROLLED:
CNuke::ShootNuke(pActivator->pev, vecSrc + vecForward*16, vecForward * 800, TRUE);
break;
case TANK_ROCKET_FLAKBOMB:
CFlakBomb::ShootFlakBomb(pActivator->pev, vecSrc + vecForward*16, vecForward * 1800);
break;
case TANK_ROCKET_30MMGREN:
C30mmgren::Shoot30mmgren(pActivator->pev, vecSrc + vecForward*16, vecForward * 4500);
break;
case TANK_ROCKET_BIOMASS:
CBiomass::ShootBiomass(pActivator->pev, vecSrc + vecForward*16, vecForward * 3000, 200);
break;
case TANK_BEAM_BLASTER:
FireBeam(vecSrc, vecForward, BEAM_BLASTER, 0, pActivator->pev);
break;
case TANK_BEAM_GAUSS:
FireBeam(vecSrc, vecForward, BEAM_GAUSS, 0, pActivator->pev);
break;
case TANK_BEAM_GAUSSCHARGED:
FireBeam(vecSrc, vecForward, BEAM_GAUSSCHARGED, 420, pActivator->pev);
break;
case TANK_BEAM_PHOTONGUN:
FireBeam(vecSrc, vecForward, BEAM_PHOTONGUN, 0, pActivator->pev);
break;
case TANK_BEAM_PHOTONGUN_EXP:
FireBeam(vecSrc, vecForward, BEAM_PHOTONGUN_EXP, 0, pActivator->pev);
break;
case TANK_BEAM_TAUCANNON:
FireBeam(vecSrc, vecForward, BEAM_TAUCANNON, 0, pActivator->pev);
break;
case TANK_BEAM_PULSERIFLE:
FireBeam(vecSrc, vecForward, BEAM_PULSERIFLE, 0, pActivator->pev);
break;
case TANK_BEAM_M72:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_0DEGREES, 16384, BULLET_2MM, pActivator->pev);
break;
case TANK_BEAM_M72QUAD:
FireMagnumBullets(vecSrc, vecForward, VECTOR_CONE_0DEGREES, 16384, BULLET_2MM_QUAD, pActivator->pev);
break;
case TANK_BEAM_IONTURRET:
FireBeam(vecSrc, vecForward, BEAM_IONTURRET, 0, pActivator->pev);
break;
case TANK_BEAM_TESLAGUN:
FireBeam(vecSrc, vecForward, BEAM_TESLAGUN, 0, pActivator->pev);
break;
}
if (m_iAmmo > 0)
m_iAmmo--;
// update ammo counter
MESSAGE_BEGIN( MSG_ONE, gmsgSpecTank, NULL, pActivator->pev );
WRITE_BYTE( 2 ); // ammo update
WRITE_LONG(m_iAmmo);
WRITE_BYTE( m_spread ); // crosshair update
MESSAGE_END();
m_flNextAttack = gpGlobals->time + (1/m_fireRate);
}
else if ( pActivator->pev->button & IN_ATTACK2 && m_AllowZoom)
{
if (m_fInZoom == 0)
{
pActivator->m_iFOV = 25;
m_fInZoom = 1;
}
else if (m_fInZoom == 1)
{
pActivator->m_iFOV = 90;
m_fInZoom = 0;
}
m_flNextAttack = gpGlobals->time + 0.3;
}
}
