source-engine/game/server/team.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

346 lines
10 KiB
C++

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Team management class. Contains all the details for a specific team
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "team.h"
#include "player.h"
#include "team_spawnpoint.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
CUtlVector< CTeam * > g_Teams;
//-----------------------------------------------------------------------------
// Purpose: SendProxy that converts the Team's player UtlVector to entindexes
//-----------------------------------------------------------------------------
void SendProxy_PlayerList( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
CTeam *pTeam = (CTeam*)pData;
// If this assertion fails, then SendProxyArrayLength_PlayerArray must have failed.
Assert( iElement < pTeam->m_aPlayers.Size() );
CBasePlayer *pPlayer = pTeam->m_aPlayers[iElement];
pOut->m_Int = pPlayer->entindex();
}
int SendProxyArrayLength_PlayerArray( const void *pStruct, int objectID )
{
CTeam *pTeam = (CTeam*)pStruct;
return pTeam->m_aPlayers.Count();
}
// Datatable
IMPLEMENT_SERVERCLASS_ST_NOBASE(CTeam, DT_Team)
SendPropInt( SENDINFO(m_iTeamNum), 5 ),
SendPropInt( SENDINFO(m_iScore), 0 ),
SendPropInt( SENDINFO(m_iRoundsWon), 8 ),
SendPropString( SENDINFO( m_szTeamname ) ),
SendPropArray2(
SendProxyArrayLength_PlayerArray,
SendPropInt("player_array_element", 0, 4, 10, SPROP_UNSIGNED, SendProxy_PlayerList),
MAX_PLAYERS,
0,
"player_array"
)
END_SEND_TABLE()
LINK_ENTITY_TO_CLASS( team_manager, CTeam );
//-----------------------------------------------------------------------------
// Purpose: Get a pointer to the specified team manager
//-----------------------------------------------------------------------------
CTeam *GetGlobalTeam( int iIndex )
{
if ( iIndex < 0 || iIndex >= GetNumberOfTeams() )
return NULL;
return g_Teams[ iIndex ];
}
//-----------------------------------------------------------------------------
// Purpose: Get the number of team managers
//-----------------------------------------------------------------------------
int GetNumberOfTeams( void )
{
return g_Teams.Size();
}
//-----------------------------------------------------------------------------
// Purpose: Needed because this is an entity, but should never be used
//-----------------------------------------------------------------------------
CTeam::CTeam( void )
{
memset( m_szTeamname.GetForModify(), 0, sizeof(m_szTeamname) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTeam::~CTeam( void )
{
m_aSpawnPoints.Purge();
m_aPlayers.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: Called every frame
//-----------------------------------------------------------------------------
void CTeam::Think( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Teams are always transmitted to clients
//-----------------------------------------------------------------------------
int CTeam::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_ALWAYS );
}
//-----------------------------------------------------------------------------
// Visibility/scanners
//-----------------------------------------------------------------------------
bool CTeam::ShouldTransmitToPlayer( CBasePlayer* pRecipient, CBaseEntity* pEntity ) const
{
// Always transmit the observer target to players
if ( pRecipient && pRecipient->IsObserver() && pRecipient->GetObserverTarget() == pEntity )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------------------
void CTeam::Init( const char *pName, int iNumber )
{
InitializeSpawnpoints();
InitializePlayers();
m_iScore = 0;
Q_strncpy( m_szTeamname.GetForModify(), pName, MAX_TEAM_NAME_LENGTH );
m_iTeamNum = iNumber;
}
//-----------------------------------------------------------------------------
// DATA HANDLING
//-----------------------------------------------------------------------------
int CTeam::GetTeamNumber( void ) const
{
return m_iTeamNum;
}
//-----------------------------------------------------------------------------
// Purpose: Get the team's name
//-----------------------------------------------------------------------------
const char *CTeam::GetName( void ) const
{
return m_szTeamname;
}
//-----------------------------------------------------------------------------
// Purpose: Update the player's client data
//-----------------------------------------------------------------------------
void CTeam::UpdateClientData( CBasePlayer *pPlayer )
{
}
//------------------------------------------------------------------------------------------------------------------
// SPAWNPOINTS
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::InitializeSpawnpoints( void )
{
m_iLastSpawn = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::AddSpawnpoint( CTeamSpawnPoint *pSpawnpoint )
{
m_aSpawnPoints.AddToTail( pSpawnpoint );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::RemoveSpawnpoint( CTeamSpawnPoint *pSpawnpoint )
{
for (int i = 0; i < m_aSpawnPoints.Size(); i++ )
{
if ( m_aSpawnPoints[i] == pSpawnpoint )
{
m_aSpawnPoints.Remove( i );
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the player at one of this team's spawnpoints. Return true if successful.
//-----------------------------------------------------------------------------
CBaseEntity *CTeam::SpawnPlayer( CBasePlayer *pPlayer )
{
if ( m_aSpawnPoints.Size() == 0 )
return NULL;
// Randomize the start spot
int iSpawn = m_iLastSpawn + random->RandomInt( 1,3 );
if ( iSpawn >= m_aSpawnPoints.Size() )
iSpawn -= m_aSpawnPoints.Size();
int iStartingSpawn = iSpawn;
// Now loop through the spawnpoints and pick one
int loopCount = 0;
do
{
if ( iSpawn >= m_aSpawnPoints.Size() )
{
++loopCount;
iSpawn = 0;
}
// check if pSpot is valid, and that the player is on the right team
if ( (loopCount > 3) || m_aSpawnPoints[iSpawn]->IsValid( pPlayer ) )
{
// DevMsg( 1, "player: spawning at (%s)\n", STRING(m_aSpawnPoints[iSpawn]->m_iName) );
m_aSpawnPoints[iSpawn]->m_OnPlayerSpawn.FireOutput( pPlayer, m_aSpawnPoints[iSpawn] );
m_iLastSpawn = iSpawn;
return m_aSpawnPoints[iSpawn];
}
iSpawn++;
} while ( iSpawn != iStartingSpawn ); // loop if we're not back to the start
return NULL;
}
//------------------------------------------------------------------------------------------------------------------
// PLAYERS
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::InitializePlayers( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Add the specified player to this team. Remove them from their current team, if any.
//-----------------------------------------------------------------------------
void CTeam::AddPlayer( CBasePlayer *pPlayer )
{
m_aPlayers.AddToTail( pPlayer );
NetworkStateChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Remove this player from the team
//-----------------------------------------------------------------------------
void CTeam::RemovePlayer( CBasePlayer *pPlayer )
{
m_aPlayers.FindAndRemove( pPlayer );
NetworkStateChanged();
}
//-----------------------------------------------------------------------------
// Purpose: Return the number of players in this team.
//-----------------------------------------------------------------------------
int CTeam::GetNumPlayers( void ) const
{
return m_aPlayers.Size();
}
//-----------------------------------------------------------------------------
// Purpose: Get a specific player
//-----------------------------------------------------------------------------
CBasePlayer *CTeam::GetPlayer( int iIndex ) const
{
Assert( iIndex >= 0 && iIndex < m_aPlayers.Size() );
return m_aPlayers[ iIndex ];
}
//------------------------------------------------------------------------------------------------------------------
// SCORING
//-----------------------------------------------------------------------------
// Purpose: Add / Remove score for this team
//-----------------------------------------------------------------------------
void CTeam::AddScore( int iScore )
{
m_iScore += iScore;
}
void CTeam::SetScore( int iScore )
{
m_iScore = iScore;
}
//-----------------------------------------------------------------------------
// Purpose: Get this team's score
//-----------------------------------------------------------------------------
int CTeam::GetScore( void ) const
{
return m_iScore;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::ResetScores( void )
{
SetScore(0);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeam::AwardAchievement( int iAchievement )
{
Assert( iAchievement >= 0 && iAchievement < 255 ); // must fit in short
CRecipientFilter filter;
int iNumPlayers = GetNumPlayers();
for ( int i=0;i<iNumPlayers;i++ )
{
if ( GetPlayer(i) )
{
filter.AddRecipient( GetPlayer(i) );
}
}
UserMessageBegin( filter, "AchievementEvent" );
WRITE_SHORT( iAchievement );
MessageEnd();
}
int CTeam::GetAliveMembers( void ) const
{
int iAlive = 0;
int iNumPlayers = GetNumPlayers();
for ( int i=0;i<iNumPlayers;i++ )
{
if ( GetPlayer(i) && GetPlayer(i)->IsAlive() )
{
iAlive++;
}
}
return iAlive;
}