bool PrintSDKEvent( IGameEvent * event ) // print Mod specific logs
{
const char *eventName = event->GetName();
if ( !Q_strncmp( eventName, "server_", strlen("server_")) )
{
return false; // ignore server_ messages, always.
}
#if defined ( SDK_USE_PLAYERCLASSES )
if ( FStrEq( eventName, "player_changeclass" ) )
{
const int userid = event->GetInt( "userid" );
CBasePlayer *pPlayer = UTIL_PlayerByUserId( userid );
if ( !pPlayer )
{
return false;
}
int iClass = event->GetInt("class");
int iTeam = pPlayer->GetTeamNumber();
//Tony; when using teams, the player can only select classes on blue or red.
#if defined ( SDK_USE_TEAMS )
if ( iTeam != SDK_TEAM_BLUE && iTeam != SDK_TEAM_RED )
#else
if ( iTeam != TEAM_UNASSIGNED )
#endif
return true;
CSDKTeam *pTeam = GetGlobalSDKTeam( iTeam );
if ( iClass == PLAYERCLASS_RANDOM )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" changed role to \"Random\"\n",
pPlayer->GetPlayerName(),
userid,
pPlayer->GetNetworkIDString(),
pTeam->GetName()
);
}
else if ( iClass < GetGlobalSDKTeam(iTeam)->GetNumPlayerClasses() )
{
const CSDKPlayerClassInfo &pInfo = GetGlobalSDKTeam(iTeam)->GetPlayerClassInfo( iClass );
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" changed role to \"%s\"\n",
pPlayer->GetPlayerName(),
userid,
pPlayer->GetNetworkIDString(),
pTeam->GetName(),
pInfo.m_szPrintName
);
}
return true;
}
#endif // SDK_USE_PLAYERCLASSES
return false;
}
int CSDKGameRules::SelectDefaultTeam()
{
int team = TEAM_UNASSIGNED;
#if defined ( SDK_USE_TEAMS )
CSDKTeam *pBlue = GetGlobalSDKTeam(SDK_TEAM_BLUE);
CSDKTeam *pRed = GetGlobalSDKTeam(SDK_TEAM_RED);
int iNumBlue = pBlue->GetNumPlayers();
int iNumRed = pRed->GetNumPlayers();
int iBluePoints = pBlue->GetScore();
int iRedPoints = pRed->GetScore();
// Choose the team that's lacking players
if ( iNumBlue < iNumRed )
{
team = SDK_TEAM_BLUE;
}
else if ( iNumBlue > iNumRed )
{
team = SDK_TEAM_RED;
}
// choose the team with fewer points
else if ( iBluePoints < iRedPoints )
{
team = SDK_TEAM_BLUE;
}
else if ( iBluePoints > iRedPoints )
{
team = SDK_TEAM_RED;
}
else
{
// Teams and scores are equal, pick a random team
team = ( random->RandomInt(0,1) == 0 ) ? SDK_TEAM_BLUE : SDK_TEAM_RED;
}
if ( TeamFull( team ) )
{
// Pick the opposite team
if ( team == SDK_TEAM_BLUE )
{
team = SDK_TEAM_RED;
}
else
{
team = SDK_TEAM_BLUE;
}
// No choices left
if ( TeamFull( team ) )
return TEAM_UNASSIGNED;
}
#endif // SDK_USE_TEAMS
return team;
}
//Tony; we only check this when using teams, unassigned can never get full.
bool CSDKGameRules::TeamFull( int team_id )
{
switch ( team_id )
{
case SDK_TEAM_BLUE:
{
int iNumBlue = GetGlobalSDKTeam(SDK_TEAM_BLUE)->GetNumPlayers();
return iNumBlue >= m_iSpawnPointCount_Blue;
}
case SDK_TEAM_RED:
{
int iNumRed = GetGlobalSDKTeam(SDK_TEAM_RED)->GetNumPlayers();
return iNumRed >= m_iSpawnPointCount_Red;
}
}
return false;
}
bool CSDKGameRules::IsPlayerClassOnTeam( int cls, int team )
{
if( cls == PLAYERCLASS_RANDOM )
return true;
CSDKTeam *pTeam = GetGlobalSDKTeam( team );
return ( cls >= 0 && cls < pTeam->GetNumPlayerClasses() );
}
void CArmorRechargerClassic::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// if it's not a player, ignore
if ( !pActivator || !pActivator->IsPlayer())
{
return;
}
else if (GameRules()->GetGameMode() == GAMEMODE_CLASSIC)
{
if (ClassicGameRules()->GetCurrentPhaseID() == PHASE_BUILD)
{
if (m_flSoundTime <= gpGlobals->curtime)
{
m_flSoundTime = gpGlobals->curtime + 0.62;
EmitSound( "SuitRecharge.Deny" );
}
return;
}
else if (GetTeamNumber() != pActivator->GetTeamNumber() &&
GetTeamNumber() != TEAM_SPECTATOR)
{
if (m_flSoundTime <= gpGlobals->curtime)
{
CBasePlayer *pPlayer = ToBasePlayer( pActivator );
Assert( pPlayer );
ClientPrint( pPlayer, HUD_PRINTTALK, "#lf_armor_charger_deny" );
m_flSoundTime = gpGlobals->curtime + 0.62;
EmitSound( "SuitRecharge.Deny" );
}
return;
}
}
CSDKPlayer *pPlayer = ToSDKPlayer( pCaller );
AssertMsg( pPlayer, "Failure SDKPlayer Armor charger\n" );
CSDKTeam *pTeam = GetGlobalSDKTeam( pPlayer->GetTeamNumber() );
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( pPlayer->m_Shared.PlayerClass() );
SetMaxArmor( pClassInfo.m_iArmor );
BaseClass::Use( pActivator, pCaller, useType, value );
}
void CSDKGameRules::ChooseRandomClass( CSDKPlayer *pPlayer )
{
int i;
int numChoices = 0;
int choices[16];
int firstclass = 0;
CSDKTeam *pTeam = GetGlobalSDKTeam( pPlayer->GetTeamNumber() );
int lastclass = pTeam->GetNumPlayerClasses();
int previousClass = pPlayer->m_Shared.PlayerClass();
// Compile a list of the classes that aren't full
for( i=firstclass;i<lastclass;i++ )
{
// don't join the same class twice in a row
if ( i == previousClass )
continue;
if( CanPlayerJoinClass( pPlayer, i ) )
{
choices[numChoices] = i;
numChoices++;
}
}
// If ALL the classes are full
if( numChoices == 0 )
{
Msg( "Random class found that all classes were full - ignoring class limits for this spawn\n" );
pPlayer->m_Shared.SetPlayerClass( random->RandomFloat( firstclass, lastclass ) );
}
else
{
// Choose a slot randomly
i = random->RandomInt( 0, numChoices-1 );
// We are now the class that was in that slot
pPlayer->m_Shared.SetPlayerClass( choices[i] );
}
}
const char *CSDKGameRules::GetPlayerClassName( int cls, int team )
{
CSDKTeam *pTeam = GetGlobalSDKTeam( team );
if( cls == PLAYERCLASS_RANDOM )
{
return "#class_random";
}
if( cls < 0 || cls >= pTeam->GetNumPlayerClasses() )
{
Assert( false );
return NULL;
}
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( cls );
return pClassInfo.m_szPrintName;
}
int CSDKGameRules::GetClassLimit( int team, int cls )
{
CSDKTeam *pTeam = GetGlobalSDKTeam( team );
Assert( pTeam );
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( cls );
int iClassLimit;
ConVar *pLimitCvar = ( ConVar * )cvar->FindVar( pClassInfo.m_szLimitCvar );
Assert( pLimitCvar );
if( pLimitCvar )
iClassLimit = pLimitCvar->GetInt();
else
iClassLimit = -1;
return iClassLimit;
}
void CSDKPlayer::InitSpeeds()
{
#if !defined ( SDK_USE_PLAYERCLASSES )
m_Shared.m_flRunSpeed = SDK_DEFAULT_PLAYER_RUNSPEED;
m_Shared.m_flSprintSpeed = SDK_DEFAULT_PLAYER_SPRINTSPEED;
m_Shared.m_flProneSpeed = SDK_DEFAULT_PLAYER_PRONESPEED;
// Set the absolute max to sprint speed
SetMaxSpeed( m_Shared.m_flSprintSpeed );
return;
#endif
#if defined ( SDK_USE_PLAYERCLASSES )
int playerclass = m_Shared.PlayerClass();
//Tony; error checkings.
if ( playerclass == PLAYERCLASS_UNDEFINED )
{
m_Shared.m_flRunSpeed = SDK_DEFAULT_PLAYER_RUNSPEED;
m_Shared.m_flSprintSpeed = SDK_DEFAULT_PLAYER_SPRINTSPEED;
m_Shared.m_flProneSpeed = SDK_DEFAULT_PLAYER_PRONESPEED;
}
else
{
CSDKTeam *pTeam = GetGlobalSDKTeam( GetTeamNumber() );
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( playerclass );
Assert( pClassInfo.m_iTeam == GetTeamNumber() );
m_Shared.m_flRunSpeed = pClassInfo.m_flRunSpeed;
m_Shared.m_flSprintSpeed = pClassInfo.m_flSprintSpeed;
m_Shared.m_flProneSpeed = pClassInfo.m_flProneSpeed;
}
// Set the absolute max to sprint speed
SetMaxSpeed( m_Shared.m_flSprintSpeed );
#endif // SDK_USE_PLAYERCLASSES
}
void CSDKGameRules::PlayerSpawn( CBasePlayer *p )
{
CSDKPlayer *pPlayer = ToSDKPlayer( p );
int team = pPlayer->GetTeamNumber();
if( team != TEAM_SPECTATOR )
{
#if defined ( SDK_USE_PLAYERCLASSES )
if( pPlayer->m_Shared.DesiredPlayerClass() == PLAYERCLASS_RANDOM )
{
ChooseRandomClass( pPlayer );
ClientPrint( pPlayer, HUD_PRINTTALK, "#game_now_as", GetPlayerClassName( pPlayer->m_Shared.PlayerClass(), team ) );
}
else
{
pPlayer->m_Shared.SetPlayerClass( pPlayer->m_Shared.DesiredPlayerClass() );
}
int playerclass = pPlayer->m_Shared.PlayerClass();
if( playerclass != PLAYERCLASS_UNDEFINED )
{
//Assert( PLAYERCLASS_UNDEFINED < playerclass && playerclass < NUM_PLAYERCLASSES );
CSDKTeam *pTeam = GetGlobalSDKTeam( team );
const CSDKPlayerClassInfo &pClassInfo = pTeam->GetPlayerClassInfo( playerclass );
Assert( pClassInfo.m_iTeam == team );
pPlayer->SetModel( pClassInfo.m_szPlayerModel );
pPlayer->SetHitboxSet( 0 );
char buf[64];
int bufsize = sizeof(buf);
//Give weapons
// Primary weapon
Q_snprintf( buf, bufsize, "weapon_%s", WeaponIDToAlias(pClassInfo.m_iPrimaryWeapon) );
CBaseEntity *pPrimaryWpn = pPlayer->GiveNamedItem( buf );
Assert( pPrimaryWpn );
// Secondary weapon
CBaseEntity *pSecondaryWpn = NULL;
if ( pClassInfo.m_iSecondaryWeapon != WEAPON_NONE )
{
Q_snprintf( buf, bufsize, "weapon_%s", WeaponIDToAlias(pClassInfo.m_iSecondaryWeapon) );
pSecondaryWpn = pPlayer->GiveNamedItem( buf );
}
// Melee weapon
if ( pClassInfo.m_iMeleeWeapon )
{
Q_snprintf( buf, bufsize, "weapon_%s", WeaponIDToAlias(pClassInfo.m_iMeleeWeapon) );
pPlayer->GiveNamedItem( buf );
}
CWeaponSDKBase *pWpn = NULL;
// Primary Ammo
pWpn = dynamic_cast<CWeaponSDKBase *>(pPrimaryWpn);
if( pWpn )
{
int iNumClip = pWpn->GetSDKWpnData().m_iDefaultAmmoClips - 1; //account for one clip in the gun
int iClipSize = pWpn->GetSDKWpnData().iMaxClip1;
pPlayer->GiveAmmo( iNumClip * iClipSize, pWpn->GetSDKWpnData().szAmmo1 );
}
// Secondary Ammo
if ( pSecondaryWpn )
{
pWpn = dynamic_cast<CWeaponSDKBase *>(pSecondaryWpn);
if( pWpn )
{
int iNumClip = pWpn->GetSDKWpnData().m_iDefaultAmmoClips - 1; //account for one clip in the gun
int iClipSize = pWpn->GetSDKWpnData().iMaxClip1;
pPlayer->GiveAmmo( iNumClip * iClipSize, pWpn->GetSDKWpnData().szAmmo1 );
}
}
// Grenade Type 1
if ( pClassInfo.m_iGrenType1 != WEAPON_NONE )
{
Q_snprintf( buf, bufsize, "weapon_%s", WeaponIDToAlias(pClassInfo.m_iGrenType1) );
CBaseEntity *pGrenade = pPlayer->GiveNamedItem( buf );
Assert( pGrenade );
pWpn = dynamic_cast<CWeaponSDKBase *>(pGrenade);
if( pWpn )
{
pPlayer->GiveAmmo( pClassInfo.m_iNumGrensType1 - 1, pWpn->GetSDKWpnData().szAmmo1 );
}
}
// Grenade Type 2
if ( pClassInfo.m_iGrenType2 != WEAPON_NONE )
{
Q_snprintf( buf, bufsize, "weapon_%s", WeaponIDToAlias(pClassInfo.m_iGrenType2) );
CBaseEntity *pGrenade2 = pPlayer->GiveNamedItem( buf );
Assert( pGrenade2 );
pWpn = dynamic_cast<CWeaponSDKBase *>(pGrenade2);
if( pWpn )
{
pPlayer->GiveAmmo( pClassInfo.m_iNumGrensType2 - 1, pWpn->GetSDKWpnData().szAmmo1 );
}
}
pPlayer->Weapon_Switch( (CBaseCombatWeapon *)pPrimaryWpn );
// DevMsg("setting spawn armor to: %d\n", pClassInfo.m_iArmor );
pPlayer->SetSpawnArmorValue( pClassInfo.m_iArmor );
}
else
{
// Assert( !"Player spawning with PLAYERCLASS_UNDEFINED" );
pPlayer->SetModel( SDK_PLAYER_MODEL );
}
#else
pPlayer->GiveDefaultItems();
#endif // SDK_USE_PLAYERCLASSES
pPlayer->SetMaxSpeed( 600 );
}
}
bool CSDKPlayer::ClientCommand( const CCommand &args )
{
const char *pcmd = args[0];
if ( FStrEq( pcmd, "jointeam" ) )
{
if ( args.ArgC() < 2 )
{
Warning( "Player sent bad jointeam syntax\n" );
}
int iTeam = atoi( args[1] );
HandleCommand_JoinTeam( iTeam );
return true;
}
else if( !Q_strncmp( pcmd, "cls_", 4 ) )
{
#if defined ( SDK_USE_PLAYERCLASSES )
CSDKTeam *pTeam = GetGlobalSDKTeam( GetTeamNumber() );
Assert( pTeam );
int iClassIndex = PLAYERCLASS_UNDEFINED;
if( pTeam->IsClassOnTeam( pcmd, iClassIndex ) )
{
HandleCommand_JoinClass( iClassIndex );
}
else
{
DevMsg( "player tried to join a class that isn't on this team ( %s )\n", pcmd );
ShowClassSelectMenu();
}
#endif
return true;
}
else if ( FStrEq( pcmd, "spectate" ) )
{
// instantly join spectators
HandleCommand_JoinTeam( TEAM_SPECTATOR );
return true;
}
else if ( FStrEq( pcmd, "joingame" ) )
{
// player just closed MOTD dialog
if ( m_iPlayerState == STATE_WELCOME )
{
//Tony; using teams, go to picking team.
#if defined( SDK_USE_TEAMS )
State_Transition( STATE_PICKINGTEAM );
//Tony; not using teams, but we are using classes, so go straight to class picking.
#elif !defined ( SDK_USE_TEAMS ) && defined ( SDK_USE_PLAYERCLASSES )
State_Transition( STATE_PICKINGCLASS );
//Tony; not using teams or classes, go straight to active.
#else
State_Transition( STATE_ACTIVE );
#endif
}
return true;
}
else if ( FStrEq( pcmd, "joinclass" ) )
{
#if defined ( SDK_USE_PLAYERCLASSES )
if ( args.ArgC() < 2 )
{
Warning( "Player sent bad joinclass syntax\n" );
}
int iClass = atoi( args[1] );
HandleCommand_JoinClass( iClass );
#endif
return true;
}
else if ( FStrEq( pcmd, "menuopen" ) )
{
#if defined ( SDK_USE_PLAYERCLASSES )
SetClassMenuOpen( true );
#endif
return true;
}
else if ( FStrEq( pcmd, "menuclosed" ) )
{
#if defined ( SDK_USE_PLAYERCLASSES )
SetClassMenuOpen( false );
#endif
return true;
}
else if ( FStrEq( pcmd, "droptest" ) )
{
ThrowActiveWeapon();
return true;
}
return BaseClass::ClientCommand( args );
}
