float GetFireRate(void) {
#ifdef MFS
#ifdef CLIENT_DLL
CHL2MPRules *pRules = HL2MPRules();
if (pRules->IsFlash() == true)
#else
if (HL2MPRules()->IsFlash() == true)
#endif
{
CHL2MP_Player *pOwner = ToHL2MPPlayer(GetOwner());
return KNIFE_REFIRE - KNIFE_REFIRE * (pOwner->speed_modifier / 2000 - pOwner->speed_modifier / 4000); //An insane Refire Rate
}
#endif
#ifdef CLIENT_DLL
#ifdef MFS
else
#endif
if (pRules->IsKnifeFight() == true)
#else
#ifdef MFS
else
#endif
if (HL2MPRules()->IsKnifeFight() == true)
#endif
return KNIFE_REFIRE*0.7;
else
return KNIFE_REFIRE;
}
void CGameDomCaptureZone::SoundThink(void)
{
SetNextThink(gpGlobals->curtime + 0.1f);
// Si ça appartient à aucune équipe, pas de son (genre points neutres en début de map)
if(HL2MPRules()->m_iDomZones[m_iZoneID] != TEAM_PINK && HL2MPRules()->m_iDomZones[m_iZoneID] != TEAM_GREEN)
return;
// Score toutes les 5 secondes, faut synchroniser le son avec
// float flDomScoreTimer = (HL2MPRules()->GetForceDomScoreTimer() != -1)?HL2MPRules()->GetForceDomScoreTimer():mp_dom_scoretime.GetFloat();
if(gpGlobals->curtime < (m_flLastScore + 5))
return;
m_flLastScore = gpGlobals->curtime;
int iScoreLeft = mp_scorelimit_dom.GetInt() - g_Teams[HL2MPRules()->m_iDomZones[m_iZoneID]]->GetScore();
int pitch = (pow(1.019f,-iScoreLeft+260))+30;
pitch = clamp(pitch, 30, 163);
CPASAttenuationFilter filter( this, 0.8 );
EmitSound_t ep;
ep.m_nChannel = CHAN_STATIC;
ep.m_pSoundName = "gameplay/domscore.wav";
ep.m_flVolume = 1.0f;
ep.m_SoundLevel = SNDLVL_80dB;
ep.m_nPitch = pitch;
EmitSound( filter, entindex(), ep );
}
void CGameFortsInfoZone::AddPlayerToInfosList(CBasePlayer *pPlayer)
{
if(pPlayer == NULL)
return;
if(pPlayer->GetTeamNumber() == TEAM_PINK)
{
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosPink[i] == NULL)
{
HL2MPRules()->m_apFortsInfosPink[i] = pPlayer;
break;
}
}
}
else
{
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosGreen[i] == NULL)
{
HL2MPRules()->m_apFortsInfosGreen[i] = pPlayer;
break;
}
}
}
}
void CFlechette::DoAOEDamage()
{
CBaseEntity *ppEnts[256];
Vector vecCenter = WorldSpaceCenter();
float flRadius = flechette_radius.GetFloat();
vecCenter.z -= flRadius * 0.8f;
int nEntCount = UTIL_EntitiesInSphere( ppEnts, 256, vecCenter, flRadius, 0 );
int i;
for ( i = 0; i < nEntCount; i++ )
{
if ( ppEnts[i] == NULL )
continue;
bool bDoDamage = true;
if(ppEnts[i]->IsPlayer() || ppEnts[i]->IsNPC())
{
CBasePlayer *pOtherPlayer = ToBasePlayer(ppEnts[i]);
CBasePlayer *pPlayer = ToBasePlayer(GetOwnerEntity());
if(pOtherPlayer != NULL && pPlayer != NULL)
{
if((HL2MPRules()->IsTeamplay() && (pPlayer->GetTeamNumber() == pOtherPlayer->GetTeamNumber()))
|| HL2MPRules()->GetGameType() == GAME_COOP)
{
const int oldHealth = pOtherPlayer->GetHealth();
pOtherPlayer->TakeHealth( HEAL_AMOUNT, DMG_GENERIC );
bDoDamage = false;
if(oldHealth <= HEAL_AMOUNT)
pOtherPlayer->PlayAutovocal(HEALED,0);
if(oldHealth != pOtherPlayer->GetHealth()) // Si on a vraiment heal
pOtherPlayer->EmitSound("Tranqu.Heal");
}
}
if(bDoDamage && ppEnts[i] != GetOwnerEntity())
{
int iApplyDamage = 0;
if(ppEnts[i]->IsNPC())
iApplyDamage = 70;
else
{
if(ppEnts[i]->GetHealth() < m_iDamage + 10)
iApplyDamage = 100;
else
iApplyDamage = ppEnts[i]->GetHealth() - m_iDamage;
}
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), GetOwnerEntity(), iApplyDamage, DMG_POISON | DMG_NEVERGIB );
//CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
dmgInfo.SetDamagePosition( vecCenter );
ppEnts[i]->TakeDamage(dmgInfo);
//ppEnts[i]->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
}
}
ApplyMultiDamage();
}
}
void CHL2MP_Player::ChangeTeam( int iTeam )
{
/* if ( GetNextTeamChangeTime() >= gpGlobals->curtime )
{
char szReturnString[128];
Q_snprintf( szReturnString, sizeof( szReturnString ), "Please wait %d more seconds before trying to switch teams again.\n", (int)(GetNextTeamChangeTime() - gpGlobals->curtime) );
ClientPrint( this, HUD_PRINTTALK, szReturnString );
return;
}*/
#ifndef GE_DLL
bool bKill = false;
if ( HL2MPRules()->IsTeamplay() != true && iTeam != TEAM_SPECTATOR )
{
//don't let them try to join combine or rebels during deathmatch.
iTeam = TEAM_UNASSIGNED;
}
if ( HL2MPRules()->IsTeamplay() == true )
{
if ( iTeam != GetTeamNumber() && GetTeamNumber() != TEAM_UNASSIGNED )
{
bKill = true;
}
}
BaseClass::ChangeTeam( iTeam );
m_flNextTeamChangeTime = gpGlobals->curtime + TEAM_CHANGE_INTERVAL;
if ( HL2MPRules()->IsTeamplay() == true )
{
SetPlayerTeamModel();
}
else
{
SetPlayerModel();
}
if ( iTeam == TEAM_SPECTATOR )
{
RemoveAllItems( true );
State_Transition( STATE_OBSERVER_MODE );
}
if ( bKill == true )
{
CommitSuicide();
}
#else
BaseClass::ChangeTeam( iTeam );
#endif
}
int CGameDomCaptureZone::DetermineZoneID(void)
{
for(int i = 0; i < DOM_MAX_ZONES; i++)
{
if(HL2MPRules()->m_iDomZones[i] == -1)
{
HL2MPRules()->m_iDomZones[i] = 0;
return i;
}
}
return -1;
}
void CPlayerFortsTimerProxy::OnBind( void *pC_BaseEntity )
{
if(HL2MPRules()->GetGameType() != GAME_FORTS)
return;
float flPhaseLimit = HL2MPRules()->GetLastFortsPhaseTime();
flPhaseLimit += HL2MPRules()->IsFortsBuildPhase() ? mp_forts_buildtime.GetFloat() * 60 : mp_forts_fighttime.GetFloat() * 60;
// Produit en croix
// ? | curtime
// 360 | phaselimit
SetFloatResult( ceil( gpGlobals->curtime * m_RangeMax.GetFloat() / flPhaseLimit ));
}
void CGameDomCaptureZone::CaptureZoneTouch(CBaseEntity *pEntity)
{
CBasePlayer *pPlayer = ToBasePlayer(pEntity);
if(!pPlayer)
return;
if(pPlayer->m_lifeState != LIFE_ALIVE)
return;
if(m_iZoneID == -1)
return;
if(HL2MPRules()->m_iDomZones[m_iZoneID] == pPlayer->GetTeamNumber())
return; // Déjà capturé par cette équipe
if(gpGlobals->curtime < m_flLastCapture + 2.0f)
return;
m_flLastCapture = gpGlobals->curtime;
HL2MPRules()->ResetDomTimer();
EmitSound("Gameplay.Domambient");
// Petite boucle moche pour reset toutes les zones
CBaseEntity *pEntity2 = gEntList.FirstEnt();
while( pEntity2 )
{
if(FClassnameIs(pEntity2, "game_dom_capturezone"))
{
CGameDomCaptureZone *pZone = dynamic_cast<CGameDomCaptureZone*>(pEntity2);
pZone->ResetScoreTimer();
}
pEntity2 = gEntList.NextEnt( pEntity2 );
}
HL2MPRules()->m_iDomZones[m_iZoneID] = pPlayer->GetTeamNumber();
if(pPlayer->GetTeamNumber() == TEAM_PINK)
m_OnPinkCapture.FireOutput(pPlayer, this);
else
m_OnGreenCapture.FireOutput(pPlayer, this);
DevMsg("Zone %d captured by team %d\n", m_iZoneID, pPlayer->GetTeamNumber());
IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
if( event )
{
event->SetInt("userid", 0 );
event->SetInt("attacker", pPlayer->GetUserID() );
event->SetString("weapon", "domcapture" );
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponTranquilizer::CreateLaserPointer( void )
{
#ifndef CLIENT_DLL
if ( m_hLaserDot != NULL )
return;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return;
if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return;
m_hLaserDot = CLaserDot::Create( GetAbsOrigin(), GetOwner() );
m_hLaserDot->TurnOff();
m_hLaserDot->SetRenderMode(kRenderWorldGlow);
if(HL2MPRules()->IsTeamplay())
{
if(pOwner->GetTeamNumber() == TEAM_PINK)
m_hLaserDot->SetRenderColor(255,100,255,255);
else
m_hLaserDot->SetRenderColor(153,255,153,255);
}
else
m_hLaserDot->SetRenderColor(255,0,0,255);
UpdateLaserPosition();
#endif
}
void CWeaponHL2MPBase::Materialize( void )
{
if ( IsEffectActive( EF_NODRAW ) )
{
// changing from invisible state to visible.
EmitSound( "AlyxEmp.Charge" );
RemoveEffects( EF_NODRAW );
DoMuzzleFlash();
}
if ( HasSpawnFlags( SF_NORESPAWN ) == false )
{
VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false );
SetMoveType( MOVETYPE_VPHYSICS );
HL2MPRules()->AddLevelDesignerPlacedObject( this );
}
if ( HasSpawnFlags( SF_NORESPAWN ) == false )
{
if ( GetOriginalSpawnOrigin() == vec3_origin )
{
m_vOriginalSpawnOrigin = GetAbsOrigin();
m_vOriginalSpawnAngles = GetAbsAngles();
}
}
SetPickupTouch();
SetThink (NULL);
}
//====================================================================================
// WEAPON SPAWNING
//====================================================================================
//-----------------------------------------------------------------------------
// Purpose: Make a weapon visible and tangible
//-----------------------------------------------------------------------------//
void CBaseCombatWeapon::Materialize( void )
{
if ( IsEffectActive( EF_NODRAW ) )
{
// changing from invisible state to visible.
#ifdef HL2MP
EmitSound( "AlyxEmp.Charge" );
#else
EmitSound( "BaseCombatWeapon.WeaponMaterialize" );
#endif
RemoveEffects( EF_NODRAW );
DoMuzzleFlash();
}
#ifdef HL2MP
if ( HasSpawnFlags( SF_NORESPAWN ) == false )
{
VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false );
SetMoveType( MOVETYPE_VPHYSICS );
HL2MPRules()->AddLevelDesignerPlacedObject( this );
}
#else
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
#endif
SetPickupTouch();
SetThink (NULL);
}
void CHL2MP_Player::CheckChatText( char *p, int bufsize )
{
//Look for escape sequences and replace
char *buf = new char[bufsize];
int pos = 0;
// Parse say text for escape sequences
for ( char *pSrc = p; pSrc != NULL && *pSrc != 0 && pos < bufsize-1; pSrc++ )
{
// copy each char across
buf[pos] = *pSrc;
pos++;
}
buf[pos] = '\0';
// copy buf back into p
Q_strncpy( p, buf, bufsize );
delete[] buf;
const char *pReadyCheck = p;
HL2MPRules()->CheckChatForReadySignal( this, pReadyCheck );
}
void C_HL2MP_Player::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
Vector vecOrigin = ptr->endpos - vecDir * 4;
float flDistance = 0.0f;
if ( info.GetAttacker() )
{
flDistance = (ptr->endpos - info.GetAttacker()->GetAbsOrigin()).Length();
}
if ( m_takedamage )
{
AddMultiDamage( info, this );
int blood = BloodColor();
CBaseEntity *pAttacker = info.GetAttacker();
if ( pAttacker )
{
if ( HL2MPRules()->IsTeamplay() && pAttacker->InSameTeam( this ) == true )
return;
}
if ( blood != DONT_BLEED )
{
SpawnBlood( vecOrigin, vecDir, blood, flDistance );// a little surface blood.
TraceBleed( flDistance, vecDir, ptr, info.GetDamageType() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Items that have just spawned run this think to catch them when
// they hit the ground. Once we're sure that the object is grounded,
// we change its solid type to trigger and set it in a large box that
// helps the player get it.
//-----------------------------------------------------------------------------
void CItem::FallThink ( void )
{
SetNextThink( gpGlobals->curtime + 0.1f );
bool shouldMaterialize = false;
IPhysicsObject *pPhysics = VPhysicsGetObject();
if ( pPhysics )
{
shouldMaterialize = pPhysics->IsAsleep();
}
else
{
shouldMaterialize = (GetFlags() & FL_ONGROUND) ? true : false;
}
if ( shouldMaterialize )
{
SetThink ( NULL );
m_vOriginalSpawnOrigin = GetAbsOrigin();
m_vOriginalSpawnAngles = GetAbsAngles();
HL2MPRules()->AddLevelDesignerPlacedObject( this );
}
}
bool CNPC_Zombine::AllowedToSprint( void )
{
if ( IsOnFire() )
return false;
//If you're sprinting then there's no reason to sprint again.
if ( IsSprinting() )
return false;
int iChance = SPRINT_CHANCE_VALUE;
//Secobmod FixMe ?? also changed to HL2MPRules
CHL2_Player *pPlayer = dynamic_cast <CHL2_Player*> ( UTIL_GetNearestPlayer(GetAbsOrigin() ));
//CHL2MP_Player *pPlayer = dynamic_cast<CHL2MP_Player *>( UTIL_GetNearestPlayer(GetAbsOrigin() );
if ( pPlayer )
{
#ifdef MFS
if ( HL2MPRules()->IsAlyxInDarknessMode() && pPlayer->FlashlightIsOn() == false )
#else
if (IsAlyxInDarknessMode() && pPlayer->FlashlightIsOn() == false)
#endif
{
iChance = SPRINT_CHANCE_VALUE_DARKNESS;
}
//Bigger chance of this happening if the player is not looking at the zombie
if ( pPlayer->FInViewCone( this ) == false )
{
iChance *= 2;
}
}
if ( HasGrenade() )
{
iChance *= 4;
}
//Below 25% health they'll always sprint
if ( ( GetHealth() > GetMaxHealth() * 0.5f ) )
{
if ( IsStrategySlotRangeOccupied( SQUAD_SLOT_ZOMBINE_SPRINT1, SQUAD_SLOT_ZOMBINE_SPRINT2 ) == true )
return false;
if ( random->RandomInt( 0, 100 ) > iChance )
return false;
if ( m_flSprintRestTime > gpGlobals->curtime )
return false;
}
float flLength = ( GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter() ).Length();
if ( flLength > MAX_SPRINT_DISTANCE )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pOther -
//-----------------------------------------------------------------------------
void CItem::ItemTouch( CBaseEntity *pOther )
{
// Vehicles can touch items + pick them up
if ( pOther->GetServerVehicle() )
{
pOther = pOther->GetServerVehicle()->GetPassenger();
if ( !pOther )
return;
}
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
return;
// Can I even pick stuff up?
if ( pOther->IsEFlagSet( EFL_NO_WEAPON_PICKUP ) )
return;
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// ok, a player is touching this item, but can he have it?
if ( !g_pGameRules->CanHaveItem( pPlayer, this ) )
{
// no? Ignore the touch.
return;
}
// Must be a valid pickup scenario (no blocking)
if ( ItemCanBeTouchedByPlayer( pPlayer ) == false )
return;
if ( MyTouch( pPlayer ) )
{
m_OnPlayerTouch.FireOutput(pOther, this);
SetTouch( NULL );
SetThink( NULL );
// player grabbed the item.
g_pGameRules->PlayerGotItem( pPlayer, this );
if ( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
{
Respawn();
}
else
{
UTIL_Remove( this );
#ifdef HL2MP
HL2MPRules()->RemoveLevelDesignerPlacedObject( this );
#endif
}
}
else if (gEvilImpulse101)
{
UTIL_Remove( this );
}
}
void CHL2MP_Player::Event_Killed( const CTakeDamageInfo &info )
{
//update damage info with our accumulated physics force
CTakeDamageInfo subinfo = info;
subinfo.SetDamageForce( m_vecTotalBulletForce );
//BP empêche de créer un ragdoll si on change de team en mode spectateur
if(GetTeamNumber() != TEAM_SPECTATOR)
CreateRagdollEntity();
BaseClass::Event_Killed( subinfo );
if ( info.GetDamageType() & DMG_DISSOLVE )
if ( m_hRagdoll )
m_hRagdoll->GetBaseAnimating()->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
CBaseEntity *pAttacker = info.GetAttacker();
if ( pAttacker )
{
int iScoreToAdd = 1;
if ( pAttacker == this)
{
if(HL2MPRules()->GetGameType() == GAME_TDM)
iScoreToAdd = 0;
else
iScoreToAdd = -1;
}
if((HL2MPRules()->GetGameType() == GAME_FORTS) || (HL2MPRules()->GetGameType() == GAME_PUSH))
iScoreToAdd = 0;
GetGlobalTeam( pAttacker->GetTeamNumber() )->AddScore( iScoreToAdd );
}
FlashlightTurnOff();
m_lifeState = LIFE_DEAD;
RemoveEffects( EF_NODRAW ); // still draw player body
StopZooming();
DetonateTripmines();
//BP enregistre le tueur
SetKiller(info.GetAttacker());
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
#ifdef GE_DLL
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
BaseClass::Spawn();
#else
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
RemoveEffects( EF_NOINTERP );
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
#endif
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
SetContextThink( &CHL2MP_Player::HL2MPPushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HL2MP_PUSHAWAY_THINK_CONTEXT );
}
bool CGameFortsInfoZone::AreInfosSlotsFilled(int team)
{
if(team != TEAM_PINK && team != TEAM_GREEN)
return false;
if(team == TEAM_PINK)
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosPink[i] == NULL)
return false;
}
else
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosGreen[i] == NULL)
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
pl.deadflag = false;
m_lifeState = LIFE_ALIVE;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
//BP On donne par défaut les armes correspondantes au mode de jeu
//GiveDefaultItems();
GiveAllItems();
RemoveEffects( EF_NOINTERP );
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
AddFlag( FL_FROZEN );
else
RemoveFlag( FL_FROZEN );
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
m_hKiller.Set(NULL);
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
SetContextThink( &CHL2MP_Player::HL2MPPushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HL2MP_PUSHAWAY_THINK_CONTEXT );
if ( GetTeamNumber() != TEAM_SPECTATOR )
StopObserverMode();
}
void CHoldout::HoldoutThink( void )
{
#ifdef MFS
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
if (!pPlayer)
{
SetNextThink(gpGlobals->curtime + 0.1f);
return;
}
if (m_Owner == TEAM_COMBINE)
{
if (pPlayer->GetBlueTime() >= 0.1f)
{
pPlayer->m_BlueTime = pPlayer->GetBlueTime() - 0.1f;
}
else
{
HL2MPRules()->GoToIntermission();
}
}
else if (m_Owner == TEAM_REBELS)
{
if (pPlayer->GetRedTime() >= 0.1f)
{
pPlayer->m_RedTime = pPlayer->GetRedTime() - 0.1f;
}
else
{
HL2MPRules()->GoToIntermission();
}
}
}
SetNextThink(gpGlobals->curtime + 0.1f);
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
SetNumAnimOverlays( 3 );
ResetAnimation();
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
m_flNextKickAttack = gpGlobals->curtime;
CBaseViewModel *Leg = GetViewModel(1);
Leg->SetWeaponModel("models/weapons/v_kick.mdl", NULL);
}
void CHL2MP_Player::PickDefaultSpawnTeam( void )
{
if ( GetTeamNumber() == 0 )
{
if ( HL2MPRules()->IsTeamplay() == false )
{
if ( GetModelPtr() == NULL )
{
const char *szModelName = NULL;
szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" );
if ( ValidatePlayerModel( szModelName ) == false )
{
char szReturnString[512];
//DHL - Skillet - Changed from combine soldier
Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel DHL_DEFAULTMODEL\n" );
engine->ClientCommand ( edict(), szReturnString );
}
ChangeTeam( TEAM_UNASSIGNED );
}
}
else
{
CTeam *pCombine = g_Teams[TEAM_COMBINE];
CTeam *pRebels = g_Teams[TEAM_REBELS];
if ( pCombine == NULL || pRebels == NULL )
{
ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) );
}
else
{
if ( pCombine->GetNumPlayers() > pRebels->GetNumPlayers() )
{
ChangeTeam( TEAM_REBELS );
}
else if ( pCombine->GetNumPlayers() < pRebels->GetNumPlayers() )
{
ChangeTeam( TEAM_COMBINE );
}
else
{
ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) );
}
}
}
}
}
bool CGameFortsInfoZone::IsPlayerCarryingInfos(CBasePlayer *pPlayer)
{
if(pPlayer == NULL)
return false;
if(pPlayer->GetTeamNumber() == TEAM_PINK)
{
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosPink[i] == pPlayer)
return true;
}
}
else
{
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosGreen[i] == pPlayer)
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
}
void CHL2MP_Player::PickDefaultSpawnTeam( void )
{
if ( GetTeamNumber() == 0 )
{
if ( HL2MPRules()->IsTeamplay() )
{
if(g_Teams[TEAM_GREEN]->GetNumPlayers() < g_Teams[TEAM_PINK]->GetNumPlayers())
ChangeTeam(TEAM_GREEN);
else
ChangeTeam(TEAM_PINK);
}
if ( GetModelPtr() == NULL )
ChangeTeam( TEAM_UNASSIGNED );
}
}
void CGameFortsInfoZone::ResetAllInfos(bool bPlayLostDataSound)
{
for(int i = 0; i < FORTS_MAX_INFOS; i++)
{
if(HL2MPRules()->m_apFortsInfosPink[i] != NULL)
{
HL2MPRules()->m_apFortsInfosPink[i]->m_nSkin = toSkinId(PLAYER_SKIN_ROSE);
HL2MPRules()->m_apFortsInfosPink[i]->EmitSound("Gameplay.Forts.LostData");
HL2MPRules()->m_apFortsInfosPink[i] = NULL;
}
if(HL2MPRules()->m_apFortsInfosGreen[i] != NULL)
{
HL2MPRules()->m_apFortsInfosGreen[i]->m_nSkin = toSkinId(PLAYER_SKIN_VERT);
HL2MPRules()->m_apFortsInfosGreen[i]->EmitSound("Gameplay.Forts.LostData");
HL2MPRules()->m_apFortsInfosGreen[i] = NULL;
}
}
}
// Le GameType est défini par un game_config, comme ce con là a pas forcément
// été spawn avant l'infozone, il faut faire les vérifications après
// le spawn de toutes les entités, ::Activate() donc
void CGameFortsInfoZone::Activate(void)
{
BaseClass::Activate();
SetTouch( &CGameFortsInfoZone::InfoZoneTouch );
if(HL2MPRules()->GetGameType() != GAME_FORTS)
{
Warning("game_forts_infozone in a non-forts game\n");
SetTouch( NULL );
}
if(m_iTeam != TEAM_PINK && m_iTeam != TEAM_GREEN)
{
Warning("Invalid team for game_forts_infozone\n");
SetTouch( NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFlechette::Spawn( void )
{
Precache( );
SetModel( BOLT_MODEL );
SetMoveType( MOVETYPE_FLY, MOVECOLLIDE_FLY_CUSTOM );
UTIL_SetSize( this, -Vector(1,1,1), Vector(1,1,1) );
SetSolid( SOLID_BBOX );
// Make sure we're updated if we're underwater
UpdateWaterState();
SetTouch( &CFlechette::BoltTouch );
SetThink( &CFlechette::BubbleThink );
SetNextThink( gpGlobals->curtime + 0.1f );
CBasePlayer *pPlayer = ToBasePlayer(GetOwnerEntity());
if(pPlayer != NULL && HL2MPRules()->IsTeamplay())
{
if(pPlayer->GetTeamNumber() == TEAM_PINK)
m_nSkin = 1;
else if(pPlayer->GetTeamNumber() == TEAM_GREEN)
m_nSkin = 2;
else
m_nSkin = 0;
}
m_pGlowTrail = CSpriteTrail::SpriteTrailCreate( "sprites/grenade/grenade_laser.vmt", GetLocalOrigin(), false );
if ( m_pGlowTrail != NULL )
{
m_pGlowTrail->FollowEntity( this );
if(m_nSkin == 1)
m_pGlowTrail->SetTransparency( kRenderTransAdd, 255, 50, 255, 70, kRenderFxNone );
else if(m_nSkin == 2)
m_pGlowTrail->SetTransparency( kRenderTransAdd, 0, 255, 0, 70, kRenderFxNone );
else
m_pGlowTrail->SetTransparency( kRenderTransAdd, 255, 255, 255, 70, kRenderFxNone );
m_pGlowTrail->SetStartWidth( 3.0f );
m_pGlowTrail->SetEndWidth( 0.5f );
m_pGlowTrail->SetLifeTime( 0.4f );
}
}
void FinishClientPutInServer( CHL2MP_Player *pPlayer )
{
pPlayer->InitialSpawn();
//BB: we dont want players to spawn immediately when joining the server, we want them to auto spectate
//pPlayer->Spawn();
pPlayer->ChangeTeam( TEAM_SPECTATOR );
char sName[128];
Q_strncpy( sName, pPlayer->GetPlayerName(), sizeof( sName ) );
// First parse the name and remove any %'s
for ( char *pApersand = sName; pApersand != NULL && *pApersand != 0; pApersand++ )
{
// Replace it with a space
if ( *pApersand == '%' )
*pApersand = ' ';
}
// notify other clients of player joining the game
UTIL_ClientPrintAll( HUD_PRINTNOTIFY, "#Game_connected", sName[0] != 0 ? sName : "<unconnected>" );
if ( HL2MPRules()->IsTeamplay() == true )
{
ClientPrint( pPlayer, HUD_PRINTTALK, "You are on team %s1\n", pPlayer->GetTeam()->GetName() );
}
const ConVar *hostname = cvar->FindVar( "hostname" );
const char *title = (hostname) ? hostname->GetString() : "MESSAGE OF THE DAY";
KeyValues *data = new KeyValues("data");
data->SetString( "title", title ); // info panel title
data->SetString( "type", "1" ); // show userdata from stringtable entry
data->SetString( "msg", "motd" ); // use this stringtable entry
data->SetBool( "unload", sv_motd_unload_on_dismissal.GetBool() );
//BB: Display the team selection panel...
pPlayer->ShowViewPortPanel( PANEL_TEAM, true, data );
pPlayer->ShowViewPortPanel( PANEL_INFO, true, data );
data->deleteThis();
}
