Remastered-Collection/REDALERT/EVENT.H

//
// 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.H 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.H                                                      *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : 12/09/94                                                     *
 *                                                                                             *
 *                  Last Update : December 9, 1994 [JLB]                                       *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#ifndef EVENT_H
#define EVENT_H

/*
**	This event class is used to contain all external game events (things that the player can
**	do at any time) so that these events can be transported between linked computers. This
**	encapsulation is required in order to ensure that each event affects all computers at the
**	same time (same game frame).
** NOTE: If you add or remove an event type, you must also update the globals
** EventLength[] and EventNames[].
*/
class EventClass
{
	public:

		/*
		**	All external events are identified by these labels.
		*/
		typedef enum EventType : unsigned char	{
			EMPTY,

			ALLY,					// Make allie of specified house.
			MEGAMISSION,		// Full change of mission with target and destination.
			MEGAMISSION_F,		// Full change of mission with target and destination, and formation overrides.
			IDLE,					// Request to enter idle mode.
			SCATTER,				// Request to scatter from current location.
			DESTRUCT,			// Self destruct request (surrender action).
			DEPLOY,				// MCV is to deploy at current location.
			PLACE,				// Place building at location specified.
			OPTIONS,				// Bring up options screen.
			GAMESPEED,			// Set game speed
			PRODUCE,				// Start or Resume production.
			SUSPEND,				// Suspend production.
			ABANDON,				// Abandon production.
			PRIMARY,				// Primary factory selected.
			SPECIAL_PLACE,		// Special target location selected
			EXIT,					// Exit game.
			ANIMATION,			// Flash ground as movement feedback.
			REPAIR,				// Repair specified object.
			SELL,					//	Sell specified object.
			SELLCELL,			// Sell wall at specified cell.
			SPECIAL,				// Special options control.

			// Private events.
			FRAMESYNC,			// Game-connection packet; includes Scenario CRC & sender's frame #
									// Used to initiate game connection phase & to reconnect;
									// When one of these is received, the receiver knows there are
									// no associated commands in this packet.
			MESSAGE,				// Message to another player (The message is the 40 bytes
									// after the event class).
			RESPONSE_TIME,		// use a new propagation delay value
			FRAMEINFO,			// Game-heartbeat packet; includes Game CRC & command count
									// All packets sent for a frame are prefixed with one of these
			SAVEGAME,			// allows multiplayer games to save
			ARCHIVE,				// Updates archive target on specified object.
			ADDPLAYER,			// Add a new player

			TIMING,				// new timing values for all systems to use
			PROCESS_TIME,		// a system's average processing time, in ticks per frame

#ifdef FIXIT_VERSION_3		//	Stalemate games.
			PROPOSE_DRAW,		//	Players proposes that 2-player game be called a stalemate.
			RETRACT_DRAW,		//	Player retracts proposed draw offer.
#endif

			LAST_EVENT,			// one past the last event
		} EventType;

		EventType Type;		// Type of queue command object.

		/*
		** 'Frame' is the frame that the command should execute on.
		** 27 bits gives over 25 days of playing time without wrapping,
		** at 30 frames per second, so it should be plenty!
		*/
		unsigned Frame : 26;

		/*
		** House index of the player originating this event
		*/
		unsigned ID : 5;

		/*
		** This bit tells us if we've already executed this event.
		*/
		unsigned IsExecuted: 1;

		/*
		**	This union contains the specific data that the event requires.
		*/
		union {
			struct {
				SpecialClass	Data;		// The special option flags.
			} Options;
			struct {
				CELL			Cell;			// The cell to sell wall at.
			} SellCell;
			struct {
				xTargetClass	Whom;			// The object to apply the event to.
			} Target;
			struct {
				AnimType		What;			// The animation to create.
				HousesType	Owner;		// The owner of the animation (when it matters).
				COORDINATE			Where;		// The location to place the animation.
				int			Visible;	// Who this animation is visible to.
			} Anim;
			struct {
				int 			Value;		// general-purpose data
			} General;
			struct {
				xTargetClass	Whom;			// Whom to apply mission to.
				MissionType	Mission;		// What mission to apply.
				xTargetClass	Target;		// Target to assign.
				xTargetClass	Destination;// Destination to assign.
			} MegaMission;
			struct {
				xTargetClass	Whom;			// Whom to apply mission to.
				MissionType	Mission;		// What mission to apply.
				xTargetClass	Target;		// Target to assign.
				xTargetClass	Destination;// Destination to assign.
				SpeedType	Speed;		// Formation override speed.
				MPHType		MaxSpeed;	// Formation override maximum speed.
			} MegaMission_F;
			struct {
				xTargetClass	Whom;			// Whom to apply mission to.
				MissionType Mission;		// What mission to apply.
			} Mission;
			struct {
				xTargetClass	Whom;			// Whom to apply movement change to.
				xTargetClass	Where;		// Where to set NavCom to.
			} NavCom;
			struct {
				xTargetClass	Whom;			// Whom to apply attack change to.
				xTargetClass	Target;		// What to set TarCom to.
			} TarCom;
			struct {
				RTTIType		Type;
				int			ID;
			} Specific;
			struct {
				RTTIType		Type;
				CELL			Cell;
			} Place;
			struct {
				int			ID;
				CELL			Cell;
			} Special;

			/*
			** This structure is used for FRAMEINFO, FRAMESYNC, and RESPONSE_TIME
			** events; exactly one of these will be sent each frame, whether there's
			** data that frame or not.
			** CRC: the game CRC when this packet was generated; used to detect sync errors
			** CommandCount: # of commands the sender has sent; used to detect missed packets
			** Delay: sender's propagation delay value for this frame
			*/
			struct {
				unsigned long CRC;
				unsigned short CommandCount;	// # commands sent so far
				unsigned char Delay;				// propagation delay used this frame
														// (Frame - Delay = sender's current frame #)
			} FrameInfo;
			/*
			** This structure is used for the special variable-length event.  This event
			** can be anything the application wants it to be.  Its purpose is to allow
			** relatively large amounts of data to be associated with the event, without
			** bloating the size of this union (and thus all other event types).
			*/
			struct {
				void * Pointer;
				unsigned long Size;
			} Variable;

			//
			// This structure sets new timing values for all systems in a multiplayer
			// game.  This structure replaces the RESPONSE_TIME event for
			// the COMM_MULTI_E_COMP protocol.
			//
			struct {
				unsigned short DesiredFrameRate;
				unsigned short MaxAhead;
			} Timing;

			//
			// This structure is transmitted by all systems, and is used to compute
			// the "desired" frame rate for the game.
			//
			struct {
				unsigned short AverageTicks;
			} ProcessTime;

		} Data;

		//-------------- Constructors ---------------------
		EventClass(void) {Type = EMPTY;};
		EventClass(SpecialClass data);
		EventClass(EventType type, TargetClass target);
		EventClass(EventType type);
		EventClass(EventType type, int val);
		EventClass(EventType type, CELL cell);
		EventClass(EventType type, TargetClass src, TargetClass dest);
		EventClass(TargetClass src, MissionType mission, TargetClass target=TARGET_NONE, TargetClass destination=TARGET_NONE);

		EventClass(TargetClass src, MissionType mission, TargetClass target, TargetClass destination, SpeedType speed, MPHType maxspeed);

		EventClass(EventType type, RTTIType object, int id);
		EventClass(EventType type, RTTIType object, CELL cell);
		EventClass(EventType type, int id, CELL cell);
		EventClass(AnimType anim, HousesType owner, COORDINATE coord, int visible = -1);
		EventClass(void *ptr, unsigned long size);
		EventClass(EventType type, void *ptr, unsigned long size);

		// Process the event.
		void Execute(void);

		int operator == (EventClass & q) {
			return memcmp(this, &q, sizeof(q)) == 0;
		};

		static unsigned char EventLength[LAST_EVENT];
		static char * EventNames[LAST_EVENT];
};

#endif