mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-24 15:32:18 +12:00
fd05be35c1
DLL version incremented Beacon functionality added Support for loading screen match preview display Placeholder handling of new key-bindable mod commands
1075 lines
47 KiB
C++
1075 lines
47 KiB
C++
//
|
|
// 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: /CounterStrike/EVENT.CPP 1 3/03/97 10:24a 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 : EVENT.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : 12/09/94 *
|
|
* *
|
|
* Last Update : November 10, 1995 [BRR] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* EventClass::EventClass -- Construct an id and cell based event. *
|
|
* EventClass::EventClass -- Construct simple target type event. *
|
|
* EventClass::EventClass -- Constructor for mission change events. *
|
|
* EventClass::EventClass -- Constructor for navigation computer events. *
|
|
* EventClass::EventClass -- Constructor for object types affecting cells event. *
|
|
* EventClass::EventClass -- Constructor for sidebar build events. *
|
|
* EventClass::EventClass -- Constructs event to transfer special flags. *
|
|
* EventClass::EventClass -- Default constructor for event objects. *
|
|
* EventClass::EventClass -- Event for sequencing animations. *
|
|
* EventClass::EventClass -- Megamission assigned to unit. *
|
|
* EventClass::Execute -- Execute a queued command. *
|
|
* EventClass::EventClass -- construct a variable-sized event *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "function.h"
|
|
#ifdef WIN32
|
|
#include "ccdde.h"
|
|
#endif //WIN32
|
|
|
|
#ifdef FIXIT_VERSION_3 // Stalemate games.
|
|
#include "WolStrng.h"
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
** Table of what data is really used in the EventClass struct for different
|
|
** events. This table must be kept current with the EventType enum.
|
|
*/
|
|
unsigned char EventClass::EventLength[EventClass::LAST_EVENT] = {
|
|
0, // EMPTY
|
|
size_of(EventClass, Data.General ), // ALLY
|
|
size_of(EventClass, Data.MegaMission ), // MEGAMISSION
|
|
size_of(EventClass, Data.MegaMission_F ), // MEGAMISSION_F
|
|
size_of(EventClass, Data.Target ), // IDLE
|
|
size_of(EventClass, Data.Target ), // SCATTER
|
|
0, // DESTRUCT
|
|
0, // DEPLOY
|
|
size_of(EventClass, Data.Place ), // PLACE
|
|
0, // OPTIONS
|
|
size_of(EventClass, Data.General ), // GAMESPEED
|
|
size_of(EventClass, Data.Specific ), // PRODUCE
|
|
size_of(EventClass, Data.Specific.Type ), // SUSPEND
|
|
size_of(EventClass, Data.Specific.Type ), // ABANDON
|
|
size_of(EventClass, Data.Target ), // PRIMARY
|
|
size_of(EventClass, Data.Special ), // SPECIAL_PLACE
|
|
0, // EXIT
|
|
size_of(EventClass, Data.Anim ), // ANIMATION
|
|
size_of(EventClass, Data.Target ), // REPAIR
|
|
size_of(EventClass, Data.Target ), // SELL
|
|
size_of(EventClass, Data.SellCell), // SELLCELL
|
|
size_of(EventClass, Data.Options ), // SPECIAL
|
|
0, // FRAMESYNC
|
|
0, // MESSAGE
|
|
size_of(EventClass, Data.FrameInfo.Delay ), // RESPONSE_TIME
|
|
size_of(EventClass, Data.FrameInfo ), // FRAMEINFO
|
|
0, // SAVEGAME
|
|
size_of(EventClass, Data.NavCom ), // ARCHIVE
|
|
size_of(EventClass, Data.Variable.Size), // ADDPLAYER
|
|
size_of(EventClass, Data.Timing ), // TIMING
|
|
size_of(EventClass, Data.ProcessTime ), // PROCESS_TIME
|
|
#ifdef FIXIT_VERSION_3 // Stalemate games.
|
|
0, // PROPOSE_DRAW
|
|
0, // RETRACT_DRAW
|
|
#endif
|
|
};
|
|
|
|
char * EventClass::EventNames[EventClass::LAST_EVENT] = {
|
|
"EMPTY",
|
|
"ALLY",
|
|
"MEGAMISSION",
|
|
"MEGAMISSION_F",
|
|
"IDLE",
|
|
"SCATTER",
|
|
"DESTRUCT",
|
|
"DEPLOY",
|
|
"PLACE",
|
|
"OPTIONS",
|
|
"GAMESPEED",
|
|
"PRODUCE",
|
|
"SUSPEND",
|
|
"ABANDON",
|
|
"PRIMARY",
|
|
"SPECIAL_PLACE",
|
|
"EXIT",
|
|
"ANIMATION",
|
|
"REPAIR",
|
|
"SELL",
|
|
"SELLCELL",
|
|
"SPECIAL",
|
|
"FRAMESYNC",
|
|
"MESSAGE",
|
|
"RESPONSE_TIME",
|
|
"FRAMEINFO",
|
|
"SAVEGAME",
|
|
"ARCHIVE",
|
|
"ADDPLAYER",
|
|
"TIMING",
|
|
"PROCESS_TIME",
|
|
#ifdef FIXIT_VERSION_3 // Stalemate games.
|
|
"PROPOSE_DRAW",
|
|
"RETRACT_DRAW",
|
|
#endif
|
|
};
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructs event to transfer special flags. *
|
|
* *
|
|
* This constructs an event that will transfer the special flags. *
|
|
* *
|
|
* INPUT: data -- The special flags to be transported to all linked computers. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/25/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(SpecialClass data)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = SPECIAL;
|
|
Frame = ::Frame;
|
|
Data.Options.Data = data;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Construct simple target type event. *
|
|
* *
|
|
* This will construct a generic event that needs only a target parameter. The actual *
|
|
* event and target values are specified as parameters. *
|
|
* *
|
|
* INPUT: type -- The event type to construct. *
|
|
* *
|
|
* target-- The target value that this event is to apply to. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/25/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, TargetClass target)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Target.Whom = target;
|
|
}
|
|
|
|
|
|
EventClass::EventClass(EventType type, CELL cell)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.SellCell.Cell = cell;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Default constructor for event objects. *
|
|
* *
|
|
* This constructs a simple event object that requires no parameters other than the *
|
|
* type of event it is. *
|
|
* *
|
|
* INPUT: type -- The type of event to construct. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for general-purpose-data events. *
|
|
* *
|
|
* INPUT: type -- The type of event to construct. *
|
|
* val -- data value *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, int val)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Data.General.Value = val;
|
|
Frame = ::Frame;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for navigation computer events. *
|
|
* *
|
|
* Constructor for events that are used to assign the navigation computer. *
|
|
* *
|
|
* INPUT: type -- The type of event (this constructor can be used by other navigation *
|
|
* type events). *
|
|
* *
|
|
* src -- The object that the event should apply to. *
|
|
* *
|
|
* dest -- The destination (or target) that the event needs to complete. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, TargetClass src, TargetClass dest)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.NavCom.Whom = src;
|
|
Data.NavCom.Where = TargetClass(dest);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Event for sequencing animations. *
|
|
* *
|
|
* This constructor is used for animations that must be created through the event system. *
|
|
* *
|
|
* INPUT: anim -- The animation that will be created. *
|
|
* *
|
|
* coord -- The location where the animation is to be created. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/19/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(AnimType anim, HousesType owner, COORDINATE coord, int visible)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = ANIMATION;
|
|
Frame = ::Frame;
|
|
Data.Anim.What = anim;
|
|
Data.Anim.Owner = owner;
|
|
Data.Anim.Where = coord;
|
|
Data.Anim.Visible = visible;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Megamission assigned to unit. *
|
|
* *
|
|
* This is the event that is used to assign most missions to units. It combines both the *
|
|
* mission and the target (navcom and tarcom). *
|
|
* *
|
|
* INPUT: src -- The object that this mission is to apply to. *
|
|
* *
|
|
* mission -- The mission to assign to this object. *
|
|
* *
|
|
* target -- The target to assign to this object's TarCom. *
|
|
* *
|
|
* destination -- The destination to assign to this object's NavCom. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(TargetClass src, MissionType mission, TargetClass target, TargetClass destination)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = MEGAMISSION;
|
|
Frame = ::Frame;
|
|
Data.MegaMission.Whom = src;
|
|
Data.MegaMission.Mission = mission;
|
|
Data.MegaMission.Target = target;
|
|
Data.MegaMission.Destination = destination;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Megamission assigned to unit. *
|
|
* *
|
|
* This is the event that is used to assign most missions to units. It combines both the *
|
|
* mission and the target (navcom and tarcom). This variation is used for formation moves. *
|
|
* *
|
|
* INPUT: src -- The object that this mission is to apply to. *
|
|
* *
|
|
* mission -- The mission to assign to this object. *
|
|
* *
|
|
* target -- The target to assign to this object's TarCom. *
|
|
* *
|
|
* destination -- The destination to assign to this object's NavCom. *
|
|
* *
|
|
* speed -- The formation override speed for this move. *
|
|
* *
|
|
* maxspeed -- The formation override maximum speed for this move. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(TargetClass src, MissionType mission, TargetClass target, TargetClass destination, SpeedType speed, MPHType maxspeed)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = MEGAMISSION_F;
|
|
Frame = ::Frame;
|
|
Data.MegaMission_F.Whom = src;
|
|
Data.MegaMission_F.Mission = mission;
|
|
Data.MegaMission_F.Target = TargetClass(target);
|
|
Data.MegaMission_F.Destination = TargetClass(destination);
|
|
Data.MegaMission_F.Speed = speed;
|
|
Data.MegaMission_F.MaxSpeed = maxspeed;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for sidebar build events. *
|
|
* *
|
|
* This constructor is used for events that deal with an object type and an object ID. *
|
|
* Typically, this is used exclusively by the sidebar. *
|
|
* *
|
|
* INPUT: type -- The event type of this object. *
|
|
* *
|
|
* object -- The object type number. *
|
|
* *
|
|
* id -- The object sub-type number. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, RTTIType object, int id)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Specific.Type = object;
|
|
Data.Specific.ID = id;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Constructor for object types affecting cells event. *
|
|
* *
|
|
* This constructor is used for those events that have an object type and associated cell. *
|
|
* Typically, this is for building placement after construction has completed. *
|
|
* *
|
|
* INPUT: type -- The event type for this object. *
|
|
* *
|
|
* object -- The object type number (actual object is probably inferred from the *
|
|
* sidebar data). *
|
|
* *
|
|
* cell -- The cell location where this event is to occur. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, RTTIType object, CELL cell)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Place.Type = object;
|
|
Data.Place.Cell = cell;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- Construct an id and cell based event. *
|
|
* *
|
|
* This constructor is used for those events that require an ID number and a cell location. *
|
|
* *
|
|
* INPUT: type -- The event type this will be. *
|
|
* *
|
|
* id -- The arbitrary id number to assign. *
|
|
* *
|
|
* cell -- The location for this event. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/18/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, int id, CELL cell)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Special.ID = id;
|
|
Data.Special.Cell = cell;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::EventClass -- construct a variable-sized event *
|
|
* *
|
|
* INPUT: *
|
|
* ptr ptr to data associated with this event *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 11/10/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
EventClass::EventClass(EventType type, void * ptr, unsigned long size)
|
|
{
|
|
ID = PlayerPtr->ID;
|
|
Type = type;
|
|
Frame = ::Frame;
|
|
Data.Variable.Pointer = ptr;
|
|
Data.Variable.Size = size;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* EventClass::Execute -- Execute a queued command. *
|
|
* *
|
|
* This routine executes an event. The even must already have been confirmed by any *
|
|
* remote machine before calling this routine. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void EventClass::Execute(void)
|
|
{
|
|
TechnoClass * techno;
|
|
AnimClass * anim = 0;
|
|
HouseClass * house = 0;
|
|
// CELL cell = 0;
|
|
char txt[80];
|
|
bool formation = false;
|
|
// RTTIType rt;
|
|
|
|
if (Debug_Print_Events) {
|
|
printf("(%d) Executing %s ID:%d Frame:%d ",
|
|
::Frame, EventNames[Type], ID, Frame);
|
|
}
|
|
|
|
switch (Type) {
|
|
|
|
/*
|
|
** Update the archive target for this building.
|
|
*/
|
|
case ARCHIVE:
|
|
techno = Data.NavCom.Whom.As_Techno();
|
|
if (techno && techno->IsActive) {
|
|
techno->ArchiveTarget = Data.NavCom.Where.As_TARGET();
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Make or break alliance.
|
|
*/
|
|
case ALLY:
|
|
house = Houses.Raw_Ptr(Data.General.Value);
|
|
if (Houses.Raw_Ptr(ID)->Is_Ally(house)) {
|
|
Houses.Raw_Ptr(ID)->Make_Enemy((HousesType)Data.General.Value);
|
|
} else {
|
|
Houses.Raw_Ptr(ID)->Make_Ally((HousesType)Data.General.Value);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Special self destruct action requested. This is active in the multiplayer mode.
|
|
*/
|
|
case DESTRUCT:
|
|
Houses.Raw_Ptr(ID)->Flag_To_Die();
|
|
break;
|
|
|
|
/*
|
|
** Update the special control flags. This is necessary so that in a multiplay
|
|
** game, all machines will agree on the rules. If these options change during
|
|
** game play, then all players are informed that options have changed.
|
|
*/
|
|
case SPECIAL:
|
|
{
|
|
Special = Data.Options.Data;
|
|
HouseClass * house = Houses.Raw_Ptr(ID);
|
|
|
|
//sprintf(txt, Text_String(TXT_SPECIAL_WARNING), house->Name); // Should be IniName? ST - 5/8/2019
|
|
sprintf(txt, Text_String(TXT_SPECIAL_WARNING), house->IniName);
|
|
Session.Messages.Add_Message(NULL, 0, txt,
|
|
house->RemapColor,
|
|
TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, 1200);
|
|
Map.Flag_To_Redraw(false);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Starts or stops repair on the specified object. This event is triggered by the
|
|
** player clicking the repair wrench on a building.
|
|
*/
|
|
case REPAIR:
|
|
techno = Data.Target.Whom.As_Techno();
|
|
if (techno && techno->IsActive) {
|
|
techno->Repair(-1);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Tells a building/unit to sell. This event is triggered by the player clicking the
|
|
** sell animating cursor over the building or unit.
|
|
*/
|
|
case SELL:
|
|
techno = Data.Target.Whom.As_Techno();
|
|
if (techno && techno->IsActive && techno->House == Houses.Raw_Ptr(ID)) {
|
|
if (techno->What_Am_I() == RTTI_BUILDING || (techno->What_Am_I() == RTTI_UNIT && Map[techno->Center_Coord()].Cell_Building() != 0)) {
|
|
techno->Sell_Back(-1);
|
|
}
|
|
} else {
|
|
// if (Is_Target_Cell(Data.Target.Whom)) {
|
|
// Houses.Raw_Ptr(ID)->Sell_Wall(As_Cell(Data.Target.Whom));
|
|
// }
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Tells the wall at the specified location to sell off.
|
|
*/
|
|
case SELLCELL:
|
|
// cell = Data.SellCell.Cell;
|
|
Houses.Raw_Ptr(ID)->Sell_Wall(Data.SellCell.Cell);
|
|
break;
|
|
|
|
/*
|
|
** This even is used to trigger an animation that is generated as a direct
|
|
** result of player intervention.
|
|
*/
|
|
case ANIMATION:
|
|
anim = new AnimClass(Data.Anim.What, Data.Anim.Where);
|
|
if (anim) {
|
|
anim->Set_Owner(Data.Anim.Owner);
|
|
anim->Set_Visible_Flags(static_cast<unsigned int>(Data.Anim.Visible));
|
|
/*
|
|
** Beacons have a 30-second kill time.
|
|
*/
|
|
if (Data.Anim.What == ANIM_BEACON) {
|
|
FILETIME ft;
|
|
GetSystemTimeAsFileTime(&ft);
|
|
|
|
unsigned long long kill_time = ((unsigned long long)ft.dwLowDateTime + ((unsigned long long)ft.dwHighDateTime << 32ULL)) + 300000000ULL;
|
|
anim->Kill_At(kill_time);
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** This event will place the specified object at the specified location.
|
|
** The event is used to place newly constructed buildings down on the map. The
|
|
** object type is specified. From this object type, the house can determine the
|
|
** exact factory and real object pointer to use.
|
|
*/
|
|
case PLACE:
|
|
Houses.Raw_Ptr(ID)->Place_Object(Data.Place.Type, Data.Place.Cell);
|
|
break;
|
|
|
|
/*
|
|
** This event starts production of the specified object type. The house can
|
|
** determine from the type and ID value, what object to begin production on and
|
|
** what factory to use.
|
|
*/
|
|
case PRODUCE:
|
|
Houses.Raw_Ptr(ID)->Begin_Production(Data.Specific.Type, Data.Specific.ID);
|
|
break;
|
|
|
|
/*
|
|
** This event is generated when the player puts production on hold. From the
|
|
** object type, the factory can be inferred.
|
|
*/
|
|
case SUSPEND:
|
|
Houses.Raw_Ptr(ID)->Suspend_Production(Data.Specific.Type);
|
|
break;
|
|
|
|
/*
|
|
** This event is generated when the player cancels production of the specified
|
|
** object type. From the object type, the exact factory can be inferred.
|
|
*/
|
|
case ABANDON:
|
|
Houses.Raw_Ptr(ID)->Abandon_Production(Data.Specific.Type);
|
|
break;
|
|
|
|
/*
|
|
** Toggles the primary factory state of the specified building.
|
|
*/
|
|
case PRIMARY:
|
|
{
|
|
BuildingClass * building = Data.Target.Whom.As_Building();
|
|
if (building && building->IsActive) {
|
|
building->Toggle_Primary();
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** This is the general purpose mission control event. Most player
|
|
** action routes through this event. It sets a unit's mission, TarCom,
|
|
** and NavCom to the values specified.
|
|
*/
|
|
case MEGAMISSION_F:
|
|
techno = Data.MegaMission_F.Whom.As_Techno();
|
|
if (techno && techno->IsActive && techno->Is_Foot()) {
|
|
((FootClass *)techno)->IsFormationMove = true;
|
|
((FootClass *)techno)->FormationSpeed = Data.MegaMission_F.Speed;
|
|
((FootClass *)techno)->FormationMaxSpeed = Data.MegaMission_F.MaxSpeed;
|
|
FormMove = true;
|
|
FormSpeed = Data.MegaMission_F.Speed;
|
|
FormMaxSpeed = Data.MegaMission_F.MaxSpeed;
|
|
formation = true;
|
|
}
|
|
// Fall thru to next case...
|
|
|
|
case MEGAMISSION:
|
|
if (Debug_Print_Events) {
|
|
printf("Whom:%x Tgt:%x Dest:%x ",
|
|
Data.MegaMission.Whom.As_TARGET(),
|
|
Data.MegaMission.Target.As_TARGET(),
|
|
Data.MegaMission.Destination.As_TARGET());
|
|
}
|
|
techno = Data.MegaMission.Whom.As_Techno();
|
|
if (techno != NULL && techno->IsActive && techno->Strength > 0 && !techno->IsInLimbo) {
|
|
|
|
/*
|
|
** Fetch a pointer to the object of the mission. If there is an error with
|
|
** this object, such as it is dead, then bail.
|
|
*/
|
|
ObjectClass * object = NULL;
|
|
if (Data.MegaMission.Target.Is_Valid()) {
|
|
object = Data.MegaMission.Target.As_Object();
|
|
if (object != NULL && (!object->IsActive || object->Strength == 0 || object->IsInLimbo)) {
|
|
break;
|
|
// object = NULL;
|
|
// Data.MegaMission.Target.Invalidate();
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If the destination target is invalid because the object is dead, then
|
|
** bail from processing this mega mission.
|
|
*/
|
|
if (Data.MegaMission.Destination.Is_Valid()) {
|
|
object = Data.MegaMission.Destination.As_Object();
|
|
if (object != NULL && (!object->IsActive || object->Strength == 0 || object->IsInLimbo)) {
|
|
break;
|
|
// object = NULL;
|
|
// Data.MegaMission.Destination.Invalidate();
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Break any existing tether or team contact, since it is now invalid.
|
|
*/
|
|
if (!techno->IsTethered) {
|
|
techno->Transmit_Message(RADIO_OVER_OUT);
|
|
}
|
|
if (techno->Is_Foot()) {
|
|
if (!formation) ((FootClass *)techno)->IsFormationMove = false;
|
|
if (((FootClass *)techno)->Team) {
|
|
((FootClass *)techno)->Team->Remove((FootClass *)techno);
|
|
}
|
|
}
|
|
|
|
if (object != NULL) {
|
|
|
|
// 2019/09/20 JAS - Added record of who clicked on the object
|
|
HouseClass* house = Houses.Raw_Ptr(ID);
|
|
bool is_allied = house != nullptr && house->Is_Ally(techno);
|
|
if (is_allied) {
|
|
object->Clicked_As_Target((HousesType)ID);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Test to see if the navigation target should really be queued rather
|
|
** than assigned to the object. This would be the case if this is a
|
|
** special queued move mission and there is already a valid navigation
|
|
** target for this unit.
|
|
*/
|
|
bool q = (Data.MegaMission.Mission == MISSION_QMOVE);
|
|
|
|
techno->Assign_Mission(Data.MegaMission.Mission);
|
|
|
|
if (techno->Is_Foot()) {
|
|
((FootClass*)techno)->SuspendedNavCom = TARGET_NONE;
|
|
}
|
|
techno->SuspendedTarCom = TARGET_NONE;
|
|
|
|
/*
|
|
** Guard area mode is handled with care. The specified target is actually
|
|
** assigned as the location that should be guarded. In addition, the
|
|
** movement destination is immediately set to this new location.
|
|
*/
|
|
if (Data.MegaMission.Mission == MISSION_GUARD_AREA && techno->Is_Foot()) {
|
|
techno->Assign_Target(TARGET_NONE);
|
|
techno->Assign_Destination(Data.MegaMission.Target.As_TARGET());
|
|
techno->ArchiveTarget = Data.MegaMission.Target.As_TARGET();
|
|
} else if (Data.MegaMission.Mission == MISSION_ENTER &&
|
|
object != NULL &&
|
|
object->What_Am_I() == RTTI_BUILDING &&
|
|
*((BuildingClass*)object) == STRUCT_REFINERY) {
|
|
techno->Transmit_Message(RADIO_HELLO, (BuildingClass*)object);
|
|
techno->Assign_Destination(TARGET_NONE);
|
|
} else {
|
|
if (q && techno->Is_Foot()) {
|
|
((FootClass *)techno)->Queue_Navigation_List(Data.MegaMission.Destination.As_TARGET());
|
|
} else {
|
|
if (techno->Is_Foot()) {
|
|
((FootClass *)techno)->Clear_Navigation_List();
|
|
}
|
|
techno->Assign_Target(Data.MegaMission.Target.As_TARGET());
|
|
techno->Assign_Destination(Data.MegaMission.Destination.As_TARGET());
|
|
}
|
|
}
|
|
|
|
//
|
|
// Special case for ship repairing: If the assigned mission is to
|
|
// move, and 'techno' is a Vessel:
|
|
// If the destination is a shipyard or sub pen, set the IsToSelfRepair flag
|
|
// Otherwise, clear both IsToSelfRepair and IsSelfRepairing
|
|
//
|
|
RTTIType rt = techno->What_Am_I();
|
|
// rt = Data.MegaMission.Whom;
|
|
if (rt == RTTI_VESSEL && techno != NULL && techno->What_Am_I() == RTTI_VESSEL) {
|
|
VesselClass *ship = (VesselClass *)techno;
|
|
if (Data.MegaMission.Mission == MISSION_MOVE) {
|
|
if (object != NULL) {
|
|
if (object->What_Am_I() == RTTI_BUILDING &&
|
|
((BuildingClass *)object)->House->Is_Ally(techno) &&
|
|
// if ((RTTIType)Data.MegaMission.Destination == RTTI_BUILDING &&
|
|
(((BuildingClass *)object)->Class->Type == STRUCT_SHIP_YARD ||
|
|
((BuildingClass *)object)->Class->Type == STRUCT_SUB_PEN)) {
|
|
ship->IsToSelfRepair = true;
|
|
} else {
|
|
ship->IsToSelfRepair = false;
|
|
ship->IsSelfRepairing = false;
|
|
}
|
|
} else {
|
|
ship->IsToSelfRepair = false;
|
|
ship->IsSelfRepairing = false;
|
|
}
|
|
} else {
|
|
ship->IsToSelfRepair = false;
|
|
ship->IsSelfRepairing = false;
|
|
}
|
|
}
|
|
|
|
#ifdef NEVER
|
|
if ((techno->What_Am_I() == RTTI_UNIT || techno->What_Am_I() == RTTI_INFANTRY) &&
|
|
Data.MegaMission.Mission == MISSION_GUARD_AREA) {
|
|
|
|
((FootClass *)techno)->ArchiveTarget = Data.MegaMission.Destination;
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Request that the unit/infantry/aircraft go into idle mode.
|
|
*/
|
|
case IDLE:
|
|
techno = Data.Target.Whom.As_Techno();
|
|
if (techno != NULL && techno->IsActive && !techno->IsInLimbo && !techno->IsTethered && techno->What_Am_I() != RTTI_BUILDING) {
|
|
techno->Transmit_Message(RADIO_OVER_OUT);
|
|
techno->Assign_Destination(TARGET_NONE);
|
|
techno->Assign_Target(TARGET_NONE);
|
|
techno->Enter_Idle_Mode();
|
|
if (techno->Is_Foot()) {
|
|
((FootClass *)techno)->Clear_Navigation_List();
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Request that the unit/infantry/aircraft scatter from its current location.
|
|
*/
|
|
case SCATTER:
|
|
techno = Data.Target.Whom.As_Techno();
|
|
if (techno != NULL && techno->Is_Foot() && techno->IsActive && !techno->IsInLimbo && !techno->IsTethered) {
|
|
((FootClass *)techno)->IsScattering = true;
|
|
techno->Scatter(0, true, false);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** If we are placing down the ion cannon blast then lets take
|
|
** care of it.
|
|
*/
|
|
case SPECIAL_PLACE:
|
|
Houses.Raw_Ptr(ID)->Place_Special_Blast((SpecialWeaponType)Data.Special.ID, Data.Special.Cell);
|
|
break;
|
|
|
|
/*
|
|
** Exit the game.
|
|
** Give parting message while palette is fading to black.
|
|
*/
|
|
case EXIT:
|
|
Theme.Queue_Song(THEME_NONE);
|
|
Stop_Speaking();
|
|
Speak(VOX_CONTROL_EXIT);
|
|
while (Is_Speaking()) {
|
|
Call_Back();
|
|
}
|
|
GameActive = false;
|
|
break;
|
|
|
|
/*
|
|
** Process the options menu, unless we're playing back a recording.
|
|
*/
|
|
case OPTIONS:
|
|
if (!Session.Play) {
|
|
SpecialDialog = SDLG_OPTIONS;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Process the options Game Speed
|
|
*/
|
|
case GAMESPEED:
|
|
Options.GameSpeed = Data.General.Value;
|
|
break;
|
|
|
|
/*
|
|
** Adjust connection timing for multiplayer games
|
|
*/
|
|
case RESPONSE_TIME:
|
|
Session.MaxAhead = Data.FrameInfo.Delay;
|
|
break;
|
|
|
|
/*
|
|
** Save a multiplayer game (this event is only generated in multiplayer mode)
|
|
*/
|
|
case SAVEGAME:
|
|
/*
|
|
** Show the user what's going on with a message box (but only if
|
|
** we're not already inside a dialog box routine!)
|
|
*/
|
|
if (SpecialDialog == SDLG_NONE) {
|
|
CDTimerClass<SystemTimerClass> timer;
|
|
//timer.Start();
|
|
timer = TICKS_PER_SECOND * 4;
|
|
|
|
WWMessageBox().Process(TXT_SAVING_GAME, TXT_NONE);
|
|
|
|
Save_Game (-1, (char *)Text_String(TXT_MULTIPLAYER_GAME));
|
|
|
|
while (timer > 0) {
|
|
Call_Back();
|
|
}
|
|
|
|
HidPage.Clear();
|
|
Map.Flag_To_Redraw(true);
|
|
Map.Render();
|
|
}
|
|
else {
|
|
Save_Game (-1, (char *)Text_String(TXT_MULTIPLAYER_GAME));
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Add a new player to the game:
|
|
** - Form a network connection to him
|
|
** - Add his name, ID, House etc to our list of players
|
|
** - Re-sort the ID array
|
|
** - Place his units on the map
|
|
*/
|
|
case ADDPLAYER:
|
|
int i;
|
|
printf("ADDPLAYER EVENT!\n");
|
|
for (i=0;i<(int)Data.Variable.Size;i++) {
|
|
printf("%d\n", ((char *)Data.Variable.Pointer)[i]);
|
|
}
|
|
if (ID != PlayerPtr->ID) {
|
|
delete [] Data.Variable.Pointer;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// This event tells all systems to use new timing values. It's like
|
|
// RESPONSE_TIME, only it works. It's only used with the
|
|
// COMM_MULTI_E_COMP protocol.
|
|
//
|
|
case TIMING:
|
|
#if(TIMING_FIX)
|
|
//
|
|
// If MaxAhead is about to increase, we're vulnerable to a Packet-
|
|
// Received-Too-Late error, if any system generates an event after
|
|
// this TIMING event, but before it executes. So, record the
|
|
// period of vulnerability's frame start & end values, so we
|
|
// can reschedule these events to execute after it's over.
|
|
//
|
|
if (Data.Timing.MaxAhead > Session.MaxAhead) {
|
|
NewMaxAheadFrame1 = Frame;
|
|
NewMaxAheadFrame2 = Frame + Data.Timing.MaxAhead;
|
|
}
|
|
#endif
|
|
Session.DesiredFrameRate = Data.Timing.DesiredFrameRate;
|
|
Session.MaxAhead = Data.Timing.MaxAhead;
|
|
|
|
#ifndef WOLAPI_INTEGRATION
|
|
/*
|
|
** If spawned from WChat then we should be getting poked every minute. If not then
|
|
** deliberately break the max ahead value
|
|
*/
|
|
#ifdef WIN32
|
|
if (Special.IsFromWChat) {
|
|
Session.MaxAhead += DDEServer.Time_Since_Heartbeat()/(70*60);
|
|
}
|
|
#endif //WIN32
|
|
#endif // !WOLAPI_INTEGRATION
|
|
if (Debug_Print_Events) {
|
|
printf("DesiredFrameRate:%d MaxAhead:%d ",
|
|
Session.DesiredFrameRate,
|
|
Session.MaxAhead);
|
|
}
|
|
|
|
break;
|
|
|
|
//
|
|
// This event tells all systems what the other systems' process
|
|
// timing requirements are; it's used to compute a desired frame rate
|
|
// for the game.
|
|
//
|
|
case PROCESS_TIME:
|
|
for (i = 0; i < Session.Players.Count(); i++) {
|
|
if (ID == Session.Players[i]->Player.ID) {
|
|
Session.Players[i]->Player.ProcessTime = Data.ProcessTime.AverageTicks;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
#ifdef FIXIT_VERSION_3 // Stalemate games.
|
|
case PROPOSE_DRAW:
|
|
if( ID == PlayerPtr->ID )
|
|
{
|
|
if( Scen.bOtherProposesDraw )
|
|
{
|
|
// Both sides agree to draw. Game will end in a tie.
|
|
Scen.bLocalProposesDraw = true;
|
|
break;
|
|
}
|
|
Scen.bLocalProposesDraw = true;
|
|
//PG Session.Messages.Add_Message( NULL, 0, TXT_WOL_DRAW_PROPOSED_LOCAL, PCOLOR_GOLD, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE );
|
|
}
|
|
else
|
|
{
|
|
if( Scen.bLocalProposesDraw )
|
|
{
|
|
// Both sides agree to draw. Game will end in a tie.
|
|
Scen.bOtherProposesDraw = true;
|
|
break;
|
|
}
|
|
char szMessage[ 100 ];
|
|
for (i = 0; i < Session.Players.Count(); i++)
|
|
{
|
|
if (ID == Session.Players[i]->Player.ID)
|
|
{
|
|
//PG sprintf( szMessage, TXT_WOL_DRAW_PROPOSED_OTHER, Session.Players[i]->Name );
|
|
break;
|
|
}
|
|
}
|
|
Scen.bOtherProposesDraw = true;
|
|
Session.Messages.Add_Message( NULL, 0, szMessage, PCOLOR_GOLD, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE );
|
|
}
|
|
Sound_Effect( VOC_INCOMING_MESSAGE );
|
|
break;
|
|
|
|
case RETRACT_DRAW:
|
|
if( ID == PlayerPtr->ID )
|
|
{
|
|
Scen.bLocalProposesDraw = false;
|
|
//PG Session.Messages.Add_Message( NULL, 0, TXT_WOL_DRAW_RETRACTED_LOCAL, PCOLOR_GOLD, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE );
|
|
}
|
|
else
|
|
{
|
|
char szMessage[ 100 ];
|
|
for (i = 0; i < Session.Players.Count(); i++)
|
|
{
|
|
if (ID == Session.Players[i]->Player.ID)
|
|
{
|
|
//PG sprintf( szMessage, TXT_WOL_DRAW_RETRACTED_OTHER, Session.Players[i]->Name );
|
|
break;
|
|
}
|
|
}
|
|
Scen.bOtherProposesDraw = false;
|
|
Session.Messages.Add_Message( NULL, 0, szMessage, PCOLOR_GOLD, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE );
|
|
}
|
|
Sound_Effect( VOC_INCOMING_MESSAGE );
|
|
break;
|
|
#endif
|
|
|
|
/*
|
|
** Default: do nothing.
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (Debug_Print_Events) {
|
|
printf("\n");
|
|
}
|
|
|
|
}
|