Wizz at 10:17, 5 November 2007

2007-11-05T10:17:33Z

New page

#define TIMED_MISSION_SHORT 0
#define TIMED_MISSION_MEDIUM 1
#define TIMED_MISSION_LONG 2

#define TIMED_MISSION_THREAD_NAME "mapObject_Default_TimedMissionThread"

object [[ScriptClass:mapObject_Default|mapObject_Default]] : [[ScriptClass:mapObject_Base|mapObject_Base]] {
void preinit();
void destroy();

void InitObjectives();

void StopTimedMission();
void StopTimedMissionThread();
void CreateInitialTimedMission( entity obj );
void CreateTimedMission( entity obj, float type );
void ClearTimedMission();
void TimedMissionThread( entity obj, float type );
void FinishTimedMission();

void CreateRespawnTimeThread( [[ScriptClass:team_base|team_base]] attackingTeam );
void ResetRespawnTimeThread();
void ClearRespawnTimeThread();
void RespawnTimeThread( [[ScriptClass:team_base|team_base]] _attackingTeam );

[[ScriptClass:task|task]] AllocWorldTask( string name );
void FreeWorldTask( [[ScriptClass:task|task]] t );
void CreateDeployTasks();

entity worldspawn;

[[ScriptClass:task|task]] timedMission;
float timedMissionXP;

float timedMissionThread;

float respawnTimeThread;
[[ScriptClass:team_base|team_base]] attackingTeam;

[[ScriptClass:task|task]] engineerDeployTask;
[[ScriptClass:task|task]] engineerMineTask;
[[ScriptClass:task|task]] constructorDeployTask;
[[ScriptClass:task|task]] constructorMineTask;
[[ScriptClass:task|task]] fieldopsDeployTask;
[[ScriptClass:task|task]] oppressorDeployTask;
[[ScriptClass:task|task]] covertopsDeployTask;
[[ScriptClass:task|task]] infiltratorDeployTask;
[[ScriptClass:task|task]] medicDeployTask;
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::preinit() {
worldspawn = sys.[[ScriptEvent:getEntity|getEntity]]( "worldspawn" );
if ( worldspawn == $null_entity ) {
sys.[[ScriptEvent:error|error]]( "mapObject_Default::preinit - worldspawn is null!" );
}

timedMissionThread = -1;
respawnTimeThread = -1;
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::destroy() {
ClearTimedMission();

FreeWorldTask( engineerDeployTask );
FreeWorldTask( engineerMineTask );
FreeWorldTask( constructorDeployTask );
FreeWorldTask( constructorMineTask );
FreeWorldTask( fieldopsDeployTask );
FreeWorldTask( oppressorDeployTask );
FreeWorldTask( covertopsDeployTask );
FreeWorldTask( infiltratorDeployTask );
FreeWorldTask( medicDeployTask );

fieldopsDeployTask = $null;
oppressorDeployTask = $null;
engineerDeployTask = $null;
engineerMineTask = $null;
constructorDeployTask = $null;
constructorMineTask = $null;
covertopsDeployTask = $null;
infiltratorDeployTask = $null;
medicDeployTask = $null;
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::ClearTimedMission() {
if ( timedMission != $null ) {
timedMission.[[ScriptEvent:free|free]]();
timedMission = $null;
}
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::InitObjectives() {
// jrad - non-game maps don't need spawn waves
CreateRespawnTimeThread( gdfTeam );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::CreateInitialTimedMission( entity obj ) {
StopTimedMissionThread();
CreateTimedMission( obj, TIMED_MISSION_SHORT );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::StopTimedMissionThread() {
if ( timedMissionThread != -1 ) {
sys.[[ScriptEvent:terminate|terminate]]( timedMissionThread );
timedMissionThread = -1;
}
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::StopTimedMission() {
StopTimedMissionThread();
ClearTimedMission();
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::CreateTimedMission( entity obj, float type ) {
ClearTimedMission();
if ( timedMissionThread != -1 ) {
sys.[[ScriptEvent:warning|warning]]( "Timed Mission Thread Already Running" );
}
timedMissionThread = thread TimedMissionThread( obj, type );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::TimedMissionThread( entity obj, float type ) {
if ( obj == $null_entity ) {
sys.[[ScriptEvent:assert|assert]]( false );
sys.[[ScriptEvent:warning|warning]]( "mapObject_Default::TimedMissionThread Entity was null" );
timedMissionThread = -1;
return;
}

float timelimit = -1;
string taskName = "task_defend_long";
timedMissionXP = 30;
if ( type == TIMED_MISSION_SHORT ) {
timelimit = 4.f; // FIXME: get this from the task
taskName = "task_defend_short";
timedMissionXP = 10; // FIXME: get this from the task
} else if ( type == TIMED_MISSION_MEDIUM ) {
timelimit = 8.f;
taskName = "task_defend_medium";
timedMissionXP = 20;
}

timedMission = taskManager.[[ScriptEvent:allocEntityTask|allocEntityTask]]( GetPlayerTask( obj.[[ScriptEvent:getKey|getKey]]( taskName ) ), obj );
if ( timedMission == $null ) {
sys.[[ScriptEvent:warning|warning]]( "mapObject_Default::TimedMissionThread Failed to create a Timed mission" );
timedMissionThread = -1;
return;
}

obj.vInitDefendMission( timedMission );

if ( timelimit != -1 ) {
sys.[[ScriptEvent:wait|wait]]( timelimit * 60.f );

timedMissionThread = -1;
FinishTimedMission();

// MCP might have been removed
if ( obj != $null_entity ) {
CreateTimedMission( obj, type + 1 );
}

return;
}

timedMissionThread = -1;
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::FinishTimedMission() {
if ( timedMission != $null ) {

timedMission.[[ScriptEvent:giveObjectiveProficiency|giveObjectiveProficiency]]( timedMissionXP, "defend task" );

timedMission.[[ScriptEvent:complete|complete]]();
timedMission.[[ScriptEvent:free|free]]();
timedMission = $null;
}

StopTimedMissionThread();
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::CreateRespawnTimeThread( [[ScriptClass:team_base|team_base]] attackingTeam ) {
sys.[[ScriptEvent:assert|assert]]( respawnTimeThread == -1 );
respawnTimeThread = thread RespawnTimeThread( attackingTeam );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::ResetRespawnTimeThread() {
// map should have called CreateRespawnTimeThread before calls to this function is valid.
ClearRespawnTimeThread();
CreateRespawnTimeThread( attackingTeam );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::ClearRespawnTimeThread() {
if ( respawnTimeThread != -1 ) {
sys.[[ScriptEvent:terminate|terminate]]( respawnTimeThread );
respawnTimeThread = -1;
}
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::RespawnTimeThread( [[ScriptClass:team_base|team_base]] _attackingTeam ) {
attackingTeam = _attackingTeam;

if ( objManager.gameState != GS_GAMEON ) {
respawnTimeThread = -1;
return;
}

if ( !g_fasterSpawn.[[ScriptEvent:getBoolValue|getBoolValue]]() ) {
respawnTimeThread = -1;
return;
}

float respawnTimeChange = attackingTeam.[[ScriptEvent:getFloatKey|getFloatKey]]( "spawnTimeChange" );
sys.[[ScriptEvent:wait|wait]]( respawnTimeChange );

float respawnTimeReduction = attackingTeam.[[ScriptEvent:getFloatKey|getFloatKey]]( "spawnTimeReduction" );
float respawnWait = attackingTeam.GetRespawnWait();
attackingTeam.SetRespawnWait( respawnWait - respawnTimeReduction );

respawnTimeThread = -1;
}

[[ScriptClass:task|task]] [[ScriptClass:mapObject_Default|mapObject_Default]]::AllocWorldTask( string name ) {
sys.[[ScriptEvent:assert|assert]]( worldspawn != $null_entity );
return taskManager.[[ScriptEvent:allocEntityTask|allocEntityTask]]( GetPlayerTask( worldspawn.[[ScriptEvent:getKey|getKey]]( name ) ), worldspawn );
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::FreeWorldTask( [[ScriptClass:task|task]] t ) {
if ( t != $null ) {
t.[[ScriptEvent:free|free]]();
}
}

void [[ScriptClass:mapObject_Default|mapObject_Default]]::CreateDeployTasks() {
engineerDeployTask = AllocWorldTask( "task_engineer_deploy" );
engineerMineTask = AllocWorldTask( "task_engineer_plant_mines" );
constructorDeployTask = AllocWorldTask( "task_constructor_deploy" );
constructorMineTask = AllocWorldTask( "task_constructor_plant_mines" );
fieldopsDeployTask = AllocWorldTask( "task_fieldops_deploy" );
oppressorDeployTask = AllocWorldTask( "task_oppressor_deploy" );
covertopsDeployTask = AllocWorldTask( "task_covertops_deploy" );
infiltratorDeployTask = AllocWorldTask( "task_infiltrator_deploy" );
medicDeployTask = AllocWorldTask( "task_medic_deploy" );
}

Script:Files:script/maps/base.script - Revision history

Wizz at 10:17, 5 November 2007