etqw-sdk/source/game/structures/TeamManager.cpp

1497 lines
37 KiB
C++
Raw Permalink Normal View History

2008-05-29 00:00:00 +00:00
// Copyright (C) 2007 Id Software, Inc.
//
#include "../precompiled.h"
#pragma hdrstop
#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#include "TeamManager.h"
#include "../structures/DeployRequest.h"
#include "../Player.h"
#include "../script/Script_Helper.h"
#include "../script/Script_ScriptObject.h"
#include "../rules/VoteManager.h"
#include "../roles/FireTeams.h"
#include "../botai/Bot.h" //mal: needed for the bots.
#include "../botai/BotThreadData.h"
/*
===============================================================================
sdTeamManagerLocal
===============================================================================
*/
/*
================
sdTeamManagerGameState::MakeDefault
================
*/
void sdTeamManagerGameState::MakeDefault( void ) {
teamData.SetNum( sdTeamManager::GetInstance().GetNumTeams() );
for ( int i = 0; i < teamData.Num(); i++ ) {
teamData[ i ].MakeDefault();
}
}
/*
================
sdTeamManagerGameState::Write
================
*/
void sdTeamManagerGameState::Write( idFile* file ) const {
for ( int i = 0; i < teamData.Num(); i++ ) {
teamData[ i ].Write( file );
}
}
/*
================
sdTeamManagerGameState::Read
================
*/
void sdTeamManagerGameState::Read( idFile* file ) {
teamData.SetNum( sdTeamManager::GetInstance().GetNumTeams() );
for ( int i = 0; i < teamData.Num(); i++ ) {
teamData[ i ].Read( file );
}
}
/*
================
sdTeamManagerLocal::sdTeamManagerLocal
================
*/
sdTeamManagerLocal::sdTeamManagerLocal( void ) {
stateObject.Init( this );
}
/*
================
sdTeamManagerLocal::~sdTeamManagerLocal
================
*/
sdTeamManagerLocal::~sdTeamManagerLocal( void ) {
Shutdown();
}
/*
================
sdTeamManagerLocal::Think
================
*/
void sdTeamManagerLocal::Think( void ) {
int i;
for( i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->Think();
// Gordon: FIXME: This could be done better without polling.
if ( teamInfo[ i ]->GetBotTeam() == GDF ) {
botThreadData.GetGameWorldState()->gameLocalInfo.nextGDFRespawnTime = ( teamInfo[ i ]->GetTeamRespawnTime() - ( gameLocal.time / 1000 ));
} else if ( teamInfo[ i ]->GetBotTeam() == STROGG ) {
botThreadData.GetGameWorldState()->gameLocalInfo.nextStroggRespawnTime = ( teamInfo[ i ]->GetTeamRespawnTime() - ( gameLocal.time / 1000 ));
}
}
}
/*
================
sdTeamManagerLocal::Init
================
*/
void sdTeamManagerLocal::Init( void ) {
for( int i = 0; i < gameLocal.declTeamInfoType.Num(); i++ ) {
sdTeamInfo* newTeamInfo = new sdTeamInfo();
newTeamInfo->PreInit( i );
teamInfo.Alloc() = newTeamInfo;
}
teamBits = idMath::BitsForInteger( gameLocal.declTeamInfoType.Num() + 1 );
}
/*
================
sdTeamManagerLocal::OnNewMapLoad
================
*/
void sdTeamManagerLocal::OnNewMapLoad( void ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->OnNewMapLoad();
}
}
/*
================
sdTeamManagerLocal::OnNewScriptLoad
================
*/
void sdTeamManagerLocal::OnNewScriptLoad( void ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->OnNewScriptLoad();
}
}
/*
================
sdTeamManagerLocal::OnMapStart
================
*/
void sdTeamManagerLocal::OnMapStart( void ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->OnMapStart();
}
}
/*
================
sdTeamManagerLocal::Shutdown
================
*/
void sdTeamManagerLocal::Shutdown( void ) {
teamInfo.DeleteContents( true );
}
/*
================
sdTeamManagerLocal::GetTeam
================
*/
sdTeamInfo* sdTeamManagerLocal::GetTeamSafe( const char* name ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
if ( idStr::Icmp( teamInfo[ i ]->GetLookupName(), name ) ) {
continue;
}
return teamInfo[ i ];
}
return NULL;
}
/*
============
sdTeamManagerLocal::GetIndexForTeam
============
*/
int sdTeamManagerLocal::GetIndexForTeam( const char* name ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
if ( idStr::Icmp( teamInfo[ i ]->GetLookupName(), name ) ) {
continue;
}
return i;
}
return -1;
}
/*
================
sdTeamManagerLocal::GetTeam
================
*/
sdTeamInfo& sdTeamManagerLocal::GetTeam( const char* name ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
if( !idStr::Icmp( teamInfo[ i ]->GetLookupName(), name ) ) {
return *teamInfo[ i ];
}
}
gameLocal.Error( "sdTeamManagerLocal::GetTeam Invalid Team Name '%s'", name );
return *( sdTeamInfo* )NULL;
}
/*
================
sdTeamManagerLocal::GetTeamByIndex
================
*/
sdTeamInfo& sdTeamManagerLocal::GetTeamByIndex( int index ) {
if( index < 0 || index >= teamInfo.Num() ) {
gameLocal.Warning( "sdTeamManagerLocal::GetTeamByIndex Index OOB %i", index );
return *teamInfo[ 0 ];
}
return *teamInfo[ index ];
}
/*
================
sdTeamManagerLocal::WriteTeamToStream
================
*/
void sdTeamManagerLocal::WriteTeamToStream( sdTeamInfo* newTeam, idFile* file ) const {
int newIndex = newTeam ? newTeam->GetIndex() + 1 : 0;
file->WriteInt( newIndex );
}
/*
================
sdTeamManagerLocal::WriteTeamToStream
================
*/
void sdTeamManagerLocal::WriteTeamToStream( sdTeamInfo* newTeam, idBitMsg& msg ) const {
int newIndex = newTeam ? newTeam->GetIndex() + 1 : 0;
msg.WriteBits( newIndex, teamBits );
}
/*
================
sdTeamManagerLocal::WriteTeamToStream
================
*/
void sdTeamManagerLocal::WriteTeamToStream( sdTeamInfo* oldTeam, sdTeamInfo* newTeam, idBitMsg& msg ) const {
int oldIndex = oldTeam ? oldTeam->GetIndex() + 1 : 0;
int newIndex = newTeam ? newTeam->GetIndex() + 1 : 0;
msg.WriteDelta( oldIndex, newIndex, teamBits );
}
/*
================
sdTeamManagerLocal::ReadTeamFromStream
================
*/
sdTeamInfo* sdTeamManagerLocal::ReadTeamFromStream( idFile* file ) const {
int teamnum;
file->ReadInt( teamnum );
teamnum--;
if ( teamnum == -1 ) {
return NULL;
}
return &sdTeamManager::GetInstance().GetTeamByIndex( teamnum );
}
/*
================
sdTeamManagerLocal::ReadTeamFromStream
================
*/
sdTeamInfo* sdTeamManagerLocal::ReadTeamFromStream( const idBitMsg& msg ) const {
int teamnum = msg.ReadBits( teamBits ) - 1;
if ( teamnum == -1 ) {
return NULL;
}
return &sdTeamManager::GetInstance().GetTeamByIndex( teamnum );
}
/*
================
sdTeamManagerLocal::ReadTeamFromStream
================
*/
sdTeamInfo* sdTeamManagerLocal::ReadTeamFromStream( sdTeamInfo* oldTeam, const idBitMsg& msg ) const {
int oldIndex = oldTeam ? oldTeam->GetIndex() + 1 : 0;
int teamnum = msg.ReadDelta( oldIndex, teamBits ) - 1;
if ( teamnum == -1 ) {
return NULL;
}
return &sdTeamManager::GetInstance().GetTeamByIndex( teamnum );
}
/*
================
sdTeamManagerLocal::OnScriptChange
================
*/
void sdTeamManagerLocal::OnScriptChange( void ) {
for( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->OnScriptChange();
}
}
/*
================
sdTeamManagerLocal::ApplyNetworkState
================
*/
void sdTeamManagerLocal::ApplyNetworkState( const sdEntityStateNetworkData& newState ) {
NET_GET_NEW( sdTeamManagerGameState );
for ( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->ApplyNetworkState( newData.teamData[ i ] );
}
}
/*
================
sdTeamManagerLocal::ReadNetworkState
================
*/
void sdTeamManagerLocal::ReadNetworkState( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const {
NET_GET_STATES( sdTeamManagerGameState );
newData.teamData.SetNum( teamInfo.Num() );
for ( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->ReadNetworkState( baseData.teamData[ i ], newData.teamData[ i ], msg );
}
}
/*
================
sdTeamManagerLocal::WriteNetworkState
================
*/
void sdTeamManagerLocal::WriteNetworkState( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const {
NET_GET_STATES( sdTeamManagerGameState );
newData.teamData.SetNum( teamInfo.Num() );
for ( int i = 0; i < teamInfo.Num(); i++ ) {
teamInfo[ i ]->WriteNetworkState( baseData.teamData[ i ], newData.teamData[ i ], msg );
}
}
/*
================
sdTeamManagerLocal::CheckNetworkStateChanges
================
*/
bool sdTeamManagerLocal::CheckNetworkStateChanges( const sdEntityStateNetworkData& baseState ) const {
NET_GET_BASE( sdTeamManagerGameState );
for ( int i = 0; i < teamInfo.Num(); i++ ) {
if ( teamInfo[ i ]->CheckNetworkStateChanges( baseData.teamData[ i ] ) ) {
return true;
}
}
return false;
}
/*
================
sdTeamManagerLocal::CreateNetworkStructure
================
*/
sdEntityStateNetworkData* sdTeamManagerLocal::CreateNetworkStructure( void ) const {
return new sdTeamManagerGameState();
}
/*
===============================================================================
sdTeamInfo
===============================================================================
*/
/*
================
sdTeamInfoGameState::MakeDefault
================
*/
void sdTeamInfoGameState::MakeDefault( void ) {
wins = 0;
scriptData.MakeDefault();
}
/*
================
sdTeamInfoGameState::MakeDefault
================
*/
void sdTeamInfoGameState::Write( idFile* file ) const {
file->WriteInt( wins );
scriptData.Write( file );
}
/*
================
sdTeamInfoGameState::Read
================
*/
void sdTeamInfoGameState::Read( idFile* file ) {
file->ReadInt( wins );
scriptData.Read( file );
}
extern const idEventDef EV_SyncScriptFieldBroadcast;
extern const idEventDef EV_SyncScriptFieldCallback;
extern const idEventDef EV_GetName;
const idEventDef EV_Team_GetTitle( "getTitle", 'h', DOC_TEXT( "Returns a handle to the localized name of the team." ), 0, NULL );
const idEventDef EV_Team_RegisterDeployable( "registerDeployable", '\0', DOC_TEXT( "Registers an entity as belonging to this team." ), 1, "See also $event:unRegisterDeployable$.", "e", "entity", "Entity to add to the list." );
const idEventDef EV_Team_UnRegisterDeployable( "unRegisterDeployable", '\0', DOC_TEXT( "Removes an entity from this team's list." ), 1, "See also $event:registerDeployable$.", "e", "entity", "Entity to remove from the list." );
const idEventDef EV_Team_RegisterSpawnPoint( "registerSpawnPoint", '\0', DOC_TEXT( "Registers an entity as an active spawn point for this team." ), 1, "See also $event:unRegisterSpawnPoint$.", "e", "entity", "Entity to add to the list." );
const idEventDef EV_Team_UnRegisterSpawnPoint( "unRegisterSpawnPoint", '\0', DOC_TEXT( "Removes an entity from thie team's active spawn points." ), 1, "See also $event:registerSpawnPoint$.", "e", "entity", "Entity to remove from the list." );
const idEventDef EV_Team_SetTeamRearSpawn( "setTeamRearSpawn", '\0', DOC_TEXT( "Marks this entity as the rear spawn for bots to use." ), 1, NULL, "E", "entity", "Entity to mark as the rear spawn." );
CLASS_DECLARATION( idClass, sdTeamInfo )
EVENT( EV_GetName, sdTeamInfo::Event_GetName )
EVENT( EV_Team_GetTitle, sdTeamInfo::Event_GetTitle )
EVENT( EV_Team_RegisterDeployable, sdTeamInfo::Event_RegisterDeployable )
EVENT( EV_Team_UnRegisterDeployable, sdTeamInfo::Event_UnRegisterDeployable )
EVENT( EV_Team_RegisterSpawnPoint, sdTeamInfo::Event_RegisterSpawnPoint )
EVENT( EV_Team_UnRegisterSpawnPoint, sdTeamInfo::Event_UnRegisterSpawnPoint )
EVENT( EV_SyncScriptFieldBroadcast, sdTeamInfo::Event_SyncScriptFieldBroadcast )
EVENT( EV_SyncScriptFieldCallback, sdTeamInfo::Event_SyncScriptFieldCallback )
EVENT( EV_GetKey, sdTeamInfo::Event_GetKey )
EVENT( EV_GetIntKey, sdTeamInfo::Event_GetIntKey )
EVENT( EV_GetFloatKey, sdTeamInfo::Event_GetFloatKey )
EVENT( EV_GetVectorKey, sdTeamInfo::Event_GetVectorKey )
EVENT( EV_GetKeyWithDefault, sdTeamInfo::Event_GetKeyWithDefault )
EVENT( EV_GetIntKeyWithDefault, sdTeamInfo::Event_GetIntKeyWithDefault )
EVENT( EV_GetFloatKeyWithDefault, sdTeamInfo::Event_GetFloatKeyWithDefault )
EVENT( EV_GetVectorKeyWithDefault, sdTeamInfo::Event_GetVectorKeyWithDefault )
EVENT( EV_Team_SetTeamRearSpawn, sdTeamInfo::Event_SetTeamRearSpawn )
END_CLASS
const char* fireTeamNames[ sdTeamInfo::MAX_FIRETEAMS ] = {
"Alpha",
"Beta",
"Gamma",
"Delta",
"Epsilon",
"Zeta",
"Eta",
"Theta"
};
/*
================
sdTeamInfo::sdTeamInfo
================
*/
sdTeamInfo::sdTeamInfo( void ) : index( -1 ), info( NULL ), passwordCVar( NULL ), lifeStatTitle( NULL ) {
wins = 0;
info = NULL;
defaultClass = NULL;
scriptObject = NULL;
scriptThread = NULL;
allowRespawnFunc = NULL;
teamNextRespawnTimeFunc = NULL;
rearSpawnBase = NULL;
playZoneExitToolTip = NULL;
fireTeams = new sdFireTeam[ MAX_FIRETEAMS ];
for ( int i = 0; i < MAX_FIRETEAMS; i++ ) {
fireTeams[ i ].SetDefaultName( fireTeamNames[ i ] );
fireTeams[ i ].SetGameTeam( this );
}
ResetAll();
}
/*
================
sdTeamInfo::sdTeamInfo
================
*/
sdTeamInfo::~sdTeamInfo( void ) {
delete[] fireTeams;
}
/*
================
sdTeamInfo::GetFireTeam
================
*/
sdFireTeam& sdTeamInfo::GetFireTeam( int index ) {
return fireTeams[ index ];
}
/*
================
sdTeamInfo::GetFireTeamIndex
================
*/
int sdTeamInfo::GetFireTeamIndex( sdFireTeam* fireTeam ) const {
if ( fireTeam == NULL ) {
return -1;
}
for ( int i = 0; i < MAX_FIRETEAMS; i++ ) {
if ( static_cast<const sdFireTeam*>( &fireTeams[ i ] ) == fireTeam ) {
return i;
}
}
return -1;
}
/*
================
sdTeamInfo::GetDefaultFireTeamName
================
*/
const char* sdTeamInfo::GetDefaultFireTeamName( int index ) {
return fireTeamNames[ index ];
}
/*
================
sdTeamInfo::PreInit
================
*/
void sdTeamInfo::PreInit( int _index ) {
index = _index;
const sdDeclStringMap* data = gameLocal.declTeamInfoType.LocalFindByIndex( index, false );
lookupname = data->GetName();
}
/*
================
sdTeamInfo::OnScriptChange
================
*/
void sdTeamInfo::OnScriptChange( void ) {
if ( scriptThread != NULL ) {
gameLocal.program->FreeThread( scriptThread );
scriptThread = NULL;
}
if ( scriptObject ) {
gameLocal.program->FreeScriptObject( scriptObject );
}
}
/*
================
sdTeamInfo::Reset
================
*/
void sdTeamInfo::Reset( void ) {
deployables.Clear();
spawnLocations.Clear();
}
/*
================
sdTeamInfo::ResetAll
================
*/
void sdTeamInfo::ResetAll( void ) {
Reset();
wins = 0;
}
/*
================
sdTeamInfo::AllowRespawn
================
*/
bool sdTeamInfo::AllowRespawn( idPlayer* player ) {
sdScriptHelper h1;
h1.Push( player->GetScriptObject() );
scriptObject->CallNonBlockingScriptEvent( allowRespawnFunc, h1 );
return gameLocal.program->GetReturnedInteger() != 0;
}
/*
================
sdTeamInfo::GetTeamRespawnTime
================
*/
int sdTeamInfo::GetTeamRespawnTime( void ) {
sdScriptHelper h1;
scriptObject->CallNonBlockingScriptEvent( teamNextRespawnTimeFunc, h1 );
return idMath::Ftoi( gameLocal.program->GetReturnedFloat() );
}
/*
================
sdTeamInfo::OnCampaignChange
================
*/
void sdTeamInfo::OnCampaignChange( void ) {
ResetAll();
}
/*
================
sdTeamInfo::Init
================
*/
void sdTeamInfo::Init( void ) {
info = gameLocal.declTeamInfoType[ index ];
const idDict& dict = info->GetDict();
title = declHolder.declLocStrType[ dict.GetString( "name" ) ];
if ( title == NULL ) {
gameLocal.Error( "sdTeamInfo::Init No Title Provided" );
}
winString = declHolder.declLocStrType[ dict.GetString( "match_win_string" ) ];
winStringSW_Speed = declHolder.declLocStrType[ dict.GetString( "match_win_sw_speed" ) ];
winStringSW_XP = declHolder.declLocStrType[ dict.GetString( "match_win_sw_xp" ) ];
winMusic = dict.GetString( "snd_music_won" );
spawnFxName = dict.GetString( "fx_spawn", "fx/teleporterplayer" );
allowRevive = dict.GetBool( "allow_revive" );
crashLandFxName = dict.GetString( "fx_crashland" );
crashLandThreshold = dict.GetFloat( "crashland_threshold" );
parachuteLandFxName = dict.GetString( "fx_parachuteland" );
parachuteLandThreshold = dict.GetFloat( "parachuteland_threshold" );
botTeam = ( playerTeamTypes_t )dict.GetInt( "bot_team" );
highCommandName = declHolder.declLocStrType[ dict.GetString( "high_command_name" ) ];
if ( highCommandName == NULL ) {
gameLocal.Warning( "sdTeamInfo::Init No High Command Name Provided" );
}
defaultClass = gameLocal.declPlayerClassType[ dict.GetString( "pc_default" ) ];
if( !defaultClass ) {
gameLocal.Error( "sdTeamInfo::Init No Default Class Supplied" );
}
proficiencyTypes.Clear();
const idKeyValue* kv = NULL;
while ( kv = dict.MatchPrefix( "proficiencyList", kv ) ) {
const sdDeclProficiencyType* pType = gameLocal.declProficiencyTypeType[ kv->GetValue() ];
if ( !pType ) {
gameLocal.Error( "sdTeamInfo::Init Invalid Proficiency Type '%s'", kv->GetValue().c_str() );
}
proficiencyTypes.Alloc() = pType;
}
const char* passwordCVarName = dict.GetString( "cvar_password" );
if ( *passwordCVarName ) {
passwordCVar = cvarSystem->Find( passwordCVarName );
if ( !passwordCVar ) {
cvarSystem->SetCVarString( passwordCVarName, "", CVAR_NOCHEAT );
passwordCVar = cvarSystem->Find( passwordCVarName );
assert( passwordCVar );
}
} else {
passwordCVar = NULL;
}
int count = dict.GetInt( "num_ratings" );
ratings.SetNum( count );
for ( int i = 0; i < count; i++ ) {
const char* ratingName = dict.GetString( va( "rating_%i", i + 1 ) );
const sdDeclRating* rating = gameLocal.declRatingType[ ratingName ];
if ( !rating ) {
gameLocal.Error( "sdTeamInfo::Init Failed to Load Rating '%s'", ratingName );
}
ratings[ i ] = rating;
}
playZoneExitToolTip = gameLocal.declToolTipType[ dict.GetString( "tt_leavingzone" ) ];
// load lifeStat titles
const char* lifeStatName = dict.GetString( "lifestat_title", "blank" );
lifeStatTitle = declHolder.declLocStrType.LocalFind( lifeStatName );
game->CacheDictionaryMedia( dict );
}
/*
================
sdTeamInfo::SortPlayers
================
*/
void sdTeamInfo::SortPlayers( idStaticList< idPlayer*, MAX_CLIENTS >& list, bool wantSpectators ) {
list.Clear();
idStaticList< idPlayer*, MAX_CLIENTS > specList;
int i;
for( i = 0; i < MAX_CLIENTS; i++ ) {
idPlayer* p = gameLocal.GetClient( i );
if( p == NULL ) {
continue;
}
sdTeamInfo* team = p->GetGameTeam();
if( ( team == NULL || *team != *this ) ) {
if( !wantSpectators ) {
continue;
}
idPlayer* specClient = p->GetSpectateClient();
if( specClient == NULL || specClient == p ) {
continue;
}
sdTeamInfo* spectatingTeam = specClient->GetGameTeam();
if( spectatingTeam == NULL || *spectatingTeam != *this ) {
continue;
}
specList.Append( p );
continue;
}
list.Append( p );
}
list.Sort( SortPlayersFunc );
// ensure that spectators always report last
specList.Sort( SortPlayersFunc );
list.Append( specList );
}
/*
================
sdTeamInfo::SortPlayersFunc
================
*/
int sdTeamInfo::SortPlayersFunc( const playerPtr_t* a, const playerPtr_t* b ) {
return idMath::Ftoi( ( *b )->GetProficiencyTable().GetXP() ) - idMath::Ftoi( ( *a )->GetProficiencyTable().GetXP() );
}
/*
================
sdTeamInfo::Think
================
*/
void sdTeamInfo::Think( void ) {
UpdateScript();
}
/*
================
sdTeamInfo::UpdateScript
================
*/
void sdTeamInfo::UpdateScript( void ) {
if ( !scriptThread || gameLocal.IsPaused() ) {
return;
}
// don't call script until it's done waiting
if ( scriptThread->IsWaiting() ) {
return;
}
scriptThread->Execute();
}
/*
================
sdTeamInfo::OnNewMapLoad
================
*/
void sdTeamInfo::OnNewMapLoad( void ) {
Init();
}
/*
================
sdTeamInfo::PointInRadar
================
*/
idEntity* sdTeamInfo::PointInRadar( const idVec3& _target, radarMasks_t type, const idList< sdRadarLayer* >& list ) {
int worldZoneIndex = gameLocal.GetWorldPlayZoneIndex( _target );
idVec2 target = _target.ToVec2();
for ( int index = 0; index < list.Num(); index++ ) {
sdRadarLayer* layer = list[ index ];
idEntity* owner = layer->GetOwner();
if ( owner == NULL ) {
gameLocal.Warning( "sdTeamInfo::PointInRadar radar layer with NULL owner" );
continue;
}
if ( ( layer->GetMask() & type ) == 0 ) {
continue;
}
const idVec2& layerOrigin = layer->GetOrigin();
idVec2 currentDir = target - layerOrigin;
float currentRange = currentDir.LengthSqr();
if ( currentRange > layer->GetRange() ) {
continue;
}
float maxAngle = layer->GetMaxAngle();
if ( maxAngle < idMath::PI ) {
currentDir.NormalizeFast();
float angle = idMath::ACos( currentDir * layer->GetDirection() );
if ( angle > maxAngle ) {
continue;
}
}
int radarZoneIndex = gameLocal.GetWorldPlayZoneIndex( idVec3( layerOrigin.x, layerOrigin.y, 0.f ) );
if ( radarZoneIndex != worldZoneIndex ) {
return NULL;
}
return owner;
}
return NULL;
}
/*
================
sdTeamInfo::PointInJammer
================
*/
idEntity* sdTeamInfo::PointInJammer( const idVec3& target, radarMasks_t type ) {
return PointInRadar( target, type, jammerLayers );
}
/*
================
sdTeamInfo::PointInRadar
================
*/
idEntity* sdTeamInfo::PointInRadar( const idVec3& target, radarMasks_t type ) {
return PointInRadar( target, type, radarLayers );
}
/*
================
sdTeamInfo::RegisterDeployable
================
*/
void sdTeamInfo::RegisterDeployable( idEntity* other ) {
AddEntityToList( deployables, other );
}
/*
================
sdTeamInfo::UnRegisterDeployable
================
*/
void sdTeamInfo::UnRegisterDeployable( idEntity* other ) {
RemoveEntityFromList( deployables, other );
}
/*
================
sdTeamInfo::RegisterSpawnPoint
================
*/
void sdTeamInfo::RegisterSpawnPoint( idEntity* other ) {
idEntity* oldDefault = spawnLocations.Num() ? spawnLocations[ 0 ].GetEntity() : NULL;
idStr priorityName = va( "spawn_priority_%s", lookupname.c_str() );
int otherPriority = other->spawnArgs.GetInt( priorityName );
int i;
for ( i = 0; i < spawnLocations.Num(); ) {
idEntity* loc = spawnLocations[ i ];
if ( !loc ) {
spawnLocations.RemoveIndex( i );
continue;
}
int locPriority = loc->spawnArgs.GetInt( priorityName );
if ( locPriority < otherPriority ) {
idEntityPtr< idEntity > temp = other;
spawnLocations.Insert( temp, i );
break;
}
i++;
}
if ( i == spawnLocations.Num() ) {
spawnLocations.Alloc() = other;
}
idEntity* newDefault = spawnLocations[ 0 ];
if ( oldDefault != newDefault ) {
gameLocal.localPlayerProperties.OnDefaultSpawnChanged( this, newDefault );
}
}
/*
================
sdTeamInfo::UnRegisterSpawnPoint
================
*/
void sdTeamInfo::UnRegisterSpawnPoint( idEntity* other ) {
idEntity* oldDefault = spawnLocations.Num() ? spawnLocations[ 0 ].GetEntity() : NULL;
RemoveEntityFromList( spawnLocations, other );
idEntity* newDefault = spawnLocations.Num() ? spawnLocations[ 0 ].GetEntity() : NULL;
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
idPlayer* player = gameLocal.GetClient( i );
if ( !player || !player->IsTeam( this ) ) {
continue;
}
if ( player->GetSpawnPoint() == other ) {
player->SetSpawnPoint( NULL );
}
}
if ( oldDefault != newDefault ) {
gameLocal.localPlayerProperties.OnDefaultSpawnChanged( this, newDefault );
}
if ( other == rearSpawnBase.GetEntity() ) {
rearSpawnBase = NULL;
}
}
/*
================
sdTeamInfo::ApplyNetworkState
================
*/
void sdTeamInfo::ApplyNetworkState( const sdTeamInfoGameState& newData ) {
// update state
wins = newData.wins;
scriptObject->ApplyNetworkState( NSM_BROADCAST, newData.scriptData );
}
/*
================
sdTeamInfo::ReadNetworkState
================
*/
void sdTeamInfo::ReadNetworkState( const sdTeamInfoGameState& baseData, sdTeamInfoGameState& newData, const idBitMsg& msg ) const {
// read state
newData.wins = msg.ReadDeltaLong( baseData.wins );
scriptObject->ReadNetworkState( NSM_BROADCAST, baseData.scriptData, newData.scriptData, msg );
}
/*
================
sdTeamInfo::WriteNetworkState
================
*/
void sdTeamInfo::WriteNetworkState( const sdTeamInfoGameState& baseData, sdTeamInfoGameState& newData, idBitMsg& msg ) const {
// update state
newData.wins = wins;
// write state
msg.WriteDeltaLong( baseData.wins, newData.wins );
scriptObject->WriteNetworkState( NSM_BROADCAST, baseData.scriptData, newData.scriptData, msg );
}
/*
================
sdTeamInfo::CheckNetworkStateChanges
================
*/
bool sdTeamInfo::CheckNetworkStateChanges( const sdTeamInfoGameState& baseData ) const {
if ( scriptObject->CheckNetworkStateChanges( NSM_BROADCAST, baseData.scriptData ) ) {
return true;
}
return ( baseData.wins != wins );
}
/*
================
sdTeamInfo::CanJoin
================
*/
bool sdTeamInfo::CanJoin( idPlayer* player, const char* password, const sdDeclLocStr*& reason ) const {
if ( player->IsType( idBot::Type ) ) {
return true;
}
if ( passwordCVar != NULL ) {
const char* passwordString = passwordCVar->GetString();
if ( *passwordString != '\0' ) {
if ( idStr::Cmp( passwordString, password ) ) {
reason = declHolder.declLocStrType[ "teams/messages/wrongpassword" ];
return false;
}
}
}
return true;
}
/*
================
sdTeamInfo::OnNewScriptLoad
================
*/
void sdTeamInfo::OnNewScriptLoad( void ) {
const char* scriptObjectName = info->GetDict().GetString( "scriptObject", "default" );
scriptObject = gameLocal.program->AllocScriptObject( this, scriptObjectName );
allowRespawnFunc = scriptObject->GetFunction( "OnAllowRespawn" );
teamNextRespawnTimeFunc = scriptObject->GetFunction( "GetNextRespawnTime" );
sdScriptHelper h1;
scriptObject->CallNonBlockingScriptEvent( scriptObject->GetPreConstructor(), h1 );
sdScriptHelper h2;
scriptObject->CallNonBlockingScriptEvent( scriptObject->GetSyncFunc(), h2 );
const sdProgram::sdFunction* constructor = scriptObject->GetConstructor();
if ( constructor ) {
scriptThread = gameLocal.program->CreateThread();
scriptThread->SetName( "sdTeamInfo" );
scriptThread->CallFunction( scriptObject, constructor );
scriptThread->ManualControl();
scriptThread->ManualDelete();
}
}
/*
================
sdTeamInfo::OnMapStart
================
*/
void sdTeamInfo::OnMapStart( void ) {
assert( scriptObject );
sdScriptHelper h1;
scriptObject->CallNonBlockingScriptEvent( scriptObject->GetFunction( "OnMapStart" ), h1 );
}
/*
================
sdTeamInfo::Event_GetName
================
*/
void sdTeamInfo::Event_GetName( void ) {
sdProgram::ReturnString( lookupname );
}
/*
================
sdTeamInfo::Event_GetTitle
================
*/
void sdTeamInfo::Event_GetTitle( void ) {
sdProgram::ReturnHandle( title->Index() );
}
/*
================
sdTeamInfo::Event_RegisterDeployable
================
*/
void sdTeamInfo::Event_RegisterDeployable( idEntity* other ) {
RegisterDeployable( other );
}
/*
================
sdTeamInfo::Event_UnRegisterDeployable
================
*/
void sdTeamInfo::Event_UnRegisterDeployable( idEntity* other ) {
UnRegisterDeployable( other );
}
/*
===============
sdTeamInfo::Event_RegisterSpawnPoint
===============
*/
void sdTeamInfo::Event_RegisterSpawnPoint( idEntity* other ) {
RegisterSpawnPoint( other );
}
/*
===============
sdTeamInfo::Event_UnRegisterSpawnPoint
===============
*/
void sdTeamInfo::Event_UnRegisterSpawnPoint( idEntity* other ) {
UnRegisterSpawnPoint( other );
}
/*
================
sdTeamInfo::Event_SyncScriptFieldBroadcast
================
*/
void sdTeamInfo::Event_SyncScriptFieldBroadcast( const char* fieldName ) {
scriptObject->SetSynced( fieldName, true );
}
/*
================
sdTeamInfo::Event_SyncScriptFieldCallback
================
*/
void sdTeamInfo::Event_SyncScriptFieldCallback( const char* fieldName, const char* functionName ) {
scriptObject->SetSyncCallback( fieldName, functionName );
}
class sdFireTeam_InitialCreateFinaliser : public sdVoteFinalizer {
public:
sdFireTeam_InitialCreateFinaliser( idPlayer* player ) : _player( player ) {
}
virtual ~sdFireTeam_InitialCreateFinaliser( void ) {
}
virtual void OnVoteCompleted( bool passed ) const {
if ( passed ) {
idPlayer* player = _player;
if ( player ) {
sdTeamInfo* team = player->GetTeam();
if ( team ) {
team->CreatePublicFireTeam( player );
} else {
assert( false );
}
}
}
}
private:
idEntityPtr< idPlayer > _player;
};
class sdFireTeam_InitialJoinFinaliser : public sdVoteFinalizer {
public:
sdFireTeam_InitialJoinFinaliser( idPlayer* player, sdFireTeam* fireTeam ) : _fireTeam( fireTeam ), _player( player ) {
}
virtual ~sdFireTeam_InitialJoinFinaliser( void ) {
}
virtual void OnVoteCompleted( bool passed ) const {
if ( passed ) {
idPlayer* player = _player;
if ( player ) {
_fireTeam->AddMember( player->entityNumber );
}
}
}
private:
sdFireTeam* _fireTeam;
idEntityPtr< idPlayer > _player;
};
/*
================
sdTeamInfo::CreatePrivateFireTeam
================
*/
void sdTeamInfo::CreatePrivateFireTeam( idPlayer* player ) {
for ( int i = 0; i < MAX_FIRETEAMS; i++ ) {
if ( fireTeams[ i ].GetNumMembers() == 0 ) {
fireTeams[ i ].AddMember( player->entityNumber );
fireTeams[ i ].SetPrivate( true );
return;
}
}
player->SendLocalisedMessage( declHolder.declLocStrType[ "fireteam/messages/noneleft" ], idWStrList() );
}
/*
================
sdTeamInfo::CreatePublicFireTeam
================
*/
bool sdTeamInfo::CreatePublicFireTeam( idPlayer* player ) {
for ( int i = 0; i < MAX_FIRETEAMS; i++ ) {
if ( fireTeams[ i ].GetNumMembers() == 0 ) {
fireTeams[ i ].AddMember( player->entityNumber );
fireTeams[ i ].SetPrivate( false );
return true;
}
}
return false;
}
/*
================
sdTeamInfo::TryFindPrivateFireTeam
================
*/
void sdTeamInfo::TryFindPrivateFireTeam( idPlayer* player ) {
for ( int i = 0; i < MAX_FIRETEAMS; i++ ) {
if ( fireTeams[ i ].GetNumMembers() == 0 ) {
sdPlayerVote* vote = sdVoteManager::GetInstance().AllocVote();
if ( !vote ) {
return;
}
vote->DisableFinishMessage();
vote->MakePrivateVote( player );
vote->Tag( VI_FIRETEAM_CREATE, player );
vote->SetText( gameLocal.declToolTipType[ "fireteam_initial_create" ] );
vote->SetFinalizer( new sdFireTeam_InitialCreateFinaliser( player ) );
vote->Start();
return;
} else if ( !fireTeams[ i ].IsPrivate() && fireTeams[ i ].GetNumMembers() != sdFireTeam::MaxMembers() ) {
sdPlayerVote* vote = sdVoteManager::GetInstance().AllocVote();
if ( !vote ) {
return;
}
vote->DisableFinishMessage();
vote->MakePrivateVote( player );
vote->Tag( VI_FIRETEAM_JOIN, player );
vote->SetText( gameLocal.declToolTipType[ "fireteam_initial_join" ] );
vote->SetFinalizer( new sdFireTeam_InitialJoinFinaliser( player, &fireTeams[ i ] ) );
vote->Start();
return;
}
}
}
/*
================
sdTeamInfo::Event_GetKey
================
*/
void sdTeamInfo::Event_GetKey( const char *key ) {
sdProgram::ReturnString( GetDict().GetString( key ) );
}
/*
================
sdTeamInfo::Event_GetIntKey
================
*/
void sdTeamInfo::Event_GetIntKey( const char *key ) {
sdProgram::ReturnInteger( GetDict().GetInt( key ) );
}
/*
================
sdTeamInfo::Event_GetFloatKey
================
*/
void sdTeamInfo::Event_GetFloatKey( const char *key ) {
sdProgram::ReturnFloat( GetDict().GetFloat( key ) );
}
/*
================
sdTeamInfo::Event_GetVectorKey
================
*/
void sdTeamInfo::Event_GetVectorKey( const char *key ) {
sdProgram::ReturnVector( GetDict().GetVector( key ) );
}
/*
================
sdTeamInfo::Event_GetKeyWithDefault
================
*/
void sdTeamInfo::Event_GetKeyWithDefault( const char *key, const char* defaultvalue ) {
sdProgram::ReturnString( GetDict().GetString( key, defaultvalue ) );
}
/*
================
sdTeamInfo::Event_GetIntKeyWithDefault
================
*/
void sdTeamInfo::Event_GetIntKeyWithDefault( const char *key, int defaultvalue ) {
sdProgram::ReturnFloat( GetDict().GetInt( key, va( "%i", defaultvalue ) ) );
}
/*
================
sdTeamInfo::Event_GetFloatKeyWithDefault
================
*/
void sdTeamInfo::Event_GetFloatKeyWithDefault( const char *key, float defaultvalue ) {
sdProgram::ReturnFloat( GetDict().GetFloat( key, va( "%f", defaultvalue ) ) );
}
/*
================
sdTeamInfo::Event_GetVectorKeyWithDefault
================
*/
void sdTeamInfo::Event_GetVectorKeyWithDefault( const char *key, const idVec3& defaultvalue ) {
sdProgram::ReturnVector( GetDict().GetVector( key, defaultvalue.ToString() ) );
}
/*
================
sdTeamInfo::Event_SetTeamRearSpawn
================
*/
void sdTeamInfo::Event_SetTeamRearSpawn( idEntity* teamRearSpawnBase ) {
rearSpawnBase = teamRearSpawnBase;
}
/*
============
sdTeamInfo::GetEquivalentClass
============
*/
const sdDeclPlayerClass* sdTeamInfo::GetEquivalentClass( const sdDeclPlayerClass& currentClass, const sdTeamInfo& desiredTeam ) const {
if( this == &desiredTeam ) {
return &currentClass;
}
const idDict& dict = desiredTeam.GetDict();
idStr key = va( "pc_team_remap_%s_%s", GetLookupName(), currentClass.GetName() );
const char* remappedClass = dict.GetString( key, "" );
if( idStr::Length( remappedClass ) == 0 ) {
return &currentClass;
}
return gameLocal.declPlayerClassType.LocalFind( remappedClass, false );
}
/*
============
sdTeamInfo::AllocRadarLayer
============
*/
sdTeamInfo::sdRadarLayer* sdTeamInfo::AllocRadarLayer( void ) {
sdRadarLayer* newLayer = radarAllocator.Alloc();
radarLayers.Alloc() = newLayer;
return newLayer;
}
/*
============
sdTeamInfo::AllocJammerLayer
============
*/
sdTeamInfo::sdRadarLayer* sdTeamInfo::AllocJammerLayer( void ) {
sdRadarLayer* newLayer = radarAllocator.Alloc();
jammerLayers.Alloc() = newLayer;
return newLayer;
}
/*
============
sdTeamInfo::FreeRadarLayer
============
*/
void sdTeamInfo::FreeRadarLayer( sdRadarLayer* layer ) {
int index;
index = radarLayers.FindIndex( layer );
if ( index != -1 ) {
radarLayers.RemoveIndexFast( index );
radarAllocator.Free( layer );
return;
}
index = jammerLayers.FindIndex( layer );
if ( index != -1 ) {
jammerLayers.RemoveIndexFast( index );
radarAllocator.Free( layer );
return;
}
}
/*
============
sdTeamInfo::GetRating
============
*/
const sdDeclRating* sdTeamInfo::GetRating( int index ) const {
if ( index < 0 || ratings.Num() <= 0 ) {
return NULL;
}
if ( index >= ratings.Num() ) {
return ratings[ ratings.Num() - 1 ];
}
return ratings[ index ];
}
/*
============
sdTeamInfo::GetNumPlayers
============
*/
int sdTeamInfo::GetNumPlayers( bool excludeBots ) const {
int count = 0;
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
idPlayer* player = gameLocal.GetClient( i );
if ( player == NULL ) {
continue;
}
if ( player->GetGameTeam() != this ) {
continue;
}
if ( excludeBots ) {
if ( player->IsType( idBot::Type ) ) {
continue;
}
}
count++;
}
return count;
}
/*
============
sdTeamInfo::GetTotalXP
============
*/
float sdTeamInfo::GetTotalXP( void ) const {
float total = 0;
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
idPlayer* player = gameLocal.GetClient( i );
if ( player == NULL ) {
continue;
}
if ( player->GetGameTeam() != this ) {
continue;
}
total += player->GetProficiencyTable().GetXP();
}
return total;
}
/*
============
sdTeamInfo::GetHomeBaseSpawn
============
*/
idEntity* sdTeamInfo::GetHomeBaseSpawn( void ) {
if ( rearSpawnBase == NULL ) { //mal: oops - someone didn't set us up!
if ( bot_debug.GetBool() ) {
gameLocal.DWarning("Bot Team %s has no valid Rear Spawn Set!", ( botTeam == GDF ) ? "GDF" : "STROGG" );
}
}
return rearSpawnBase;
}
/*
============
sdTeamInfo::GetLifeStatTitle
============
*/
const sdDeclLocStr* sdTeamInfo::GetLifeStatTitle( void ) const {
return lifeStatTitle;
}