tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Scripts/Test_GTH.cpp

1105 lines
35 KiB
C++
Raw Permalink Blame History

/*
** 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);
}
}
};
Reference in a new issue View git blame Copy permalink