// 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 "Tasks.h"
#include "../Player.h"
#include "../interfaces/TaskInterface.h"
#include "../script/Script_Helper.h"
#include "../script/Script_ScriptObject.h"
#include "../roles/WayPointManager.h"
#include "FireTeams.h"
#include "../rules/GameRules.h"
#include "../rules/VoteManager.h"

/*
===============================================================================

	sdPlayerTask

===============================================================================
*/

const idEventDef EV_PlayerTask_Complete( "complete", '\0', DOC_TEXT( "Marks the task as complete, and gives any bonus associated with it to players on it." ), 0, NULL );
const idEventDef EV_PlayerTask_SetTimeout( "setTimeout", '\0', DOC_TEXT( "Marks the task to auto free itself once the timeout has expired." ), 1, "Timeouts do not apply to mission or objective level tasks.", "f", "timeout", "Timeout in seconds." );
const idEventDef EV_PlayerTask_Free( "free", '\0', DOC_TEXT( "Removes the task." ), 0, "This does the same as $event:remove$." );

const idEventDef EV_PlayerTask_SetUserCreated( "setUserCreated", '\0', DOC_TEXT( "Marks a task as user created, this will demote it to task level from whatever its current level is." ), 0, NULL );
const idEventDef EV_PlayerTask_IsUserCreated( "isUserCreated", 'b', DOC_TEXT( "Returns whether the task has been marked as user created or not." ), 0, NULL );

const idEventDef EV_PlayerTask_GetTaskEntity( "getTaskEntity", 'e', DOC_TEXT( "Returns the entity associated with this task." ), 0, NULL );
const idEventDef EV_PlayerTask_SetTargetPos( "setLocation", '\0', DOC_TEXT( "Sets a fixed location for the specified task waypoint." ), 2, NULL, "d", "index", "Index of the waypoint.", "v", "position", "Fixed position for the waypoint." );
const idEventDef EV_PlayerTask_SetWayPointState( "setWayPointState", '\0', DOC_TEXT( "Sets the visibility state for the specified task waypoint." ), 2, NULL, "d", "index", "Index of the waypoint.", "b", "state", "State to set." );

const idEventDef EV_PlayerTask_GiveObjectiveProficiency( "giveObjectiveProficiency", '\0', DOC_TEXT( "Gives class XP to all players elligible for the task." ), 2, NULL, "f", "count", "Amount of XP to give.", "s", "reason", "Reason to record in log." );

const idEventDef EV_PlayerTask_FlashIcon( "flashWorldIcon", '\0', DOC_TEXT( "Flash the icon for a set time." ), 1, NULL, "d", "time", "Time to flash in milliseconds." );

CLASS_DECLARATION( idClass, sdPlayerTask )
	EVENT( EV_PlayerTask_Complete,				sdPlayerTask::Event_Complete )
	EVENT( EV_PlayerTask_SetTimeout,			sdPlayerTask::Event_SetTimeout )
	EVENT( EV_PlayerTask_Free,					sdPlayerTask::Event_Free )
	EVENT( EV_SafeRemove,						sdPlayerTask::Event_Free ) // Gordon: Also handle remove nicely, in case people use it

	EVENT( EV_PlayerTask_SetUserCreated,		sdPlayerTask::Event_SetUserCreated )
	EVENT( EV_PlayerTask_IsUserCreated,			sdPlayerTask::Event_IsUserCreated )

	EVENT( EV_PlayerTask_GetTaskEntity,			sdPlayerTask::Event_GetTaskEntity )
	EVENT( EV_PlayerTask_SetTargetPos,			sdPlayerTask::Event_SetTargetPos )
	EVENT( EV_PlayerTask_SetWayPointState,		sdPlayerTask::Event_SetWayPointState )

	EVENT( EV_GetKey,							sdPlayerTask::Event_GetKey )
	EVENT( EV_GetIntKey,						sdPlayerTask::Event_GetIntKey )
	EVENT( EV_GetFloatKey,						sdPlayerTask::Event_GetFloatKey )
	EVENT( EV_GetVectorKey,						sdPlayerTask::Event_GetVectorKey )

	EVENT( EV_GetKeyWithDefault,				sdPlayerTask::Event_GetKeyWithDefault )
	EVENT( EV_GetIntKeyWithDefault,				sdPlayerTask::Event_GetIntKeyWithDefault )
	EVENT( EV_GetFloatKeyWithDefault,			sdPlayerTask::Event_GetFloatKeyWithDefault )
	EVENT( EV_GetVectorKeyWithDefault,			sdPlayerTask::Event_GetVectorKeyWithDefault )

	EVENT( EV_PlayerTask_GiveObjectiveProficiency,	sdPlayerTask::Event_GiveObjectiveProficiency )
	EVENT( EV_PlayerTask_FlashIcon,					sdPlayerTask::Event_FlashIcon )
END_CLASS

/*
================
sdPlayerTask::sdPlayerTask
================
*/
sdPlayerTask::sdPlayerTask( void ) : _taskInfo( NULL ), _flags( 0 ), _endTime( -1 ), _scriptObject( NULL ), _xp( 0.0f ), _wayPointEnabled( false ) {
	_node.SetOwner( this );
	_worldNode.SetOwner( this );
	_objectiveNode.SetOwner( this );
}

/*
================
sdPlayerTask::Create
================
*/
void sdPlayerTask::Create( int taskIndex, const sdDeclPlayerTask* taskInfo ) {
	_creationTime = gameLocal.time;
	_taskInfo = taskInfo;
	_taskIndex = taskIndex;
	_xp = _taskInfo->GetData().GetFloat( "xp" );
	_wayPointEnabled = false;

	if ( taskInfo->IsTask() ) {
		_flags |= TF_USERCREATED;
	}

	_wayPointInfo.SetNum( Min( taskInfo->GetNumWayPoints(), MAX_WAYPOINTS ) );
	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		_wayPointInfo[ i ].fixed = false;
		_wayPointInfo[ i ].enabled = true;
		_wayPointInfo[ i ].offset.Zero();
		_wayPointInfo[ i ].wayPoint = NULL;
	}

	_scriptObject = gameLocal.program->AllocScriptObject( this, taskInfo->GetScriptObject() );

	sdScriptHelper h1;
	_scriptObject->CallNonBlockingScriptEvent( _scriptObject->GetPreConstructor(), h1 );
}

/*
================
sdPlayerTask::SetEntity
================
*/
void sdPlayerTask::SetEntity( int spawnId ) {
	_entity.ForceSpawnId( spawnId );
}

/*
================
sdPlayerTask::~sdPlayerTask
================
*/
sdPlayerTask::~sdPlayerTask( void ) {
	if ( _scriptObject ) {
		sdScriptHelper h1;
		_scriptObject->CallNonBlockingScriptEvent( _scriptObject->GetDestructor(), h1 );

		gameLocal.program->FreeScriptObject( _scriptObject );
	}

	HideWayPoint();

	if ( gameLocal.isServer ) {
		sdTaskMessage msg( this, TM_REMOVE );
		msg.Send( sdReliableMessageClientInfoAll() );
	}
}

/*
================
sdPlayerTask::Think
================
*/
void sdPlayerTask::Think( void ) {
	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		if ( _wayPointInfo[ i ].wayPoint == NULL ) {
			continue;
		}
		_wayPointInfo[ i ].wayPoint->SetText( GetTitle() );
	}
}

/*
================
sdPlayerTask::GetHandle
================
*/
taskHandle_t sdPlayerTask::GetHandle( void ) const {
	return _taskIndex;
}

/*
================
sdPlayerTask::GetTimeLimit
================
*/
const char* sdPlayerTask::GetTimeLimit( void ) const {
	int limit = _taskInfo->GetTimeLimit();
	if ( limit <= 0 ) {
		return idStr::MS2HMS( gameLocal.rules->GetGameTime() );
	}

	int ms = limit - ( gameLocal.time - _creationTime );
	return idStr::MS2HMS( ms );
}

/*
================
sdPlayerTask::UpdateObjectiveWayPoint
================
*/
void sdPlayerTask::UpdateObjectiveWayPoint( void ) {
	idPlayer* localPlayer = gameLocal.GetLocalPlayer();
	if ( localPlayer == NULL ) {
		return;
	}

	sdTeamInfo* team = localPlayer->GetGameTeam();
	if ( team == NULL || team != _taskInfo->GetTeam() ) {
		HideWayPoint();
	} else {
		ShowWayPoint();
	}
}

/*
============
sdPlayerTask::GetXP
============
*/
float sdPlayerTask::GetXP() const {
	return _xp;
}

/*
================
sdPlayerTask::ShowWayPoint
================
*/
void sdPlayerTask::ShowWayPoint( void ) {
	_wayPointEnabled = true;
	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		ShowWayPoint( i );
	}
}

/*
================
sdPlayerTask::ShowWayPoint
================
*/
void sdPlayerTask::ShowWayPoint( int i ) {
	if ( _wayPointInfo[ i ].wayPoint != NULL ) {
		return;
	}

	if ( !_wayPointInfo[ i ].enabled ) {
		return;
	}

	const idDict& waypointData = _taskInfo->GetWayPointData( i );

	const char* materialName;
	const char* offScreenMaterialName;
	if ( IsUserCreated() ) {
		materialName = waypointData.GetString( "mtr_user_waypoint" );
		offScreenMaterialName = waypointData.GetString( "mtr_user_waypoint_offscreen" );
	} else {
		materialName = waypointData.GetString( "mtr_waypoint" );
		offScreenMaterialName = waypointData.GetString( "mtr_waypoint_offscreen" );
	}

	const idMaterial* material = gameLocal.declMaterialType[ materialName ];
	if ( material == NULL ) {
		gameLocal.Warning( "sdPlayerTask::ShowWayPoint Invalid Material '%s'", materialName );
		return;
	}

	const idMaterial* offScreenMaterial = gameLocal.declMaterialType[ offScreenMaterialName ];
	if ( offScreenMaterial == NULL ) {
		gameLocal.Warning( "sdPlayerTask::ShowWayPoint Invalid Offscreen Material '%s'", offScreenMaterialName );
		return;
	}

	sdWayPoint* wayPoint = sdWayPointManager::GetInstance().AllocWayPoint();
	if ( wayPoint == NULL ) {
		return;
	}		
	_wayPointInfo[ i ].wayPoint = wayPoint;

	if ( _wayPointInfo[ i ].fixed ) {
		wayPoint->SetOrigin( _wayPointInfo[ i ].offset );
	}
	wayPoint->SetOwner( _entity );

	wayPoint->SetMinRange( waypointData.GetFloat( "min_range", "320" ) );

	wayPoint->SetMaterial( material );
	wayPoint->SetOffScreenMaterial( offScreenMaterial );

	if ( IsUserCreated() ) {
		float range;
		if ( waypointData.GetFloat( "range", "", range ) ) {
			wayPoint->SetRange( range );
		}
	} else {
		wayPoint->SetAlwaysActive();
	}

	if ( waypointData.GetBool( "team_colored" ) ) {
		wayPoint->SetTeamColored();
	}

	if ( IsObjective() || IsMission() || _taskInfo->NoOcclusion() ) {
		wayPoint->SetCheckLineOfSight( false );
	}
	
	wayPoint->SetBracketed( waypointData.GetBool( "bracketed" ) );
	if ( waypointData.GetBool( "bracket_use_rendermodel" ) ) {
		wayPoint->UseRenderModel();
	}

	idVec3 mins, maxs;
	if ( waypointData.GetVector( "bracket_mins", NULL, mins ) && waypointData.GetVector( "bracket_maxs", NULL, maxs ) ) {
		wayPoint->SetBounds( idBounds( mins, maxs ) );
	}
}

/*
================
sdPlayerTask::HideWayPoint
================
*/
void sdPlayerTask::HideWayPoint( void ) {
	_wayPointEnabled = false;
	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		HideWayPoint( i );
	}
}

/*
================
sdPlayerTask::HideWayPoint
================
*/
void sdPlayerTask::HideWayPoint( int i ) {
	if ( _wayPointInfo[ i ].wayPoint == NULL ) {
		return;
	}

	sdWayPointManager::GetInstance().FreeWayPoint( _wayPointInfo[ i ].wayPoint );
	_wayPointInfo[ i ].wayPoint = NULL;
}

/*
================
sdPlayerTask::ProcessTitle
================
*/
idWStr& sdPlayerTask::ProcessTitle( const wchar_t* text, idWStr& output ) const {
	output.Empty();

	const wchar_t* p = text;
	while ( *p ) {
		if ( *p == L'%' ) {
			p++;
			if( !*p ) {
				break;
			}

			switch ( *p ) {
				case L'%':
					output += L'%';
					p++;
					break;

				case L'r': {
					idEntity* other = GetEntity();
					idPlayer* player = gameLocal.GetLocalPlayer();
					if ( !other || !player ) {
						output += L"???";
					} else {
						float range = idMath::Sqrt( gameLocal.RangeSquare( player, other ) );
						output += va( L"%im", ( int )( InchesToMetres( range ) ) );
					}
					p++;
					break;
				}

				case L'n': {
					idEntity* other = GetEntity();
					if ( other ) {
						idWStr name;
						other->GetTaskName( name );
						output += name;
					}
					p++;
					break;
				}

				case L'm': {
					idWStr timeLimit( va( L"%hs", GetTimeLimit() ) );
					timeLimit += L" ";
					if ( timeLimit.Find( L':' ) != idWStr::INVALID_POSITION ) {
						timeLimit += common->LocalizeText( "game/tasks/min" );
					} else {
						timeLimit += common->LocalizeText( "game/tasks/sec" );
					}
					output += timeLimit;
					p++;
					break;
				}

				default:
					output += L'%';
					break;
			}
		} else {
			output += *p;

			p++;
		}
	}

	return output;
}

/*
================
sdPlayerTask::GetTitle
================
*/
const wchar_t* sdPlayerTask::GetTitle( idPlayer* player ) const {
	const sdDeclLocStr* title = NULL;

	if ( IsObjective() ) {
		title = _taskInfo->GetFriendlyTitle();
		if ( player == NULL ) {
			player = gameLocal.GetLocalPlayer();
		}
		if ( player != NULL ) {
			if ( IsPlayerEligible( player ) ) {
				title = _taskInfo->GetTitle();
			}
		}
	} else {
		title = _taskInfo->GetTitle();
	}

	if ( title == NULL ) {
		return L"";
	}

	return ProcessTitle( title->GetText(), _titleBuffer ).c_str();
}

/*
================
sdPlayerTask::GetCompletedTitle
================
*/
const wchar_t* sdPlayerTask::GetCompletedTitle( idPlayer* player ) const {
	const sdDeclLocStr* title = NULL;

	if ( IsObjective() ) {
		if( player == NULL ) {
			player = gameLocal.GetLocalPlayer();
		}
		if ( player != NULL ) {
			if ( IsPlayerEligible( player ) ) {
				title = _taskInfo->GetCompletedTitle();
			} else {
				title = _taskInfo->GetCompletedFriendlyTitle();
			}
		}
	} else {
		title = _taskInfo->GetCompletedTitle();
	}

	if ( title == NULL ) {
		return L"";
	}

	return ProcessTitle( title->GetText(), _titleBuffer ).c_str();
}

/*
================
sdPlayerTask::SetWayPointState
================
*/
bool sdPlayerTask::SetWayPointState( int index, bool state ) {
	if ( index < 0 || index >= _wayPointInfo.Num() ) {
		gameLocal.Warning( "sdPlayerTask::SetWayPointState Index Out Of Range" );
		return false;
	}

	if ( _wayPointInfo[ index ].enabled == state ) {
		return false;
	}

	_wayPointInfo[ index ].enabled = state;
	if ( state ) {
		if ( _wayPointEnabled ) {
			ShowWayPoint( index );
		}
	} else {
		HideWayPoint( index );
	}

	return true;
}

/*
================
sdPlayerTask::SetTargetPos
================
*/
bool sdPlayerTask::SetTargetPos( int index, const idVec3& target ) {
	if ( index < 0 || index >= _wayPointInfo.Num() ) {
		gameLocal.Warning( "sdPlayerTask::SetTargetPos Index Out Of Range" );
		return false;
	}
	_wayPointInfo[ index ].fixed = true;
	_wayPointInfo[ index ].offset = target;
	if ( _wayPointInfo[ index ].wayPoint != NULL ) {
		_wayPointInfo[ index ].wayPoint->SetOrigin( target );
	}
	return true;
}

/*
================
sdPlayerTask::SetComplete
================
*/
void sdPlayerTask::SetComplete( void ) {
	if ( IsComplete() ) {
		return;
	}

	idPlayer* localPlayer = gameLocal.GetLocalPlayer();
	if ( localPlayer != NULL ) {
		if ( localPlayer->GetActiveTaskHandle() == GetHandle() ) {
			gameLocal.localPlayerProperties.OnTaskCompleted( this );
		} else if ( IsObjective() ) {
			if ( _taskInfo->GetTeam() == localPlayer->GetGameTeam() ) {
				gameLocal.localPlayerProperties.OnTaskCompleted( this );
			}
		}
	}

	_flags |= TF_COMPLETE;

	if ( !gameLocal.isClient ) {
		sdProficiencyManager::GetInstance().GiveMissionProficiency( this, GetInfo()->GetXPBonus() );
	}

	if ( gameLocal.isServer ) {
		sdTaskMessage msg( this, TM_COMPLETE );
		msg.Send( sdReliableMessageClientInfoAll() );
	}
}

/*
================
sdPlayerTask::SetUserCreated
================
*/
void sdPlayerTask::SetUserCreated( void ) {
	if ( IsUserCreated() ) {
		return;
	}

	_flags |= TF_USERCREATED;

	if ( gameLocal.isServer ) {
		sdTaskMessage msg( this, TM_USER_CREATED );
		msg.Send( sdReliableMessageClientInfoAll() );
	}
}


/*
================
sdPlayerTask::SetTimeout
================
*/
void sdPlayerTask::SetTimeout( int duration ) {
	_endTime = gameLocal.time + duration;
}

/*
================
sdPlayerTask::IsAvailable
================
*/
bool sdPlayerTask::IsAvailable( idPlayer* player ) const {
	if ( _flags & TF_COMPLETE || IsUserCreated() || IsObjective() || !IsPlayerEligible( player ) ) {
		return false;
	}

	return true;
}

/*
================
sdPlayerTask::OnPlayerJoined
================
*/
void sdPlayerTask::OnPlayerJoined( idPlayer* player ) {
	*_players.Alloc() = player;
}

/*
================
sdPlayerTask::OnPlayerLeft
================
*/
void sdPlayerTask::OnPlayerLeft( idPlayer* player ) {
	_players.Remove( player );
}

/*
============
sdPlayerTask::SelectWayPoints
============
*/
void sdPlayerTask::SelectWayPoints( int time ) {
	for( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		if( _wayPointInfo[ i ].wayPoint != NULL ) {
			_wayPointInfo[ i ].wayPoint->SetSelected( time );
		}
	}
}

/*
================
sdPlayerTask::IsPlayerEligible
================
*/
bool sdPlayerTask::IsPlayerEligible( idPlayer* player ) const {
	return _taskInfo->GetEligibility().Check( player, _entity );
}

/*
================
sdPlayerTask::HandleMessage
================
*/
void sdPlayerTask::HandleMessage( taskMessageType_t type, const idBitMsg& msg ) {
	switch ( type ) {
		case TM_USER_CREATED: {
			SetUserCreated();
			break;
		}
		case TM_COMPLETE: {
			SetComplete();
			break;
		}
		case TM_SETLOCATIION: {
			int index		= msg.ReadLong();
			idVec3 location = msg.ReadVector();
			SetTargetPos( index, location );
			break;
		}
		case TM_VISSTATE: {
			int index		= msg.ReadLong();
			bool state		= msg.ReadBool();
			SetWayPointState( index, state );
			break;
		}
		default: {
			gameLocal.Error( "sdPlayerTask::HandleMessage Invalid Message Type '%i'", type );
			break;
		}
	}
}

/*
================
sdPlayerTask::HandleMessage
================
*/
void sdPlayerTask::HandleMessage( const idBitMsg& msg ) {
	if ( gameLocal.isServer ) {
		return; // listen servers should ignore these
	}

	taskMessageType_t type = ( taskMessageType_t )msg.ReadBits( idMath::BitsForInteger( TM_NUM_MESSAGES ) );
	taskHandle_t handle = msg.ReadBits( sdPlayerTask::TASK_BITS );

	switch ( type ) {
		case TM_FULLSTATE: {
			int taskInfoIndex = msg.ReadBits( idMath::BitsForInteger( gameLocal.declPlayerTaskType.Num() ) );
			int spawnId = msg.ReadLong();
			sdTaskManager::GetInstance().AllocTask( handle, gameLocal.declPlayerTaskType[ taskInfoIndex ], spawnId );
			sdPlayerTask* task = sdTaskManager::GetInstance().TaskForHandle( handle );
			assert( task );
			task->ReadInitialState( msg );
			break;
		}

		case TM_CREATE: {
			int taskInfoIndex = msg.ReadBits( idMath::BitsForInteger( gameLocal.declPlayerTaskType.Num() ) );
			int spawnId = msg.ReadLong();
			sdTaskManager::GetInstance().AllocTask( handle, gameLocal.declPlayerTaskType[ taskInfoIndex ], spawnId );
			break;
		}

		case TM_REMOVE: {
			sdTaskManager::GetInstance().FreeTask( handle );
			break;
		}

		default: {
			sdPlayerTask* task = sdTaskManager::GetInstance().TaskForHandle( handle );
			if ( task ) {
				task->HandleMessage( type, msg );
			} else {
				gameLocal.Warning( "sdPlayerTask::HandleMessage Received Message for Un-allocated task" );
			}
		}
	}
}

/*
================
sdPlayerTask::Write
================
*/
void sdPlayerTask::Write( idFile* file ) const {
	file->WriteInt( GetHandle() );
	file->WriteInt( _taskInfo->Index() );
	file->WriteInt( _entity.GetSpawnId() );

	file->WriteInt( _flags );
	
	int count = _wayPointInfo.Num();
	file->WriteInt( count );
	for ( int i = 0; i < count; i++ ) {
		file->WriteBool( _wayPointInfo[ i ].enabled );
		file->WriteBool( _wayPointInfo[ i ].fixed );
		file->WriteVec3( _wayPointInfo[ i ].offset );
	}
}

/*
================
sdPlayerTask::Read
================
*/
void sdPlayerTask::Read( idFile* file ) {
	int handle;
	file->ReadInt( handle );

	int taskInfoIndex;
	file->ReadInt( taskInfoIndex );

	int spawnId;
	file->ReadInt( spawnId );

	sdTaskManager::GetInstance().AllocTask( handle, gameLocal.declPlayerTaskType[ taskInfoIndex ], spawnId );
	sdPlayerTask* task = sdTaskManager::GetInstance().TaskForHandle( handle );
	assert( task );
	task->ReadInitialState( file );
}

/*
================
sdPlayerTask::WriteInitialState
================
*/
void sdPlayerTask::WriteInitialState( const sdReliableMessageClientInfoBase& target ) const {
	sdTaskMessage msg( this, TM_FULLSTATE );
	msg.WriteBits( _taskInfo->Index(), idMath::BitsForInteger( gameLocal.declPlayerTaskType.Num() ) );
	msg.WriteLong( _entity.GetSpawnId() );
	msg.WriteBits( _flags, NUM_TASKFLAGS );

	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		msg.WriteBool( _wayPointInfo[ i ].fixed );
		msg.WriteBool( _wayPointInfo[ i ].enabled );
		if ( _wayPointInfo[ i ].fixed ) {
			msg.WriteVector( _wayPointInfo[ i ].offset );
		}
	}

	msg.Send( target );
}

/*
================
sdPlayerTask::ReadInitialState
================
*/
void sdPlayerTask::ReadInitialState( const idBitMsg& msg ) {
	_flags			= msg.ReadBits( NUM_TASKFLAGS );

	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		_wayPointInfo[ i ].fixed = msg.ReadBool();
		_wayPointInfo[ i ].enabled = msg.ReadBool();
		if ( _wayPointInfo[ i ].fixed ) {
			_wayPointInfo[ i ].offset = msg.ReadVector();
		}
	}
}

/*
================
sdPlayerTask::ReadInitialState
================
*/
void sdPlayerTask::ReadInitialState( idFile* file ) {
	file->ReadInt( _flags );

	int count;
	file->ReadInt( count );
	_wayPointInfo.SetNum( count );
	for ( int i = 0; i < count; i++ ) {
		file->ReadBool( _wayPointInfo[ i ].enabled );
		file->ReadBool( _wayPointInfo[ i ].fixed );
		file->ReadVec3( _wayPointInfo[ i ].offset );
	}
}

/*
================
sdPlayerTask::FlashIcon
================
*/
void sdPlayerTask::FlashIcon( int time ) {
	for ( int i = 0; i < _wayPointInfo.Num(); i++ ) {
		if ( _wayPointInfo[ i ].wayPoint != NULL ) {
			_wayPointInfo[ i ].wayPoint->SetFlashEndTime( gameLocal.ToGuiTime( gameLocal.time ) + time );
		}
	}
}

/*
================
sdPlayerTask::Event_Complete
================
*/
void sdPlayerTask::Event_Complete( void ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return;
	}
	SetComplete();
}

/*
================
sdPlayerTask::Event_SetTimeout
================
*/
void sdPlayerTask::Event_SetTimeout( float duration ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return;
	}
	SetTimeout( SEC2MS( duration ) );
}

/*
================
sdPlayerTask::Event_Free
================
*/
void sdPlayerTask::Event_Free( void ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return;
	}
	sdTaskManager::GetInstance().FreeTask( _taskIndex );
}

/*
================
sdPlayerTask::Event_GetTaskEntity
================
*/
void sdPlayerTask::Event_GetTaskEntity( void ) {
	sdProgram::ReturnEntity( GetEntity() );
}

/*
================
sdPlayerTask::Event_SetTargetPos
================
*/
void sdPlayerTask::Event_SetTargetPos( int index, const idVec3& position ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return;
	}

	if ( SetTargetPos( index, position ) ) {
		if ( gameLocal.isServer ) {
			sdTaskMessage msg( this, TM_SETLOCATIION );
			msg.WriteLong( index );
			msg.WriteVector( position );
			msg.Send( sdReliableMessageClientInfoAll() );
		}
	}
}

/*
================
sdPlayerTask::Event_SetWayPointState
================
*/
void sdPlayerTask::Event_SetWayPointState( int index, bool state ) {
	if ( gameLocal.isClient ) {
		assert( false );
		return;
	}

	if ( SetWayPointState( index, state ) ) {
		if ( gameLocal.isServer ) {
			sdTaskMessage msg( this, TM_VISSTATE );
			msg.WriteLong( index );
			msg.WriteBool( state );
			msg.Send( sdReliableMessageClientInfoAll() );
		}
	}
}

/*
================
sdPlayerTask::Event_GetKey
================
*/
void sdPlayerTask::Event_GetKey( const char *key ) {
	sdProgram::ReturnString( _taskInfo->GetData().GetString( key ) );
}

/*
================
sdPlayerTask::Event_GetIntKey
================
*/
void sdPlayerTask::Event_GetIntKey( const char *key ) {
	sdProgram::ReturnInteger( _taskInfo->GetData().GetInt( key ) );
}

/*
================
sdPlayerTask::Event_GetFloatKey
================
*/
void sdPlayerTask::Event_GetFloatKey( const char *key ) {
	sdProgram::ReturnFloat( _taskInfo->GetData().GetFloat( key ) );
}

/*
================
sdPlayerTask::Event_GetVectorKey
================
*/
void sdPlayerTask::Event_GetVectorKey( const char *key ) {
	sdProgram::ReturnVector( _taskInfo->GetData().GetVector( key ) );
}

/*
================
sdPlayerTask::Event_GetKeyWithDefault
================
*/
void sdPlayerTask::Event_GetKeyWithDefault( const char *key, const char* defaultvalue ) {
	sdProgram::ReturnString( _taskInfo->GetData().GetString( key, defaultvalue ) );
}

/*
================
sdPlayerTask::Event_GetIntKeyWithDefault
================
*/
void sdPlayerTask::Event_GetIntKeyWithDefault( const char *key, int defaultvalue ) {
	sdProgram::ReturnFloat( _taskInfo->GetData().GetInt( key, va( "%i", defaultvalue ) ) );
}

/*
================
sdPlayerTask::Event_GetFloatKeyWithDefault
================
*/
void sdPlayerTask::Event_GetFloatKeyWithDefault( const char *key, float defaultvalue ) {
	sdProgram::ReturnFloat( _taskInfo->GetData().GetFloat( key, va( "%f", defaultvalue ) ) );
}

/*
================
sdPlayerTask::Event_GetVectorKeyWithDefault
================
*/
void sdPlayerTask::Event_GetVectorKeyWithDefault( const char *key, const idVec3& defaultvalue ) {
	sdProgram::ReturnVector( _taskInfo->GetData().GetVector( key, defaultvalue.ToString() ) );
}

/*
================
sdPlayerTask::Event_GiveObjectiveProficiency
================
*/
void sdPlayerTask::Event_GiveObjectiveProficiency( float count, const char* reason ) {
	if ( !IsObjective() ) {
		return;
	}

	sdTeamInfo* team = _taskInfo->GetTeam();
	if ( team == NULL ) {
		return;
	}

	sdProficiencyManagerLocal& manager = sdProficiencyManager::GetInstance();

	for ( int i = 0; i < MAX_CLIENTS; i++ ) {
		idPlayer* player = gameLocal.GetClient( i );
		if ( player == NULL ) {
			continue;
		}

		if ( player->GetGameTeam() != team ) {
			continue;
		}

		const sdDeclPlayerClass* cls = player->GetInventory().GetClass();
		if ( cls == NULL ) {
			continue;
		}

		if ( cls->GetNumProficiencies() < 1 ) {
			continue;
		}

		manager.GiveProficiency( cls->GetProficiency( 0 ).index, count, player, 1.f, reason );
	}
}

/*
================
sdPlayerTask::Event_SetUserCreated
================
*/
void sdPlayerTask::Event_SetUserCreated( void ) {
	if ( gameLocal.isClient ) {
		return;
	}

	SetUserCreated();
}

/*
================
sdPlayerTask::Event_IsUserCreated
================
*/
void sdPlayerTask::Event_IsUserCreated( void ) {
	sdProgram::ReturnBoolean( IsUserCreated() );
}

/*
================
sdPlayerTask::Event_FlashIcon
================
*/
void sdPlayerTask::Event_FlashIcon( int time ) {
	FlashIcon( time );
}

/*
===============================================================================

	sdTaskManagerLocal

===============================================================================
*/

const idEventDef EV_TaskManager_AllocEntityTask( "allocEntityTask", 'o', DOC_TEXT( "Allocates a mission and returns the object. If the allocation fails for any reason the result will be $null$." ), 2, "Task objects are of type $class:sdPlayerTask$.", "d", "index", "Index of the $decl:task$ to use.", "e", "owner", "Entity which the task will be associated with." );

CLASS_DECLARATION( idClass, sdTaskManagerLocal )
	EVENT( EV_TaskManager_AllocEntityTask,						sdTaskManagerLocal::Event_AllocEntityTask )
END_CLASS


/*
================
sdTaskManagerLocal::sdTaskManagerLocal
================
*/
sdTaskManagerLocal::sdTaskManagerLocal( void ) : _scriptObject( NULL ) {
}

/*
================
sdTaskManagerLocal::~sdTaskManagerLocal
================
*/
sdTaskManagerLocal::~sdTaskManagerLocal( void ) {
}

/*
================
sdTaskManagerLocal::Init
================
*/
void sdTaskManagerLocal::Init( void ) {
	Shutdown();

	_objectiveTasks.SetNum( sdTeamManager::GetInstance().GetNumTeams() );
	_taskList.SetNum( sdPlayerTask::MAX_TASKS );
	_freeTasks.SetNum( sdPlayerTask::MAX_TASKS );
	for ( int i = 0; i < sdPlayerTask::MAX_TASKS; i++ ) {
		_taskList[ i ] = NULL;
		_freeTasks[ i ] = sdPlayerTask::MAX_TASKS - i - 1;
	}
}

/*
================
sdTaskManagerLocal::Shutdown
================
*/
void sdTaskManagerLocal::Shutdown( void ) {
	CheckForLeaks();

	for ( int i = 0; i < MAX_CLIENTS; i++ ) {
		idPlayer* player = gameLocal.GetClient( i );
		if ( player == NULL ) {
			continue;
		}

		player->GetTaskList().SetNum( 0 );
		player->SetManualTaskSelection( false );
	}

	_taskList.DeleteContents( true );
	_freeTasks.Clear();
	_objectiveTasks.SetNum( 0, false );
}

/*
================
sdTaskManagerLocal::OnNewTask
================
*/
void sdTaskManagerLocal::OnNewTask( sdPlayerTask* task ) {
	task->GetNode().AddToEnd( _activeTasks );

	if ( task->IsObjective() ) {
		sdTeamInfo* taskTeam = task->GetInfo()->GetTeam();
		if ( taskTeam != NULL ) {
			task->GetObjectiveNode().AddToEnd( _objectiveTasks[ taskTeam->GetIndex() ] );
			task->UpdateObjectiveWayPoint();
		}
	}

	idPlayer* localPlayer = gameLocal.GetLocalPlayer();
	if ( localPlayer != NULL ) {
		if ( task->IsAvailable( localPlayer ) ) {
			gameLocal.localPlayerProperties.OnNewTask( task );
		}
	}
}

/*
================
sdTaskManagerLocal::AllocTask
================
*/
sdPlayerTask* sdTaskManagerLocal::AllocTask( const sdDeclPlayerTask* taskInfo, idEntity* object ) {
	if ( gameLocal.isClient ) {
		return NULL;
	}

	if ( _freeTasks.Num() == 0 ) {
		gameLocal.Warning( "sdTaskManagerLocal::AllocTask No Free Tasks" );
		return NULL;
	}

	int index = _freeTasks[ _freeTasks.Num() - 1 ];
	_freeTasks.RemoveIndex( _freeTasks.Num() - 1 );

	assert( _taskList[ index ] == NULL );

	_taskList[ index ] = new sdPlayerTask();
	_taskList[ index ]->Create( index, taskInfo );
	_taskList[ index ]->SetEntity( gameLocal.GetSpawnId( object ) );
	_taskList[ index ]->WriteInitialState( sdReliableMessageClientInfoAll() );

	OnNewTask( _taskList[ index ] );

	return _taskList[ index ];
}

/*
================
sdTaskManagerLocal::AllocTask
================
*/
void sdTaskManagerLocal::AllocTask( taskHandle_t handle, const sdDeclPlayerTask* taskInfo, int spawnId ) {
	assert( _taskList[ handle ] == NULL );

	_taskList[ handle ] = new sdPlayerTask();
	_taskList[ handle ]->Create( handle, taskInfo );
	_taskList[ handle ]->SetEntity( spawnId );

	OnNewTask( _taskList[ handle ] );
}

/*
================
sdTaskManagerLocal::FreeTask
================
*/
void sdTaskManagerLocal::FreeTask( taskHandle_t handle ) {
	sdPlayerTask* task = TaskForHandle( handle );
	if ( !task ) {
		return;
	}

	if ( !task->IsComplete() ) {
		idPlayer* localPlayer = gameLocal.GetLocalPlayer();
		if ( localPlayer != NULL && localPlayer->GetActiveTaskHandle() == handle ) {
			gameLocal.localPlayerProperties.OnTaskExpired( task );
		}
	}

	for ( int i = 0; i < MAX_CLIENTS; i++ ) {
		idPlayer* player = gameLocal.GetClient( i );
		if ( player == NULL ) {
			continue;
		}

		player->GetTaskList().Remove( task );

		if ( !gameLocal.isClient ) {
			if ( player->GetActiveTaskHandle() == handle ) {
				player->SetActiveTask( taskHandle_t() );
				player->SetManualTaskSelection( false );
			}
		}
	}

	int index = task->GetIndex();
	delete task;
	_taskList[ index ] = NULL;

	if ( !gameLocal.isClient ) {
		if ( _freeTasks.FindIndex( index ) != -1 ) {
			gameLocal.Warning( "sdTaskManagerLocal::FreeTask - Freed an already free task '%d'", index );
		} else {
			int* freeTask = _freeTasks.Alloc();
			if ( freeTask == NULL ) {
				gameLocal.Error( "sdTaskManagerLocal::FreeTask - free tasks exceeded MAX_TASKS" );
			}
			*freeTask = index;
		}
	}
}

/*
================
sdTaskManagerLocal::Write
================
*/
void sdTaskManagerLocal::Write( idFile* file ) const {
	file->WriteInt( _activeTasks.Num() );
	for ( sdPlayerTask* task = _activeTasks.Next(); task; task = task->GetNode().Next() ) {
		task->Write( file );
	}
}

/*
================
sdTaskManagerLocal::Read
================
*/
void sdTaskManagerLocal::Read( idFile* file ) {
	int count;
	file->ReadInt( count );

	for ( int i = 0; i < count; i++ ) {
		sdPlayerTask::Read( file );
	}
}

/*
================
sdTaskManagerLocal::IsTaskValid
================
*/
bool sdTaskManagerLocal::IsTaskValid( idPlayer* player, taskHandle_t taskHandle, bool onlyCheckInitialFT ) {
	if ( taskHandle < 0 || taskHandle >= sdPlayerTask::MAX_TASKS ) {
		return false;
	}

	sdPlayerTask* task = TaskForHandle( taskHandle );
	if ( task == NULL ) {
		return false;
	}

	sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( player->entityNumber );
	if ( fireTeam != NULL ) {
		if ( fireTeam->GetCommander() != player ) {
			return false;
		}

		if ( player->GetTaskList().FindIndex( task ) == -1 ) {
			bool pass = false;
			for ( int i = 0; i < fireTeam->GetNumMembers(); i++ ) {
				idPlayer* p = fireTeam->GetMember( i );
				if ( p == player ) {
					continue;
				}

				if ( onlyCheckInitialFT ) {
					if ( p->GetTaskList().Num() < 1 ) {
						continue;
					}

					if ( p->GetTaskList()[ 0 ] == task ) {
						pass = true;
						break;
					}
				} else {
					if ( p->GetTaskList().FindIndex( task ) != -1 ) {
						pass = true;
						break;
					}
				}
			}

			if ( !pass ) {
				return false;
			}
		}
	} else {
		if ( player->GetTaskList().FindIndex( task ) == -1 ) {
			return false;
		}
	}

	return true;
}

/*
================
sdTaskManagerLocal::SelectTask
================
*/
void sdTaskManagerLocal::SelectTask( idPlayer* player, taskHandle_t taskHandle ) {
	if ( !taskHandle.IsValid() ) { // Gordon: always let the player choose "no task" == objective
		player->SetActiveTask( taskHandle );
		player->SetManualTaskSelection( true );
		return;
	}

	if ( player->GetActiveTaskHandle() == taskHandle ) {
		return;
	}

	if ( !IsTaskValid( player, taskHandle, true ) ) {
		return;
	}

	player->SetActiveTask( taskHandle );
	player->SetManualTaskSelection( true );
}

/*
================
sdTaskManagerLocal::WriteInitialReliableMessages
================
*/
void sdTaskManagerLocal::WriteInitialReliableMessages( const sdReliableMessageClientInfoBase& target ) const {
	for ( sdPlayerTask* task = _activeTasks.Next(); task; task = task->GetNode().Next() ) {
		task->WriteInitialState( target );
	}
}

idCVar g_debugWorldTasks( "g_debugWorldTasks", "0", CVAR_BOOL | CVAR_CHEAT, "draws a sphere around ranged based tasks" );

/*
================
sdTaskManagerLocal::Think
================
*/
void sdTaskManagerLocal::Think( void ) {
	if ( !gameLocal.isClient ) {
		sdPlayerTask* task;
		sdPlayerTask* nextTask;
		for ( task = _activeTasks.Next(); task; task = nextTask ) {
			nextTask = task->GetNode().Next();

			int endTime = task->GetEndTime();
			if ( endTime >= 0 && gameLocal.time > endTime && !( task->IsObjective() || task->IsMission() ) ) {
				FreeTask( task->GetHandle() );
				continue;
			}

			int timeLimit = task->GetInfo()->GetTimeLimit();
			if ( timeLimit != -1 && !( task->IsObjective() || task->IsMission() ) ) {
				endTime = task->GetStartTime() + timeLimit;
				if ( gameLocal.time > endTime ) {
					FreeTask( task->GetHandle() );
					continue;
				}
			}
		}

		sdTeamManagerLocal& manager = sdTeamManager::GetInstance();

		idEntity* entity;
		sdTaskInterface* iface;
		for ( entity = _taskEntities.Next(); entity; entity = iface->GetNode().Next() ) {
			iface = entity->GetTaskInterface();

			if ( entity->fl.spotted ) {
				continue;
			}

			sdTeamInfo* team = entity->GetGameTeam();
			if ( team == NULL ) {
				continue;
			}

			const idVec3& origin = entity->GetPhysics()->GetOrigin();

			if ( team->PointInJammer( origin, RM_RADAR ) ) {
				continue;
			}

			for ( int i = 0; i < manager.GetNumTeams(); i++ ) {
				sdTeamInfo& otherTeam = manager.GetTeamByIndex( i );
				if ( otherTeam == *team ) {
					continue;
				}

				idEntity* other = otherTeam.PointInRadar( origin, RM_RADAR );
				if ( other == NULL ) {
					continue;
				}

				entity->SetSpotted( other );
				break;
			}
		}
	}

	for ( sdPlayerTask* task = _activeTasks.Next(); task; task = task->GetNode().Next() ) {
		task->Think();
	}

	idPlayer* localPlayer = gameLocal.GetLocalPlayer();
	sdFireTeam* ft = NULL;
	if ( localPlayer != NULL ) {
		ft = gameLocal.rules->GetPlayerFireTeam( localPlayer->entityNumber );
		if ( ft && !ft->IsCommander( localPlayer ) ) {
			ft = NULL;
		}
	}
	
	for ( int i = 0; i < MAX_CLIENTS; i++ ) {
		idPlayer* player = gameLocal.GetClient( i );
		if ( player == NULL ) {
			continue;
		}

		if ( gameLocal.isClient ) {
			if ( ft == NULL ) {
				if ( player != localPlayer ) {
					continue;
				}
			} else {
				if ( !ft->IsMember( player ) ) {
					continue;
				}
			}
		}

		playerTaskList_t& taskList = player->GetTaskList();
		taskList.SetNum( 0 );

		for ( sdPlayerTask* task = _activeTasks.Next(); task; task = task->GetNode().Next() ) {
			bool isAvailable = task->IsAvailable( player );
			if ( isAvailable ) {
				sdPlayerTask** newTask = taskList.Alloc();
				if ( newTask == NULL ) {
					gameLocal.Error( "sdTaskManagerLocal::Think - taskList exceeded MAX_TASKS" );
				}

				*newTask = task;

				if ( player == localPlayer ) {
					float currentRange = 0.f;
					idEntity* other = task->GetEntity();
					if ( other != NULL ) {
						currentRange = idMath::Sqrt( gameLocal.RangeSquare( other, player ) );
					}
					task->SetCurrentRange( currentRange );
				}
			}

			if ( player == localPlayer ) {
				if ( task->HasEligibleWayPoint() ) {
					if ( isAvailable || task->IsPlayerEligible( player ) ) {
						task->ShowWayPoint();
					} else {
						task->HideWayPoint();
					}
				}
			}
		}

		taskList.Sort( SortTasksByPriority );

		if ( !gameLocal.isClient && !player->userInfo.isBot ) {
			bool canSelectTask = true;
			sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( player->entityNumber );
			if ( fireTeam != NULL ) {
				canSelectTask = fireTeam->GetCommander() == player;
			}

			if ( canSelectTask && !player->GetManualTaskSelection() ) {
				if ( player->GetActiveTask() == NULL ) {
					if ( taskList.Num() > 0 ) {
						player->SetActiveTask( taskList[ 0 ]->GetHandle() );
					}
				}
			}
		}
	}

	if ( !gameLocal.isClient ) {
		for ( int i = 0; i < MAX_CLIENTS; i++ ) {
			idPlayer* player = gameLocal.GetClient( i );
			if ( player == NULL ) {
				continue;
			}

			taskHandle_t taskHandle = player->GetActiveTaskHandle();
			if ( taskHandle.IsValid() ) {
				if ( !IsTaskValid( player, taskHandle, false ) ) {
					player->SetActiveTask( taskHandle_t() );
					player->SetManualTaskSelection( false );
				}
			}
		}
	}
}

/*
================
sdTaskManagerLocal::AddTaskEntity
================
*/
void sdTaskManagerLocal::AddTaskEntity( idLinkList< idEntity >& entity ) {
	entity.AddToEnd( _taskEntities );
}

/*
================
sdTaskManagerLocal::SortTasksByPriority
================
*/
int sdTaskManagerLocal::SortTasksByPriority( const taskPtr_t* a, const taskPtr_t* b ) {
	int diff = ( *a )->GetPriority() - ( *b )->GetPriority();
	if ( diff != 0 ) {
		return diff;
	}

	diff = idMath::Ftoi( idMath::Ceil( ( *a )->GetCurrentRange() - ( *b )->GetCurrentRange() ) );
	return diff;
}

/*
================
sdTaskManagerLocal::CheckForLeaks
================
*/
void sdTaskManagerLocal::CheckForLeaks( void ) {
#if 0
	for ( sdPlayerTask* task = _activeTasks.Next(); task; task = task->GetNode().Next() ) {
		gameLocal.Printf( "Task '%ls' not freed\n", task->GetTitle() );
	}
#endif // 0
}

/*
================
sdTaskManagerLocal::OnNewScriptLoad
================
*/
void sdTaskManagerLocal::OnNewScriptLoad( void ) {
	_scriptObject = gameLocal.program->AllocScriptObject( this, "taskManagerType" );

	sdScriptHelper h1;
	_scriptObject->CallNonBlockingScriptEvent( _scriptObject->GetPreConstructor(), h1 );

	const sdProgram::sdFunction* constructor = _scriptObject->GetConstructor();
	if ( constructor ) {
		sdProgramThread* scriptThread = gameLocal.program->CreateThread();
		scriptThread->SetName( "sdTaskManagerLocal" );
		scriptThread->CallFunction( _scriptObject, constructor );
		scriptThread->DelayedStart( 0 );
		scriptThread->GetAutoNode().AddToEnd( _scriptObject->GetAutoThreads() );
	}
}


/*
================
sdTaskManagerLocal::OnMapStart
================
*/
void sdTaskManagerLocal::OnMapStart( void ) {
	if ( _scriptObject ) {
		const sdProgram::sdFunction* callback = _scriptObject->GetFunction( "OnMapStart" );
		if ( callback ) {
			sdProgramThread* scriptThread = gameLocal.program->CreateThread();
			scriptThread->SetName( "sdTaskManagerLocal" );
			scriptThread->CallFunction( _scriptObject, callback );
			scriptThread->DelayedStart( 0 );
			scriptThread->GetAutoNode().AddToEnd( _scriptObject->GetAutoThreads() );
		}
	}
}

/*
================
sdTaskManagerLocal::OnMapShutdown
================
*/
void sdTaskManagerLocal::OnMapShutdown( void ) {
	if ( _scriptObject ) {
		sdScriptHelper h1;
		_scriptObject->CallNonBlockingScriptEvent( _scriptObject->GetFunction( "OnMapShutdown" ), h1 );
	}

	Shutdown();
}

/*
================
sdTaskManagerLocal::OnScriptChange
================
*/
void sdTaskManagerLocal::OnScriptChange( void ) {
	if ( _scriptObject ) {
		sdScriptHelper h1;
		_scriptObject->CallNonBlockingScriptEvent( _scriptObject->GetDestructor(), h1 );

		gameLocal.program->FreeScriptObject( _scriptObject );
	}
}

/*
============
sdTaskManagerLocal::Event_AllocEntityTask
============
*/
void sdTaskManagerLocal::Event_AllocEntityTask( int taskIndex, idEntity* object ) {
	const sdDeclPlayerTask* taskInfo = gameLocal.declPlayerTaskType[ taskIndex ];
	if ( !taskInfo ) {
		sdProgram::ReturnObject( NULL );
		return;
	}

	sdPlayerTask* task = AllocTask( taskInfo, object );
	if ( !task ) {
		sdProgram::ReturnObject( NULL );
		return;
	}
	sdProgram::ReturnObject( task->GetScriptObject() );
}

/*
============
sdTaskManagerLocal::BuildTaskList
============
*/
void sdTaskManagerLocal::BuildTaskList( idPlayer* player, playerTaskList_t& list ) {
	sdFireTeam* fireTeam = gameLocal.rules->GetPlayerFireTeam( player->entityNumber );
	if ( fireTeam != NULL ) {
		if ( fireTeam->GetCommander() == player ) {
			list = player->GetTaskList();
			for ( int i = 0; i < fireTeam->GetNumMembers(); i++ ) {
				idPlayer* other = fireTeam->GetMember( i );
				if ( other == player ) {
					continue;
				}

				if ( other->GetTaskList().Num() < 1 ) {
					continue;
				}

				list.AddUnique( other->GetTaskList()[ 0 ] );
			}
		}
	} else {
		list = player->GetTaskList();
	}
}

/*
============
sdTaskManagerLocal::GetObjectiveTasks
============
*/
const sdPlayerTask::nodeType_t& sdTaskManagerLocal::GetObjectiveTasks( const sdTeamInfo* team ) {
	return _objectiveTasks[ team->GetIndex() ];
}

/*
============
sdTaskManagerLocal::OnLocalTeamChanged
============
*/
void sdTaskManagerLocal::OnLocalTeamChanged( void ) {
	for ( int i = 0; i < _objectiveTasks.Num(); i++ ) {
		sdPlayerTask::nodeType_t& node = _objectiveTasks[ i ];
		for ( sdPlayerTask* task = node.Next(); task != NULL; task = task->GetObjectiveNode().Next() ) {
			task->UpdateObjectiveWayPoint();
		}
	}
}