Renegade/Code/Scripts/Test_GTH.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "scripts.h"
#include <string.h>
#include "toolkit.h"

#define GTH_DEBUG	0

#if (GTH_DEBUG)
#define GTH_DEBUG_INT( x , format )			Commands->Display_Int( x, format )
#define GTH_DEBUG_FLOAT( x , format )		Commands->Display_Float( x, format )
#else
#define GTH_DEBUG_INT( x , format )			
#define GTH_DEBUG_FLOAT( x , format )		
#endif


/*
** GTH_Drop_Object_On_Death  (verified)
** This script will create an object at the position of the object when it dies.
** 
** Params:
** Drop_Object - name of the preset to create an instance of
** Drop_Height - float meters to add to the Z coord of the original object when creating the drop obj
** Probability - int between 1 and 100, chance that the object will be created
*/
DECLARE_SCRIPT(GTH_Drop_Object_On_Death, "Drop_Object=:string,Drop_Height=0.25:float,Probability=100:int")
{
	void Killed( GameObject * obj, GameObject * killer ) 
	{
		const char * obj_name = Get_Parameter("Drop_Object");
		
		bool doit = false;
		float probability = Get_Int_Parameter("Probability");
		
		if (probability >= 100) {
			doit = true;
		} else {
			int random = Commands->Get_Random_Int(0,100);
			doit = random < probability;
		}

		if ((obj_name != NULL) && (doit)) {
			Vector3 spawn_location = Commands->Get_Position ( obj );
			spawn_location.Z = spawn_location.Z + Get_Float_Parameter("Drop_Height");
			Commands->Create_Object ( obj_name, spawn_location );
		}
	}
};

/*
** GTH_Drop_Object_On_Death_Zone (verified)
** This script is just like the other drop object on death except that it must also
** be activated by a custom message from another script.  Use the GTH_Zone_Send_Custom 
** to enable and disable this script.  
**
** Params:
** Custom_Message - message id that turns this script on or off, use message ID's greater than 10000!
** Drop_Object - name of the preset to create an instance of
** Drop_Height - float meters to add to the Z coord of the original object when creating the drop obj
** Probability - int between 1 and 100, chance that the object will be created
*/ 
DECLARE_SCRIPT(GTH_Drop_Object_On_Death_Zone, "Custom_Message=20000:int,Drop_Object=:string,Drop_Height=0.25:float,Probability=100:int")
{
	bool enabled;
	
	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE(enabled, 1);
	}

	void Created( GameObject * obj )
	{
		enabled = false;
	}

	void Custom(GameObject * obj, int type, int param, GameObject * sender)
	{
		if (type == Get_Int_Parameter("Custom_Message")) {
			enabled = (param==1);
			GTH_DEBUG_INT(enabled,"GTH_Drop_Object_On_Death_Zone custom message: enable = %d\n");
		}
	}

	void Killed( GameObject * obj, GameObject * killer ) 
	{
		GTH_DEBUG_INT(0,"GTH_Drop_Object_On_Death_Zone Killed callback\n");
		if (!enabled) {
			GTH_DEBUG_INT(0,"not in zone\n");
			return;
		}
		
		const char * obj_name = Get_Parameter("Drop_Object");
		
		bool doit = false;
		float probability = Get_Int_Parameter("Probability");
		
		if (probability >= 100) {
			doit = true;
		} else {
			int random = Commands->Get_Random_Int(0,100);
			doit = random < probability;
		}

		if ((obj_name != NULL) && (doit)) {

			Vector3 spawn_location = Commands->Get_Position ( obj );
			spawn_location.Z = spawn_location.Z + Get_Float_Parameter("Drop_Height");

			GTH_DEBUG_INT(0,"Creating object ");
			GTH_DEBUG_INT(0,obj_name);
			GTH_DEBUG_FLOAT(spawn_location.X," x=%f, ");
			GTH_DEBUG_FLOAT(spawn_location.Y," y=%f, ");
			GTH_DEBUG_FLOAT(spawn_location.Z," z=%f, ");
			
			Commands->Create_Object ( obj_name, spawn_location );
		}
	}
};

/*
** GTH_Zone_Send_Custom (verified)
** This script lets you send a custom message to an object on enter and exit of a zone.  To talk 
** to the "drop in death zone" script, send the same custom message with 1 for Enter_Param and
** 0 for Exit_Param...
** 
** Params:
** Enter_Message = message id to send when an object enters this zone
** Enter_Param = message parameter to send when an object enters
** Exit_Message = message id to send when an object exits
** Exit_Param = message id to send when and object exits
*/
DECLARE_SCRIPT(GTH_Zone_Send_Custom, "Enter_Message=20000:int,Enter_Param=1:int,Exit_Message=20000:int,Exit_Param=0:int")
{
	void Entered( GameObject * obj, GameObject * enterer )
	{
		int message = Get_Int_Parameter("Enter_Message");
		GTH_DEBUG_INT(message,"GTH_Zone_Send_Custom sending enter message %d\n");
		if (message != 0) {
			Commands->Send_Custom_Event(obj,enterer,message,Get_Int_Parameter("Enter_Param"));
		}
	}

	void Exited( GameObject * obj, GameObject * exiter ) 
	{
		int message = Get_Int_Parameter("Exit_Message");
		GTH_DEBUG_INT(message,"GTH_Zone_Send_Custom sending exit message %d\n");
		if (message != 0) {
			Commands->Send_Custom_Event(obj,exiter,message,Get_Int_Parameter("Exit_Param"));
		}
	}
};

/*
** GTH_Create_Object_On_Enter (verified)
** This script will create an object when a script zone is entered by a game object.  Use it
** to fire off cinematics for example... 
** 
** Params:
** Create_Object - name of the preset to create an instance of
** Position - world space position to create the object at
** Min_Delay - amount of time to wait before re-enabling the script once it has fired
** Max_Creations - maximum number of times the script should create an object
** Probability - integer between 1 and 100, chance on any given "Enter" that the object will be created
** Player_Type - type of player that can trigger integer, 0 = Nod, 1 = GDI, 2 = any
*/
DECLARE_SCRIPT(GTH_Create_Object_On_Enter, "Create_Object=:string,Position:vector3,Min_Delay=10:int,Max_Creations=1:int,Probability=100:int,Player_Type=2:int")
{
	bool script_enabled;
	int trigger_count;
	
	enum { TIMER_ID_REENABLE = 0 };

public:
	GTH_Create_Object_On_Enter(void) :
		script_enabled(true),
		trigger_count(0)
	{
	}

protected:
	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE(script_enabled, 1);
		SAVE_VARIABLE(trigger_count, 2);
	}
	
	void Entered( GameObject * obj, GameObject * enterer )
	{
		if (script_enabled == false) {
			return;
		}

		// Check player type, if it doesn't match, just return
		int our_player_type = Get_Int_Parameter("Player_Type");
		if (our_player_type != 2) {
			int enter_player_type = Commands->Get_Player_Type(enterer);
			if (enter_player_type != our_player_type) {
				return;
			}
		}

		// Check probability, if the check fails, just return
		float probability = Get_Int_Parameter("Probability");
		if (probability < 100) {
			int random = Commands->Get_Random_Int(0,100);
			if (random > probability) {
				return;
			}
		}
		
		GTH_DEBUG_INT( 0, "Enter callback in GTH_Create_Object_On_Enter" );

		// Inc our trigger count, if we're allowed to fire again, set a timer to re-enable the script
		trigger_count++;
		script_enabled = false;
		if (trigger_count < Get_Int_Parameter("Max_Creations")) {
			Commands->Start_Timer(obj, this, Get_Float_Parameter("Min_Delay"), TIMER_ID_REENABLE);
		}

		// Ok, create the object
		const char * obj_name = Get_Parameter("Create_Object");
		Vector3 obj_pos = Get_Vector3_Parameter("Position");
		
		if (obj_name != NULL) {

			GTH_DEBUG_INT( 0, obj_name );
			GTH_DEBUG_INT( obj_pos.X, " x: %f, " );
			GTH_DEBUG_INT( obj_pos.Y, "y: %f, " );
			GTH_DEBUG_INT( obj_pos.Z, "z: %f\n" );

			Commands->Create_Object ( obj_name, obj_pos );
		}
	}

	void Timer_Expired( GameObject * obj, int timer_id ) 
	{
		if (timer_id == TIMER_ID_REENABLE) {
			script_enabled = true;
		}
	}

};

#if 0
/*
** GTH_Speed_Controlled_Anim
** NOTE: THIS PROBABLY WON'T WORK IN A NET GAME ANYWAY....  DELETE ME
** Stop_Speed - float, maximum speed where the object is considered "stopped"
** Stop_Anim - name of the anim to play when the unit is "stopped"
** Walk_Speed - float, max speed where the object is considered "walking"
** Walk_Anim - name of the anim to play when the unit is "walking"
** Run_Anim - name of anim to play when the unit is moving faster than "walking"
** Update_Delay - delay between re-evaluating the state of the object (0.1 = 10 times a second)
*/
DECLARE_SCRIPT(GTH_Speed_Controlled_Anim,"Stop_Speed=0.1:float,StopAnim=none:string,Walk_Speed=5.0:float,Walk_Anim=none:string,Run_Anim=none:string,Update_Rate=0.1:float")
{
	enum { STOPPED = 0, WALKING, RUNNING };
	enum { TIMER_ID_TICK = 0xbeef };

	int cur_state;
	Vector3 last_pos;

	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE(cur_state, 1);
		SAVE_VARIABLE(last_pos, 2);
	}

	void Created( GameObject * obj ) 
	{
		// initialize the state
		cur_state = -1;
		last_pos = Commands->Get_Position( obj );
		update_state(obj,eval_speed(obj));
		
		// start up our update timer
		Commands->Start_Timer(obj, this, Get_Float_Parameter("Update_Rate"), TIMER_ID_TICK);
	}

		
	void	( * Set_Animation )( GameObject * obj, const char * anim_name, bool looping, const char * sub_obj_name = NULL, float start_frame = 0.0F, float end_frame = -1.0F, bool is_blended = false );


	void Timer_Expired( GameObject * obj, int timer_id ) 
	{
		if (timer_id == TIMER_ID_TICK) {
			update_state(obj,eval_speed(obj));
			Commands->Start_Timer(obj, this, get_update_rate(), TIMER_ID_TICK);
		}
	}

	float get_update_rate( void ) 
	{
		float update_rate = Get_Float_Parameter("Update_Rate");
		if (update_rate <= 0.01f) {
			update_rate = 0.01f;
		}
		return update_rate;
	}

	int	eval_speed( GameObject * obj )
	{
		// This function evaluates the object's current speed and returns the state
		Vector3 cur_pos = Commands->Get_Position(obj);
		Vector3 vel = (cur_pos - last_pos) / get_update_rate();
		last_pos = cur_pos;

		float speed = vel.Length();
		if (speed <= Get_Float_Parameter("Stop_Speed")) {
			return STOPPED;
		}

		if (speed <= Get_Float_Parameter("Walk_Speed")) {
			return WALKING;
		}

		return RUNNING;
	}
	
	void update_state( GameObject * obj, int new_state )
	{
		// This function plugs in the animation depending on the current state
		if (new_state != cur_state) {
			cur_state = new_state;
			const char * anim = NULL;
			switch( cur_state )
			{
			case STOPPED:
				{
					anim = Get_Parameter("Stop_Anim");
				}
				break;
			case WALKING:
				{ 
					anim = Get_Parameter("Walk_Anim");
				}
				break;
			case RUNNING:
				{
					anim = Get_Parameter("Run_Anim");
				}
				break;
			};

			if (anim != NULL) {
				Commands->Set_Animation( obj, anim, true );
			}
		}
	}
};
#endif

/*
** GTH_On_Enter_Mission_Complete (verified)
** When you enter a zone with this script on it, the mission is complete. NOTE, this only
** works in single player levels
** 
** Parameters:
** Success - 0 = mission failed, 1 = missuion succeeded
** Player_Type - type of player allowed to trigger, 0=nod, 1=gdi, 2=any
*/
DECLARE_SCRIPT(GTH_On_Enter_Mission_Complete, "Success=1:int, Player_Type=2:int" )
{
	void Entered( GameObject * obj, GameObject * enterer )
	{
		GTH_DEBUG_INT(0,"GTH_On_Enter_Mission_Complete::Entered\n");

		// check the player type
		int our_player_type = Get_Int_Parameter("Player_Type");
		GTH_DEBUG_INT(our_player_type,"Script desired player type: %d\n");

		if (our_player_type != 2) {
		
			int enter_player_type = Commands->Get_Player_Type(enterer);
			GTH_DEBUG_INT(enter_player_type,"Enterer player type: %d\n");
			if (enter_player_type != our_player_type) {
				return;
			}
		}
		
		// if we get here, complete the mission
		int success = Get_Int_Parameter("Success");
		GTH_DEBUG_INT(success,"Calling Mission_Complete(%d)\n");
		
		if (success == 0) {
			Commands->Mission_Complete(false);
		} else {
			Commands->Mission_Complete(true);
		}
	}	
};


/*
** GTH_On_Death_Mission_Complete (verified)
** When you kill something this script on it, the mission is complete.  NOTE this 
** only works in single-player levels.
** 
** Parameters:
** Success - 0 = mission failed, 1 = missuion succeeded
** Player_Type - type of player allowed to trigger, 0=nod, 1=gdi, 2=any
*/
DECLARE_SCRIPT(GTH_On_Killed_Mission_Complete, "Success=1:int, Player_Type=2:int" )
{
	void Killed( GameObject * obj, GameObject * killer ) 
	{
		GTH_DEBUG_INT(0,"GTH_On_Killed_Mission_Complete::Killed\n");
	
		// check the player type
		int our_player_type = Get_Int_Parameter("Player_Type");
		GTH_DEBUG_INT(our_player_type,"Script desired player type: %d\n");

		if (our_player_type != 2) {
			int enter_player_type = Commands->Get_Player_Type(killer);
			GTH_DEBUG_INT(enter_player_type,"Enterer player type: %d\n");

			if (enter_player_type != our_player_type) {
				return;
			}
		}
		
		// if we get here, complete the mission
		int success = Get_Int_Parameter("Success");
		GTH_DEBUG_INT(success,"Calling Mission_Complete(%d)\n");

		if (success == 0) {
			Commands->Mission_Complete(false);
		} else {
			Commands->Mission_Complete(true);
		}
	}	
};


/*
** GTH_Create_Objective
** Adds an objective to the mission when the specified action (create, enter, poke, or kill) 
** happens to the object with this script on it.
** 
** params:
** Creation_Type - 0=Create, 1=Entered, 2=Poked, 3=Killed
** Objective_ID - id of the objective, match this with the "GTH_Objective_Complete" script
** Objective_Type - 0=PRIMARY, 1=SECONDARY
** Short_Desc_ID - string id for short description
** Long_Desc_ID - string id for long description
** Priority - priority of this objective
** Position - 3d position of the objective 
** Pog_Texture - tga file for the objective pog
** Pog_Text_ID - string id for the pog text (usually something like IDS_POG_DESTROY)
** 
*/
DECLARE_SCRIPT(GTH_Create_Objective,"Creation_Type=0:int,Objective_ID=0:int,Objective_Type=0:int,Short_Desc_ID=0:int,Long_Desc_ID=0:int,Priority=90:float,Position:vector3,Pog_Texture:string")
{
	bool	already_triggered;

	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE(already_triggered, 1);
	}

	void	Created( GameObject * obj )							{ if (Get_Int_Parameter("Creation_Type") == 0) create_objective(); }
	void	Entered( GameObject * obj, GameObject * enterer )	{ if (Get_Int_Parameter("Creation_Type") == 1) create_objective(); }
	void	Poked( GameObject * obj, GameObject * poker )		{ if (Get_Int_Parameter("Creation_Type") == 2) create_objective(); }
	void	Killed( GameObject * obj, GameObject * killer )		{ if (Get_Int_Parameter("Creation_Type") == 3) create_objective(); }

	void create_objective(void) 
	{
		if (already_triggered) {
			return;
		}

		// create the objective
		int id = Get_Int_Parameter("Objective_ID");
		int type;

		if (Get_Int_Parameter("Objective_Type") == 0) {
			type = OBJECTIVE_TYPE_PRIMARY;
		} else {
			type = OBJECTIVE_TYPE_SECONDARY;
		}
		int short_desc_id = Get_Int_Parameter("Short_Desc_ID");
		int long_desc_id = Get_Int_Parameter("Long_Desc_ID");

		Commands->Add_Objective(id,type,OBJECTIVE_STATUS_PENDING,short_desc_id, NULL, long_desc_id );

		// set up the radar blip
		Vector3 objective_pos = Get_Vector3_Parameter("Position");
		Commands->Set_Objective_Radar_Blip(id, objective_pos);

		// set up the hud stuff
		const char * pog = Get_Parameter("Pog_Texture");
		float priority = Get_Float_Parameter("Priority");
		int pog_text_id = Get_Int_Parameter("Pog_Text_ID");
		
		Commands->Set_Objective_HUD_Info_Position(id, priority, pog, pog_text_id, objective_pos);
	}
};


/*
** GTH_Objective_Complete
** Ends an objective with either success or failure.  All of the following things
** cause the objective to complete: "Entered", "Killed", or "Poked"
**
** param
** Objective_ID - id of the objective
** Success - 0 or 1, success or failure
** Player_Type - player type allowed to trigger this.  0=nod, 1=gdi, 2=any
*/
DECLARE_SCRIPT(GTH_Objective_Complete_Enter_Kill_Poke, "Objective_ID=0:int, Success=1:int, Player_Type=2:int" )
{
	bool	already_triggered;

	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE(already_triggered, 1);
	}
	
	void	Created( GameObject * obj )							{ already_triggered = false; }
	void	Poked( GameObject * obj, GameObject * poker )		{ trigger(poker); }
	void	Killed( GameObject * obj, GameObject * killer )		{ trigger(killer); }
	void	Entered( GameObject * obj, GameObject * enterer )	{ trigger(enterer); }

	
	void trigger(GameObject * obj)
	{
		// check if we've already triggered
		if (already_triggered) {
			return;
		}

		// check the player type
		int our_player_type = Get_Int_Parameter("Player_Type");
		if (our_player_type != 2) {
			int other_player_type = Commands->Get_Player_Type(obj);
			if (other_player_type != our_player_type) {
				return;
			}
		}
		
		// if we get here, complete the mission
		int success = Get_Int_Parameter("Success");
		int id = Get_Int_Parameter("Objective_ID");

		if (success == 0) {
			Commands->Set_Objective_Status(id, 0);
		} else {
			Commands->Set_Objective_Status(id, 1);
		}

		already_triggered = true;
	}	
};


/*
** GTH_User_Controllable_Base_Defense (verified)
** Just like M00_Base_Defense except that if a player enters, he can control the object
**
** params:
** MinAttackDistance - min range for auto attack
** MaxAttackDistance - max range for auto attack
** AttackTimer - amount of time to continue tracking after last "enemy seen"
*/
DECLARE_SCRIPT (GTH_User_Controllable_Base_Defense, "MinAttackDistance=0:int, MaxAttackDistance=300:int, AttackTimer=10:int")
{
	int token_01_id;
	int token_02_id;
	int token_03_id;
	int player_type;
	bool occupied;


	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE (token_01_id, 1);
		SAVE_VARIABLE (token_02_id, 2);
		SAVE_VARIABLE (token_03_id, 3);
		SAVE_VARIABLE (player_type, 4);
		SAVE_VARIABLE (occupied, 5);
	}

	void Created (GameObject * obj)
	{
		occupied = false;
		
		// find out what my team preset is.
		player_type = Commands->Get_Player_Type( obj );
		Commands->Debug_Message( "***** Player Type Saved *****\n" );

		Commands->Enable_Hibernation (obj, false);
		Commands->Innate_Enable (obj);
		Commands->Enable_Enemy_Seen (obj, true);

		Vector3 my_position = Commands->Get_Position (obj);
		Vector3 token_01_pos = my_position;
		Vector3 token_02_pos = my_position;
		Vector3 token_03_pos = my_position;

		token_01_pos.X -= 10.0f;
		token_01_pos.Y -= 10.0f;
		token_01_pos.Z += 2.0f;

		token_02_pos.X += 10.0f;
		token_02_pos.Z += 2.0f;

		token_03_pos.X += 10.0f;
		token_03_pos.Y -= 10.0f;
		token_03_pos.Z += 2.0f;

		GameObject * token_01 = Commands->Create_Object ("Invisible_Object", token_01_pos);
		if (token_01)
		{
			token_01_id = Commands->Get_ID (token_01);
		}
		token_01 = Commands->Create_Object ("Invisible_Object", token_02_pos);
		if (token_01)
		{
			token_02_id = Commands->Get_ID (token_01);
		}
		token_01 = Commands->Create_Object ("Invisible_Object", token_03_pos);
		if (token_01)
		{
			token_03_id = Commands->Get_ID (token_01);
		}
		Commands->Start_Timer (obj, this, 10.0f, 1);
	}

	void Timer_Expired (GameObject * obj, int timer_id)
	{
		if (timer_id == 1)
		{
			int rnd_num = Get_Int_Random(0,2);

			if (occupied == false) {
	
				GTH_DEBUG_INT(rnd_num,"GTH_User_Controllable_Base_Defense aiming at target %d\n");
				switch (rnd_num)
				{
				case (0):
					{
						GameObject * token_01 = Commands->Find_Object (token_01_id);
						if (token_01)
						{
							ActionParamsStruct params;
							params.Set_Basic(this, 70, 1);
							params.Set_Attack(token_01, 0.0f, 0.0f, true);
							Commands->Action_Attack(obj, params);
						}
						break;
					}
				case (1):
					{
						GameObject * token_02 = Commands->Find_Object (token_02_id);
						if (token_02)
						{
							ActionParamsStruct params;
							params.Set_Basic(this, 70, 1);
							params.Set_Attack(token_02, 0.0f, 0.0f, true);
							Commands->Action_Attack(obj, params);
						}
						break;
					}
				default:
					{
						GameObject * token_03 = Commands->Find_Object (token_03_id);
						if (token_03)
						{
							ActionParamsStruct params;
							params.Set_Basic(this, 70, 1);
							params.Set_Attack(token_03, 0.0f, 0.0f, true);
							Commands->Action_Attack(obj, params);
						}
					}
				}
			}
			Commands->Start_Timer (obj, this, 10.0f, 1);
		}
		else if (timer_id == 2)
		{
			Commands->Action_Reset (obj, 100.0f);
		}
	}

	void Enemy_Seen (GameObject * obj, GameObject * enemy)
	{
		GTH_DEBUG_INT(occupied,"GTH_User_Controllable_Base_Defense::Enemy_Seen, occupied = %d\n");
		if (occupied == false) {
			Vector3 my_loc = Commands->Get_Position (obj);
			Vector3 enemy_loc = Commands->Get_Position (enemy);
			float distance = Commands->Get_Distance (my_loc, enemy_loc);
			if (distance > Get_Int_Parameter("MinAttackDistance") )
			{
				ActionParamsStruct params;
				params.Set_Basic(this, 100, 2);
				params.Set_Attack(enemy, Get_Int_Parameter("MaxAttackDistance"), 0.0f, true);
				params.AttackCheckBlocked = false;
				Commands->Action_Attack(obj, params);
				Commands->Start_Timer (obj, this, Get_Int_Parameter( "AttackTimer"), 2);
			}
		}
	}

	void Action_Complete (GameObject * obj, int action_id, ActionCompleteReason complete_reason)
	{
		if (action_id == 2)
		{
			Commands->Action_Reset (obj, 100.0f);
		}
	}

	void Custom(GameObject * obj, int type, int param, GameObject * sender)
	{
		ActionParamsStruct params;
			
		switch (type)
		{
		case CUSTOM_EVENT_VEHICLE_ENTERED:
			occupied = true;

			params.Set_Basic(this, 100, 3);
			Commands->Action_Follow_Input( obj, params );
			
			break;

		case CUSTOM_EVENT_VEHICLE_EXITED:
			occupied = false;
			// set team back to my preset.
			Commands->Set_Player_Type( obj, player_type );
			Commands->Action_Reset (obj, 100.0f);

			break;
		}

		GTH_DEBUG_INT(occupied,"GTH_User_Controllable_Base_Defense occupied = %d\n");
			
	}
};


/*
** GTH_Credit_Trickle
** This script will give an amount money to its team at a regular interval.  You can use it to
** create silos that give money as long as they're alive.
** NOTE: this won't work on buildings, only things like turrets, characters, or vehicles so make your
** "silos" as a weaponless vehcile set up like the nod-turret for example.
** 
** Params:
** Credits - number of credits to give
** Delay - time between credit grants
*/
DECLARE_SCRIPT(GTH_Credit_Trickle, "Credits=1:int,Delay=2.0:float")
{
	enum { TRICKLE_TIMER = 667 };

	void Created (GameObject * obj)
	{
		// start the trickle timer
		Commands->Start_Timer (obj, this, Get_Float_Parameter("Delay"), TRICKLE_TIMER);
	}

	void Timer_Expired (GameObject * obj, int timer_id)
	{
		if (timer_id == TRICKLE_TIMER)
		{
			Commands->Give_Money( obj, Get_Int_Parameter("Credits"), true );
			Commands->Start_Timer (obj, this, Get_Int_Parameter("Delay"), TRICKLE_TIMER);
		}
	}
};


/*
** GTH_Enable_Spawner_On_Enter
** This script will enable or disable a spawner when its zone is entered
**
** Params:
** SpawnerID - id of the spawner
** Player_Type - type of player that can trigger integer, 0 = Nod, 1 = GDI, 2 = any
** Enable - enable or disable the spawner (1=enable, 0=disable)
*/
DECLARE_SCRIPT(GTH_Enable_Spawner_On_Enter, "SpawnerID=0:int,Player_Type=2:int,Enable=1:int")
{
	void Entered( GameObject * obj, GameObject * enterer )
	{
		// Check player type, if it doesn't match, just return
		int our_player_type = Get_Int_Parameter("Player_Type");
		if (our_player_type != 2) {
			int enter_player_type = Commands->Get_Player_Type(enterer);
			if (enter_player_type != our_player_type) {
				return;
			}
		}

		// Now enable the spawner
		bool enable = (Get_Int_Parameter("Enable") != 0);
		Commands->Enable_Spawner( Get_Int_Parameter("SpawnerID"),enable);
	}
};






/*
** GTH_CTF_Object
** This script will make the object it is attached to behave kind of like a CTF "flag" by
** attaching to the opposing player who pokes it.  If its position gets within a 
** certain distance of the "enemy home" an internal counter is incremented.  Once the counter
** reaches a desired number, an object in the level is destroyed.  This object should be the
** only building owned by the flag's team so that they immediately lose.  
**
** You should use this script on an object that has "projectile" collision only.  Make a model
** of your "flag", give it projectile collision and make a preset for it similar to the "Marker_Flag"
** in LevelEdit (you can find "Marker_Flag" under Object->Simple).
**
** CTF Rules as implemented:
** - this script controls how many flag captures cause a win
** - enemy entering the pickup radius of the flag attaches it to him
** - enemy teammates can take the flag from each other 
** - friend poking the flag sends it back to its initial position (only if its not carried by an enemy)
** - enemy getting the flag to his home position increments an internal counter
** - when win count is reached, all of the "Win_Object_To_Kill" objects are destroyed (make sure
**   this destroys all of the enemy team's buildings
**  
** Params:
** Update_Delay - how many times per second to update (this will *always* be laggy though...)
** Enemy_Player_Type - type of player that wants to grab this flag (0=Nod,1=GDI)
** Enemy_Home_Position - when flag gets here, capture count increments!
** Pickup_Radius - how close to flag we need to pickup flag
** Home_Radius - how close to enemy home position we need to get to count
** Capture_Respawn_Timer - When flag is dropped respawn back at home position after x seconds.  
**       x < 0 means flag MUST be poked for it to be returned.
** Captures_Needed_To_Win - after this many captures, we destroy the token "building" for the win
** Flag_Stolen_Event_ID - custom event id to send when the flag is stolen
** Flag_Stolen_Object_ID - Object that receives the event
** Flag_Lost_Event_ID - custom event id to send when enemy team gets flag back to Enemy_Home_Position :-(
** Flag_Lost_Object_ID - Object that receives the event
** Flag_Saved_Event_ID - custom event id to send when flag carrier is killed
** Flag_Saved_Object_ID - Object that receives the event
** Flag_Returned_Event_ID - custom event id to send when flag has been returned to home position.
** Flag_Returned_Object_ID - Object that receives the event
** Captures_Exceeded_Event_ID - custom event id to send when flag has been captured "Captures_Needed_To_Win" times.
** Captures_Exceeded_Object_ID - Object that receives the event
** Win_Object_To_Kill0 - object that we destroy when the capture count is reached
** Win_Object_To_Kill1 - object that we destroy when the capture count is reached
** Win_Object_To_Kill2 - object that we destroy when the capture count is reached
** Win_Object_To_Kill3 - object that we destroy when the capture count is reached
** Win_Object_To_Kill4 - object that we destroy when the capture count is reached
** 
*/
DECLARE_SCRIPT(GTH_CTF_Object2, "Update_Delay=0.05:float,Enemy_Player_Type=0:int,Enemy_Home_Position:vector3,"
                                "Pickup_Radius=5.0:float,Home_Radius=5.0:float,Capture_Respawn_Timer=30.0:float,"
                                "Captures_Needed_To_Win=5:int,"
										  "Flag_Stolen_Event_ID=25000:int,Flag_Stolen_Object_ID=0:int,Flag_Lost_Event_ID=25001:int,"
										  "Flag_Lost_Object_ID=0:int,Flag_Saved_Event_ID=25002:int,Flag_Saved_Object_ID=0:int,"
										  "Flag_Returned_Event_ID=25003:int,Flag_Returned_Object_ID=0:int,"
										  "Captures_Exceeded_Event_ID=25004:int,Captures_Exceeded_Object_ID=0:int,"
                                "Win_Object_To_Kill0=0:int,Win_Object_To_Kill1=0:int,Win_Object_To_Kill2=0:int,"
                                "Win_Object_To_Kill3=0:int,Win_Object_To_Kill4=0:int")
{
	enum { CTF_UPDATE_TIMER = 0x10211131 };

	int capture_count;
	int captured_by_id;
	Vector3 home_position;
	float capture_timer;


	REGISTER_VARIABLES()
	{
		SAVE_VARIABLE (capture_count, 1);
		SAVE_VARIABLE (captured_by_id, 2);
		SAVE_VARIABLE (home_position, 3);
		SAVE_VARIABLE (capture_timer, 4);
	}

	void Created (GameObject * obj)
	{
		// Initialize everything
		capture_count = 0;
		captured_by_id = 0;
		capture_timer = 0.0;
		home_position = Commands->Get_Position(obj);
		
		GTH_DEBUG_FLOAT(home_position.X,"Flag x: %f");
		GTH_DEBUG_FLOAT(home_position.Y,"Flag y: %f");
		GTH_DEBUG_FLOAT(home_position.Z,"Flag z: %f\n");

		// Start the update timer!
		Commands->Start_Timer (obj, this, Get_Float_Parameter("Update_Delay"), CTF_UPDATE_TIMER);
	}

	void Damaged( GameObject * obj, GameObject * damager, float amount ) 
	{
		Grab_Flag(obj,damager);
	}

//	void Poked( GameObject * obj, GameObject * poker )	
//	{
//		Grab_Flag(obj,poker);
//	}

	void Grab_Flag( GameObject * obj, GameObject * grabber )
	{ 
		// If we're already captured, bail
		if (captured_by_id != 0) {
			return;
		}
		
		// Check distance, if the damager is too far away, bail
		Vector3 my_pos = Commands->Get_Position(obj);
		Vector3 delta = my_pos - Commands->Get_Position(grabber);
		if (delta.Length() > Get_Float_Parameter("Pickup_Radius")) {
			GTH_DEBUG_FLOAT(delta.Length(),"Flag too far away, dist = %f\n");
			return;
		}
		
		// Check player type, if it doesn't match, warp back to our home position
		int capture_player_type = Get_Int_Parameter("Enemy_Player_Type");
		int poke_player_type = Commands->Get_Player_Type(grabber);

		// Someone poked the flag...see if it needs to respawn back at home.
		if (capture_player_type != 2) {
			if (poke_player_type != capture_player_type) {
				// if we're not being carried and the flag isn't on a timer, warp back
				if (captured_by_id == 0 && Get_Float_Parameter("Capture_Respawn_Timer") < 0) {
					Commands->Set_Position(obj,home_position);
			
					GTH_DEBUG_INT(poke_player_type,"Flag recovered back by team: %d\n");
					// Play flag returned sound
					int cust_id = Get_Int_Parameter("Flag_Returned_Event_ID");
					GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Flag_Returned_Object_ID"));
					if (event_obj == NULL) event_obj = obj;
					Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);
				}
				return;
			}
		}

		// The player type matches, Attach to this dude! 
		captured_by_id = Commands->Get_ID(grabber);

		// attach to bone 0 (root) 
		Commands->Attach_To_Object_Bone(obj,grabber,"ROOTTRANSFORM");
		GTH_DEBUG_INT(poke_player_type,"Flag captured by team: %d\n");

		// Play picked up sound
		int cust_id = Get_Int_Parameter("Flag_Stolen_Event_ID");
		GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Flag_Stolen_Object_ID"));
		if (event_obj == NULL) event_obj = obj;
		Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);
	}

	void Timer_Expired (GameObject * obj, int timer_id)
	{
		if (timer_id == CTF_UPDATE_TIMER)
		{
			// Search for a player around the flag and let them auto-grab it.
			// BMH 12/7/02 - Get_A_Star only returns the closest to the position.  So if someone just sat
			// on top of the flag that's the only star we'd ever check.  So check from a random position
			// within the pickup radius
			Vector3 my_pos = Commands->Get_Position(obj);
			Vector3 find_pos = my_pos;
			float pick_rad = Get_Float_Parameter("Pickup_Radius");
			float rval = Commands->Get_Random(-pick_rad, pick_rad);
			find_pos.X += rval;
			rval = Commands->Get_Random(-pick_rad, pick_rad);
			find_pos.Y += rval;
			rval = Commands->Get_Random(-pick_rad, pick_rad);
			find_pos.Z += rval;
			GameObject *star_obj = Commands->Get_A_Star(find_pos);
			Grab_Flag(obj,star_obj);

			// check if we've been captured enough to end the game
			if (capture_count >= Get_Int_Parameter("Captures_Needed_To_Win")) {
				
				// Play Win Sound!
				int cust_id = Get_Int_Parameter("Captures_Exceeded_Event_ID");
				GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Captures_Exceeded_Object_ID"));
				if (event_obj == NULL) event_obj = obj;
				Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);

				// win!  
				GameObject * win_obj = Commands->Find_Object(Get_Int_Parameter("Win_Object_To_Kill0"));
				if (win_obj != NULL) {
					Commands->Destroy_Object( win_obj );
				}
				win_obj = Commands->Find_Object(Get_Int_Parameter("Win_Object_To_Kill1"));
				if (win_obj != NULL) {
					Commands->Destroy_Object( win_obj );
				}
				win_obj = Commands->Find_Object(Get_Int_Parameter("Win_Object_To_Kill2"));
				if (win_obj != NULL) {
					Commands->Destroy_Object( win_obj );
				}
				win_obj = Commands->Find_Object(Get_Int_Parameter("Win_Object_To_Kill3"));
				if (win_obj != NULL) {
					Commands->Destroy_Object( win_obj );
				}
				win_obj = Commands->Find_Object(Get_Int_Parameter("Win_Object_To_Kill4"));
				if (win_obj != NULL) {
					Commands->Destroy_Object( win_obj );
				}
		
				GTH_DEBUG_INT(0,"Capture count exceeded\n");
				
				return;
			}

			// check if we're in our enemies home position
			Vector3 delta = my_pos - Get_Vector3_Parameter("Enemy_Home_Position");

			float dist = delta.Length();
			if (dist < Get_Float_Parameter("Home_Radius")) {
				
				// Increment the capture count, detatch from our carrier and warp home
				capture_count++;
				captured_by_id = 0;
				Commands->Attach_To_Object_Bone(obj,NULL,NULL);
				Commands->Set_Position(obj,home_position);
				GTH_DEBUG_INT(capture_count,"Flag stolen, counter now %d, returning to home!\n");

				// Play flag capture sound
				int cust_id = Get_Int_Parameter("Flag_Lost_Event_ID");
				GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Flag_Lost_Object_ID"));
				if (event_obj == NULL) event_obj = obj;
				Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);
			}
			
			// check if we have a capturer and need to update
			if (captured_by_id != 0) {
				GameObject * capturer = Commands->Find_Object(captured_by_id);
				
				if (capturer != NULL) {
				
					// Don't do this cause we're using the attach to bone method!
					//Vector3 cap_position = Commands->Get_Position(capturer);
					//Commands->Set_Position(obj,cap_position);
				
				} else {
				
					captured_by_id = 0;
					// start the flag respawn timer.
					capture_timer = (((float)Commands->Get_Sync_Time()) / 1000.0);
					Commands->Attach_To_Object_Bone(obj,NULL,NULL);
					GTH_DEBUG_INT(0,"Capturer killed!\n");

					// Play flag saved sound
					int cust_id = Get_Int_Parameter("Flag_Saved_Event_ID");
					GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Flag_Saved_Object_ID"));
					if (event_obj == NULL) event_obj = obj;
					Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);
				}
			}

			// Check if the flag has been sitting idle for too long and return it if need be.
			float ctimer = Get_Float_Parameter("Capture_Respawn_Timer");
			if (captured_by_id == 0 && ctimer > 0) {

				// Make sure the flag isn't already at the base
				delta = my_pos - home_position;
				dist = delta.Length();
				if (dist > Get_Float_Parameter("Pickup_Radius")) {

					// has the Respawn_Timer expired
					if (((((float)Commands->Get_Sync_Time()) / 1000.0) - capture_timer) > ctimer) {

						// Return the flag
						Commands->Set_Position(obj,home_position);
						GTH_DEBUG_INT(0,"Flag timeout has been hit, respawning flag back at home.\n");

						// Play flag returned sound
						int cust_id = Get_Int_Parameter("Flag_Returned_Event_ID");
						GameObject * event_obj = Commands->Find_Object(Get_Int_Parameter("Flag_Returned_Object_ID"));
						if (event_obj == NULL) event_obj = obj;
						Commands->Send_Custom_Event(obj,event_obj,cust_id, 1);
					}
				}
			}

			// register for another update!
			Commands->Start_Timer (obj, this, Get_Float_Parameter("Update_Delay"), CTF_UPDATE_TIMER);
		}
	}
};