// 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;
}