Script:Files:script/maps/valley.script

From Mod Wiki
#define OBJECTIVE_VALLEY_BUILD_BRIDGE            0
#define OBJECTIVE_VALLEY_CAPTURE_OUTPOST        1
#define OBJECTIVE_VALLEY_HACK_OBJECTIVE            2
#define OBJECTIVE_VALLEY_DESTROY_CONTAMINATOR    3

//Base Deployables
#define    VAL_GDF_BASE_DEPLOY                    0
#define VAL_STROGG_BASE_DEPLOY                1

// Objective One - Build Bridge
#define    VAL_OBJ_CONSTRUCT_BRIDGE            2
#define VAL_GDF_ATTACK_BRIDGE                3
#define    VAL_GDF_DEPLOY_BRIDGE                4
#define    VAL_STROGG_DEFEND_BRIDGE            5
#define VAL_STROGG_DEPLOY_BRIDGE            6

// Objective Two - Deploy MCP
#define VAL_OBJ_ESCORT_MCP                    7
#define    VAL_GDF_ATTACK_OUTPOST                8
#define VAL_GDF_DEPLOY_TUNNEL                9
#define VAL_STROGG_DEFEND_OUTPOST            10
#define VAL_STROGG_DEPLOY_OUTPOST            11

//Objective Three - Hack Shield
#define    VAL_OBJ_HACK_SHIELD                    12
#define    VAL_GDF_ATTACK_SHIELD                13
#define    VAL_GDF_DEPLOY_OUTPOST                14
#define    VAL_STROGG_DEFEND_SHEILD            15
#define VAL_STROGG_DEPLOY_SHIELD            16

//Objective Four - Destroy Strogg Device
#define    VAL_OBJ_DESTROY_PLANT                17
#define    VAL_GDF_ATTACK_PLANT                18
//#define VAL_GDF_DEPLOY_PLANT				19 /* Not going to be used, instead there will be a forward spawn deploy group*/
#define    VAL_STROGG_DEFEND_PLANT                20
#define    VAL_STROGG_DEPLOY_PLANT                21

//Secondary Objectives
#define VAL_GDF_BRIDGE_GUARDTOWER            22
#define VAL_GDF_OUTPOST_GUARDTOWER            23
#define    VAL_GDF_SEWER_GRATE                    24

//Forward Spawns
//Tunnel Forward Spawn
#define VAL_OBJ_TUNNEL_SPAWN                25
#define VAL_GDF_ATTACK_TUNNEL_SPAWN            26
#define    VAL_GDF_DEFEND_TUNNEL_SPAWN            27
#define    VAL_STROGG_ATTACK_TUNNEL_SPAWN        28
#define    VAL_STROGG_DEFEND_TUNNEL_SPAWN        29

//Reservoir Forward Spawn
#define    VAL_OBJ_RESRVOIR_SPAWN                30
#define VAL_GDF_ATTACK_RESRVOIR_SPAWN        31
#define VAL_GDF_DEFEND_RESRVOIR_SPAWN        32
#define VAL_GDF_RESRVOIR_DEPLOY                33
#define VAL_STROGG_ATTACK_RESRVOIR_SPAWN    34
#define VAL_STROGG_DEFEND_RESRVOIR_SPAWN    35

//Forced secondary objectives for Strogg
#define VAL_STROGG_TUNNEL_MINES                36
#define    VAL_STROGG_MINE_SHIELD                37
#define VAL_STROGG_CONTAMINATION_PREMINE    38

// guard tower actions
#define VAL_GDF_BRIDGE_GUARDTOWER_ATTACKS    39
#define VAL_GDF_OUTPOST_GUARDTOWER_ATTACKS    40

// field ops only deployable, not turned off after bridge is built - this
// will allow field ops to use this deployable during mcp deploy objective -jk
#define VAL_GDF_BASE_DEPLOY_FIELDOPS_ONLY    51

object mapObject_Valley : mapObject_Default {
    void            InitObjectives();

    void            CompleteObjective( float index, entity p );
    handle            GetObjectiveMessage( float index );

    void            OnBridgeBuilt();
    void            OnOutpostCaptured();
    void            OnHackObjective();
    void            OnDeviceDestroyed();

    void            PostBridgeBuiltAudio();
    void            StartShieldObjective();
    void            StartFirstObjective();
    void            OnShieldDestroyedScud( entity trigger );

    vector            GetGDFBasePosition() { return '9800 -10870 2080'; }

    void            WallEffectsThread();

    void            FinalEffectsThread();

    void            OnTimeLimitHit();

    void            OnGuardTower1Built();
    void            OnGuardTower1Destroyed();
    void            OnGuardTower2Built();
    void            OnGuardTower2Destroyed();
    void            OnShieldHacked();
    void            OnSewerGrateDestroyed();

    void            OnConstructionComplete( entity obj );
    void            OnDestructionComplete( entity obj );
    void            OnShieldDeployed( entity obj, entity trigger );
    void            OnHackComplete( entity obj );
    void            OnMCPSpawned( entity obj );
    void            OnMCPDestroyed( entity obj, vector newLocation, vector newAngles );
    void            OnMCPDelivered( entity obj );

    void            ClearMCPData();

    // Bot Functions -- MBJ
    void             SetupBot_BridgeObjective();
    void             OnSpawnCaptured( string actionName );
    void             OnSpawnLiberated( string actionName );
    //void			RunBotMCPMapScript( float actionGroupOff, float actionGroupOn );
    // End Bot Functions -- MBJ

    float            mainObjectiveIndex;

    entity            gdfBaseTerritory;
    entity            bridgeTerritory;
    entity            outpost1Territory;
    entity            stroggBaseTerritory;
    entity            outpost2Territory;

    entity            gdfBaseArrow1;
    entity            gdfBaseArrow2;
    entity            tunnelArrow1;
    entity            tunnelArrow2;
    entity            outpostArrow1;
    entity            outpostArrow2;
    entity            reservoirArrow1;
    entity            reservoirArrow2;

    entity            objective1Marker;
    entity            objective2Marker;
    entity            objective3Marker;
    entity            objective4Marker;
    entity            objective5Marker;

    entity            gdfTunnelSpawn;
    entity            stroggTunnelSpawn;
    entity            gdfOutpost1Spawn;
    entity            stroggOutpost1Spawn;
    entity             stroggBaseSpawn1;
    entity             stroggBaseSpawn2;
    entity             gdfBaseSpawn;

    entity             effectEnt1; // fx for after the SCUD hits the corner of the building

    entity             gdfForwardTunnelSpawn;
    entity             gdfForwardReservoirSpawn;

    entity            entrance_smoke;
    entity            entrance_rubble;

    entity            entrance_blowout_1;
    entity            entrance_blowout_2;
    entity            entrance_blowout_3;

    entity            final_steam_1;
    entity            final_steam_2;
    entity            final_steam_3;
    entity            final_steam_4;
    entity            final_steam_5;
    entity            final_steam_6;
    entity            final_steam_7;
    entity            final_steam_8;

    entity            final_sparks_1;
    entity            final_sparks_2;
    entity            final_sparks_3;
    entity            final_sparks_4;

    entity            bridgeConstruction;
    entity            contaminator;
    entity            sewerGrate;

    entity            scudTrigger;
    entity            treatmentPlantDoor1; // no_touch door to close a portal
    entity            treatmentPlantDoor2; // no_touch door to close a portal
    entity            treatmentPlantDoor3; // no_touch door to close a portal

    entity            guardTower1;
    entity            guardTower1Construction;
    entity            guardTower2;
    entity            guardTower2Construction;

    entity            noplant_sewer_grate;
    entity            noplant_contamination_device;

    entity            mcpRoute;
    entity            mcpCaller;
    entity            shieldCaller;

    entity            currentMCP;

    entity             endCameraA;
    entity            endCameraB;

    boolean            sewerGrateDestroyed;
    boolean            guardTower2Built;

    void            SetupBot_BridgeObjective();
    void            DelayedBotSpawnThread();
    void            SetupBot_DeployMCP();
    void            DisableMcpBotAction();
    void            SetupBot_HackShield();
    void            SetupBot_DestroyDevice();
    void            DelayedEngineerCheck();
    void            DelayedRearSpawnThread();
    void            SetupBot_BridgeObjective_classesGDF();
    void            SetupBot_BridgeObjective_classesSTROGG();

    entity            botBridgeobstacle1;
    //entity			botBridgeobstacle2;
    entity            botPlantobstacle;
    entity            botPlantDoors;

    cvar             debug_script;
}

mapObject_Base Valley_MapScript() {
    return new mapObject_Valley;
}

void mapObject_Valley::InitObjectives() {
    gameRules.setWinningTeam( stroggTeam );
    gdfTeam.SetRespawnWait( 20 );
    stroggTeam.SetRespawnWait( 20 );
    CreateRespawnTimeThread( gdfTeam );

    gdfBaseTerritory        = worldspawn.getEntityKey( "script_gdf_base_territory" );
    bridgeTerritory            = worldspawn.getEntityKey( "script_bridge_territory" );
    outpost1Territory        = worldspawn.getEntityKey( "script_outpost1_territory" );
    stroggBaseTerritory        = worldspawn.getEntityKey( "script_strogg_base_territory" );
    outpost2Territory        = worldspawn.getEntityKey( "script_outpost2_territory" );

    gdfBaseArrow1            = worldspawn.getEntityKey( "script_obj1_arrow1" );
    gdfBaseArrow2            = worldspawn.getEntityKey( "script_obj1_arrow2" );
    tunnelArrow1            = worldspawn.getEntityKey( "script_obj2_arrow1" );
    tunnelArrow2            = worldspawn.getEntityKey( "script_obj2_arrow2" );
    outpostArrow1            = worldspawn.getEntityKey( "script_obj3_arrow1" );
    outpostArrow2            = worldspawn.getEntityKey( "script_obj3_arrow2" );
    reservoirArrow1            = worldspawn.getEntityKey( "script_obj4_arrow1" );
    reservoirArrow2            = worldspawn.getEntityKey( "script_obj4_arrow2" );

    objective1Marker        = worldspawn.getEntityKey( "script_obj1_marker" );
    objective2Marker        = worldspawn.getEntityKey( "script_obj2_marker" );
    objective3Marker        = worldspawn.getEntityKey( "script_obj3_marker" );
    objective4Marker        = worldspawn.getEntityKey( "script_obj4_marker" );

    entrance_smoke            = worldspawn.getEntityKey( "script_entrance_smoke" );
    entrance_rubble            = worldspawn.getEntityKey( "script_entrance_rubble" );

    entrance_blowout_1        = worldspawn.getEntityKey( "script_entrance_blowout_1" );
    entrance_blowout_2        = worldspawn.getEntityKey( "script_entrance_blowout_2" );
    entrance_blowout_3        = worldspawn.getEntityKey( "script_entrance_blowout_3" );

    final_sparks_1            = worldspawn.getEntityKey( "script_final_sparks_1" );
    final_sparks_2            = worldspawn.getEntityKey( "script_final_sparks_2" );
    final_sparks_3            = worldspawn.getEntityKey( "script_final_sparks_3" );
    final_sparks_4            = worldspawn.getEntityKey( "script_final_sparks_4" );

    final_steam_1            = worldspawn.getEntityKey( "script_final_steam_1" );
    final_steam_2            = worldspawn.getEntityKey( "script_final_steam_2" );
    final_steam_3            = worldspawn.getEntityKey( "script_final_steam_3" );
    final_steam_4            = worldspawn.getEntityKey( "script_final_steam_4" );
    final_steam_5            = worldspawn.getEntityKey( "script_final_steam_5" );
    final_steam_6            = worldspawn.getEntityKey( "script_final_steam_6" );
    final_steam_7            = worldspawn.getEntityKey( "script_final_steam_7" );
    final_steam_8            = worldspawn.getEntityKey( "script_final_steam_8" );

    endCameraA                = worldspawn.getEntityKey( "script_placement_camera_a" );
    endCameraB                = worldspawn.getEntityKey( "script_placement_camera_b" );

    bridgeConstruction        = worldspawn.getEntityKey( "script_bridge_materials" );
    contaminator            = worldspawn.getEntityKey( "script_contaminator" );

    effectEnt1                = worldspawn.getEntityKey( "script_final_effect" );


    gdfBaseSpawn            = worldspawn.getEntityKey( "script_gdf_base_spawn" );
    gdfTunnelSpawn            = worldspawn.getEntityKey( "script_gdf_tunnel_spawn" );
    stroggTunnelSpawn        = worldspawn.getEntityKey( "script_strogg_tunnel_spawn" );
    stroggBaseSpawn2        = worldspawn.getEntityKey( "script_strogg_base2_spawn" );
    stroggBaseSpawn1        = worldspawn.getEntityKey( "script_strogg_base1_spawn" );
    gdfOutpost1Spawn        = worldspawn.getEntityKey( "script_gdf_outpost1_spawn" );
    stroggOutpost1Spawn        = worldspawn.getEntityKey( "script_strogg_outpost1_spawn" );
    gdfForwardTunnelSpawn    = worldspawn.getEntityKey( "script_gdf_forward_tunnel_spawn" );
    gdfForwardReservoirSpawn    = worldspawn.getEntityKey( "script_gdf_forward_reservoir_spawn" );

    guardTower1                = worldspawn.getEntityKey( "script_gdf_tower_1_object" );
    guardTower1Construction    = worldspawn.getEntityKey( "script_gdf_tower_1" );
    guardTower2                = worldspawn.getEntityKey( "script_gdf_tower_2_object" );
    guardTower2Construction    = worldspawn.getEntityKey( "script_gdf_tower_2" );

    noplant_sewer_grate        = worldspawn.getEntityKey( "script_noplant_sewer_grate" );
    noplant_contamination_device     = worldspawn.getEntityKey( "script_noplant_contamination_device" );

    sewerGrate                = worldspawn.getEntityKey( "script_sewer_grate" );

    mcpRoute                = worldspawn.getEntityKey( "script_mcp_route" );
    mcpCaller                = worldspawn.getEntityKey( "script_mcp_caller" );
    shieldCaller            = worldspawn.getEntityKey( "script_shieldgen_caller" );

    treatmentPlantDoor1        = worldspawn.getEntityKey( "script_plant_door_1" );
    treatmentPlantDoor2        = worldspawn.getEntityKey( "script_plant_door_2" );
    treatmentPlantDoor3        = worldspawn.getEntityKey( "script_plant_door_3" );

    botBridgeobstacle1        = worldspawn.getEntityKey( "script_bot_bridge_obstacle_1" );
    //botBridgeobstacle2	= worldspawn.getEntityKey( "script_bot_bridge_obstacle_2" );
    botPlantobstacle        = worldspawn.getEntityKey( "script_plant_obstacle" );
    botPlantDoors            = worldspawn.getEntityKey( "merge_script_door_obstacles" );

    debug_script             =    sys.getCVar( "bot_debugMapScript", "1" );

    CreateDeployTasks();

    gdfBaseSpawn.setGameTeam( gdfTeam );
    gdfTunnelSpawn.setGameTeam( $null_entity );
    stroggTunnelSpawn.setGameTeam( stroggTeam );
    stroggBaseSpawn2.setGameTeam( stroggTeam );
    stroggBaseSpawn1.setGameTeam( stroggTeam );
    gdfOutpost1Spawn.setGameTeam( $null_entity );
    stroggOutpost1Spawn.setGameTeam( stroggTeam );
    gdfForwardTunnelSpawn.vSetActive( false );
    gdfForwardReservoirSpawn.vSetActive( false );

    gdfBaseArrow1.setGameTeam( gdfTeam );
    gdfBaseArrow1.vStartObjective();
    gdfBaseArrow2.setGameTeam( gdfTeam );
    gdfBaseArrow2.vStartObjective();
    tunnelArrow1.setGameTeam( gdfTeam );
    tunnelArrow2.setGameTeam( gdfTeam );
    outpostArrow1.setGameTeam( gdfTeam );
    outpostArrow2.setGameTeam( gdfTeam );
    reservoirArrow1.setGameTeam( gdfTeam );
    reservoirArrow2.setGameTeam( gdfTeam );

    objective1Marker.vStartObjective();
    objective2Marker.vFinishObjective();
    objective3Marker.vFinishObjective();
    objective4Marker.vFinishObjective();

    gdfBaseTerritory.setActive( true );
    stroggBaseTerritory.setActive( false );
    bridgeTerritory.setActive( true );
    outpost1Territory.setActive( false );
    outpost2Territory.setActive( false );

    thread StartFirstObjective();

    gameRules.setEndGameCamera( endCameraB );

    guardTower1Construction.vCreateMission();

    sewerGrateDestroyed = false;
    guardTower2Built = false;

    mainObjectiveIndex = OBJECTIVE_VALLEY_BUILD_BRIDGE;
    objManager.setNextObjective( gdfTeam, mainObjectiveIndex );
    objManager.setNextObjective( stroggTeam, mainObjectiveIndex );

    SetupBot_BridgeObjective();

}
void mapObject_Valley::SetupBot_BridgeObjective_classesGDF() {
    if ( objManager.getNumBotsOnTeam (GDF ) >= 12.0f ) {

    }    else if ( objManager.getNumBotsOnTeam ( GDF ) >= 6.0f ) {

    }
}
void mapObject_Valley::SetupBot_BridgeObjective_classesSTROGG() {
    if ( objManager.getNumBotsOnTeam ( STROGG ) >= 12.0f ) {

    }    else if ( objManager.getNumBotsOnTeam ( STROGG ) >= 6.0f ) {

    }
}

void mapObject_Valley::SetupBot_BridgeObjective() {
    if ( debug_script.getBoolValue() ) {        
        sys.print( "*****BOTS SETUP FOR BRIDGE OBJECTIVE*****\n" );
    }        
    objManager.activateBotActionGroup( VAL_OBJ_CONSTRUCT_BRIDGE );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_BRIDGE );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_BRIDGE );
    objManager.activateBotActionGroup( VAL_STROGG_DEPLOY_BRIDGE );
    objManager.activateBotActionGroup( VAL_GDF_BASE_DEPLOY );
    objManager.activateBotActionGroup( VAL_GDF_BASE_DEPLOY_FIELDOPS_ONLY );
    objManager.activateBotActionGroup( VAL_STROGG_TUNNEL_MINES );
    objManager.activateBotActionGroup( VAL_GDF_DEPLOY_BRIDGE );
    objManager.activateBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER );

    objManager.setAttackingTeam( GDF );
    objManager.setBotSightDist( 3000.0f );
    objManager.setBotCriticalClass( GDF, ENGINEER );
    objManager.setBotCriticalClass( STROGG, ENGINEER );
    //objManager.setTeamNeededClass( GDF, SOLDIER, FIELDOPS, 1, false, false );
    //objManager.setTeamNeededClass( STROGG, SOLDIER, FIELDOPS, 1, false, false );
    objManager.setPrimaryTeamAction( STROGG, "gdf_bridge_1" );
    objManager.setPrimaryTeamAction( GDF, "gdf_bridge_1" );
    objManager.setSecondaryTeamAction( GDF, "gdf_guardtower_1" );
    objManager.setSecondaryTeamAction( STROGG, "strogg_mine_tunnel_1" );

    objManager.disableNode( "Bridge_Node_1" );
    objManager.disableNode( "Bridge_Node_2" );    

    thread DelayedBotSpawnThread();
    thread DelayedEngineerCheck(); //add another engineer after 4 mins if gdf have not been able to build bridge
    thread DelayedRearSpawnThread();
}

void mapObject_Valley::DelayedBotSpawnThread() {
    sys.wait( 10.0f );

    objManager.setTeamNeededClass( GDF, ENGINEER, NOCLASS, 1, false, true );
    objManager.setTeamNeededClass( GDF, MEDIC, NOCLASS, 1, false, false );
    objManager.setTeamNeededClass( GDF, SOLDIER, NOCLASS, 1, false, false );
    objManager.setTeamNeededClass( STROGG, FIELDOPS, NOCLASS, 2, false, false );
}

void mapObject_Valley::DelayedEngineerCheck() {
    sys.wait( 240.0f );

    if ( objManager.isActionGroupActive( VAL_OBJ_CONSTRUCT_BRIDGE ) == 1.0f ) {
        objManager.setTeamNeededClass( GDF, ENGINEER, NOCLASS, 2, true, true );
    }
}

void mapObject_Valley::DelayedRearSpawnThread() {

    sys.wait( 15.0f ); //wait until tormentors are spawned in
    objManager.setTeamUseRearSpawn( STROGG, true );
    stroggTeam.setTeamRearSpawn( stroggBaseSpawn1 );
    objManager.setTeamUseRearSpawnPercentage( STROGG, 100 );
}

void mapObject_Valley::CompleteObjective( float index, entity p ) {
    if ( index == OBJECTIVE_VALLEY_BUILD_BRIDGE ) {
        OnBridgeBuilt();
    } else if ( index == OBJECTIVE_VALLEY_CAPTURE_OUTPOST ) {
        OnOutpostCaptured();
    } else if ( index == OBJECTIVE_VALLEY_HACK_OBJECTIVE ) {
        OnHackObjective();
    } else if ( index == OBJECTIVE_VALLEY_DESTROY_CONTAMINATOR ) {
        OnDeviceDestroyed();
    }
}

void mapObject_Valley::OnConstructionComplete( entity obj ) {
    if ( obj == guardTower1Construction ) {
        OnGuardTower1Built();
    } else if ( obj == guardTower2Construction ) {
        OnGuardTower2Built();
    }
}

void mapObject_Valley::OnDestructionComplete( entity obj ) {
    if ( obj == guardTower1Construction ) {
        OnGuardTower1Destroyed();
    } else if ( obj == guardTower2Construction ) {
        OnGuardTower2Destroyed();
    } else if ( obj == sewerGrate ) {
        OnSewerGrateDestroyed();
    }
}

void mapObject_Valley::OnShieldDeployed( entity obj, entity trigger ) {
    scudTrigger = trigger;
    scudTrigger.vStartObjective();
}

void mapObject_Valley::OnHackComplete( entity obj ) {
    if ( obj == scudTrigger ) {
        OnShieldHacked();
    }
}

void mapObject_Valley::ClearMCPData() {
    if ( currentMCP != $null_entity ) {
        currentMCP.vFreeMission();
        currentMCP = $null_entity;
    }
}

void mapObject_Valley::OnMCPSpawned( entity obj ) {
    ClearMCPData();
}

void mapObject_Valley::OnMCPDestroyed( entity obj, vector newLocation, vector newAngles ) {
    if ( currentMCP != obj ) {
        return;
    }

    ClearMCPData();

    mcpCaller.vCallDrop( newLocation, newAngles );
}

void mapObject_Valley::OnMCPDelivered( entity obj ) {
    ClearMCPData();

    if ( mainObjectiveIndex == OBJECTIVE_VALLEY_CAPTURE_OUTPOST ) {
        currentMCP = obj;
        objManager.SetObjectiveEntity( currentMCP, mainObjectiveIndex );
        currentMCP.vSetGoalMarker( objective2Marker );
        currentMCP.vSetPathTargets( mcpCaller.getWorldOrigin(), objective2Marker.getWorldOrigin() );
        currentMCP.setTrackerEntity( mcpRoute );
        CreateInitialTimedMission( currentMCP );
        currentMCP.vCreateMission();
    }
}

handle mapObject_Valley::GetObjectiveMessage( float index ) {
    if ( index == OBJECTIVE_VALLEY_BUILD_BRIDGE ) {
        return sys.localizeString( "maps/valley/obj_bridge" );
    }

    if ( index == OBJECTIVE_VALLEY_CAPTURE_OUTPOST ) {
        return sys.localizeString( "maps/valley/obj_outpost" );
    }

    if ( index == OBJECTIVE_VALLEY_HACK_OBJECTIVE ) {
        return sys.localizeString( "maps/valley/obj_depot" );
    }

    if ( index == OBJECTIVE_VALLEY_DESTROY_CONTAMINATOR ) {
        return sys.localizeString( "maps/valley/obj_contaminator" );
    }

    return g_locStr_BadObjective;
}

void mapObject_Valley::OnGuardTower1Built() {
    guardTower1Construction.vCompleteMission();
    objManager.deactivateBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER );
    objManager.activateBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER_ATTACKS );

    if ( mainObjectiveIndex == OBJECTIVE_VALLEY_BUILD_BRIDGE ) {
        guardTower1.vCreateMission();
    }
}

void mapObject_Valley::OnGuardTower1Destroyed() {
    if ( mainObjectiveIndex != OBJECTIVE_VALLEY_BUILD_BRIDGE ) {
        return;
    }

    guardTower1Construction.vCreateMission();
    objManager.activateBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER );
    objManager.deactivateBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER_ATTACKS );
}

void mapObject_Valley::OnGuardTower2Built() {
    guardTower2Built = true;
    guardTower2Construction.vCompleteMission();
    objManager.deactivateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER );

    if ( mainObjectiveIndex > OBJECTIVE_VALLEY_CAPTURE_OUTPOST ) {
        guardTower2.vCreateMission();
        objManager.activateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER_ATTACKS );
    }
}

void mapObject_Valley::OnGuardTower2Destroyed() {
    guardTower2Built = false;
    objManager.deactivateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER_ATTACKS );

    if ( mainObjectiveIndex < OBJECTIVE_VALLEY_HACK_OBJECTIVE ) {
        return;
    }

    guardTower2Construction.vCreateMission();
    objManager.activateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER );
}

void mapObject_Valley::OnShieldHacked() {
    objManager.SetObjectiveEntity( $null_entity, -1 );
    StopTimedMission();
    scudTrigger.vCompleteMission();
}

void mapObject_Valley::OnSewerGrateDestroyed() {
    sewerGrateDestroyed = true;
    noplant_sewer_grate.remove();
    sewerGrate.vCompleteMission();
    objManager.killBotAction( "gdf_sewer_grate_1" );
    objManager.killBotAction( "gdf_sewer_grate_2" );
    objManager.enableRoute ("hack_sewer_path_1" );
    objManager.enableRoute ("hack_sewer_path_2" );
}

void mapObject_Valley::SetupBot_DeployMCP () {
    if ( debug_script.getBoolValue() ) {
        sys.print( "*****BOTS SETUP FOR MCP OBJECTIVE*****\n" );
    }        
    objManager.botUpdateForEvent( NOTEAM, NOCLASS, ACTION_STATE_NULL );
    objManager.setBotCriticalClass( GDF, ENGINEER );
    objManager.setBotCriticalClass( STROGG, ENGINEER );
    objManager.setMapHasMCPGoal( true );

    objManager.killBotActionGroup( VAL_OBJ_CONSTRUCT_BRIDGE );
    objManager.killBotActionGroup( VAL_GDF_ATTACK_BRIDGE );
    objManager.killBotActionGroup( VAL_STROGG_DEFEND_BRIDGE );
    objManager.killBotActionGroup( VAL_STROGG_DEPLOY_BRIDGE );
    objManager.killBotActionGroup( VAL_GDF_BASE_DEPLOY );
    objManager.killBotActionGroup( VAL_STROGG_TUNNEL_MINES );
    objManager.killBotActionGroup( VAL_GDF_BRIDGE_GUARDTOWER_ATTACKS );

    objManager.activateBotActionGroup( VAL_OBJ_ESCORT_MCP );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_OUTPOST );
    objManager.activateBotActionGroup( VAL_GDF_DEPLOY_TUNNEL );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_OUTPOST );
    objManager.activateBotActionGroup( VAL_STROGG_DEPLOY_OUTPOST );
    objManager.activateBotActionGroup( VAL_OBJ_TUNNEL_SPAWN );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_TUNNEL_SPAWN );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_TUNNEL_SPAWN );

    objManager.switchTeamWeapons( STROGG, SOLDIER, 2, 6, true );    
    objManager.switchTeamWeapons( STROGG, SOLDIER, 2, 5, true );

    objManager.setPrimaryTeamAction( STROGG, "gdf_outpost_1" );
    objManager.setPrimaryTeamAction( GDF, "gdf_outpost_1" );

    objManager.setTeamUseRearSpawn( GDF, true );
    gdfTeam.setTeamRearSpawn( gdfBaseSpawn );
    objManager.setTeamUseRearSpawnPercentage( GDF, 50 );
    objManager.setTeamUseRearSpawnPercentage( STROGG, 50 );

    objManager.setTeamNeededClass( GDF, ENGINEER, NOCLASS, 2, false, false );
    objManager.setTeamNeededClass( STROGG, ENGINEER, COVERTOPS, 2, true, false );
    objManager.setTeamNeededClass( STROGG, SOLDIER, NOCLASS, 2, false, false );

}

void mapObject_Valley::OnBridgeBuilt() {

    mainObjectiveIndex = OBJECTIVE_VALLEY_CAPTURE_OUTPOST;
    objManager.enableNode( "Bridge_Node_1" );
    objManager.enableNode( "Bridge_Node_2" );
    objManager.setNextObjective( gdfTeam, mainObjectiveIndex );
    objManager.setNextObjective( stroggTeam, mainObjectiveIndex );

    gdfBaseArrow1.vFinishObjective();
    gdfBaseArrow2.vFinishObjective();
    tunnelArrow1.vStartObjective();
    tunnelArrow2.vStartObjective();

    objective1Marker.vFinishObjective();
    objective2Marker.vStartObjective();

    bridgeTerritory.setGameTeam( gdfTeam );
    gdfTunnelSpawn.setGameTeam( gdfTeam );
    stroggTunnelSpawn.setGameTeam( $null_entity );

    gdfBaseTerritory.setActive( false );
    bridgeTerritory.setActive( true );
    outpost1Territory.setActive( true );

    gdfForwardTunnelSpawn.vSetActive( true );

    objManager.SetObjectiveEntity( $null_entity, -1 );

    StopTimedMission();
    bridgeConstruction.vCompleteMission();
    guardTower1.vFreeMission();
    guardTower1Construction.vFreeMission();

    mcpCaller.vOnDeploy();

    thread PostBridgeBuiltAudio();

    gdfTeam.SetRespawnWait( 15 );
    ResetRespawnTimeThread();

    botBridgeobstacle1.activate( botBridgeobstacle1 );
    //botBridgeobstacle2.activate( botBridgeobstacle1 );

    SetupBot_DeployMCP();
    thread DisableMcpBotAction();
}

void mapObject_Valley::DisableMcpBotAction() {

    sys.wait( 45.f ); //wait 45 seconds and disable bot_action 28
    objManager.deactivateBotAction( "gdf_bridge_2" );
}

void mapObject_Valley::SetupBot_HackShield() {
    if ( debug_script.getBoolValue() ) {
        sys.print( "*****BOTS SETUP FOR HACK OBJECTIVE*****\n" );
    }
    objManager.botUpdateForEvent( NOTEAM, NOCLASS, ACTION_STATE_NULL );
    objManager.setBotCriticalClass( GDF, COVERTOPS );
    objManager.setBotCriticalClass( STROGG, ENGINEER );

    objManager.killBotActionGroup( VAL_OBJ_ESCORT_MCP );
    objManager.killBotActionGroup( VAL_GDF_ATTACK_OUTPOST );
    objManager.killBotActionGroup( VAL_STROGG_DEFEND_OUTPOST );
    objManager.killBotActionGroup( VAL_STROGG_DEPLOY_OUTPOST );
    objManager.killBotActionGroup( VAL_GDF_DEPLOY_BRIDGE );
    objManager.killBotActionGroup( VAL_GDF_DEPLOY_TUNNEL );
    objManager.killBotActionGroup( VAL_OBJ_TUNNEL_SPAWN );
    objManager.killBotActionGroup( VAL_GDF_ATTACK_TUNNEL_SPAWN );
    objManager.killBotActionGroup( VAL_GDF_DEFEND_TUNNEL_SPAWN );
    objManager.killBotActionGroup( VAL_STROGG_ATTACK_TUNNEL_SPAWN );
    objManager.killBotActionGroup( VAL_STROGG_DEFEND_TUNNEL_SPAWN );
    objManager.killBotActionGroup( VAL_GDF_BASE_DEPLOY_FIELDOPS_ONLY ); // this will destroy any field op deployables still at GDF main base

    objManager.activateBotActionGroup( VAL_OBJ_HACK_SHIELD );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_SHIELD );
    objManager.activateBotActionGroup( VAL_GDF_DEPLOY_OUTPOST );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_SHEILD );
    objManager.activateBotActionGroup( VAL_STROGG_DEPLOY_SHIELD );
    if ( !sewerGrateDestroyed ) {
        objManager.activateBotActionGroup( VAL_GDF_SEWER_GRATE );
    }

    if ( !guardTower2Built ) {
        objManager.activateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER );
    } else {
        objManager.activateBotActionGroup( VAL_GDF_OUTPOST_GUARDTOWER_ATTACKS );
    }

    objManager.activateBotActionGroup( VAL_STROGG_CONTAMINATION_PREMINE );
    objManager.activateBotActionGroup( VAL_STROGG_MINE_SHIELD );

    // ==========================================
    // Test
    objManager.activateBotActionGroup( VAL_OBJ_RESRVOIR_SPAWN );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_RESRVOIR_SPAWN );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_RESRVOIR_SPAWN );
    // End test
    // ==========================================

    objManager.setTeamAttacksDeployables( STROGG, false );

    objManager.setPrimaryTeamAction( STROGG, "gdf_hack_1" );
    objManager.setPrimaryTeamAction( GDF, "gdf_hack_1" );
    objManager.setSecondaryTeamAction( GDF, "gdf_sewer_grate_1" );
    objManager.setSecondaryTeamAction( GDF, "gdf_guardtower_2" );

    objManager.setSecondaryTeamAction( STROGG, "strogg_mine_shield_1" );
    objManager.setSecondaryTeamAction( STROGG, "strogg_contamination_premine_1" );

    objManager.setMapHasMCPGoal( false );
    objManager.setTeamNeededClass( GDF, COVERTOPS, ENGINEER, 2, true, true );

    objManager.setTeamUseRearSpawn( GDF, true );
    gdfTeam.setTeamRearSpawn( gdfOutpost1Spawn );
    objManager.setTeamUseRearSpawnPercentage( STROGG, 80 );
}

void mapObject_Valley::OnOutpostCaptured() {
    mainObjectiveIndex = OBJECTIVE_VALLEY_HACK_OBJECTIVE;
    objManager.setNextObjective( gdfTeam, mainObjectiveIndex );
    objManager.setNextObjective( stroggTeam, mainObjectiveIndex );

    gdfForwardTunnelSpawn.vSetActive( false );
    gdfForwardTunnelSpawn.setGameTeam( gdfTeam );

    gdfOutpost1Spawn.setGameTeam( gdfTeam );
    stroggOutpost1Spawn.setGameTeam( $null_entity );

    tunnelArrow1.vFinishObjective();
    tunnelArrow2.vFinishObjective();
    outpostArrow1.vStartObjective();
    outpostArrow2.vStartObjective();

    outpost1Territory.setGameTeam( gdfTeam );

    // ==========================================
    // Test
    gdfForwardReservoirSpawn.vSetActive( true );

    // give gdf territory outside final objective compound
    outpost2Territory.setGameTeam( gdfTeam );
    // End test
    // ==========================================

    objective2Marker.vFinishObjective();
    objective3Marker.vStartObjective();

    objManager.SetObjectiveEntity( $null_entity, -1 );

    if ( currentMCP != $null_entity ) {
        currentMCP.vCompleteMission();
    }
    StopTimedMission();

    if ( !guardTower2Built ) {
        guardTower2Construction.vCreateMission();
    }

    if ( !sewerGrateDestroyed ) {
        sewerGrate.vCreateMission();
    }

    shieldCaller.vOnDeploy();

    G_PlayObjectiveCompletedRoll( GDF );
    objManager.PlaySound( worldspawn.getKey( "snd_outpost_captured_strogg" ), stroggTeam );
    objManager.PlaySound( worldspawn.getKey( "snd_outpost_captured_gdf" ), gdfTeam );

    gdfTeam.SetRespawnWait( 20 );
    // Test: old Strogg value was 30
    stroggTeam.SetRespawnWait( 20 );
    ResetRespawnTimeThread();
    SetupBot_HackShield();

}

void mapObject_Valley::SetupBot_DestroyDevice() {
    if ( debug_script.getBoolValue() ) {
        sys.print( "*****BOTS SETUP FOR FINAL OBJECTIVE*****\n" );
    }
    objManager.botUpdateForEvent( NOTEAM, NOCLASS, ACTION_STATE_NULL );
    objManager.setBotCriticalClass( GDF, SOLDIER );
    objManager.setBotCriticalClass( STROGG, ENGINEER );

    objManager.killBotActionGroup( VAL_OBJ_HACK_SHIELD );
    objManager.killBotActionGroup( VAL_GDF_ATTACK_SHIELD );
    objManager.killBotActionGroup( VAL_STROGG_DEFEND_SHEILD );
    objManager.killBotActionGroup( VAL_STROGG_DEPLOY_SHIELD );
    objManager.killBotActionGroup( VAL_STROGG_CONTAMINATION_PREMINE );
    objManager.killBotActionGroup( VAL_STROGG_MINE_SHIELD );

    // <xian>
    // Added per nakedape	
    objManager.killBotActionGroup( VAL_OBJ_RESRVOIR_SPAWN );
    objManager.killBotActionGroup( VAL_GDF_ATTACK_RESRVOIR_SPAWN );
    objManager.killBotActionGroup( VAL_GDF_DEFEND_RESRVOIR_SPAWN );
    objManager.killBotActionGroup( VAL_STROGG_ATTACK_RESRVOIR_SPAWN );
    objManager.killBotActionGroup( VAL_STROGG_DEFEND_RESRVOIR_SPAWN );
    objManager.activateBotActionGroup( VAL_GDF_RESRVOIR_DEPLOY );
    // </xian>

    objManager.activateBotActionGroup( VAL_OBJ_DESTROY_PLANT );
    objManager.activateBotActionGroup( VAL_GDF_ATTACK_PLANT );
    objManager.activateBotActionGroup( VAL_STROGG_DEFEND_PLANT );
    objManager.activateBotActionGroup( VAL_STROGG_DEPLOY_PLANT );

    // ==========================================
    // Test: moved to the Hack objectve
    //objManager.activateBotActionGroup( VAL_OBJ_RESRVOIR_SPAWN );
    //objManager.activateBotActionGroup( VAL_GDF_ATTACK_RESRVOIR_SPAWN );
    //objManager.activateBotActionGroup( VAL_STROGG_DEFEND_RESRVOIR_SPAWN );
    // End test
    // ==========================================

    objManager.switchTeamWeapons( GDF, SOLDIER, 2, 5, false );
    objManager.switchTeamWeapons( GDF, SOLDIER, 5, 6, false );

    objManager.disableRoute( "strogg_defend_shield_route_1" );
    objManager.disableRoute( "strogg_defend_shield_route_2" );

    objManager.enableRoute( "strogg_defend_plant_route_1" );
    objManager.enableRoute( "strogg_defend_plant_route_2" );

    objManager.setPrimaryTeamAction( STROGG, "gdf_bomb_1" );
    objManager.setPrimaryTeamAction( GDF, "gdf_bomb_1" );

    objManager.setSecondaryTeamAction( GDF, "gdf_plant_priority_firesupport_1" );

    objManager.setTeamAttacksDeployables( STROGG, false );

    objManager.setTeamNeededClass( GDF, SOLDIER, COVERTOPS, 2, true, true );
    objManager.setTeamNeededClass( GDF, MEDIC, ENGINEER, 2, true, true );
    objManager.setTeamNeededClass( STROGG, ENGINEER, NOCLASS, 2, true, true );

    objManager.setTeamUseRearSpawn( STROGG, false );

}

void mapObject_Valley::OnHackObjective() {

    mainObjectiveIndex = OBJECTIVE_VALLEY_DESTROY_CONTAMINATOR;
    objManager.setNextObjective( gdfTeam, mainObjectiveIndex );
    objManager.setNextObjective( stroggTeam, mainObjectiveIndex );

    objective3Marker.vFinishObjective();
    objective4Marker.vStartObjective();

    contaminator.vStartObjective();

    thread WallEffectsThread();

    // ==========================================
    // Test: moved to Hack objective
    //gdfForwardReservoirSpawn.vSetActive( true );

    // give gdf territory outside final objective compound
    //outpost2Territory.setGameTeam( gdfTeam );

    // Test
    gdfForwardReservoirSpawn.vSetActive( false );
    gdfForwardReservoirSpawn.setGameTeam( gdfTeam );    
    // End test
    // ==========================================

    stroggBaseTerritory.setActive( true );
    outpost1Territory.setActive( false );
    outpost2Territory.setActive( true );

    scudTrigger.vFreeMission();

    outpostArrow1.vFinishObjective();
    outpostArrow2.vFinishObjective();
    reservoirArrow1.vStartObjective();
    reservoirArrow2.vStartObjective();

    // start the fx after the SCUD hits the corner of the building
    //effectEnt1.activate( effectEnt1 );

    treatmentPlantDoor1.remove();
    treatmentPlantDoor2.remove();
    treatmentPlantDoor3.remove();

    objManager.SetObjectiveEntity( contaminator, mainObjectiveIndex );
    CreateInitialTimedMission( contaminator );
    contaminator.vCreateMission();

    gdfTeam.SetRespawnWait( 20 );
    stroggTeam.SetRespawnWait( 20 );
    ResetRespawnTimeThread();
    SetupBot_DestroyDevice();

    botPlantobstacle.activate( botPlantobstacle );
    botPlantDoors.activate ( botPlantDoors );
}

void mapObject_Valley::WallEffectsThread() {
    entrance_blowout_1.vTriggerParticleEffect( 1 );
    entrance_blowout_2.vTriggerParticleEffect( 1 );
    entrance_blowout_3.vTriggerParticleEffect( 1 );
    entrance_smoke.vTriggerParticleEffect( 1 );

    sys.wait( 1.5f );
    entrance_rubble.vTriggerParticleEffect( 1 );
}

void mapObject_Valley::FinalEffectsThread() {
    sys.wait( 0.5f );
    final_sparks_1.vTriggerParticleEffect( 1 );
    final_steam_2.vTriggerParticleEffect( 1 );
    final_steam_4.vTriggerParticleEffect( 1 );

    sys.wait( 0.2f );
    final_sparks_2.vTriggerParticleEffect( 1 );
    final_steam_1.vTriggerParticleEffect( 1 );
    final_steam_6.vTriggerParticleEffect( 1 );

    sys.wait( 0.8f );
    final_sparks_3.vTriggerParticleEffect( 1 );
    final_steam_3.vTriggerParticleEffect( 1 );
    final_steam_7.vTriggerParticleEffect( 1 );

    sys.wait( 0.3f );
    final_sparks_4.vTriggerParticleEffect( 1 );
    final_steam_5.vTriggerParticleEffect( 1 );

    sys.wait( 0.3f );
    final_steam_8.vTriggerParticleEffect( 1 );
}

void mapObject_Valley::OnDeviceDestroyed() {
    objective4Marker.vFinishObjective();

    thread FinalEffectsThread();

    StopTimedMission();
    contaminator.vFinishObjective();

    gameRules.setEndGameCamera( endCameraA );

    gameRules.setWinningTeam( gdfTeam );
    gameRules.endGame();

    contaminator.vCompleteMission();
}

void mapObject_Valley::PostBridgeBuiltAudio() {
    sys.wait( 10.f );

    objManager.PlaySound( worldspawn.getKey( "snd_mcp_intro_strogg" ), stroggTeam );
    objManager.PlaySound( worldspawn.getKey( "snd_mcp_intro_gdf" ), gdfTeam );
}

void mapObject_Valley::StartShieldObjective() {
    sys.wait( 5.f );

    scudTrigger.vSetActive( true );
    CreateInitialTimedMission( scudTrigger );
    scudTrigger.vCreateMission();
    objManager.SetObjectiveEntity( scudTrigger, mainObjectiveIndex );
}

void mapObject_Valley::OnShieldDestroyedScud( entity trigger ) {
    thread StartShieldObjective();
}

void mapObject_Valley::StartFirstObjective() {
    sys.wait( 5.f );

    objManager.SetObjectiveEntity( bridgeConstruction, mainObjectiveIndex );

    CreateInitialTimedMission( bridgeConstruction );
    bridgeConstruction.vCreateMission();
    bridgeConstruction.vStartObjective();
}

void mapObject_Valley::OnTimeLimitHit() {
    FinishTimedMission();
    objManager.SetObjectiveEntity( $null_entity, -1 );

    objManager.PlaySound( worldspawn.getKey( "snd_gdflose_strogg" ), stroggTeam );
    objManager.PlaySound( worldspawn.getKey( "snd_gdflose_gdf" ), gdfTeam );
}
/*
void mapObject_Valley::RunBotMCPMapScript
( float actionGroupOff, float actionGroupOn ) {

	if ( actionGroupOff == STROGG_DEFEND_TUNNEL && actionGroupOn == STROGG_ATTACK_TUNNEL ) {
		objManager.deactivateBotActionGroup( STROGG_DEFEND_TUNNEL );
		objManager.activateBotActionGroup( STROGG_ATTACK_TUNNEL );
	}
	if ( actionGroupOff == GDF_DEFEND_TUNNEL && actionGroupOn == GDF_DEFEND_MCP ) {
		objManager.deactivateBotActionGroup( GDF_DEFEND_TUNNEL );
		objManager.activateBotActionGroup( GDF_DEFEND_MCP );
	}
	if ( actionGroupOff == STROGG_ATTACK_TUNNEL && actionGroupOn == VAL_STROGG_DEPLOY_OUTPOST ) {
		objManager.deactivateBotActionGroup( STROGG_ATTACK_TUNNEL );
		objManager.activateBotActionGroup( VAL_STROGG_DEPLOY_OUTPOST );
	}
}
*/
void mapObject_Valley::OnSpawnCaptured( string actionName )
{
    if( actionName == "gdf_tunnelspawn_1" )
    {
        if ( debug_script.getBoolValue() ) {
            sys.print( "*****GDF CAPTURED TUNNEL SPAWN*****\n" );
        }
        objManager.deactivateBotActionGroup( VAL_GDF_ATTACK_TUNNEL_SPAWN );
        objManager.activateBotActionGroup( VAL_GDF_DEFEND_TUNNEL_SPAWN );
        objManager.deactivateBotActionGroup( VAL_STROGG_DEFEND_TUNNEL_SPAWN );
        objManager.activateBotActionGroup( VAL_STROGG_ATTACK_TUNNEL_SPAWN );

        objManager.enableRoute( "tunnel_forward_spawn_node_1" );
        objManager.enableRoute( "tunnel_forward_spawn_node_2" );
    }
    if( actionName == "gdf_reservoir_spawn_1" )
    {
        if ( debug_script.getBoolValue() ) {
            sys.print( "*****GDF CAPTURED RESERVOIR SPAWN*****\n" );
        }
        objManager.deactivateBotActionGroup( VAL_GDF_ATTACK_RESRVOIR_SPAWN );
        objManager.activateBotActionGroup( VAL_GDF_DEFEND_RESRVOIR_SPAWN );
        objManager.activateBotActionGroup( VAL_GDF_RESRVOIR_DEPLOY );
        objManager.deactivateBotActionGroup( VAL_STROGG_DEFEND_RESRVOIR_SPAWN );
        objManager.activateBotActionGroup( VAL_STROGG_ATTACK_RESRVOIR_SPAWN );

        objManager.enableRoute( "gdf_resrvoir_spawn_node_1" );
    }
}

void mapObject_Valley::OnSpawnLiberated( string actionName )
{
    if( actionName == "gdf_tunnelspawn_1" )
    {
        if ( debug_script.getBoolValue() ) {
            sys.print( "*****GDF LOST TUNNEL SPAWN*****\n" );
        }
        objManager.deactivateBotActionGroup( VAL_GDF_DEFEND_TUNNEL_SPAWN );
        objManager.activateBotActionGroup( VAL_GDF_ATTACK_TUNNEL_SPAWN );
        objManager.deactivateBotActionGroup( VAL_STROGG_ATTACK_TUNNEL_SPAWN );
        objManager.activateBotActionGroup( VAL_STROGG_DEFEND_TUNNEL_SPAWN );

        objManager.disableRoute( "tunnel_forward_spawn_node_1" );
        objManager.disableRoute( "tunnel_forward_spawn_node_2" );
    }
    if( actionName == "gdf_reservoir_spawn_1" )
    {
        if ( debug_script.getBoolValue() ) {
            sys.print( "*****GDF LOST RESERVOIR SPAWN*****\n" );
        }
        objManager.deactivateBotActionGroup( VAL_GDF_DEFEND_RESRVOIR_SPAWN );
        objManager.activateBotActionGroup( VAL_GDF_ATTACK_RESRVOIR_SPAWN );
        objManager.deactivateBotActionGroup( VAL_GDF_RESRVOIR_DEPLOY );
        objManager.deactivateBotActionGroup( VAL_STROGG_ATTACK_RESRVOIR_SPAWN );
        objManager.activateBotActionGroup( VAL_STROGG_DEFEND_RESRVOIR_SPAWN );

        objManager.disableRoute( "gdf_resrvoir_spawn_node_1" );
        //objManager.disableRoute( "gdf_resrvoir_spawn_node_2" );
    }
}