819 lines
28 KiB
C++
819 lines
28 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/GLOBALS.CPP 2 3/10/97 6:22p Steve_tall $ */
|
|
/***********************************************************************************************
|
|
*** 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"
|
|
|
|
bool IsVQ640 = false;
|
|
unsigned long GameVersion = 0;
|
|
bool Debug_MotionCapture = false;
|
|
bool Debug_Rotate = false; // Rotation algorithm control.
|
|
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;
|
|
|
|
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_Modem_Dump = false; // true = print the Modem Stuff
|
|
bool Debug_Print_Events = false; // true = print event & packet processing
|
|
bool Debug_Force_Crash = false;
|
|
|
|
TFixedIHeapClass<AircraftClass> Aircraft;
|
|
TFixedIHeapClass<AnimClass> Anims;
|
|
TFixedIHeapClass<BuildingClass> Buildings;
|
|
TFixedIHeapClass<BulletClass> Bullets;
|
|
TFixedIHeapClass<FactoryClass> Factories;
|
|
TFixedIHeapClass<HouseClass> Houses;
|
|
TFixedIHeapClass<InfantryClass> Infantry;
|
|
TFixedIHeapClass<OverlayClass> Overlays;
|
|
TFixedIHeapClass<SmudgeClass> Smudges;
|
|
TFixedIHeapClass<TeamClass> Teams;
|
|
TFixedIHeapClass<TeamTypeClass> TeamTypes;
|
|
TFixedIHeapClass<TemplateClass> Templates;
|
|
TFixedIHeapClass<TerrainClass> Terrains;
|
|
TFixedIHeapClass<TriggerClass> Triggers;
|
|
TFixedIHeapClass<UnitClass> Units;
|
|
TFixedIHeapClass<VesselClass> Vessels;
|
|
TFixedIHeapClass<TriggerTypeClass> TriggerTypes;
|
|
|
|
TFixedIHeapClass<HouseTypeClass> HouseTypes;
|
|
TFixedIHeapClass<BuildingTypeClass> BuildingTypes;
|
|
TFixedIHeapClass<AircraftTypeClass> AircraftTypes;
|
|
TFixedIHeapClass<InfantryTypeClass> InfantryTypes;
|
|
TFixedIHeapClass<BulletTypeClass> BulletTypes;
|
|
TFixedIHeapClass<AnimTypeClass> AnimTypes;
|
|
TFixedIHeapClass<UnitTypeClass> UnitTypes;
|
|
TFixedIHeapClass<VesselTypeClass> VesselTypes;
|
|
TFixedIHeapClass<TemplateTypeClass> TemplateTypes;
|
|
TFixedIHeapClass<TerrainTypeClass> TerrainTypes;
|
|
TFixedIHeapClass<OverlayTypeClass> OverlayTypes;
|
|
TFixedIHeapClass<SmudgeTypeClass> SmudgeTypes;
|
|
|
|
|
|
/*
|
|
** These are the instantiate static heap pointers for the various
|
|
** CCPtr class objects that are allowed to exist. If the linker generates
|
|
** an error about a missing heap pointer, then this indicates that CCPtr objects
|
|
** for that type are not allowed. For every case of a TFixedIHeap manager of
|
|
** game objects, then a CCPtr can be instantiated for it.
|
|
*/
|
|
#if (0) //Moved to runtime initialization. ST - 5/20/2019
|
|
template<> FixedIHeapClass * CCPtr<AircraftClass>::Heap = &Aircraft;
|
|
template<> FixedIHeapClass * CCPtr<AnimClass>::Heap = &Anims;
|
|
template<> FixedIHeapClass * CCPtr<BuildingClass>::Heap = &Buildings;
|
|
template<> FixedIHeapClass * CCPtr<BulletClass>::Heap = &Bullets;
|
|
template<> FixedIHeapClass * CCPtr<FactoryClass>::Heap = &Factories;
|
|
template<> FixedIHeapClass * CCPtr<HouseClass>::Heap = &Houses;
|
|
template<> FixedIHeapClass * CCPtr<InfantryClass>::Heap = &Infantry;
|
|
template<> FixedIHeapClass * CCPtr<OverlayClass>::Heap = &Overlays;
|
|
template<> FixedIHeapClass * CCPtr<SmudgeClass>::Heap = &Smudges;
|
|
template<> FixedIHeapClass * CCPtr<TeamClass>::Heap = &Teams;
|
|
template<> FixedIHeapClass * CCPtr<TeamTypeClass>::Heap = &TeamTypes;
|
|
template<> FixedIHeapClass * CCPtr<TemplateClass>::Heap = &Templates;
|
|
template<> FixedIHeapClass * CCPtr<TerrainClass>::Heap = &Terrains;
|
|
template<> FixedIHeapClass * CCPtr<TriggerClass>::Heap = &Triggers;
|
|
template<> FixedIHeapClass * CCPtr<TriggerTypeClass>::Heap = &TriggerTypes;
|
|
|
|
template<> FixedIHeapClass * CCPtr<HouseTypeClass>::Heap = &HouseTypes;
|
|
template<> FixedIHeapClass * CCPtr<BuildingTypeClass>::Heap = &BuildingTypes;
|
|
template<> FixedIHeapClass * CCPtr<AircraftTypeClass>::Heap = &AircraftTypes;
|
|
template<> FixedIHeapClass * CCPtr<InfantryTypeClass>::Heap = &InfantryTypes;
|
|
template<> FixedIHeapClass * CCPtr<BulletTypeClass>::Heap = &BulletTypes;
|
|
template<> FixedIHeapClass * CCPtr<AnimTypeClass>::Heap = &AnimTypes;
|
|
template<> FixedIHeapClass * CCPtr<UnitTypeClass>::Heap = &UnitTypes;
|
|
template<> FixedIHeapClass * CCPtr<VesselTypeClass>::Heap = &VesselTypes;
|
|
template<> FixedIHeapClass * CCPtr<TemplateTypeClass>::Heap = &TemplateTypes;
|
|
template<> FixedIHeapClass * CCPtr<TerrainTypeClass>::Heap = &TerrainTypes;
|
|
template<> FixedIHeapClass * CCPtr<OverlayTypeClass>::Heap = &OverlayTypes;
|
|
template<> FixedIHeapClass * CCPtr<SmudgeTypeClass>::Heap = &SmudgeTypes;
|
|
#endif
|
|
|
|
/* These variables are used to keep track of the slowest speed of a team */
|
|
TeamFormDataStruct TeamFormData[HOUSE_COUNT];
|
|
bool FormMove;
|
|
SpeedType FormSpeed;
|
|
MPHType FormMaxSpeed;
|
|
|
|
|
|
char _staging_buffer[32000];
|
|
|
|
/*
|
|
** Global flag for the life of Tanya. If this flag is set, she is
|
|
** no longer available.
|
|
*/
|
|
bool IsTanyaDead;
|
|
bool SaveTanya;
|
|
|
|
#ifdef FIXIT_ANTS
|
|
bool AntsEnabled = false;
|
|
#endif
|
|
|
|
#ifdef FIXIT_CSII // checked - ajw 9/28/98
|
|
bool NewUnitsEnabled = false;
|
|
bool SecretUnitsEnabled = false;
|
|
int MTankDistance = 15;
|
|
bool OverrideNewUnitsEnabled = false; // ST - 12/13/2019 12:21PM
|
|
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
|
|
int CarrierLaunchDelay = 60;
|
|
#endif
|
|
#endif
|
|
|
|
int NewINIFormat = 0;
|
|
|
|
bool TimeQuake;
|
|
|
|
#ifdef FIXIT_CSII // checked - ajw 9/28/98
|
|
bool PendingTimeQuake;
|
|
TARGET TimeQuakeCenter;
|
|
fixed QuakeUnitDamage=0x300;
|
|
fixed QuakeBuildingDamage=0x300;
|
|
int QuakeInfantryDamage=25;
|
|
int QuakeDelay;
|
|
fixed ChronoTankDuration=0x300; // chrono override for chrono tanks
|
|
#ifdef FIXIT_ENGINEER // checked - ajw 9/28/98
|
|
fixed EngineerDamage=0x55; // Amount of damage an engineer does
|
|
fixed EngineerCaptureLevel=0x40; // Building damage level before engineer can capture
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
unsigned short Hard_Error_Occured = 0;
|
|
WWMouseClass * WWMouse = NULL;
|
|
GraphicBufferClass SysMemPage(DEFAULT_SCREEN_WIDTH, 200, (void*)NULL);
|
|
WinTimerClass * WindowsTimer=NULL;
|
|
int ScreenWidth=3072;
|
|
int ScreenHeight=3072;
|
|
GraphicBufferClass ModeXBuff;
|
|
bool InMovie = FALSE; //Are we currently playing a VQ movie?
|
|
HANDLE hInstance;
|
|
int AllDone;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is true if the game is the currently in focus windows app
|
|
**
|
|
*/
|
|
bool GameInFocus = false;
|
|
|
|
#endif
|
|
|
|
|
|
/***************************************************************************
|
|
** Encryption keys.
|
|
*/
|
|
PKey FastKey;
|
|
#ifdef CHEAT_KEYS
|
|
PKey SlowKey;
|
|
#endif
|
|
|
|
#ifdef FIXIT_NAME_OVERRIDE
|
|
/***************************************************************************
|
|
** This is where the name overrides for the units will reside.
|
|
*/
|
|
char const * NameOverride[25];
|
|
int NameIDOverride[25];
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
** These are the mission control structures. They hold the information about
|
|
** how the missions should behave in the system.
|
|
*/
|
|
MissionControlClass MissionControl[MISSION_COUNT];
|
|
|
|
|
|
/***************************************************************************
|
|
** There are various tutorial messages that can appear in the game. These
|
|
** are called upon by number and pointed to by this array.
|
|
*/
|
|
char const * TutorialText[225];
|
|
|
|
|
|
/***************************************************************************
|
|
** This holds the rules database. The rules database won't change during the
|
|
** program's run, but may need to be referenced intermitently.
|
|
*/
|
|
CCINIClass RuleINI;
|
|
#ifdef FIXIT_CSII // checked - ajw 9/28/98
|
|
CCINIClass AftermathINI;
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
** This points to the benchmark objects that are allocated only if the
|
|
** machine is running on a Pentium and this is a debug version.
|
|
*/
|
|
//Benchmark * Benches;
|
|
|
|
|
|
/***************************************************************************
|
|
** General rules that control the game.
|
|
*/
|
|
RulesClass Rule;
|
|
|
|
|
|
/***************************************************************************
|
|
** All keyboard input is routed through the object pointed to by this
|
|
** keyboard class pointer.
|
|
*/
|
|
KeyboardClass * Keyboard;
|
|
|
|
|
|
/***************************************************************************
|
|
** Remap control array. This is used to hold the remap
|
|
** tables for the various possible player colors, and the color schemes
|
|
** for dialogs.
|
|
*/
|
|
RemapControlType ColorRemaps[PCOLOR_COUNT];
|
|
|
|
/*
|
|
** Special remap scheme for font that hs to print over metallic tabs
|
|
*/
|
|
RemapControlType MetalScheme;
|
|
|
|
/*
|
|
** This remap table is for special purposes. It consists of dark grey shades,
|
|
** and is used for dimming things out.
|
|
*/
|
|
RemapControlType GreyScheme;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the source of the random numbers used in the game. This controls
|
|
** the game logic and thus must be in sync with any networked machines.
|
|
*/
|
|
RandomClass NonCriticalRandomNumber;
|
|
RandomStraw CryptRandom;
|
|
|
|
|
|
/***************************************************************************
|
|
** This tracks all selected objects per house (for this map).
|
|
*/
|
|
SelectedObjectsType CurrentObject;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the game version.
|
|
*/
|
|
//PG VersionClass VerNum;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the VQ animation controller structure. It is filled in by reading
|
|
** the PLAYER.INI and overridden through program control.
|
|
*/
|
|
//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 = false; // 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.
|
|
*/
|
|
ScenarioClass Scen;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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 suppressed
|
|
** when a large group of infantry is given the movement order.
|
|
*/
|
|
bool AllowVoice = true;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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[2];
|
|
VoxType SpeechRecord[2];
|
|
|
|
|
|
/***************************************************************************
|
|
** The theater specific mixfiles are cached into the buffer pointed to by
|
|
** this global.
|
|
*/
|
|
Buffer * TheaterBuffer;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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;
|
|
long PathCount; // Number of findpaths called.
|
|
long CellCount; // Number of cells redrawn.
|
|
long TargetScan; // Number of target scans.
|
|
long SidebarRedraws; // Number of sidebar redraws.
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the monochrome debug page array. The various monochrome data
|
|
** screens are located here.
|
|
*/
|
|
MonoClass MonoArray[DMONO_COUNT];
|
|
DMonoType MonoPage = DMONO_STRESS; // The current page.
|
|
|
|
|
|
/***************************************************************************
|
|
** This holds the theater specific mixfiles.
|
|
*/
|
|
MFCD * TheaterData = 0;
|
|
MFCD * MoviesMix = 0;
|
|
MFCD * GeneralMix = 0;
|
|
MFCD * ScoreMix = 0;
|
|
MFCD * MainMix = 0;
|
|
MFCD * ConquerMix = 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;
|
|
|
|
|
|
/**************************************************************************
|
|
** This class records the special command override options that C&C
|
|
** supports.
|
|
*/
|
|
SpecialClass Special;
|
|
|
|
|
|
bool PassedProximity; // used in display.cpp
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the scenario data for the currently loaded scenario.
|
|
** These variables should all be set together.
|
|
*/
|
|
HousesType Whom; // Initial command line house choice.
|
|
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. This value is the
|
|
** displayed value for tech level in the multiplay dialogs. It remaps to
|
|
** the in-game rules.ini tech levels.
|
|
*/
|
|
int BuildLevel = 10; // Buildable level (1 = simplest)
|
|
|
|
|
|
/***************************************************************************
|
|
** The various tutor and dialog messages are located in the data block
|
|
** referenced by this pointer.
|
|
*/
|
|
char const * SystemStrings;
|
|
char const * DebugStrings;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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 * Metal12FontPtr; //Font for use on in-game tabs in hires
|
|
void const * MapFontPtr; // Standard very small font.
|
|
void const * TypeFontPtr; // Teletype font for mission briefings.
|
|
void const * Font3Ptr; // Standard very small font.
|
|
void const * Font6Ptr; // Standard small font.
|
|
void const * EditorFont; // Font used for scenario editor.
|
|
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.
|
|
*/
|
|
PaletteClass CCPalette;
|
|
PaletteClass GamePalette;
|
|
//PaletteClass InGamePalette;
|
|
PaletteClass BlackPalette(RGBClass(0, 0, 0));
|
|
PaletteClass WhitePalette(RGBClass(RGBClass::MAX_VALUE, RGBClass::MAX_VALUE, RGBClass::MAX_VALUE));
|
|
PaletteClass OriginalPalette;
|
|
PaletteClass ScorePalette;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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 * 64)> DoList;
|
|
|
|
#ifdef MIRROR_QUEUE
|
|
QueueClass<EventClass, (MAX_EVENTS * 64)> MirrorList;
|
|
#endif
|
|
|
|
|
|
/***************************************************************************
|
|
** These are arrays/lists of trigger pointers for each cell & the houses.
|
|
*/
|
|
DynamicVectorClass<TriggerClass *> HouseTriggers[HOUSE_COUNT];
|
|
DynamicVectorClass<TriggerClass *> MapTriggers;
|
|
int MapTriggerID;
|
|
DynamicVectorClass<TriggerClass *> LogicTriggers;
|
|
int LogicTriggerID;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the list of BuildingTypes that define the AI's base.
|
|
*/
|
|
BaseClass Base;
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the list of carry over objects. These objects are part of the
|
|
** pseudo saved game that might be carried along with the current saved
|
|
** game.
|
|
*/
|
|
CarryoverClass * Carryover;
|
|
|
|
|
|
/***************************************************************************
|
|
** 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;
|
|
|
|
|
|
/***************************************************************************
|
|
** This class manages data specific to multiplayer games.
|
|
*/
|
|
SessionClass Session;
|
|
#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
|
|
|
|
#ifdef FIXIT_VERSION_3
|
|
bool bAftermathMultiplayer; // Is multiplayer game being played with Aftermath rules?
|
|
#else
|
|
unsigned long PlayingAgainstVersion; // Negotiated version number
|
|
bool Version107InMix; // Is there a v1.07 in the game
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
** This is the null modem manager class. Declaring this class doesn't
|
|
** perform any allocations;
|
|
*/
|
|
#if (0)
|
|
NullModemClass NullModem (
|
|
16, // number of send entries
|
|
16, // number of receive entries
|
|
(MAX_SERIAL_PACKET_SIZE / sizeof(EventClass) ) * sizeof(EventClass) + sizeof( CommHeaderType ),
|
|
0x1234); // Magic number must have each digit unique
|
|
// and different from the queue magic number
|
|
#endif
|
|
|
|
|
|
/***************************************************************************
|
|
** 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 (
|
|
// MAX (sizeof (GlobalPacketType), sizeof(RemoteFileTransferType)), // 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_CONQUER0);// Product ID #
|
|
|
|
IPXManagerClass Ipx (
|
|
MAX (sizeof (GlobalPacketType), sizeof(RemoteFileTransferType)), // size of Global Channel packets
|
|
((546 - sizeof(CommHeaderType)) / sizeof(EventClass) ) * sizeof(EventClass),
|
|
160, // # entries in Global Queue
|
|
32, // # entries in Private Queues
|
|
VIRGIN_SOCKET, // Socket ID #
|
|
IPXGlobalConnClass::COMMAND_AND_CONQUER0);// Product ID #
|
|
|
|
|
|
#if(TEN)
|
|
/***************************************************************************
|
|
** This is the connection manager for Ten. Special Ten notes:
|
|
** - TEN connection ID's are equal to the HousesType for that player.
|
|
** - The TEN internal player ID is used to determine the player's color.
|
|
** - Ten's broadcast destination address -1
|
|
*/
|
|
TenConnManClass *Ten = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
#if(MPATH)
|
|
/***************************************************************************
|
|
** This is the connection manager for Ten. Special Ten notes:
|
|
** - MPATH connection ID's are equal to the HousesType for that player.
|
|
** - The player's color is read from the OPTIONS.INI file
|
|
** - MPath's broadcast destination address is 0
|
|
*/
|
|
MPlayerManClass *MPath = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
/***************************************************************************
|
|
** This is the random-number seed; it's synchronized between systems for
|
|
** multiplayer games.
|
|
*/
|
|
int Seed = 0;
|
|
|
|
|
|
/***************************************************************************
|
|
** If this value is non-zero, use it as the random # seed instead; this should
|
|
** help reproduce some bugs.
|
|
*/
|
|
int CustomSeed = 0;
|
|
|
|
int WindowList[][9] = {
|
|
/* 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*8*RESFACTOR,200*RESFACTOR,WHITE,BLACK,0,0}, /* screen window */
|
|
{1*8,75,38*8,100,WHITE,BLACK,0,0}, /* DOS Error window */
|
|
|
|
// Tactical map.
|
|
{0, 0, 40*8*RESFACTOR, 200*RESFACTOR, WHITE,LTGREY,0,0},
|
|
|
|
// Initial menu window.
|
|
{12*8, 199-42, 16*8, 42, LTGREY, DKGREY, 0, 0},
|
|
|
|
// Sidebar clipping window.
|
|
{0,0,0,0,0,0,0,0},
|
|
|
|
// Scenario editor window.
|
|
{5*8, 30, 30*8, 140, 0, 0, 0, 0},
|
|
|
|
// Partial object draw sub-window.
|
|
{0,0,0,0,WHITE,BLACK,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},
|
|
};
|
|
|
|
|
|
#ifdef WIN32
|
|
GraphicBufferClass VisiblePage;
|
|
GraphicBufferClass HiddenPage;
|
|
GraphicViewPortClass SeenBuff(&VisiblePage, 0, 0, 3072, 3072);
|
|
GraphicViewPortClass HidPage(&HiddenPage, 0, 0, 3072, 3072);
|
|
#else
|
|
GraphicBufferClass HidPage(DEFAULT_SCREEN_WIDTH, 201, (void*)NULL);
|
|
GraphicBufferClass SeenBuff(320, 200, (void *)0xA0000L);
|
|
VideoBufferClass SeenPage;
|
|
GraphicBufferClass & VisiblePage = SeenBuff;
|
|
#endif
|
|
|
|
|
|
#ifdef WIN32
|
|
#else
|
|
#endif
|
|
|
|
int SoundOn;
|
|
CDTimerClass<SystemTimerClass> FrameTimer;
|
|
CDTimerClass<SystemTimerClass> CountDownTimer;
|
|
|
|
NewConfigType NewConfig;
|
|
TheaterType LastTheater = THEATER_NONE; //Lets us know when theater type changes.
|
|
|
|
|
|
/***************************************************************************
|
|
** This flag is for popping up dialogs that call the main loop.
|
|
*/
|
|
SpecialDialogType SpecialDialog = SDLG_NONE;
|
|
|
|
|
|
int RequiredCD = -1;
|
|
int CurrentCD = -1;
|
|
int MouseInstalled;
|
|
|
|
//
|
|
// Variables for helping track how much time goes bye in routines
|
|
//
|
|
int LogLevel = 0;
|
|
unsigned long LogLevelTime[ MAX_LOG_LEVEL ] = { 0 };
|
|
unsigned long LogLastTime = 0;
|
|
bool LogDump_Print = false; // true = print the Log time Stuff
|
|
|
|
|
|
/***************************************************************************
|
|
** Tick Count global timer object.
|
|
*/
|
|
TTimerClass<SystemTimerClass> TickCount = 0;
|
|
|
|
|
|
/***************************************************************************
|
|
** Win32 specific globals
|
|
*/
|
|
#ifdef WIN32
|
|
|
|
bool InDebugger = false;
|
|
int ReadyToQuit = 0;
|
|
|
|
#else
|
|
bool IsTheaterShape = false; // must be defined only if not Win32
|
|
#endif //WIN32
|
|
|
|
//PG GetCDClass CDList;
|
|
int UnitBuildPenalty = 100;
|
|
|
|
#ifdef MPEGMOVIE // Denzil 6/15/98
|
|
#ifdef MCIMPEG
|
|
#include "mcimovie.h"
|
|
MCIMovie* MciMovie = NULL;
|
|
#endif
|
|
|
|
#include "mpgset.h"
|
|
MPGSettings* MpgSettings = NULL;
|
|
#endif
|
|
|
|
#ifdef FIXIT_VERSION_3 // For endgame auto-sonar pulse.
|
|
bool bAutoSonarPulse = false;
|
|
#endif
|
|
|
|
bool MMXAvailable = false;
|
|
|
|
|
|
// ST - 5/14/2019
|
|
bool RunningAsDLL = false;
|
|
bool RunningFromEditor = false;
|