CnC_Remastered_Collection

GLOBALS.CPP (33480B)

---

 //
 // 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\globals.cpv   2.17   16 Oct 1995 16:52:22   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 : GLOBALS.CPP                                                  *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : September 10, 1993                                           *
  *                                                                                             *
  *                  Last Update : September 10, 1993   [JLB]                                   *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include "function.h"
 
 #ifdef JAPANESE
 bool ForceEnglish = false;
 #endif
 
 bool Debug_Quiet = false;
 bool Debug_Cheat = false;
 bool Debug_Remap = false;
 bool Debug_Icon = false;
 bool Debug_Flag = false;
 bool Debug_Lose = false;
 bool Debug_Win = false;
 bool Debug_Map = false;					// true = map editor mode
 bool Debug_Passable = false;			// true = show passable/impassable terrain
 bool Debug_Unshroud = false;			// true = hide the shroud
 bool Debug_Threat = false;
 bool Debug_Find_Path = false;
 bool Debug_Check_Map = false;			// true = validate the map each frame
 bool Debug_Playtest = false;
 int  In_Debugger = 0;
 bool Debug_Heap_Dump = false;			// true = print the Heap Dump
 bool Debug_Smart_Print = false;		// true = print everything that calls Smart_Printf
 bool Debug_Trap_Check_Heap = false;	// true = check the Heap
 bool Debug_Instant_Build = false;
 bool Debug_Force_Crash = false;
 
 
 TFixedIHeapClass<UnitClass>		Units;
 TFixedIHeapClass<FactoryClass>	Factories;
 TFixedIHeapClass<TerrainClass>	Terrains;
 TFixedIHeapClass<TemplateClass>	Templates;
 TFixedIHeapClass<SmudgeClass>		Smudges;
 TFixedIHeapClass<OverlayClass>	Overlays;
 TFixedIHeapClass<InfantryClass>	Infantry;
 TFixedIHeapClass<BulletClass>		Bullets;
 TFixedIHeapClass<BuildingClass>	Buildings;
 TFixedIHeapClass<AnimClass>		Anims;
 TFixedIHeapClass<AircraftClass>	Aircraft;
 TFixedIHeapClass<TriggerClass>	Triggers;
 TFixedIHeapClass<TeamTypeClass>	TeamTypes;
 TFixedIHeapClass<TeamClass>		Teams;
 TFixedIHeapClass<HouseClass>		Houses;
 
 
 #ifdef PATCH
 /***************************************************************************
 **	Compatibility with version 1.07 flag.
 */
 bool IsV107 = false;
 char OverridePath[128]=".";
 #endif
 
 
 /***************************************************************************
 **	This tracks all selected objects per house (for this map).
 */
 SelectedObjectsType CurrentObject;
 
 
 /***************************************************************************
 **	This holds the custom version text that is fetched from the version
 **	text file. This version is displayed on the options dialog.
 */
 char VersionText[16];
 
 
 /***************************************************************************
 **	This is the VQ animation controller structure. It is filled in by reading
 **	the PLAYER.INI and overridden through program control.
 */
 //PG_TO_FIX
 //VQAConfig AnimControl;
 
 int PreserveVQAScreen;			// Used for screen mode transition control.
 bool BreakoutAllowed = true;	// "true" if aborting of movies is allowed.
 bool Brokeout;						// Was the movie broken out of?
 bool SlowPalette = true;		// Slow palette flag set?
 
 
 /***************************************************************************
 **	These are the movie names to use for mission briefing, winning, and losing
 **	sequences. They are read from the INI file.
 */
 char IntroMovie[_MAX_FNAME+_MAX_EXT];
 char BriefMovie[_MAX_FNAME+_MAX_EXT];
 char WinMovie[_MAX_FNAME+_MAX_EXT];
 char WinMovie2[_MAX_FNAME + _MAX_EXT];
 char WinMovie3[_MAX_FNAME + _MAX_EXT];
 char WinMovie4[_MAX_FNAME + _MAX_EXT];
 char LoseMovie[_MAX_FNAME+_MAX_EXT];
 char ActionMovie[_MAX_FNAME+_MAX_EXT];
 char MovieThemeName[_MAX_FNAME + _MAX_EXT];
 char BriefingText[512];
 ThemeType TransitTheme = THEME_NONE;
 
 
 /***************************************************************************
 **	This records the view hotspots for the player. These are the cell numbers
 **	of the upper left corner for the view position.
 */
 CELL Views[4];
 
 
 /***************************************************************************
 **	This is the pending speech sample to play. This sample will be played
 **	at the first opportunity.
 */
 VoxType SpeakQueue = VOX_NONE;
 
 
 /***************************************************************************
 **	This records if the score (music) file is present. If not, then much of
 **	the streaming score system can be disabled.
 */
 bool ScoresPresent;
 
 
 /***************************************************************************
 **	This flag will control whether there is a response from game units.
 **	By carefully controlling this global, multiple responses are supressed
 **	when a large group of infantry is given the movement order.
 */
 bool AllowVoice = true;
 
 
 /***************************************************************************
 **	This counts the number of crates on the map. When this value reaches zero,
 **	then a timer is started that will control crate creation.
 */
 int CrateCount;
 TCountDownTimerClass CrateTimer;
 bool CrateMaker = false;
 
 
 /***************************************************************************
 **	This is the current frame number. This number is guaranteed to count
 **	upward at the rate of one per game logic process. The target rate is 15
 **	per second. This value is saved and restored with the saved game.
 */
 long Frame = 0;
 
 
 /***************************************************************************
 **	These globals are constantly monitored to determine if the player
 **	has won or lost. They get set according to the trigger events associated
 **	with the scenario.
 */
 bool PlayerWins;
 bool PlayerLoses;
 bool PlayerRestarts;
 
 /*
 ** This flag is set if the player neither wins nor loses; it's mostly for
 ** multiplayer mode.
 */
 bool PlayerAborts;
 
 
 /***************************************************************************
 **	This is the pointer for the speech staging buffer. This buffer is used
 **	to hold the currently speaking voice data. Since only one speech sample
 **	is played at a time, this buffer is only as big as the largest speech
 **	sample that can be played.
 */
 void * SpeechBuffer;
 
 
 /***************************************************************************
 **	This is a running accumulation of the number of ticks that were unused.
 ** This accumulates into a useful value that contributes to a
 **	histogram of game performance.
 */
 long SpareTicks;
 
 
 /***************************************************************************
 **	This is a special scenario count down value. End of game condition will
 **	not be checked until this value reaches zero.
 */
 int EndCountDown;
 
 
 /***************************************************************************
 **	When the player sabotages a building (scenario #6 GDI only) then when
 **	the next scenario starts, that building will already be destroyed.
 */
 StructType SabotagedType;
 
 
 /***************************************************************************
 **	If the Nod temple was destroyed by the ion cannon, then this flag will
 **	be set to true.
 */
 bool TempleIoned = false;
 
 
 /***************************************************************************
 **	This is the monochrome debug page array. The various monochrome data
 **	screens are located here.
 */
 MonoClass MonoArray[MonoClass::MAX_MONO_PAGES];
 int MonoPage;			// The current page.
 
 
 /***************************************************************************
 **	This is true if the game is the currently in focus windows app
 **
 */
 bool GameInFocus = true;
 
 /***************************************************************************
 **	This holds the theater specific mixfiles.
 */
 MixFileClass *TheaterData = NULL;
 MixFileClass *TheaterIcons = NULL;
 MixFileClass *LowTheaterData;
 MixFileClass *MoviesMix = 0;
 MixFileClass *GeneralMix = 0;
 MixFileClass *ScoreMix = 0;
 
 
 /***************************************************************************
 **	This is the options control class. The options control such things as
 **	game speed, visual controls, and other user settings.
 */
 GameOptionsClass Options;
 
 
 /***************************************************************************
 **	Logic processing is controlled by this element. It handles both graphic
 **	and AI logic.
 */
 LogicClass Logic;
 
 
 /***************************************************************************
 **	This handles the background music.
 */
 ThemeClass Theme;
 
 
 /***************************************************************************
 **	This is the main control class for the map.
 */
 #ifdef SCENARIO_EDITOR
 MapEditClass Map;
 #else
 MouseClass Map;
 #endif
 
 /**************************************************************************
 **	The running game score is handled by this class (and member functions).
 */
 ScoreClass Score;
 
 
 /***************************************************************************
 **	The running credit display is controlled by this class (and member
 **	functions.
 */
 CreditClass CreditDisplay;
 
 
 /***************************************************************************
 **	These are the bits that are set when the appropriate tutor message
 **	has been displayed. Once the message has been displayed, it will not be
 **	displayed again.
 */
 long TutorFlags[2];
 
 
 /**************************************************************************
 ** This class records the special command override options that C&C
 **	supports.
 */
 SpecialClass Special;
 
 
 /***************************************************************************
 **	General rules that control the game.
 */
 RulesClass Rule;
 
 
 /***************************************************************************
 **	This is the scenario data for the currently loaded scenario.
 ** These variables should all be set together.
 */
 HousesType Whom;							// Initial command line house choice.
 unsigned Scenario;						// Scenario #
 ScenarioPlayerType ScenPlayer;		// GDI, NOD, 2-Player, Multi-Player
 ScenarioDirType ScenDir;				// East/West
 ScenarioVarType ScenVar;				// variation A/B/C
 char ScenarioName[_MAX_FNAME+_MAX_EXT];	// name of scenario
 int CarryOverMoney;						// Carry over money from last scenario.
 int CarryOverPercent;					// Carry over money percentage control.
 int CarryOverCap;							// Maxmimum carry over money allowed.
 int ScenarioInit;
 bool SpecialFlag = false;
 
 
 /***************************************************************************
 ** This value tells the sidebar what items it's allowed to add.  The
 ** lower the value, the simpler the sidebar will be.
 */
 unsigned BuildLevel = 3;				// Buildable level (1 = simplest)
 
 
 /***************************************************************************
 ** This value is computed every time a new scenario is loaded; it's a
 ** CRC of the INI and binary map files.
 */
 unsigned long ScenarioCRC;
 
 
 /***************************************************************************
 **	The various tutor and dialog messages are located in the data block
 **	referenced by this pointer.
 */
 char const * SystemStrings;
 
 
 /***************************************************************************
 **	The game plays as long as this var is true.
 */
 bool GameActive;
 
 
 /***************************************************************************
 **	This is a scratch variable that is used to when a reference is needed to
 **	a long, but the value wasn't supplied to a function. This is used
 **	specifically for the default reference value. As such, it is not stable.
 */
 long LParam;
 
 
 #ifdef SCENARIO_EDITOR
 /***************************************************************************
 ** The currently-selected cell for the Scenario Editor
 */
 CELL CurrentCell = 0;
 #endif
 
 
 /***************************************************************************
 **	Most of the text in the game will use the six point font. These are the
 **	pointers to the fonts. If it is NULL, then the font hasn't been loaded
 **	yet.
 */
 void const *Green12FontPtr;			// Green font for pressed in tabs
 void const *Green12GradFontPtr;   // Graduated green font for tabs
 void const *MapFontPtr;				// Standard very small font.
 void const *Font3Ptr;					// Standard very small font.
 void const *Font6Ptr;					// Standard small font.
 void const *Font8Ptr;					// 8 point proportional.
 void const *FontLEDPtr;				// LED fixed point font.
 void const *VCRFontPtr;				// VCR font pointer.
 void const *ScoreFontPtr;			// font for score & map selection screens
 void const *GradFont6Ptr;			// gradient 6 point font pointer.
 
 
 /***************************************************************************
 **	This is the house that the human player is currently playing.
 */
 HouseClass * PlayerPtr;
 
 
 /***************************************************************************
 **	Special palettes for MCGA mode goes here. These palette buffers are used
 **	for pictures that do not use the game palette or are used for fading to
 **	black.
 */
 unsigned char *GamePalette;
 unsigned char *BlackPalette;
 unsigned char *WhitePalette;
 unsigned char *OriginalPalette;
 unsigned char *Palette;
 
 
 /***************************************************************************
 **	These are the event queues. One is for holding events until they are ready to be
 **	sent to the remote computer for processing. The other list is for incoming events
 **	that need to be executed when the correct frame has been reached.
 */
 QueueClass<EventClass, MAX_EVENTS> OutList;
 QueueClass<EventClass, (MAX_EVENTS * 8)> DoList;
 
 
 /***************************************************************************
 **	These are arrays/lists of trigger pointers for each cell & the houses.
 */
 DynamicVectorClass<TriggerClass *> CellTriggers;
 DynamicVectorClass<TriggerClass *> HouseTriggers[HOUSE_COUNT];
 
 
 /***************************************************************************
 **	This is an array of waypoints; each waypoint corresponds to a letter of
 ** the alphabet, and points to a cell number.  -1 means unassigned.
 ** The CellClass has a bit that tells if that cell has a waypoint attached to
 ** it; the only way to find which waypoint it is, is to scan this array.  This
 ** shouldn't be needed often; usually, you know the waypoint & you want the CELL.
 */
 CELL Waypoint[WAYPT_COUNT];
 
 
 /***************************************************************************
 **	This is the list of BuildingTypes that define the AI's base.
 */
 BaseClass Base;
 
 
 /***************************************************************************
 **	This value tells what type of multiplayer game we're playing.
 */
 GameType GameToPlay = GAME_NORMAL;
 
 
 /***************************************************************************
 **	This is the current communications protocol
 */
 CommProtocolType CommProtocol;
 
 
 /***************************************************************************
 **	These values are used for recording & playing back a game.
 */
 CCFileClass RecordFile ("RECORD.BIN");
 int RecordGame = 0;			// 1 = record a game
 int SuperRecord = 0;			// 1 = reopen record file with every write
 int PlaybackGame= 0;			// 1 = play back a game
 int AllowAttract = 0;		// 1 = allow attract mode
 
 
 /***************************************************************************
 **	This is the null modem manager class.  Declaring this class doesn't
 ** perform any allocations;
 ** the class itself is ?? bytes.
 */
 #if (0)	//PG_TO_FIX
 bool ModemService = true;					// When false disable servicing modem.
 NullModemClass NullModem (
    16,											// number of send entries
 	64,											// number of receive entries
 //	sizeof (EventClass) * MAX_EVENTS,	// maxlen of entry buffer
 	(200 / sizeof(EventClass) ) * sizeof(EventClass) + sizeof( CommHeaderType ),
 	0x1234);										// Magic number must have each digit unique
 													// and different from the queue magic number
 
 
 DynamicVectorClass <PhoneEntryClass *> PhoneBook;
 int CurPhoneIdx;								// current phonebook index, for dialing
 
 DynamicVectorClass <char *> InitStrings;
 
 SerialSettingsType SerialDefaults;		// serial port default settings
 
 //ModemGameType ModemGameToPlay;			// type of modem play Dialer, answerer, null
 
 char *DialMethodCheck[ DIAL_METHODS ] = {
 	"T",
 	"P"
 };
 
 char *CallWaitStrings[ CALL_WAIT_STRINGS_NUM ] = {
 	"*70,",
 	"70#,",
 	"1170,",
 	"CUSTOM -                "
 };
 #endif
 
 ModemGameType ModemGameToPlay;			// type of modem play Dialer, answerer, null
 
 /***************************************************************************
 **	Index into scenario description list box
 */
 int ScenarioIdx;
 
 
 /***************************************************************************
 **	This array of flags tells if the given colors have been used, or are
 */
 int ColorUsed[MAX_MPLAYER_COLORS];
 
 
 /***************************************************************************
 **	This string stores the player's name.
 */
 char MPlayerName[MPLAYER_NAME_MAX];
 
 
 /***************************************************************************
 **	This is the array of remap colors.  Each player in a network game is
 ** assigned one of these colors.  The 'G' is for graphics drawing; the 'T'
 ** is for text printing (indicates a remap table for the font to use).
 */
 int MPlayerGColors[MAX_MPLAYER_COLORS] = {
 	5, 			// Yellow
 	127, 			// Red
 	135, 			// BlueGreen
 	26,			// Orange
 	4,				// Green
 	202			// Blue-Grey
 };
 
 int MPlayerTColors[MAX_MPLAYER_COLORS] = {
 	CC_GDI_COLOR, 			// Yellow
 	CC_NOD_COLOR, 			// Red
 	CC_BLUE_GREEN, 		// BlueGreen
 	CC_ORANGE,				// Orange	//26
 	CC_GREEN,				// Green
 	CC_BLUE_GREY,			// Blue
 };
 
 
 /***************************************************************************
 **	This is a list of all the names of the multiplayer scenarios that use
 ** bases (production), and those that don't.  There is a list for
 ** descriptions, and another for actual filenames.
 */
 char MPlayerDescriptions[100][40];
 DynamicVectorClass <char *> MPlayerScenarios;
 DynamicVectorClass <int> MPlayerFilenum;
 
 
 /***************************************************************************
 **	This value determines the max allowable # of players.
 */
 int MPlayerMax = 6;
 
 
 /***************************************************************************
 **	Multiplayer game options
 */
 int MPlayerPrefColor;			// preferred color index for this player
 int MPlayerColorIdx;				// actual color index of this player
 HousesType MPlayerHouse;		// House of this player (GDI/NOD)
 unsigned char MPlayerLocalID;	// ID of this player
 int MPlayerCount;					// # of human players in this game
 int MPlayerBases;					// 1 = bases are on for this scenario
 int MPlayerCredits;				// # credits everyone gets
 int MPlayerTiberium;				// 1 = tiberium enabled for this scenario
 int MPlayerGoodies;				// 1 = goodies enabled for this scenario
 int MPlayerGhosts;				// 1 = houses with no players will still play
 int MPlayerSolo = 0;				// 1 = allows a single-player net game
 int MPlayerUnitCount = 10;		// # units for non-base multiplayer scenarios
 
 
 /*---------------------------------------------------------------------------
 Min & Max unit count values; index0 = bases OFF, index1 = bases ON
 ---------------------------------------------------------------------------*/
 int MPlayerCountMin[2] = {1,0};
 int MPlayerCountMax[2] = {50,12};
 
 
 /*---------------------------------------------------------------------------
 MPlayerMaxAhead is the number of frames ahead of this one to execute a given
 packet.  It's set by the RESPONSE_TIME event.
 ---------------------------------------------------------------------------*/
 unsigned long MPlayerMaxAhead = 3;
 
 
 /*---------------------------------------------------------------------------
 'FrameSendRate' is the # frames between data packets
 'FrameRateDelay' is the time ticks to wait between frames, for smoothing.
 ---------------------------------------------------------------------------*/
 unsigned long FrameSendRate;
 
 
 /***************************************************************************
 **	Multiplayer ID's, stored in order of event execution.
 ** Format:
 ** bits 0-3: the "preferred" house of the player (GDI/NOD)
 ** bits 4-7: the player's Color Index
 ** These values are used as the IPX connection ID's.
 */
 unsigned char MPlayerID [MAX_PLAYERS];
 
 
 /***************************************************************************
 ** This array stores the actual HousesType for all players (MULT1, etc).
 */
 HousesType MPlayerHouses [MAX_PLAYERS];
 
 
 /***************************************************************************
 ** This array stores the names of all players in a multiplayer game.
 */
 char MPlayerNames [MAX_PLAYERS][MPLAYER_NAME_MAX];
 
 
 /***************************************************************************
 **	This is a list of the messages received from / sent to other players,
 ** the address to send to (IPX only), and the last message received or
 ** sent (for the computer's messages).
 */
 MessageListClass Messages;
 IPXAddressClass MessageAddress;
 char LastMessage[MAX_MESSAGE_LENGTH];
 
 
 /***************************************************************************
 ** If this flag is set, computer AI will blitz the humans all at once;
 ** otherwise, the computer units trickle gradually out.
 */
 int MPlayerBlitz = 0;
 
 
 /***************************************************************************
 ** If this flag is set, we can move around the map, but we can't do anything.
 ** It means we've been defeated, but we're still allowed to watch the action.
 */
 int MPlayerObiWan = 0;
 
 
 /***************************************************************************
 ** These variables keep track of the multiplayer game scores.
 */
 MPlayerScoreType MPlayerScore[MAX_MULTI_NAMES];
 int MPlayerGamesPlayed;					// # games played this run
 int MPlayerNumScores;					// # active entries in MPlayerScore
 int MPlayerWinner;						// index of winner of last game
 int MPlayerCurGame;						// index of current game being played
 
 
 //
 // This array stores the processing time required by all multiplayer systems.
 // The values are stored in the same order as the 'MPlayerID' array.
 //
 int TheirProcessTime[MAX_PLAYERS - 1];
 int DesiredFrameRate;
 
 
 /***************************************************************************
 ** These values are used purely for the Mono debug display.  They show the
 ** names of the Global Channel packet types, and the event types.
 */
 char *GlobalPacketNames[] = {
 	"Game?",
 	"Game!",
 	"Player?",
 	"Player!",
 	"Join?",
 	"Join!",
 	"Reject",
 	"GameOptions",
 	"Sign Off",
 	"GO!",
 	"Message",
 	"Ping"
 };
 
 
 // yeah, there's 100 empty names here, because the SerialCommandType starts at 100.
 char *SerialPacketNames[] = {
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"",
 	"CONNECT",
 	"GAME_OPTIONS",
 	"SIGN_OFF",
 	"GO",
 	"MESSAGE",
 	"TIMING",
 	"SCORE_SCREEN",
 	"LAST_COMMAND",
 };
 
 
 /***************************************************************************
 **	These variables are just to help find sync bugs.
 */
 long TrapFrame = 0x7fffffff;				// frame to start trapping object values at
 RTTIType TrapObjType = RTTI_NONE;		// type of object to trap
 TrapObjectType TrapObject = {NULL};		// ptr to object being trapped
 COORDINATE TrapCoord = 0;							// COORD of object to trap
 void *TrapThis = NULL;						// 'this' ptr of object to trap
 CellClass *TrapCell = NULL;				// for trapping a cell
 int TrapCheckHeap = 0;						// start checking the Heap
 
 
 /***************************************************************************
 **	This is the network IPX manager class.  It handles multiple remote
 ** connections.  Declaring this class doesn't perform any allocations;
 ** the class itself is 140 bytes.
 */
 IPXManagerClass Ipx (
 	sizeof (GlobalPacketType),						// size of Global Channel packets
 	((546 - sizeof(CommHeaderType)) / sizeof(EventClass) ) * sizeof(EventClass),
 	10, 													// # entries in Global Queue
 	8, 													// # entries in Private Queues
 	VIRGIN_SOCKET, 									// Socket ID #
 	IPXGlobalConnClass::COMMAND_AND_CONQUER);	// Product ID #
 
 
 //#if(TIMING_FIX)
 //
 // These values store the min & max frame #'s for when MaxAhead >>increases<<.
 // If MaxAhead increases, and the other systems free-run to the new MaxAhead
 // value, they may miss an event generated after the MaxAhead event was sent,
 // but before it executed, since it will have been scheduled with the older,
 // shorter MaxAhead value.  This will cause a Packet_Received_Too_Late error.
 // The frames from the point where the new MaxAhead takes effect, up to that
 // frame Plus the new MaxAhead, represent a "period of vulnerability"; any
 // events received that are scheduled to execute during this period should
 // be re-scheduled for after that period.
 //
 int NewMaxAheadFrame1;
 int NewMaxAheadFrame2;
 //#endif
 
 /***************************************************************************
 **	This is the user-specified IPX address of a desired game owner machine.
 ** Use this to cross a bridge.  Only the 1st 4 numbers in the address are
 ** used; the rest are set to ff's, for broadcasting.  'IsBridge' is set
 ** if this address should be used.
 */
 int IsBridge = 0;
 IPXAddressClass BridgeNet;
 
 
 /***************************************************************************
 **	This flag is true if the user has requested that this game be "secret"
 ** (The game will not appear to other systems just starting up.)
 */
 bool NetStealth = false;
 
 
 /***************************************************************************
 **	If this flag is true, the user won't receive messages from any player
 ** other than those in his own game. It defaults to protected mode.
 */
 bool NetProtect = true;
 
 
 /***************************************************************************
 **	This flag indicates whether the game is "open" or not to other network players.
 */
 bool NetOpen = false;
 
 
 /***************************************************************************
 **	This string stores the game's network name.
 ** GameName does not include the "'s Game"; comparing GameName to
 ** PlayerName can determine if this player is the originator of the game.
 */
 char MPlayerGameName[MPLAYER_NAME_MAX];
 
 
 /***************************************************************************
 **	These variables are for servicing the Global Channel.
 */
 GlobalPacketType GPacket;				// Global Channel packet
 int GPacketlen;							// length of incoming packet
 IPXAddressClass GAddress;				// address of sender
 unsigned short GProductID;				// sender's Product ID
 
 
 /***************************************************************************
 **	This is the "meta-packet"; it's a bunch of events lumped together.
 ** The packet's size is IPX's max size (546), rounded down to accommodate
 ** the max number of events possible.
 */
 char *MetaPacket = 0;
 int MetaSize = ((546 - sizeof(CommHeaderType)) / sizeof(EventClass) ) * sizeof(EventClass);
 
 
 /***************************************************************************
 **	This is the random-number seed; it's synchronized between systems for
 ** multiplayer games.
 */
 int Seed = 0;
 long *RandSeedPtr;
 
 
 /***************************************************************************
 ** If this value is non-zero, use it as the random # seed instead; this should
 ** help reproduce some bugs.
 */
 int CustomSeed = 0;
 
 int WindowList[][8] = {
 /* xbyte, ypixel, bytewid, pixelht, cursor color, bkgd color,	cursor x, cursor y */
 
 	/* do not change the first 2 entries!! they are necc. to the system */
 	{0,0,40,200,WHITE,BLACK,0,0},	/* screen window */
 	{1,75,38,100,WHITE,BLACK,0,0},	/* DOS Error window */
 
 	// Tactical map.
 	{0, 0, 40, 200, WHITE,LTGREY,0,0},
 
 	// Initial menu window.
 	{12, 199-42, 16, 42, LTGREY, DKGREY, 0, 0},
 
 	// Sidebar clipping window.
 	{0,0,0,0,0,0,0,0},
 
 	// Scenario editor window.
 	{5, 30, 30, 140, 0, 0, 0, 0},
 
 	// Custom window.
 	{0, 0, 0, 0, 0, 0, 0, 0},
 
 	// Virtual window for external rendering. ST - 1/15/2019 3:02PM
 	{0, 0, 0, 0, 0, 0, 0, 0},
 };
 
 
 /* X,Y,Item Width,Items High,Selected,Norm Color,Sel Color,zero 	*/
 int MenuList[][8]={
 		{1, 3, 12, 3, 0, WHITE, PINK, 0},
 };
 
 GraphicBufferClass		VisiblePage;
 GraphicBufferClass		HiddenPage;
 
 GraphicViewPortClass	SeenBuff(&VisiblePage, 0,0,1536,1536);
 GraphicBufferClass		ModeXBuff;
 GraphicViewPortClass	HidPage(&HiddenPage, 0,0, 1536,1536);
 GraphicBufferClass		SysMemPage(DEFAULT_SCREEN_WIDTH, 200, (void*)NULL);
 int 						SoundOn;
 CountDownTimerClass	FrameTimer(BT_SYSTEM, 0L);
 CountDownTimerClass	DebugTimer(BT_SYSTEM, 0L);
 CountDownTimerClass	CountDownTimer(BT_SYSTEM, 0L);
 
 NewConfigType NewConfig;
 
 /***************************************************************************
 **	This timer measures how long (in ticks) it takes to process the game's
 ** logic, with no packet processing or artificial delays.
 */
 TimerClass ProcessTimer;
 int ProcessTicks;				// accumulated ticks
 int ProcessFrames;			// # frames used to measure 'ProcessTicks'
 
 
 /***************************************************************************
 **	This flag is for popping up dialogs that call the main loop.
 */
 SpecialDialogType SpecialDialog = SDLG_NONE;
 
 
 /*
 ** This flags if used to tell can enter cell that we are in a find path
 ** check and thus should not uncloak units via Can_Enter_Cell.
 */
 //bool	IsFindPath = false;
 
 
 /***************************************************************************
 **	Globals for the network Dialogs.
 */
 
 /*
 **	List of all games out there, & the address of the game's owner
 */
 DynamicVectorClass <NodeNameType *> Games;
 
 /*
 **	List of names & addresses of all the players in the game I'm joining.
 **	This is the really critical list, since it's used to form connections with
 **	all other players in my game.  It's updated when I get a response to my
 **	outgoing query, or when I get a query from another system in my game asking
 **	who I am.  This double-insurance means that if any system knows about me,
 **	I know about them too.  The only catch is that if the game is started very,
 **	very soon after a player joins, not everyone may know about him; to prevent
 **	this, a timer restriction is put on the New Game dialog's GO button.
 */
 DynamicVectorClass <NodeNameType *> Players;
 
 char *DebugFname;	// for stoopid debugging purposes
 int DebugLine;		// for stoopid debugging purposes
 #ifdef DEMO
 int RequiredCD = -2;
 #else
 int RequiredCD = -1;
 #endif
 int MouseInstalled;
 
 /*
 ** Certain options must be enabled by both a command-line option, and an
 ** an entry in an INI file.  If this flag is 'true', those options have been
 ** enabled by the INI file.
 */
 int AreThingiesEnabled = false;
 
 
 /*
 ** Pointer to windows timer object
 **
 **
 */
 
 WinTimerClass	*WindowsTimer=NULL;
 
 
 /*
 ** Command line arguments
 **
 **
 */
 char *				Argv[20];		//Pointers to command line arguments
 int					Argc;				//Command line argument count
 
 
 WWKeyboardClass	Kbd;
 int					ScreenWidth=1536;
 int					ScreenHeight=1536;
 WWMouseClass		*WWMouse = NULL;
 HANDLE hInstance;
 int AllDone;
 BOOL				InMovie = FALSE;	//Are we currently playing a VQ movie?
 bool				MMXAvailable = false;	//Does this CPU support MMX extensions?
 //GetCDClass		CDList;
 bool				GameStatisticsPacketSent;
 bool				ConnectionLost;
 
 TheaterType		LastTheater = THEATER_NONE;
 
 
 bool RunningAsDLL = false;