//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: F:\projects\c&c\vcs\code\trigger.cpv 2.17 16 Oct 1995 16:51:20 JOE_BOSTIC $ */
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : TRIGGER.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : 11/12/94 *
* *
* Last Update : August 27, 1995 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* Do_All_To_Hunt -- Forces all computer controlled units into hunt mode. *
* TriggerClass::Action_From_Name -- retrieves ActionType for given name *
* TriggerClass::Action_Need_Team -- Determines if this action event requires a team. *
* TriggerClass::As_Pointer -- returns pointer for the given trigger name *
* TriggerClass::As_Target -- Converts trigger to a target value *
* TriggerClass::Event_From_Name -- retrieves EventType for given name *
* TriggerClass::Event_Need_Data -- Determines if this event requires a data value. *
* TriggerClass::Event_Need_House -- Determines if this event requires a house identifier. *
* TriggerClass::Event_Need_Object -- Determines if the specified event requires an object. *
* TriggerClass::Init -- clears triggers for new scenario *
* TriggerClass::Name_From_Action -- retrieves name for ActionType *
* TriggerClass::Name_From_Event -- retrieves name for EventType *
* TriggerClass::Read_INI -- reads triggers from the INI file *
* TriggerClass::Remove -- removes this trigger from the game *
* TriggerClass::Spring -- Trigger processing routine for cell-based triggers *
* TriggerClass::Spring -- Trigger processing routine for house-based triggers *
* TriggerClass::Spring -- Trigger processing routine for object-based triggers *
* TriggerClass::TriggerClass -- constructor *
* TriggerClass::Validate -- validates trigger pointer *
* TriggerClass::Write_INI -- writes triggers to the INI file *
* TriggerClass::operator delete -- 'delete' operator *
* TriggerClass::operator new -- 'new' operator *
* TriggerClass::~TriggerClass -- Destructor for trigger objects. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
static void Do_All_To_Hunt(void);
#define FIXUP 0
/*
********************************** Globals **********************************
*/
static const char * EventText[EVENT_COUNT + 1] = {
"None",
"Player Enters",
"Discovered",
"Attacked",
"Destroyed",
"Any",
"House Discov.",
"Units Destr.",
"Bldgs Destr.",
"All Destr.",
"Credits",
"Time",
"# Bldgs Dstr.",
"# Units Dstr.",
"No Factories",
"Civ. Evac.",
"Built It"
};
static const char * ActionText[TriggerClass::ACTION_COUNT + 1] = {
"None",
"Win",
"Lose",
"Production",
"Create Team",
"Dstry Teams",
"All to Hunt",
"Reinforce.",
"DZ at 'Z'",
"Airstrike",
"Nuclear Missile",
"Ion Cannon",
"Dstry Trig 'XXXX'",
"Dstry Trig 'YYYY'",
"Dstry Trig 'ZZZZ'",
"Autocreate",
"Cap=Win/Des=Lose",
"Allow Win"
};
/***********************************************************************************************
* TriggerClass::Validate -- validates trigger pointer *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* 1 = ok, 0 = error *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 08/09/1995 BRR : Created. *
*=============================================================================================*/
#ifdef CHEAT_KEYS
int TriggerClass::Validate(void) const
{
int num;
num = Triggers.ID(this);
if (num < 0 || num >= TRIGGER_MAX) {
Validate_Error("TRIGGER");
return (0);
}
else
return (1);
}
#else
#define Validate()
#endif
/***********************************************************************************************
* TriggerClass::Event_Need_Object -- Determines if the specified event requires an object. *
* *
* This routine determines if the specified event must be attached to an object. Such *
* events can only exist in a parasitic fashion attached to object(s) in the game. *
* *
* INPUT: event -- The event type to examine. *
* *
* OUTPUT: Does the specified event require attachement to an object? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/27/1995 JLB : Created. *
*=============================================================================================*/
bool TriggerClass::Event_Need_Object(EventType event)
{
switch (event) {
case EVENT_PLAYER_ENTERED:
case EVENT_DISCOVERED:
case EVENT_ATTACKED:
case EVENT_DESTROYED:
case EVENT_ANY:
return(true);
}
return(false);
}
/***********************************************************************************************
* TriggerClass::Event_Need_House -- Determines if this event requires a house identifier. *
* *
* This routine is used to determine if the specified event requires a house identifier. *
* All trigger events that affect a house will require a house identifier. *
* *
* INPUT: event -- The event type to examine. *
* *
* OUTPUT: Does the specified event type require a house identifier? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/27/1995 JLB : Created. *
*=============================================================================================*/
bool TriggerClass::Event_Need_House(EventType event)
{
switch (event) {
case EVENT_PLAYER_ENTERED:
case EVENT_HOUSE_DISCOVERED:
case EVENT_UNITS_DESTROYED:
case EVENT_BUILDINGS_DESTROYED:
case EVENT_ALL_DESTROYED:
case EVENT_CREDITS:
case EVENT_TIME:
case EVENT_NBUILDINGS_DESTROYED:
case EVENT_NUNITS_DESTROYED:
case EVENT_NOFACTORIES:
case EVENT_EVAC_CIVILIAN:
case EVENT_BUILD:
return(true);
}
return(false);
}
/***********************************************************************************************
* TriggerClass::Event_Need_Data -- Determines if this event requires a data value. *
* *
* This routine will determine if the specified event requires a data number parameter. *
* This is commonly needed for trigger events. *
* *
* INPUT: event -- The event to examine. *
* *
* OUTPUT: Does the specified event require a data number parameter? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/27/1995 JLB : Created. *
*=============================================================================================*/
bool TriggerClass::Event_Need_Data(EventType event)
{
switch (event) {
case EVENT_CREDITS:
case EVENT_TIME:
case EVENT_NBUILDINGS_DESTROYED:
case EVENT_NUNITS_DESTROYED:
case EVENT_BUILD:
return(true);
}
return(false);
}
/***********************************************************************************************
* TriggerClass::Action_Need_Team -- Determines if this action event requires a team. *
* *
* This routine will determine if the specified action requires a team name parameter. *
* Typically, this is needed for reinforcements or other trigger events that affect *
* a particular team type. *
* *
* INPUT: action -- The action that is to be examined. *
* *
* OUTPUT: Does the specified action require a team type name? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/27/1995 JLB : Created. *
*=============================================================================================*/
bool TriggerClass::Action_Need_Team(TriggerClass::ActionType action)
{
switch (action) {
case ACTION_CREATE_TEAM:
case ACTION_DESTROY_TEAM:
case ACTION_REINFORCEMENTS:
return(true);
}
return(false);
}
/***********************************************************************************************
* TriggerClass::TriggerClass -- constructor *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
TriggerClass::TriggerClass(void)
{
IsPersistant = VOLATILE;
AttachCount = 0;
Event = EVENT_NONE;
Action = ACTION_NONE;
House = HOUSE_NONE;
DataCopy = Data = 0L;
Name[0] = '\0';
Team = NULL;
}
/***********************************************************************************************
* TriggerClass::~TriggerClass -- Destructor for trigger objects. *
* *
* This destructor will update the house blockage value if necessary. No other action need *
* be performed on trigger destruction. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/29/1995 JLB : Created. *
*=============================================================================================*/
TriggerClass::~TriggerClass(void)
{
if (GameActive && House != HOUSE_NONE && Action == ACTION_ALLOWWIN) {
if (Houses.Ptr(House)->Blockage) Houses.Ptr(House)->Blockage--;
Houses.Ptr(House)->BorrowedTime = TICKS_PER_SECOND*4;
}
}
/***********************************************************************************************
* TriggerClass::Init -- clears triggers for new scenario *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/29/1994 BR : Created. *
*=============================================================================================*/
void TriggerClass::Init(void)
{
Triggers.Free_All();
}
/***********************************************************************************************
* TriggerClass::Spring -- Trigger processing routine *
* *
* Checks whether this trigger should "spring" for the given event & object; *
* If it should, then some really cool undocumented stuff magically happens. *
* *
* INPUT: *
* event EventType: What happened? *
* object Ptr to object containing this trigger: What did it happen to? *
* *
* OUTPUT: *
* 0 = nothing happened; 1 = the trigger was sprung *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/06/1994 BR : Created. *
* 06/25/1995 JLB : Added more trigger events. *
*=============================================================================================*/
bool TriggerClass::Spring(EventType event, ObjectClass *obj)
{
Validate();
/*
** If this is not the event for this trigger, just return.
*/
if (event != Event && Event != EVENT_ANY) {
return(false);
}
/*
** If time-based, decrement the minute counter; return if it's not time yet
*/
if (Event == EVENT_TIME) {
Data--;
if (Data > 0) {
return(false);
}
Data = DataCopy;
}
/*
** Semi-persistant trigger: first detach it from the calling object, then
** see if this is the last object we're attached to; if so, the trigger
** will spring.
*/
if (IsPersistant == SEMIPERSISTANT) {
/*
** Detach ourselves from the object
*/
obj->Trigger = NULL;
/*
** Decrement our attachment counter
*/
AttachCount--;
/*
** If we're attached to more objects, don't spring; otherwise, spring.
** And, mark ourselves as volatile so we'll completely remove ourselves
** from the game after we go off.
*/
if (AttachCount > 0) {
return(false);
} else {
IsPersistant = VOLATILE;
}
}
/*
** Otherwise, take an appropriate action.
*/
bool success = true;
TriggerClass * trig = NULL;
switch (Action) {
case ACTION_NUKE:
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Enable(true, false);
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Forced_Charge(PlayerPtr->Class->House == HOUSE_BAD);
break;
case ACTION_ION:
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Enable(true, false);
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Forced_Charge(PlayerPtr->Class->House == HOUSE_GOOD);
break;
case ACTION_WINLOSE:
switch (event) {
case EVENT_DESTROYED:
if (!PlayerPtr->IsToWin || PlayerPtr->Blockage > 0) PlayerPtr->Flag_To_Lose();
success = true;
break;
case EVENT_PLAYER_ENTERED:
if (!PlayerPtr->IsToLose) PlayerPtr->Flag_To_Win();
success = true;
break;
default:
success = false;
break;
}
break;
case ACTION_DESTROY_XXXX:
trig = As_Pointer("XXXX");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_YYYY:
trig = As_Pointer("YYYY");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_ZZZZ:
trig = As_Pointer("ZZZZ");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_AIRSTRIKE:
PlayerPtr->IsAirstrikePending = true;
// PlayerPtr->Make_Air_Strike_Available(true);
break;
case ACTION_DZ:
new AnimClass(ANIM_LZ_SMOKE, Cell_Coord(Waypoint[25]));
break;
case ACTION_NONE:
break;
case ACTION_WIN:
PlayerPtr->Flag_To_Win();
break;
case ACTION_LOSE:
PlayerPtr->Flag_To_Lose();
break;
case ACTION_BEGIN_PRODUCTION:
HouseClass::As_Pointer(House)->Begin_Production();
break;
case ACTION_AUTOCREATE:
if (obj && obj->Is_Techno()) {
((TechnoClass *)obj)->House->IsAlerted = true;
}
break;
case ACTION_CREATE_TEAM:
if (Team) {
ScenarioInit++;
Team->Create_One_Of();
ScenarioInit--;
}
break;
case ACTION_DESTROY_TEAM:
if (Team) {
Team->Destroy_All_Of();
}
break;
case ACTION_REINFORCEMENTS:
if (Team) {
success = Do_Reinforcements(Team);
}
break;
case ACTION_ALL_HUNT:
Do_All_To_Hunt();
break;
default:
break;
}
if (!success && Event == EVENT_TIME) Data = 1;
/*
** Remove trigger from the game.
*/
if (success && IsPersistant == VOLATILE) {
Remove();
}
return(true);
}
/***********************************************************************************************
* TriggerClass::Spring -- Trigger processing routine *
* *
* This version of Spring is for cell-based triggers. *
* *
* INPUT: *
* data elapsed time, or credits, depending on what 'Event' is. *
* *
* OUTPUT: *
* 0 = nothing happened; 1 = the trigger was sprung *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/06/1994 BR : Created. *
*=============================================================================================*/
bool TriggerClass::Spring(EventType event, CELL cell)
{
Validate();
/*
** If this is not the event for this trigger, just return.
*/
if (event != Event) {
return(false);
}
/*
** If time-based, decrement the minute counter; return if it's not time yet
*/
if (Event == EVENT_TIME) {
Data--;
if (Data > 0) {
return(false);
}
Data = DataCopy;
}
/*
** Semi-persistant trigger: first detach it from the calling cell, then
** see if this is the last cell we're attached to; if so, the trigger
** will spring.
*/
if (IsPersistant == SEMIPERSISTANT) {
/*
** Detach ourselves from the cell
*/
Map[cell].IsTrigger = 0;
/*
** Decrement our attachment counter
*/
AttachCount--;
/*
** If we're attached to more cells, don't spring; otherwise, spring.
** And, mark ourselves as volatile so we'll completely remove ourselves
** from the game after we go off.
*/
if (AttachCount > 0) {
return(false);
} else {
IsPersistant = VOLATILE;
}
}
/*
** Otherwise, take an appropriate action.
*/
bool success = true;
TriggerClass * trig = NULL;
int index;
switch (Action) {
case ACTION_NUKE:
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Enable(true, false);
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Forced_Charge(PlayerPtr->Class->House == HOUSE_BAD);
break;
case ACTION_ION:
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Enable(true, false);
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Forced_Charge(PlayerPtr->Class->House == HOUSE_GOOD);
break;
case ACTION_AUTOCREATE:
for (index = 0; index < Houses.Count(); index++) {
Houses.Ptr(index)->IsAlerted = true;
}
break;
case ACTION_DESTROY_XXXX:
trig = As_Pointer("XXXX");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_YYYY:
trig = As_Pointer("YYYY");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_ZZZZ:
trig = As_Pointer("ZZZZ");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_AIRSTRIKE:
HouseClass::As_Pointer(House)->AirStrike.Enable(false, true);
if (House == PlayerPtr->Class->House) {
PlayerPtr->AirStrike.Forced_Charge(true);
Map.Add(RTTI_SPECIAL, SPC_AIR_STRIKE);
Map.Column[1].Flag_To_Redraw();
}
// PlayerPtr->Make_Air_Strike_Available(true);
break;
case ACTION_DZ:
new AnimClass(ANIM_LZ_SMOKE, Cell_Coord(Waypoint[25]));
break;
case ACTION_NONE:
break;
case ACTION_WIN:
PlayerPtr->Flag_To_Win();
break;
case ACTION_LOSE:
PlayerPtr->Flag_To_Lose();
break;
case ACTION_BEGIN_PRODUCTION:
if (PlayerPtr->Class->House == HOUSE_GOOD) {
HouseClass::As_Pointer(HOUSE_BAD)->Begin_Production();
} else {
HouseClass::As_Pointer(HOUSE_GOOD)->Begin_Production();
}
break;
case ACTION_CREATE_TEAM:
if (Team) {
ScenarioInit++;
Team->Create_One_Of();
ScenarioInit--;
}
break;
case ACTION_DESTROY_TEAM:
if (Team) {
Team->Destroy_All_Of();
}
break;
case ACTION_REINFORCEMENTS:
if (Team) {
success = Do_Reinforcements(Team);
}
break;
case ACTION_ALL_HUNT:
Do_All_To_Hunt();
break;
default:
break;
}
if (!success && Event == EVENT_TIME) Data = 1;
/*
** Remove trigger from the game.
*/
if (success && IsPersistant == VOLATILE) {
Remove();
}
return(true);
}
/***********************************************************************************************
* TriggerClass::Spring -- Trigger processing routine *
* *
* This version of Spring is for house-specific triggers. *
* For a time-based trigger, 'data' will the the current TickCount. *
* For a credit-based trigger, 'data' will be the credits for the HouseClass *
* containing this trigger. *
* *
* INPUT: *
* event the event that happened *
* house house that this event relates to *
* data elapsed time, or credits, depending on what 'Event' is. *
* *
* OUTPUT: *
* 0 = nothing happened; 1 = the trigger was sprung *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/06/1994 BR : Created. *
* 06/25/1995 JLB : Added more trigger events. *
*=============================================================================================*/
bool TriggerClass::Spring(EventType event, HousesType house, long data)
{
Validate();
/*
** If this is not the event for this trigger, just return.
*/
if (event != Event || house != House) {
return(false);
}
/*
** If credits-based, check 'data'
*/
if (Event == EVENT_CREDITS && data < Data) {
return(false);
}
/*
** Building event check to ensure that the building number matches.
*/
if (Event == EVENT_BUILD && data != Data) {
return(false);
}
/*
** Number of objects destroyed checker. If the data supplied indicates that
** the correct number of objects have been destroyed, then this trigger
** will succeed.
*/
if (Event == EVENT_NBUILDINGS_DESTROYED || Event == EVENT_NUNITS_DESTROYED) {
if (data < Data) {
return(false);
}
}
/*
** If time-based, decrement the minute counter; return if it's not time yet
*/
if (Event == EVENT_TIME) {
Data--;
if (Data > 0) {
return(false);
}
Data = DataCopy;
}
/*
** The trigger has gone off; take appropriate action
*/
bool success = true;
TriggerClass * trig = NULL;
switch (Action) {
case ACTION_NUKE:
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Enable(true, false);
HouseClass::As_Pointer(HOUSE_BAD)->NukeStrike.Forced_Charge(PlayerPtr->Class->House == HOUSE_BAD);
break;
case ACTION_ION:
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Enable(true, false);
HouseClass::As_Pointer(HOUSE_GOOD)->IonCannon.Forced_Charge(PlayerPtr->Class->House == HOUSE_GOOD);
break;
/*
** This will remove a blockage to the win condition. No action need
** be performed here since the act of deleting the trigger will
** remove the blockage.
*/
case ACTION_ALLOWWIN:
break;
case ACTION_AUTOCREATE:
HouseClass::As_Pointer(House)->IsAlerted = true;
break;
case ACTION_DESTROY_XXXX:
trig = As_Pointer("XXXX");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_YYYY:
trig = As_Pointer("YYYY");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_DESTROY_ZZZZ:
trig = As_Pointer("ZZZZ");
if (trig) {
trig->Remove();
}
delete trig;
break;
case ACTION_AIRSTRIKE:
PlayerPtr->AirStrike.Enable(false, true);
if (House == PlayerPtr->Class->House) {
PlayerPtr->AirStrike.Forced_Charge(true);
Map.Add(RTTI_SPECIAL, SPC_AIR_STRIKE);
Map.Column[1].Flag_To_Redraw();
}
break;
case ACTION_NONE:
break;
case ACTION_DZ:
new AnimClass(ANIM_LZ_SMOKE, Cell_Coord(Waypoint[25]));
break;
case ACTION_WIN:
PlayerPtr->Flag_To_Win();
break;
case ACTION_LOSE:
PlayerPtr->Flag_To_Lose();
break;
case ACTION_BEGIN_PRODUCTION:
HouseClass::As_Pointer(House)->Begin_Production();
break;
case ACTION_CREATE_TEAM:
if (Team) {
ScenarioInit++;
Team->Create_One_Of();
ScenarioInit--;
}
break;
case ACTION_DESTROY_TEAM:
if (Team) {
Team->Destroy_All_Of();
}
break;
case ACTION_REINFORCEMENTS:
if (Team) {
success = Do_Reinforcements(Team);
}
break;
case ACTION_ALL_HUNT:
Do_All_To_Hunt();
break;
default:
break;
}
if (!success && Event == EVENT_TIME) Data = 1;
/*
** Remove trigger from the game.
*/
if (success && IsPersistant == VOLATILE) {
Remove();
}
return(true);
}
/***********************************************************************************************
* TriggerClass::Remove -- removes this trigger from the game *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* 1 = trigger was removed, 0 = it wasn't *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 12/06/1994 BR : Created. *
*=============================================================================================*/
bool TriggerClass::Remove(void)
{
Validate();
CELL cell;
HousesType h;
int index;
/*
** Loop through all cells; remove any reference to this trigger
*/
for (cell = 0; cell < MAP_CELL_TOTAL; cell++) {
if (Map[cell].IsTrigger) {
if (CellTriggers[cell] == this) {
Map[cell].IsTrigger = 0;
CellTriggers[cell] = NULL;
}
}
}
/*
** Loop through all objects, removing any reference to this trigger
*/
for (index = 0; index < Infantry.Count(); index++) {
if (Infantry.Ptr(index)->Trigger == this) {
Infantry.Ptr(index)->Trigger = NULL;
}
}
for (index = 0; index < Buildings.Count(); index++) {
if (Buildings.Ptr(index)->Trigger == this) {
Buildings.Ptr(index)->Trigger = NULL;
}
}
for (index = 0; index < Units.Count(); index++) {
if (Units.Ptr(index)->Trigger == this) {
Units.Ptr(index)->Trigger = NULL;
}
}
for (index = 0; index < Terrains.Count(); index++) {
if (Terrains.Ptr(index)->Trigger == this) {
Terrains.Ptr(index)->Trigger = NULL;
}
}
/*
** Remove this trigger from any house list it's in. Invoking '-=' with a
** pointer not in the list has no effect; loop through all houses just to
** be on the safe side.
*/
for (h = HOUSE_FIRST; h < HOUSE_COUNT; h++) {
HouseTriggers[h].Delete(this);
}
delete this;
return(true);
}
/***********************************************************************************************
* TriggerClass::Read_INI -- reads triggers from the INI file *
* *
* INI entry format: *
* Triggername = Eventname, Actionname, Data, Housename, TeamName, IsPersistant *
* *
* This routine reads in the triggers & creates them. Then, other classes can *
* get pointers to the triggers they're linked to. *
* *
* The routine relies on the TeamTypeClasses already being loaded so it can resolve *
* references to teams in this function. *
* *
* Cell Trigger pointers & IsTrigger flags are set in DisplayClass::Read_INI(), *
* and cleared in the Map::Init() routine (which clears all cell objects to 0's). *
* *
* Object's pointers are set in: *
* InfantryClass::Read_INI() *
* BuildingClass::Read_INI() *
* UnitClass::Read_INI() *
* TerrainClass::Read_INI() *
* The object trigger pointers are cleared in the ObjectClass constructor. *
* *
* The House's EMSListOf triggers is set in this routine, and cleared in the *
* HouseClass::Init() routine. *
* *
* INPUT: *
* buffer buffer to hold the INI data *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* This function must be called before any other class's Read_INI. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
void TriggerClass::Read_INI(char *buffer)
{
TriggerClass *trigger; // Working trigger pointer.
char *tbuffer; // Accumulation buffer of trigger IDs.
int len; // Length of data in buffer.
char buf[128];
/*
** Set 'tbuffer' to point just past the INI buffer
*/
len = strlen(buffer) + 2;
tbuffer = buffer + len;
/*
** Read all TRIGGER entry names into 'tbuffer'
*/
WWGetPrivateProfileString(INI_Name(), NULL, NULL, tbuffer, ShapeBufferSize-len, buffer);
/*
** Loop for all trigger entries.
*/
while (*tbuffer != '\0') {
/*
** Create a new trigger.
*/
trigger = new TriggerClass();
/*
** Set its name.
*/
trigger->Set_Name (tbuffer);
/*
** Get the trigger entry.
*/
WWGetPrivateProfileString(INI_Name(), tbuffer, NULL, buf, sizeof(buf)-1, buffer);
/*
** Fill in the trigger.
*/
trigger->Fill_In(tbuffer,buf);
/*
** Add 'trigger' to the House's list.
*/
// if (trigger->House != HOUSE_NONE && trigger->Event != EVENT_PLAYER_ENTERED) {
// if (Event_Need_House(trigger->Event) && !Event_Need_Object(trigger->Event)) {
if (trigger->House != HOUSE_NONE) {
if (trigger->Action == ACTION_ALLOWWIN) HouseClass::As_Pointer(trigger->House)->Blockage++;
HouseTriggers[trigger->House].Add(trigger);
trigger->AttachCount++;
}
/*
** Go to next entry.
*/
tbuffer += strlen(tbuffer)+1;
}
}
/***********************************************************************************************
* TriggerClass::Fill_In -- fills in trigger from the given INI entry *
* *
* This routine fills in the given trigger with the given name, and values from *
* the given INI entry. *
* *
* (This routine is used by the scenario editor, to import teams from the MASTER.INI file.) *
* *
* INI entry format: *
* Triggername = Eventname, Actionname, Data, Housename, TeamName, IsPersistant *
* *
* INPUT: *
* name mnemonic for the desired trigger *
* entry INI entry to parse *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
void TriggerClass::Fill_In(char * name, char *entry)
{
Validate();
char *p;
/*
** Set its name.
*/
Set_Name(name);
/*
** 1st token: Event.
*/
Event = Event_From_Name(strtok(entry, ","));
/*
** 2nd token: Action.
*/
Action = Action_From_Name(strtok(NULL, ","));
/*
** 3rd token: Data.
*/
DataCopy = Data = atol(strtok(NULL, ","));
/*
** 4th token: House.
*/
House = HouseTypeClass::From_Name(strtok(NULL, ","));
if (House == HOUSE_NONE && Event == EVENT_PLAYER_ENTERED) {
House = PlayerPtr->Class->House;
}
/*
** 5th token: Team.
*/
Team = TeamTypeClass::As_Pointer(strtok(NULL, ","));
/*
** 6th token: IsPersistant. This token was added later, so we must check
** for its existence.
*/
p = strtok(NULL, ",");
if (p) {
IsPersistant = (PersistantType)atoi(p);
} else {
IsPersistant = VOLATILE;
}
}
/***********************************************************************************************
* TriggerClass::Write_INI -- writes triggers to the INI file *
* *
* INI entry format: *
* Triggername = Eventname, Actionname, Data, Housename, TeamName, IsPersistant *
* *
* INPUT: *
* buffer buffer to hold the INI data *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
void TriggerClass::Write_INI(char *buffer, bool refresh)
{
int index;
char buf[128];
TriggerClass *trigger;
char const *hname;
char const *tname;
/*
** First, clear out all existing trigger data from the INI file.
*/
if (refresh) {
WWWritePrivateProfileString(INI_Name(), NULL, NULL, buffer);
}
/*
** Now write all the trigger data out
*/
for (index = 0; index < Triggers.Count(); index++) {
/*
** Get ptr to next active trigger.
*/
trigger = Triggers.Ptr(index);
/*
** Generate INI entry.
*/
if (trigger->House==HOUSE_NONE) {
hname = "None";
} else {
hname = HouseClass::As_Pointer(trigger->House)->Class->IniName;
}
if (trigger->Team==NULL) {
tname = "None";
} else {
tname = trigger->Team->IniName;
}
sprintf(buf,"%s,%s,%ld,%s,%s,%d",
TriggerClass::Name_From_Event(trigger->Event),
TriggerClass::Name_From_Action(trigger->Action),
trigger->Data,
hname,
tname,
trigger->IsPersistant);
WWWritePrivateProfileString(INI_Name(), trigger->Get_Name(), buf, buffer);
}
}
/***********************************************************************************************
* TriggerClass::As_Pointer -- returns pointer for the given trigger name *
* *
* This function is designed for use at initialization time, ie when the *
* trigger mnemonics are read from the INI and the Read_INI functions need *
* to get a pointer to that trigger. *
* *
* INPUT: *
* name mnemonic for the desired trigger *
* *
* OUTPUT: *
* near pointer to that trigger, NULL if not found *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
TriggerClass * TriggerClass::As_Pointer(char const * name)
{
if (name == NULL) {
return(NULL);
}
for (int i = 0; i < Triggers.Count(); i++) {
TriggerClass * trigger = Triggers.Ptr(i);
if (!stricmp(name, trigger->Name)) {
return(trigger);
}
}
return(NULL);
}
/***********************************************************************************************
* TriggerClass::operator new -- 'new' operator *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* pointer to new trigger *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
void * TriggerClass::operator new(size_t )
{
void * ptr = Triggers.Allocate();
if (ptr) {
((TriggerClass *)ptr)->IsActive = true;
}
return(ptr);
}
/***********************************************************************************************
* TriggerClass::operator delete -- 'delete' operator *
* *
* INPUT: *
* ptr pointer to delete *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/28/1994 BR : Created. *
*=============================================================================================*/
void TriggerClass::operator delete(void *ptr)
{
if (ptr) {
((TriggerClass *)ptr)->IsActive = false;
}
Triggers.Free((TriggerClass *)ptr);
}
/***********************************************************************************************
* TriggerClass::Event_From_Name -- retrieves EventType for given name *
* *
* INPUT: *
* name name to get event for *
* *
* OUTPUT: *
* EventType for given name *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/29/1994 BR : Created. *
*=============================================================================================*/
EventType TriggerClass::Event_From_Name (char const *name)
{
int i;
if (name == NULL) {
return(EVENT_NONE);
}
for (i = EVENT_NONE; i < EVENT_COUNT; i++) {
if (!stricmp(name,EventText[i + 1])) {
return((EventType)i);
}
}
return(EVENT_NONE);
}
/***********************************************************************************************
* TriggerClass::Name_From_Event -- retrieves name for EventType *
* *
* INPUT: *
* event EventType to get name for *
* *
* OUTPUT: *
* name for EventType *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/29/1994 BR : Created. *
*=============================================================================================*/
char const *TriggerClass::Name_From_Event(EventType event)
{
return(EventText[event + 1]);
}
/***********************************************************************************************
* TriggerClass::Action_From_Name -- retrieves ActionType for given name *
* *
* INPUT: *
* name name to get ActionType for *
* *
* OUTPUT: *
* ActionType for given name *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/29/1994 BR : Created. *
*=============================================================================================*/
TriggerClass::ActionType TriggerClass::Action_From_Name (char const *name)
{
int i;
if (name == NULL) {
return(ACTION_NONE);
}
for (i = ACTION_NONE; i < ACTION_COUNT; i++) {
if (!stricmp(name,ActionText[i + 1])) {
return((ActionType)i);
}
}
return(ACTION_NONE);
}
/***********************************************************************************************
* TriggerClass::Name_From_Action -- retrieves name for ActionType *
* *
* INPUT: *
* action ActionType to get name for *
* *
* OUTPUT: *
* name of ActionType *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/29/1994 BR : Created. *
*=============================================================================================*/
char const *TriggerClass::Name_From_Action(ActionType action)
{
return(ActionText[action + 1]);
}
/***********************************************************************************************
* TriggerClass::As_Target -- Converts trigger to a target value *
* *
* INPUT: none *
* *
* OUTPUT: TARGET value *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/19/1994 JLB : Created. *
*=============================================================================================*/
TARGET TriggerClass::As_Target(void) const
{
Validate();
return(Build_Target(KIND_TRIGGER, Triggers.ID(this)));
}
/***********************************************************************************************
* Do_All_To_Hunt -- Forces all computer controlled units into hunt mode. *
* *
* This trigger action will cause the computer units and infantry to go into hunt mode. *
* Use it to bring a scenario to a sudden conclusion. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/20/1995 JLB : Created. *
* 08/14/1995 JLB : Removes the member from a team if necessary. *
*=============================================================================================*/
static void Do_All_To_Hunt(void)
{
int index;
for (index = 0; index < Units.Count(); index++) {
UnitClass * unit = Units.Ptr(index);
if (!unit->House->IsHuman && unit->IsDown && !unit->IsInLimbo) {
if (unit->Team) unit->Team->Remove(unit);
unit->Assign_Mission(MISSION_HUNT);
}
}
for (index = 0; index < Infantry.Count(); index++) {
InfantryClass * infantry = Infantry.Ptr(index);
if (!infantry->House->IsHuman && infantry->IsDown && !infantry->IsInLimbo) {
if (infantry->Team) infantry->Team->Remove(infantry);
infantry->Assign_Mission(MISSION_HUNT);
}
}
}