mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/TIBERIANDAWN/CONQUER.CPP

4257 lines
141 KiB
C++
Raw Blame History

//
// 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\conquer.cpv 2.18 16 Oct 1995 16:50:24 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 : CONQUER.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : April 3, 1991 *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* CC_Draw_Shape -- Custom draw shape handler. *
* Call_Back -- Main game maintenance callback routine. *
* Color_Cycle -- Handle the general palette color cycling. *
* Disk_Space_Available -- returns bytes of free disk space *
* Do_Record_Playback -- handles saving/loading map pos & current object *
* Fading_Table_Name -- Builds a theater specific fading table name. *
* Fetch_Techno_Type -- Convert type and ID into TechnoTypeClass pointer. *
* Force_CD_Available -- Ensures that specified CD is available. *
* Get_Radar_Icon -- Builds and alloc a radar icon from a shape file *
* Handle_Team -- Processes team selection command. *
* Handle_View -- Either records or restores the tactical view. *
* KN_To_Facing -- Converts a keyboard input number into a facing value. *
* Keyboard_Process -- Processes the tactical map input codes. *
* Language_Name -- Build filename for current language. *
* Main_Game -- Main game startup routine. *
* Main_Loop -- This is the main game loop (as a single loop). *
* Map_Edit_Loop -- a mini-main loop for map edit mode only *
* Message_Input -- allows inter-player message input processing *
* MixFileHandler -- Handles VQ file access. *
* Name_From_Source -- retrieves the name for the given SourceType *
* Play_Movie -- Plays a VQ movie. *
* Source_From_Name -- Converts ASCII name into SourceType. *
* Sync_Delay -- Forces the game into a 15 FPS rate. *
* Theater_From_Name -- Converts ASCII name into a theater number. *
* Trap_Object -- gets a ptr to object of given type & coord *
* Unselect_All -- Causes all selected objects to become unselected. *
* VQ_Call_Back -- Maintenance callback used for VQ movies. *
* Validate_Error -- prints an error message when an object fails validation *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "tcpip.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <direct.h>
#include <fcntl.h>
#include <io.h>
#include <dos.h>
#include <share.h>
#include <malloc.h>
#include "ccdde.h"
#define SHAPE_TRANS 0x40
void *Get_Shape_Header_Data(void *ptr);
/****************************************
** Function prototypes for this module **
*****************************************/
bool Main_Loop();
void Keyboard_Process(KeyNumType & input);
#ifndef DEMO
static void Message_Input(KeyNumType &input);
#endif
bool Color_Cycle(void);
bool Map_Edit_Loop(void);
void Trap_Object(void);
#ifdef CHEAT_KEYS
void Heap_Dump_Check( char *string );
void Dump_Heap_Pointers( void );
void Error_In_Heap_Pointers( char *string );
#endif
static void Do_Record_Playback(void);
extern void Register_Game_Start_Time(void);
extern void Register_Game_End_Time(void);
extern void Send_Statistics_Packet(void);
extern "C" {
extern char *__nheapbeg;
}
bool InMainLoop = false;
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
#endif
/***********************************************************************************************
* Main_Game -- Main game startup routine. *
* *
* This is the first official routine of the game. It handles game initialization and *
* the main game loop control. *
* *
* Initialization: *
* - Init_Game handles one-time-only inits *
* - Select_Game is responsible for initializations required for each new game played *
* (these may be different depending on whether a multiplayer game is selected, and *
* other parameters) *
* - This routine performs any un-inits required, both for each game played, and one-time *
* *
* INPUT: argc -- Number of command line arguments (including program name itself). *
* *
* argv -- Array of command line argument pointers. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/01/1994 JLB : Created. *
*=============================================================================================*/
extern int TotalLocks;
extern bool Spawn_WChat(bool can_launch);
extern bool SpawnedFromWChat;
void Main_Game(int argc, char *argv[])
{
bool fade = false; // don't fade title screen the first time through
/*
** Perform one-time-only initializations
*/
if (!Init_Game(argc, argv)) {
return;
}
CCDebugString ("C&C95 - Game initialisation complete.\n");
/*
** Game processing loop:
** 1) Select which game to play, or whether to exit (don't fade the palette
** on the first game selection, but fade it in on subsequent calls)
** 2) Invoke either the main-loop routine, or the editor-loop routine,
** until they indicate that the user wants to exit the scenario.
*/
while (Select_Game(fade)) {
if (RunningAsDLL) {
return;
}
ScenarioInit = 0; // Kludge.
// Theme.Queue_Song(THEME_PICK_ANOTHER);
fade = true;
/*
** Make the game screen visible, clear the keyboard buffer of spurious
** values, and then show the mouse. This PRESUMES that Select_Game() has
** told the map to draw itself.
*/
Fade_Palette_To(GamePalette, FADE_PALETTE_MEDIUM, NULL);
Keyboard::Clear();
/*
** Only show the mouse if we're not playing back a recording.
*/
if (PlaybackGame) {
Hide_Mouse();
} else {
Show_Mouse();
}
SpecialDialog = SDLG_NONE;
//Start_Profiler();
if (GameToPlay == GAME_INTERNET){
Register_Game_Start_Time();
GameStatisticsPacketSent = false;
PacketLater = NULL;
ConnectionLost = false;
}else{
DDEServer.Disable();
}
InMainLoop = true;
#ifdef SCENARIO_EDITOR
/*
** Scenario-editor version of main-loop processing
*/
for (;;) {
/*
** Non-scenario-editor-mode: call the game's main loop
*/
if (!Debug_Map) {
TotalLocks=0;
if (Main_Loop()) {
break;
}
if (SpecialDialog != SDLG_NONE) {
//Stop_Profiler();
switch (SpecialDialog) {
case SDLG_SPECIAL:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
Special_Dialog();
Map.Revert_Mouse_Shape();
SpecialDialog = SDLG_NONE;
break;
case SDLG_OPTIONS:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
Options.Process();
Map.Revert_Mouse_Shape();
SpecialDialog = SDLG_NONE;
break;
case SDLG_SURRENDER:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
if (Surrender_Dialog()) {
OutList.Add(EventClass(EventClass::DESTRUCT));
}
SpecialDialog = SDLG_NONE;
Map.Revert_Mouse_Shape();
break;
default:
break;
}
}
} else {
/*
** Scenario-editor-mode: call the editor's main loop
*/
if (Map_Edit_Loop()) {
break;
}
}
}
#else
/*
** Non-editor version of main-loop processing
*/
for (;;) {
/*
** Call the game's main loop
*/
TotalLocks=0;
if (Main_Loop()) {
break;
}
/*
** If the SpecialDialog flag is set, invoke the given special dialog.
** This must be done outside the main loop, since the dialog will call
** Main_Loop(), allowing the game to run in the background.
*/
if (SpecialDialog != SDLG_NONE) {
//Stop_Profiler();
switch (SpecialDialog) {
case SDLG_SPECIAL:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
Special_Dialog();
Map.Revert_Mouse_Shape();
SpecialDialog = SDLG_NONE;
break;
case SDLG_OPTIONS:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
Options.Process();
Map.Revert_Mouse_Shape();
SpecialDialog = SDLG_NONE;
break;
case SDLG_SURRENDER:
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
if (Surrender_Dialog()) {
OutList.Add(EventClass(EventClass::DESTRUCT));
}
SpecialDialog = SDLG_NONE;
Map.Revert_Mouse_Shape();
break;
default:
break;
}
}
}
#endif
//Stop_Profiler();
InMainLoop = false;
if (!GameStatisticsPacketSent && PacketLater){
Send_Statistics_Packet();
}
/*
** Scenario is done; fade palette to black
*/
Fade_Palette_To(BlackPalette, FADE_PALETTE_SLOW, NULL);
VisiblePage.Clear();
#ifndef DEMO
/*
** Un-initialize whatever needs it, for each game played.
**
** Shut down either the modem or network; they'll get re-initialized if
** the user selections those options again in Select_Game(). This
** "re-boots" the modem & network code, which I currently feel is safer
** than just letting it hang around.
** (Skip this step if we're in playback mode; the modem or net won't have
** been initialized in that case.)
*/
if ( (RecordGame && !SuperRecord) || PlaybackGame) {
RecordFile.Close();
}
if (!PlaybackGame){
switch (GameToPlay){
case GAME_NULL_MODEM:
case GAME_MODEM:
//ST - 1/2/2019 4:04PM
//Modem_Signoff();
break;
case GAME_IPX:
Shutdown_Network();
break;
case GAME_INTERNET:
//Winsock.Close();
break;
}
}
/*
** If we're playing back, the mouse will be hidden; show it.
** Also, set all variables back to normal, to return to the main menu.
*/
if (PlaybackGame) {
Show_Mouse();
GameToPlay = GAME_NORMAL;
PlaybackGame = 0;
}
/*
** If we were spawned from WChat then dont go back to the main menu - just quit
**
** New: If spawned from WChat then maximise WChat and go back to the main menu after all
*/
#ifdef FORCE_WINSOCK
if (Special.IsFromWChat){
Shutdown_Network(); // Clear up the pseudo IPX stuff
Winsock.Close();
Special.IsFromWChat = false;
SpawnedFromWChat = false;
DDEServer.Delete_MPlayer_Game_Info(); //Make sure we dont use the same start packet twice
GameToPlay = GAME_NORMAL; //Have to do this or we will got straight to the multiplayer menu
Spawn_WChat(false); //Will switch back to Wchat. It must be there because its been poking us
//break;
}
#endif //FORCE_WINSOCK
#endif //DEMO
}
#ifdef DEMO
Hide_Mouse();
Fade_Palette_To(BlackPalette, FADE_PALETTE_MEDIUM, NULL);
Load_Title_Screen("DEMOPIC.PCX", &HidPage, Palette);
Blit_Hid_Page_To_Seen_Buff();
Fade_Palette_To(Palette, FADE_PALETTE_MEDIUM, NULL);
Clear_KeyBuffer();
Get_Key();
Fade_Palette_To(BlackPalette, FADE_PALETTE_MEDIUM, NULL);
// Show_Mouse();
#else
/*
** Free the scenario description buffers
*/
Free_Scenario_Descriptions();
#endif
#ifndef NOMEMCHECK
Uninit_Game();
#endif
}
/***********************************************************************************************
* Keyboard_Process -- Processes the tactical map input codes. *
* *
* This routine is used to process the input codes while the player *
* has the tactical map displayed. It handles all the keys that *
* are appropriate to that mode. *
* *
* INPUT: input -- Input code as returned from Input_Num(). *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/21/1992 JLB : Created. *
* 07/04/1995 JLB : Handles team and map control hotkeys. *
*=============================================================================================*/
extern int DebugColour;
void Keyboard_Process(KeyNumType &input)
{
ObjectClass * obj;
int index;
/*
** Don't do anything if there is not keyboard event.
*/
if (input == KN_NONE) {
return;
}
#ifndef DEMO
/*
** For network & modem, process user input for inter-player messages.
*/
Message_Input(input);
#endif
/*
** Use WWKEY values because KN values have WWKEY_VK_BIT or'd in with them
** and we need WWKEY_VK_BIT to still be set if it is.
*/
KeyNumType plain = input & ~(WWKEY_SHIFT_BIT|WWKEY_ALT_BIT|WWKEY_CTRL_BIT);
#ifdef CHEAT_KEYS
if (Debug_Flag) {
switch (input) {
case (int)KN_M|(int)KN_SHIFT_BIT:
case (int)KN_M|(int)KN_ALT_BIT:
case (int)KN_M|(int)KN_CTRL_BIT:
PlayerPtr->Credits += 10000;
break;
default:
break;
}
}
#endif
#ifdef VIRGIN_CHEAT_KEYS
if (Debug_Playtest && input == (KN_W|KN_ALT_BIT)) {
PlayerPtr->Blockage = false;
PlayerPtr->Flag_To_Win();
}
#endif
//#ifdef CHEAT_KEYS
if (/*Debug_Playtest && */input == (KN_W|KN_ALT_BIT)) {
PlayerPtr->Blockage = false;
PlayerPtr->Flag_To_Win();
}
if (Debug_Flag && input == KN_SLASH) {
if (GameToPlay != GAME_NORMAL) {
SpecialDialog = SDLG_SPECIAL;
input = KN_NONE;
} else {
Special_Dialog();
}
}
//#endif
/*
** If the options key(s) were pressed, then bring up the options screen.
*/
if (input == KN_SPACE || input == KN_ESC) {
Map.Help_Text(TXT_NONE); // Turns off help text.
Queue_Options();
input = KN_NONE;
//DebugColour++;
//DebugColour &=7;
}
/*
** Process prerecorded team selection. This will be an addative select
** if the SHIFT key is held down. It will create the team if the
** CTRL or ALT key is held down.
*/
int action = 0;
if (input & WWKEY_SHIFT_BIT) action = 1;
if (input & WWKEY_ALT_BIT) action = 3;
if (input & WWKEY_CTRL_BIT) action = 2;
switch (KN_To_VK(plain)) {
/*
** Center the map around the currently selected objects. If no
** objects are selected, then fall into the home case.
*/
case VK_HOME:
if (CurrentObject.Count()) {
Map.Center_Map();
Map.Flag_To_Redraw(true);
break;
}
// Fall into next case.
/*
** Center the map about the construction yard or construction vehicle
** if one is present.
*/
case VK_H:
for (index = 0; index < Units.Count(); index++) {
UnitClass * unit = Units.Ptr(index);
if (unit && !unit->IsInLimbo && unit->House == PlayerPtr && *unit == UNIT_MCV) {
Unselect_All();
unit->Select();
break;
}
}
for (index = 0; index < Buildings.Count(); index++) {
BuildingClass * building = Buildings.Ptr(index);
if (building && !building->IsInLimbo && building->House == PlayerPtr && *building == STRUCT_CONST) {
Unselect_All();
building->Select();
break;
}
}
Map.Center_Map();
Map.Flag_To_Redraw(true);
break;
#ifdef CHEAT_KEYS
/*
** Toggle free scrolling mode.
*/
case VK_F:
Options.IsFreeScroll = (Options.IsFreeScroll == false);
break;
#endif
/*
** If the "N" key is pressed, then select the next object.
*/
case VK_N:
if (action) {
obj = Map.Prev_Object(CurrentObject.Count() ? CurrentObject[0] : NULL);
} else {
obj = Map.Next_Object(CurrentObject.Count() ? CurrentObject[0] : NULL);
}
if (obj) {
Unselect_All();
obj->Select();
Map.Center_Map();
Map.Flag_To_Redraw(true);
}
break;
/*
** For multiplayer, 'R' pops up the surrender dialog.
*/
case VK_R:
if (/*GameToPlay != GAME_NORMAL &&*/ !PlayerPtr->IsDefeated) {
SpecialDialog = SDLG_SURRENDER;
input = KN_NONE;
}
break;
/*
** Handle making and breaking alliances.
*/
case VK_A:
if (GameToPlay != GAME_NORMAL || Debug_Flag) {
if (CurrentObject.Count() && !PlayerPtr->IsDefeated) {
if (CurrentObject[0]->Owner() != PlayerPtr->Class->House) {
OutList.Add(EventClass(EventClass::ALLY, (int)CurrentObject[0]->Owner()));
}
}
}
break;
/*
** Control the remembered tactical location.
*/
case VK_F7:
case VK_F8:
case VK_F9:
case VK_F10:
if (!Debug_Map) {
Handle_View(KN_To_VK(plain) - VK_F7, action);
}
break;
#if (0)
case VK_F11:
Winsock.Set_Protocol_UDP(FALSE);
break;
case VK_F12:
Winsock.Set_Protocol_UDP(TRUE);
break;
#endif //(0)
/*
** Control the custom team select state.
*/
case VK_1:
case VK_2:
case VK_3:
case VK_4:
case VK_5:
case VK_6:
case VK_7:
case VK_8:
case VK_9:
case VK_0:
Handle_Team(KN_To_VK(plain) - VK_1, action);
break;
/*
** All selected units will go into idle mode.
*/
case VK_S:
if (CurrentObject.Count()) {
for (int index = 0; index < CurrentObject.Count(); index++) {
ObjectClass const * tech = CurrentObject[index];
if (tech && (tech->Can_Player_Move() || (tech->Can_Player_Fire() &&
tech->What_Am_I() != RTTI_BUILDING))) {
OutList.Add(EventClass(EventClass::IDLE, tech->As_Target()));
}
}
}
break;
/*
** All selected units will attempt to scatter.
*/
case VK_X:
if (CurrentObject.Count()) {
for (int index = 0; index < CurrentObject.Count(); index++) {
ObjectClass const * tech = CurrentObject[index];
if (tech && tech->Can_Player_Move()) {
OutList.Add(EventClass(EventClass::SCATTER, tech->As_Target()));
}
}
}
break;
/*
** All selected units will attempt to go into guard area mode.
*/
case VK_G:
if (CurrentObject.Count()) {
for (int index = 0; index < CurrentObject.Count(); index++) {
ObjectClass const * tech = CurrentObject[index];
if (tech && tech->Can_Player_Move() && tech->Can_Player_Fire()) {
OutList.Add(EventClass(tech->As_Target(), MISSION_GUARD_AREA));
}
}
}
break;
default:
break;
}
#ifdef NEVER
FacingType facing = KN_To_Facing(input);
/*
** Scroll the map according to the cursor key pressed.
*/
if (facing != FACING_NONE) {
Map.Scroll_Map(facing);
input = 0;
facing = FACING_NONE;
}
#endif
#ifdef NEVER
/*
** If the <TAB> key is pressed, then select the next object.
*/
if (input == KN_TAB) {
ObjectClass * obj = Map.Next_Object(CurrentObject);
if (obj) {
if (CurrentObject) {
CurrentObject->Unselect();
}
obj->Select();
}
}
#endif
#ifdef CHEAT_KEYS
if (Debug_Flag && input && (input & KN_RLSE_BIT) == 0) {
Debug_Key(input);
}
#endif
}
#ifndef DEMO
/***********************************************************************************************
* Message_Input -- allows inter-player message input processing *
* *
* INPUT: *
* input key value *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* MAX_MESSAGE_LENGTH has increased over the DOS version. COMPAT_MESSAGE_LENGTH reflects * *
* the length of the DOS message and also the length of the message in the packet header. *
* To allow transmission of longer messages I split the message into COMPAT_MESSAGE_LENGTH-4 *
* sized chunks and use the extra space after the zero terminator to specify which segment *
* of the whole message this is and also to supply a crc for the string. *
* This allows message segments to arrive out of order and still be displayed correctly. *
* *
* HISTORY: *
* 05/22/1995 BRR : Created. *
* 03/26/1995 ST : Modified to break up longer messages into multiple packets *
*=============================================================================================*/
static void Message_Input(KeyNumType &input)
{
int rc;
char txt[MAX_MESSAGE_LENGTH+12];
int id;
//PG_TO_FIX
#if (0)
SerialPacketType *serial_packet;
int i;
int message_length;
int sent_so_far;
unsigned short magic_number;
unsigned short crc;
#endif
int factor = (SeenBuff.Get_Width() == 320) ? 1 : 2;
/*
** Check keyboard input for a request to send a message.
** The 'to' argument for Add_Edit is prefixed to the message buffer; the
** message buffer is big enough for the 'to' field plus MAX_MESSAGE_LENGTH.
** To send the message, calling Get_Edit_Buf retrieves the buffer minus the
** 'to' portion. At the other end, the buffer allocated to display the
** message must be MAX_MESSAGE_LENGTH plus the size of "From: xxx (house)".
*/
if (input >= KN_F1 && input < (KN_F1 + MPlayerMax) &&
Messages.Get_Edit_Buf()==NULL) {
memset (txt, 0, 40);
/*
** For a serial game, send a message on F1 or F4; set 'txt' to the
** "Message:" string & add an editable message to the list.
*/
if (GameToPlay==GAME_NULL_MODEM
|| GameToPlay==GAME_MODEM){
//|| GameToPlay == GAME_INTERNET) {
if (input==KN_F1 || input==(KN_F1 + MPlayerMax - 1)) {
strcpy(txt,Text_String(TXT_MESSAGE)); // "Message:"
Messages.Add_Edit (MPlayerTColors[MPlayerColorIdx],
TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_FULLSHADOW, txt, 180*factor);
Map.Flag_To_Redraw(false);
}
} else {
/*
** For a network game:
** F1-F3 = "To <name> (house):" (only allowed if we're not in ObiWan mode)
** F4 = "To All:"
*/
if (GameToPlay == GAME_IPX || GameToPlay == GAME_INTERNET) {
if (input==(KN_F1 + MPlayerMax - 1) && Messages.Get_Edit_Buf()==NULL) {
MessageAddress = IPXAddressClass(); // set to broadcast
strcpy(txt,Text_String(TXT_TO_ALL)); // "To All:"
Messages.Add_Edit(MPlayerTColors[MPlayerColorIdx],
TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_FULLSHADOW, txt, 180*factor);
Map.Flag_To_Redraw(false);
} else {
if (Messages.Get_Edit_Buf()==NULL) {
if ((input - KN_F1) < Ipx.Num_Connections() && !MPlayerObiWan) {
id = Ipx.Connection_ID(input - KN_F1);
MessageAddress = (*(Ipx.Connection_Address (id)));
sprintf(txt,Text_String(TXT_TO),Ipx.Connection_Name(id));
Messages.Add_Edit(MPlayerTColors[MPlayerColorIdx],
TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_FULLSHADOW, txt, 180*factor);
Map.Flag_To_Redraw(false);
}
}
}
}
}
}
/*
** Function key input is meaningless beyond this point
*/
if (input >= KN_F1 && input <= KN_F10) return;
if (input >= KN_F11 && input <= KN_F12) return;
/*
** Process message-system input; send the message out if RETURN is hit.
*/
rc = Messages.Input(input);
/*
** If a single character has been added to an edit buffer, update the display.
*/
if (rc == 1) {
Map.Flag_To_Redraw(false);
}
/*
** If backspace was hit, redraw the map. This assumes the map is going to
** completely refresh all cells covered by the messages. Set DisplayClass's
** IsToRedraw to true to tell it to re-compute the cells that it needs to
** redraw.
*/
if (rc==2) {
Map.Flag_To_Redraw(false);
Map.DisplayClass::IsToRedraw = true;
}
/*
** Send a message
*/
if (rc==3) {
//
// PG_TO_FIX
#if (0)
/*.....................................................................
Store this message in our LastMessage buffer; the computer may send
us a version of it later.
.....................................................................*/
if (strlen(Messages.Get_Edit_Buf())) {
strcpy(LastMessage,Messages.Get_Edit_Buf());
}
message_length = strlen(Messages.Get_Edit_Buf());
long actual_message_size;
char *the_string;
/*
** Serial game: fill in a SerialPacketType & send it.
** (Note: The size of the SerialPacketType.Command must be the same as
** the EventClass.Type!)
*/
if (GameToPlay==GAME_NULL_MODEM
|| GameToPlay==GAME_MODEM){
//|| GameToPlay==GAME_INTERNET) {
sent_so_far = 0;
magic_number = MESSAGE_HEAD_MAGIC_NUMBER;
crc = (unsigned short) (Calculate_CRC(Messages.Get_Edit_Buf(), message_length) & 0xffff);
while (sent_so_far < message_length){
serial_packet = (SerialPacketType *)NullModem.BuildBuf;
serial_packet->Command = SERIAL_MESSAGE;
strcpy (serial_packet->Name, MPlayerName);
memcpy (serial_packet->Message, Messages.Get_Edit_Buf()+sent_so_far, COMPAT_MESSAGE_LENGTH-5);
/*
** Steve I's stuff for splitting message on word boundries
*/
actual_message_size = COMPAT_MESSAGE_LENGTH - 5;
/* Start at the end of the message and find a space with 10 chars. */
the_string = serial_packet->Message;
while ( (COMPAT_MESSAGE_LENGTH -5) -actual_message_size < 10 &&
the_string[actual_message_size] != ' '){
--actual_message_size;
}
if ( the_string[actual_message_size] == ' ' ){
/* Now delete the extra characters after the space (they musnt print) */
for ( int i=0 ; i< (COMPAT_MESSAGE_LENGTH-5) - actual_message_size; i++ ){
the_string[i + actual_message_size] = 0xff;
}
}else{
actual_message_size = COMPAT_MESSAGE_LENGTH - 5;
}
*(serial_packet->Message + COMPAT_MESSAGE_LENGTH-5) = 0;
/*
** Flag this message segment as either a message head or a message tail.
*/
*((unsigned short*)(serial_packet->Message + COMPAT_MESSAGE_LENGTH-4)) = magic_number;
*((unsigned short*)(serial_packet->Message + COMPAT_MESSAGE_LENGTH-2)) = crc;
serial_packet->ID = MPlayerLocalID;
NullModem.Send_Message(NullModem.BuildBuf, sizeof(SerialPacketType), 1);
magic_number++;
sent_so_far += actual_message_size; //COMPAT_MESSAGE_LENGTH-5;
}
} else {
/*
** Network game: fill in a GlobalPacketType & send it.
*/
if (GameToPlay == GAME_IPX || GameToPlay == GAME_INTERNET) {
sent_so_far = 0;
magic_number = MESSAGE_HEAD_MAGIC_NUMBER;
crc = (unsigned short) (Calculate_CRC(Messages.Get_Edit_Buf(), message_length) & 0xffff);
while (sent_so_far < message_length){
GPacket.Command = NET_MESSAGE;
strcpy (GPacket.Name, MPlayerName);
memcpy (GPacket.Message.Buf, Messages.Get_Edit_Buf()+sent_so_far, COMPAT_MESSAGE_LENGTH-5);
/*
** Steve I's stuff for splitting message on word boundries
*/
actual_message_size = COMPAT_MESSAGE_LENGTH - 5;
/* Start at the end of the message and find a space with 10 chars. */
the_string = GPacket.Message.Buf;
while ( (COMPAT_MESSAGE_LENGTH -5) -actual_message_size < 10 &&
the_string[actual_message_size] != ' '){
--actual_message_size;
}
if ( the_string[actual_message_size] == ' ' ){
/* Now delete the extra characters after the space (they musnt print) */
for ( int i=0 ; i< (COMPAT_MESSAGE_LENGTH-5) - actual_message_size; i++ ){
the_string[i + actual_message_size] = 0xff;
}
}else{
actual_message_size = COMPAT_MESSAGE_LENGTH - 5;
}
*(GPacket.Message.Buf + COMPAT_MESSAGE_LENGTH-5) = 0;
/*
** Flag this message segment as either a message head or a message tail.
*/
*((unsigned short*)(GPacket.Message.Buf + COMPAT_MESSAGE_LENGTH-4)) = magic_number;
*((unsigned short*)(GPacket.Message.Buf + COMPAT_MESSAGE_LENGTH-2)) = crc;
GPacket.Message.ID = MPlayerLocalID;
GPacket.Message.NameCRC = Compute_Name_CRC(MPlayerGameName);
/*
** If 'F4' was hit, MessageAddress will be a broadcast address; send
** the message to every player we have a connection with.
*/
if (MessageAddress.Is_Broadcast()) {
for (i = 0; i < Ipx.Num_Connections(); i++) {
Ipx.Send_Global_Message(&GPacket, sizeof(GlobalPacketType), 1,
Ipx.Connection_Address(Ipx.Connection_ID(i)));
Ipx.Service();
}
} else {
/*
** Otherwise, MessageAddress contains the exact address to send to.
** Send to that address only.
*/
Ipx.Send_Global_Message(&GPacket, sizeof(GlobalPacketType), 1,
&MessageAddress);
Ipx.Service();
}
magic_number++;
sent_so_far += actual_message_size; //COMPAT_MESSAGE_LENGTH-5;
}
}
}
/*
** Tell the map to completely update itself, since a message is now missing.
*/
Map.Flag_To_Redraw(true);
#endif
}
}
#endif
/***********************************************************************************************
* Color_Cycle -- Handle the general palette color cycling. *
* *
* This is a maintenance routine that handles the color cycling. It should be called as *
* often as necessary to achieve smooth color cycling effects -- at least 8 times a second. *
* *
* INPUT: none *
* *
* OUTPUT: true if palette changed *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/31/1994 JLB : Created. *
* 06/10/1994 JLB : Uses new cycle color values. *
* 12/21/1994 JLB : Handles text fade color. *
*=============================================================================================*/
bool Color_Cycle(void)
{
static CountDownTimerClass _timer(BT_SYSTEM,0L);
static CountDownTimerClass _ftimer(BT_SYSTEM,0L);
static bool _up = false;
bool changed = false;
/*
** Process the fading white color. It is used for the radar box and other glowing
** game interface elements.
*/
if (!_ftimer.Time()) {
_ftimer.Set(TIMER_SECOND/8);
/*
** Pulse the pulsing text color.
*/
#define STEP_RATE 5
if (_up) {
GamePalette[767] += STEP_RATE;
GamePalette[766] += STEP_RATE;
GamePalette[765] += STEP_RATE;
if (GamePalette[767] > MAX_CYCLE_COLOR) {
GamePalette[767] = MAX_CYCLE_COLOR;
GamePalette[766] = MAX_CYCLE_COLOR;
GamePalette[765] = MAX_CYCLE_COLOR;
_up = false;
}
} else {
GamePalette[767] -= STEP_RATE;
GamePalette[766] -= STEP_RATE;
GamePalette[765] -= STEP_RATE;
if ((unsigned)GamePalette[767] < MIN_CYCLE_COLOR) {
GamePalette[767] = MIN_CYCLE_COLOR;
GamePalette[766] = MIN_CYCLE_COLOR;
GamePalette[765] = MIN_CYCLE_COLOR;
_up = true;
}
}
changed = true;
}
/*
** Process the color cycling effects -- water.
*/
if (!_timer.Time()) {
unsigned char colors[3];
_timer.Set(TIMER_SECOND/4);
memmove(colors, &GamePalette[(CYCLE_COLOR_START+CYCLE_COLOR_COUNT-1)*3], sizeof(colors));
memmove(&GamePalette[(CYCLE_COLOR_START+1)*3], &GamePalette[CYCLE_COLOR_START*3], (CYCLE_COLOR_COUNT-1)*3);
memmove(&GamePalette[CYCLE_COLOR_START*3], colors, sizeof(colors));
changed = true;
}
/*
** If any of the processing functions changed the palette, then this palette must be
** passed to the system.
*/
if (changed) {
Wait_Vert_Blank();
Set_Palette(GamePalette);
return (true);
}
return (false);
}
/***********************************************************************************************
* Call_Back -- Main game maintenance callback routine. *
* *
* This routine handles all the "real time" processing that needs to *
* occur. This includes palette fading and sound updating. It needs *
* to be called as often as possible. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/07/1992 JLB : Created. *
*=============================================================================================*/
void Call_Back(void)
{
#ifndef DEMO
int i;
int id;
int color;
unsigned short magic_number;
unsigned short crc;
#endif
/*
** Score maintenance
*/
if (SampleType) {
Theme.AI();
Speak_AI();
}
#ifndef DEMO
/*
** Network maintenance
*/
if (GameToPlay == GAME_IPX || GameToPlay == GAME_INTERNET) {
Ipx.Service();
/*
** Read packets only if the game is "closed", so we don't steal global
** messages from the connection dialogs.
*/
if (!NetOpen) {
if (Ipx.Get_Global_Message (&GPacket, &GPacketlen, &GAddress, &GProductID)) {
if (GProductID == IPXGlobalConnClass::COMMAND_AND_CONQUER) {
/*
** If this is another player signing off, remove the connection &
** mark that player's house as non-human, so the computer will take
** it over.
*/
if (GPacket.Command == NET_SIGN_OFF) {
for (i = 0; i < Ipx.Num_Connections(); i++) {
id = Ipx.Connection_ID(i);
if (!strcmp (GPacket.Name, Ipx.Connection_Name(id) ) &&
GAddress == (*Ipx.Connection_Address(id))) {
CCDebugString ("C&C95 = Destroying connection due to sign off\n");
Destroy_Connection (id,0);
}
}
} else {
/*
** Process a message from another user.
*/
if (GPacket.Command == NET_MESSAGE) {
bool msg_ok = false;
char txt[80];
/*
** If NetProtect is set, make sure this message came from within
** this game.
*/
if (!NetProtect) {
msg_ok = true;
} else {
if (GPacket.Message.NameCRC == Compute_Name_CRC(MPlayerGameName)) {
msg_ok = true;
} else {
msg_ok = false;
}
}
if (msg_ok) {
sprintf(txt,Text_String (TXT_FROM), GPacket.Name, GPacket.Message.Buf);
magic_number = *((unsigned short*)(GPacket.Message.Buf + COMPAT_MESSAGE_LENGTH-4));
crc = *((unsigned short*)(GPacket.Message.Buf + COMPAT_MESSAGE_LENGTH-2));
color = MPlayerID_To_ColorIndex(GPacket.Message.ID);
Messages.Add_Message(txt, MPlayerTColors[color],
TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_FULLSHADOW, 600, magic_number, crc);
/*
** Tell the map to do a partial update (just to force the messages
** to redraw).
*/
Map.Flag_To_Redraw(false);
/*
** Save this message in our last-message buffer
*/
if (strlen(GPacket.Message.Buf)) {
strcpy(LastMessage, GPacket.Message.Buf);
}
}
} else {
Process_Global_Packet(&GPacket, &GAddress);
}
}
}
}
}
}
/*
** Modem and Null Modem maintenance
*/
if (GameToPlay == GAME_NULL_MODEM
|| ((GameToPlay == GAME_MODEM) && ModemService)){
//|| GameToPlay == GAME_INTERNET) {
// PG_TO_FIX
//NullModem.Service();
}
#endif
}
/***********************************************************************************************
* Language_Name -- Build filename for current language. *
* *
* This routine attaches a language specific suffix to the base *
* filename provided. Typical use of this is when loading language *
* specific files at game initialization time. *
* *
* INPUT: basename -- Base name to append language specific *
* extension to. *
* *
* OUTPUT: Returns with pointer to completed filename. *
* *
* WARNINGS: The return pointer value is valid only until the next time *
* this routine is called. *
* *
* HISTORY: *
* 10/07/1992 JLB : Created. *
*=============================================================================================*/
char const *Language_Name(char const *basename)
{
static char _fullname[_MAX_FNAME+_MAX_EXT];
if (!basename) return(NULL);
sprintf(_fullname, "%s.ENG", basename);
return(_fullname);
}
/***********************************************************************************************
* Source_From_Name -- Converts ASCII name into SourceType. *
* *
* This routine is used to convert an ASCII name representing a *
* SourceType into the actual SourceType value. Typically, this is *
* used when processing the scenario INI file. *
* *
* INPUT: name -- The ASCII source name to process. *
* *
* OUTPUT: Returns with the SourceType represented by the name *
* specified. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/17/1994 JLB : Created. *
*=============================================================================================*/
SourceType Source_From_Name(char const *name)
{
if (name) {
for (SourceType source = SOURCE_FIRST; source < SOURCE_COUNT; source++) {
if (stricmp(SourceName[source], name) == 0) {
return(source);
}
}
}
return(SOURCE_NONE);
}
/***********************************************************************************************
* Name_From_Source -- retrieves the name for the given SourceType *
* *
* INPUT: *
* source SourceType to get the name for *
* *
* OUTPUT: *
* name of SourceType *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/15/1994 BR : Created. *
*=============================================================================================*/
char const *Name_From_Source(SourceType source)
{
if ((unsigned)source < SOURCE_COUNT) {
return(SourceName[source]);
}
return("None");
}
/***********************************************************************************************
* Theater_From_Name -- Converts ASCII name into a theater number. *
* *
* This routine converts an ASCII representation of a theater and converts it into a *
* matching theater number. If no match was found, then THEATER_NONE is returned. *
* *
* INPUT: name -- Pointer to ASCII name to convert. *
* *
* OUTPUT: Returns with the name converted into a theater number. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/01/1994 JLB : Created. *
*=============================================================================================*/
TheaterType Theater_From_Name(char const *name)
{
TheaterType index;
if (name) {
for (index = THEATER_FIRST; index < THEATER_COUNT; index++) {
if (stricmp(name, Theaters[index].Name) == 0) {
return(index);
}
}
}
return(THEATER_NONE);
}
/***********************************************************************************************
* KN_To_Facing -- Converts a keyboard input number into a facing value. *
* *
* This routine determine which compass direction is represented by the keyboard value *
* provided. It is used for map scrolling and other directional control operations from *
* the keyboard. *
* *
* INPUT: input -- The KN number to convert. *
* *
* OUTPUT: Returns with the facing type that the keyboard number represents. If it could *
* not be translated, then FACING_NONE is returned. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/28/1994 JLB : Created. *
*=============================================================================================*/
FacingType KN_To_Facing(int input)
{
input &= ~(KN_ALT_BIT|KN_SHIFT_BIT|KN_CTRL_BIT);
switch (input) {
case KN_LEFT:
return(FACING_W);
case KN_RIGHT:
return(FACING_E);
case KN_UP:
return(FACING_N);
case KN_DOWN:
return(FACING_S);
case KN_UPLEFT:
return(FACING_NW);
case KN_UPRIGHT:
return(FACING_NE);
case KN_DOWNLEFT:
return(FACING_SW);
case KN_DOWNRIGHT:
return(FACING_SE);
}
return(FACING_NONE);
}
/***********************************************************************************************
* Sync_Delay -- Forces the game into a 15 FPS rate. *
* *
* This routine will wait until the timer for the current frame has expired before *
* returning. It is called at the end of every game loop in order to force the game loop *
* to run at a fixed rate. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Will delay for up to 1/15 of a second. *
* *
* HISTORY: *
* 01/04/1995 JLB : Created. *
* 03/06/1995 JLB : Fixed. *
*=============================================================================================*/
static void Sync_Delay(void)
{
/*
** Delay one tick and keep a record that one tick was "wasted" here.
** This accumulates into a running histogram of performance.
*/
SpareTicks += FrameTimer.Time();
while (FrameTimer.Time()) {
Color_Cycle();
Call_Back();
if (SpecialDialog == SDLG_NONE) {
WWMouse->Erase_Mouse(&HidPage, TRUE);
KeyNumType input = KN_NONE;
int x, y;
WWMouse->Erase_Mouse(&HidPage, TRUE);
Map.Input(input, x, y);
if (input) {
Keyboard_Process(input);
}
Map.Render();
}
}
Color_Cycle();
Call_Back();
}
/***********************************************************************************************
* Main_Loop -- This is the main game loop (as a single loop). *
* *
* This function will perform one game loop. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Should the game end? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/01/1994 JLB : Created. *
*=============================================================================================*/
extern void Check_For_Focus_Loss(void);
void Reallocate_Big_Shape_Buffer(void);
bool Main_Loop()
{
KeyNumType input; // Player input.
int x;
int y;
int framedelay;
// InMainLoop = true;
/*
** I think I'm gonna cry if this makes it work
*/
if (Get_Mouse_State())Show_Mouse();
/*
** Call the focus loss handler
*/
Check_For_Focus_Loss();
/*
** Allocate extra memory for uncompressed shapes as needed
*/
Reallocate_Big_Shape_Buffer();
/*
** Sync-bug trapping code
*/
if (Frame >= TrapFrame) {
Trap_Object();
}
//
// Initialize our AI processing timer
//
ProcessTimer.Set(0, true);
#if 1
if (TrapCheckHeap) {
Debug_Trap_Check_Heap = true;
}
#endif
#ifdef CHEAT_KEYS
Heap_Dump_Check( "After Trap" );
/*
** Update the running status debug display.
*/
Self_Regulate();
#endif
/*
** If there is no theme playing, but it looks like one is required, then start one
** playing. This is usually the symptom of there being no transition score.
*/
if (SampleType && Theme.What_Is_Playing() == THEME_NONE) {
Theme.Queue_Song(THEME_PICK_ANOTHER);
}
/*
** Setup the timer so that the Main_Loop function processes at the correct rate.
*/
if (GameToPlay != GAME_NORMAL && CommProtocol == COMM_PROTOCOL_MULTI_E_COMP) {
framedelay = 60 / DesiredFrameRate;
FrameTimer.Set(framedelay);
} else {
FrameTimer.Set(Options.GameSpeed);
}
/*
** Update the display, unless we're inside a dialog.
*/
if (!PlaybackGame) {
if (SpecialDialog == SDLG_NONE && GameInFocus) {
WWMouse->Erase_Mouse(&HidPage, TRUE);
Map.Input(input, x, y);
if (input) {
Keyboard_Process(input);
}
// HidPage.Lock();
Map.Render();
// HidPage.Unlock();
}
}
/*
** Save map's position & selected objects, if we're recording the game.
*/
if (RecordGame || PlaybackGame) {
Do_Record_Playback();
}
/*
** Sort the map's ground layer by y-coordinate value. This is done
** outside the IsToRedraw check, for the purposes of game sync'ing
** between machines; this way, all machines will sort the Map's
** layer in the same way, and any processing done that's based on
** the order of this layer will sync on different machines.
*/
Map.Layer[LAYER_GROUND].Sort();
// Heap_Dump_Check( "Before Logic.AI" );
/*
** AI logic operations are performed here.
*/
Logic.AI();
// Heap_Dump_Check( "After Logic.AI" );
/*
** Manage the inter-player message list. If Manage() returns true, it means
** a message has expired & been removed, and the entire map must be updated.
*/
if (Messages.Manage()) {
HiddenPage.Clear();
Map.Flag_To_Redraw(true);
}
//
// Measure how long it took to process the AI
//
ProcessTicks += ProcessTimer.Time();
ProcessFrames++;
// Heap_Dump_Check( "Before Queue_AI" );
/*
** Process all commands that are ready to be processed.
*/
Queue_AI();
// Heap_Dump_Check( "After Queue_AI" );
/*
** Keep track of elapsed time in the game.
*/
Score.ElapsedTime += TIMER_SECOND / TICKS_PER_SECOND;
Call_Back();
// Heap_Dump_Check( "After Call_Back" );
/*
** Perform any win/lose code as indicated by the global control flags.
*/
if (EndCountDown) EndCountDown--;
/*
** Check for player wins or loses according to global event flag.
*/
if (PlayerWins) {
if (GameToPlay == GAME_INTERNET && !GameStatisticsPacketSent){
Register_Game_End_Time();
Send_Statistics_Packet();
}
WWMouse->Erase_Mouse(&HidPage, TRUE);
PlayerLoses = false;
PlayerWins = false;
PlayerRestarts = false;
Map.Help_Text(TXT_NONE);
Do_Win();
}
if (PlayerLoses) {
if (GameToPlay == GAME_INTERNET && !GameStatisticsPacketSent){
Register_Game_End_Time();
Send_Statistics_Packet();
}
WWMouse->Erase_Mouse(&HidPage, TRUE);
PlayerWins = false;
PlayerLoses = false;
PlayerRestarts = false;
Map.Help_Text(TXT_NONE);
Do_Lose();
}
if (PlayerRestarts) {
WWMouse->Erase_Mouse(&HidPage, TRUE);
PlayerWins = false;
PlayerLoses = false;
PlayerRestarts = false;
Map.Help_Text(TXT_NONE);
Do_Restart();
}
/*
** The frame logic has been completed. Increment the frame
** counter.
*/
Frame++;
/*
** Very rarely, the human players will get a message from the computer.
*/
if (GameToPlay != GAME_NORMAL && MPlayerGhosts && IRandom(0,10000) == 1) {
Computer_Message();
}
/*
** Is there a memory trasher altering the map??
*/
if (Debug_Check_Map) {
if (!Map.Validate()) {
#ifdef GERMAN
if (CCMessageBox().Process ("Kartenfehler!","Halt","Weiter")==0)
#else
#ifdef FRENCH
if (CCMessageBox().Process ("Erreur de carte!","Stop","Continuer")==0)
#else
if (CCMessageBox().Process ("Map Error!","Stop","Continue")==0)
#endif
#endif
GameActive = false;
Map.Validate(); // give debugger a chance to catch it
}
}
Sync_Delay();
// InMainLoop = false;
return(!GameActive);
}
#ifdef SCENARIO_EDITOR
/***************************************************************************
* Map_Edit_Loop -- a mini-main loop for map edit mode only *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 10/19/1994 BR : Created. *
*=========================================================================*/
bool Map_Edit_Loop(void)
{
/*
** Redraw the map.
*/
Map.Render();
/*
** Get user input (keys, mouse clicks).
*/
KeyNumType input;
int x;
int y;
Map.Input(input, x, y);
/*
** Process keypress.
*/
if (input) {
Keyboard_Process(input);
}
Call_Back(); // maintains Theme.AI() for music
Color_Cycle();
return(!GameActive);
}
/***************************************************************************
* Go_Editor -- Enables/disables the map editor *
* *
* INPUT: *
* flag true = go into editor mode; false = go into game mode *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 10/19/1994 BR : Created. *
*=========================================================================*/
void Go_Editor(bool flag)
{
/*
** Go into Scenario Editor mode
*/
if (flag) {
Debug_Map = true;
Debug_Unshroud = true;
/*
** Un-select any selected objects
*/
Unselect_All();
/*
** Turn off the sidebar if it's on
*/
Map.Activate(0);
/*
** Reset the map's Button list for the new mode
*/
Map.Init_IO();
/*
** Force a complete redraw of the screen
*/
HiddenPage.Clear();
Map.Flag_To_Redraw(true);
Map.Render();
} else {
/*
** Go into normal game mode
*/
Debug_Map = false;
Debug_Unshroud = false;
/*
** Un-select any selected objects
*/
Unselect_All();
/*
** Reset the map's Button list for the new mode
*/
Map.Init_IO();
/*
** Force a complete redraw of the screen
*/
HiddenPage.Clear();
Map.Flag_To_Redraw(true);
Map.Render();
}
}
#endif
#if (0)
#define VQ_THREAD_BUFFER_SIZE 1024*1024
#define VQ_THREAD_BUFFER_CHUNK VQ_THREAD_BUFFER_SIZE/4
unsigned char *VQThreadBuffer = NULL;
volatile bool ThreadReading = false;
unsigned long VQThreadBlockHead;
unsigned long VQThreadBlockTail;
unsigned long VQBytesLeft;
unsigned long VQBytesRead;
void Init_VQ_Threading(CCFileClass *file)
{
if (!VQThreadBuffer){
VQThreadBuffer = new unsigned char [VQ_THREAD_BUFFER_SIZE];
}
Force_VM_Page_In(VQThreadBuffer, VQ_THREAD_BUFFER_SIZE);
VQThreadBlockHead = 0;
VQThreadBlockTail = 0;
VQBytesRead = 0;
VQBytesLeft = file->Size();
}
void Cleanup_VQ_Threading(void)
{
while (ThreadReading){}
if (VQThreadBuffer){
delete VQThreadBuffer;
VQThreadBuffer = NULL;
}
}
unsigned long __stdcall Thread_Read(void *file)
{
int bytes_to_read;
int left_to_read;
int read_this_time;
unsigned long head;
int sleep_time;
CCFileClass *ccfile = (CCFileClass*)file;
bytes_to_read = MIN (VQBytesLeft, VQ_THREAD_BUFFER_CHUNK);
if (!bytes_to_read){
ThreadReading = false;
return(0);
}
left_to_read = bytes_to_read;
while (left_to_read){
read_this_time = MIN(8*1024, left_to_read);
//if (read_this_time & 3){
ccfile->Read(VQThreadBuffer+VQThreadBlockHead, read_this_time);
//}else{
// ccfile->Read(VQThreadBuffer+VQThreadBlockHead, read_this_time/4);
// ccfile->Read(VQThreadBuffer+VQThreadBlockHead+read_this_time/4, read_this_time/4);
// ccfile->Read(VQThreadBuffer+VQThreadBlockHead+(read_this_time/4)*2, read_this_time/4);
// ccfile->Read(VQThreadBuffer+VQThreadBlockHead+(read_this_time/4)*3, read_this_time/4);
//}
VQThreadBlockHead += read_this_time;
left_to_read -= read_this_time;
head = VQThreadBlockHead;
if (head<VQThreadBlockTail) head+= VQ_THREAD_BUFFER_SIZE;
sleep_time = head - VQThreadBlockTail;
sleep_time = sleep_time/ (VQ_THREAD_BUFFER_CHUNK/32);
sleep_time += 2;
if (sleep_time<1) sleep_time=1;
Sleep(sleep_time);
}
VQThreadBlockHead &= VQ_THREAD_BUFFER_SIZE-1;
VQBytesLeft -= bytes_to_read;
ThreadReading = false;
return (0);
}
void Read_VQ_Thread_Block(CCFileClass *file)
{
HANDLE thread_handle;
DWORD thread_id;
if (!ThreadReading){
//_beginthreadex (&Thread_Read, NULL, 16*1024, NULL);
ThreadReading = true;
thread_handle = CreateThread(NULL, 0, &Thread_Read, (void*)file, 0, &thread_id);
//SetThreadPriority (thread_handle, THREAD_PRIORITY_IDLE);
CloseHandle (thread_handle);
}
}
int VQ_Thread_Read (CCFileClass *file, void *buffer, long bytes)
{
long bytes_to_read;
do {
if (VQThreadBlockHead > VQThreadBlockTail){
bytes_to_read = MIN(bytes, VQThreadBlockHead-VQThreadBlockTail);
}else{
bytes_to_read = MIN(bytes, VQThreadBlockHead+VQ_THREAD_BUFFER_SIZE - VQThreadBlockTail);
}
}while(ThreadReading && bytes_to_read<bytes);
if (VQThreadBlockTail+bytes_to_read > VQ_THREAD_BUFFER_SIZE){
int first_chunk = VQ_THREAD_BUFFER_SIZE - VQThreadBlockTail;
int second_chunk = bytes_to_read - first_chunk;
memcpy (buffer, VQThreadBuffer + VQThreadBlockTail, first_chunk);
memcpy ((unsigned char*)buffer + first_chunk, VQThreadBuffer, second_chunk);
}else{
memcpy (buffer, VQThreadBuffer + VQThreadBlockTail, bytes_to_read);
}
VQThreadBlockTail += bytes_to_read;
VQThreadBlockTail &= VQ_THREAD_BUFFER_SIZE - 1;
unsigned long head = VQThreadBlockHead;
if (head<VQThreadBlockTail) head+= VQ_THREAD_BUFFER_SIZE;
if (head-VQThreadBlockTail < VQ_THREAD_BUFFER_CHUNK && !ThreadReading) Read_VQ_Thread_Block(file);
VQBytesRead += bytes_to_read;
return (bytes_to_read);
}
int VQ_Thread_Seek (long bytes)
{
VQThreadBlockTail += bytes;
VQBytesRead += bytes;
return (VQBytesRead);
}
/***********************************************************************************************
* MixFileHandler -- Handles VQ file access. *
* *
* This routine is called from the VQ player when it needs to access the source file. By *
* using this routine it is possible to virtualize the file system. *
* *
* INPUT: vqa -- Pointer to the VQA handle for this animation. *
* *
* action-- The requested action to perform. *
* *
* buffer-- Optional buffer pointer as needed by the type of action. *
* *
* nbytes-- The number of bytes (if needed) for this operation. *
* *
* OUTPUT: Returns a value consistent with the action requested. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/04/1995 JLB : Created. *
*=============================================================================================*/
long MixFileHandler(VQAHandle *vqa, long action, void *buffer, long nbytes)
{
CCFileClass *file;
long error;
file = (CCFileClass *)vqa->VQAio;
/*
** Perform the action specified by the stream command.
*/
switch (action) {
/*
** VQACMD_READ means read NBytes from the stream and place it in the
** memory pointed to by Buffer.
**
** Any error code returned will be remapped by VQA library into
** VQAERR_READ.
*/
case VQACMD_READ:
error = VQ_Thread_Read (file, buffer, nbytes);
//error = (file->Read(buffer, (unsigned short)nbytes) != (unsigned short)nbytes);
if (error == nbytes) error = 0;
break;
/*
** VQACMD_WRITE is analogous to VQACMD_READ.
**
** Writing is not allowed to the VQA file, VQA library will remap the
** error into VQAERR_WRITE.
*/
case VQACMD_WRITE:
error = 1;
break;
/*
** VQACMD_SEEK asks that you perform a seek relative to the current
** position. NBytes is a signed number, indicating seek direction
** (positive for forward, negative for backward). Buffer has no meaning
** here.
**
** Any error code returned will be remapped by VQA library into
** VQAERR_SEEK.
*/
case VQACMD_SEEK:
//error = (file->Seek(nbytes, SEEK_CUR) == -1);
VQ_Thread_Seek(nbytes);
error = 0;
break;
/*
** VQACMD_OPEN asks that you open your stream for access.
*/
case VQACMD_OPEN:
file = new CCFileClass((char *)buffer);
if (file != NULL && file->Is_Available()) {
error = file->Open((char *)buffer, READ);
if (error != -1) {
vqa->VQAio = (unsigned long)file;
error = 0;
//file->Set_Buffer_Size(8*1024);
} else {
delete file;
file = 0;
error = 1;
}
} else {
error = 1;
}
if (error != -1){
Init_VQ_Threading(file);
Read_VQ_Thread_Block(file);
CountDownTimerClass timer;
timer.Set(60);
while (ThreadReading || timer.Time()){}
}
break;
case VQACMD_CLOSE:
Cleanup_VQ_Threading();
file->Close();
delete file;
file = 0;
vqa->VQAio = 0;
error = 0;
break;
/*
** VQACMD_INIT means to prepare your stream for reading. This is used for
** certain streams that can't be read immediately upon opening, and need
** further preparation. This operation is allowed to fail; the error code
** will be returned directly to the client.
*/
case VQACMD_INIT:
/*
** IFFCMD_CLEANUP means to terminate the transaction with the associated
** stream. This is used for streams that can't simply be closed. This
** operation is not allowed to fail; any error returned will be ignored.
*/
case VQACMD_CLEANUP:
error = 0;
break;
}
return(error);
}
#endif //(0)
//#if (0)
// PG_TO_FIX
typedef void* VQAHandle;
/***********************************************************************************************
* MixFileHandler -- Handles VQ file access. *
* *
* This routine is called from the VQ player when it needs to access the source file. By *
* using this routine it is possible to virtualize the file system. *
* *
* INPUT: vqa -- Pointer to the VQA handle for this animation. *
* *
* action-- The requested action to perform. *
* *
* buffer-- Optional buffer pointer as needed by the type of action. *
* *
* nbytes-- The number of bytes (if needed) for this operation. *
* *
* OUTPUT: Returns a value consistent with the action requested. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/04/1995 JLB : Created. *
*=============================================================================================*/
long MixFileHandler(VQAHandle *vqa, long action, void *buffer, long nbytes)
{
return 0;;
#if (0)
CCFileClass *file;
long error;
file = (CCFileClass *)vqa->VQAio;
/*
** Perform the action specified by the stream command.
*/
switch (action) {
/*
** VQACMD_READ means read NBytes from the stream and place it in the
** memory pointed to by Buffer.
**
** Any error code returned will be remapped by VQA library into
** VQAERR_READ.
*/
case VQACMD_READ:
error = (file->Read(buffer, (unsigned short)nbytes) != (unsigned short)nbytes);
break;
/*
** VQACMD_WRITE is analogous to VQACMD_READ.
**
** Writing is not allowed to the VQA file, VQA library will remap the
** error into VQAERR_WRITE.
*/
case VQACMD_WRITE:
error = 1;
break;
/*
** VQACMD_SEEK asks that you perform a seek relative to the current
** position. NBytes is a signed number, indicating seek direction
** (positive for forward, negative for backward). Buffer has no meaning
** here.
**
** Any error code returned will be remapped by VQA library into
** VQAERR_SEEK.
*/
case VQACMD_SEEK:
error = (file->Seek(nbytes, SEEK_CUR) == -1);
break;
/*
** VQACMD_OPEN asks that you open your stream for access.
*/
case VQACMD_OPEN:
file = new CCFileClass((char *)buffer);
if (file != NULL && file->Is_Available()) {
error = file->Open((char *)buffer, READ);
if (error != -1) {
vqa->VQAio = (unsigned long)file;
error = 0;
file->Set_Buffer_Size(8*1024);
} else {
delete file;
file = 0;
error = 1;
}
} else {
error = 1;
}
break;
case VQACMD_CLOSE:
file->Close();
delete file;
file = 0;
vqa->VQAio = 0;
error = 0;
break;
/*
** VQACMD_INIT means to prepare your stream for reading. This is used for
** certain streams that can't be read immediately upon opening, and need
** further preparation. This operation is allowed to fail; the error code
** will be returned directly to the client.
*/
case VQACMD_INIT:
/*
** IFFCMD_CLEANUP means to terminate the transaction with the associated
** stream. This is used for streams that can't simply be closed. This
** operation is not allowed to fail; any error returned will be ignored.
*/
case VQACMD_CLEANUP:
error = 0;
break;
}
return(error);
#endif
}
//#endif //(0)
void Rebuild_Interpolated_Palette(unsigned char *interpal)
{
for (int y=0 ; y<255 ; y++){
for (int x=y+1 ; x<256 ; x++){
*(interpal + (y*256+x)) = *(interpal + (x*256+y));
}
}
}
unsigned char *InterpolatedPalettes[100];
BOOL PalettesRead;
unsigned PaletteCounter;
int Load_Interpolated_Palettes(char const *filename, BOOL add)
{
int num_palettes=0;
int i;
int start_palette;
PalettesRead = FALSE;
CCFileClass file(filename);
// RawFileClass *palette_file;
if (!add){
for (i=0 ; i<ARRAY_SIZE(InterpolatedPalettes) ; i++){
InterpolatedPalettes[i]=NULL;
}
start_palette=0;
} else {
for (start_palette=0 ; start_palette< ARRAY_SIZE(InterpolatedPalettes) ; start_palette++){
if (!InterpolatedPalettes[start_palette]) break;
}
}
// palette_file = new RawFileClass (filename);
// if (file.Is_Available()){
file.Open(READ);
file.Read(&num_palettes , 4);
for (i=0 ; i<num_palettes ; i++){
InterpolatedPalettes[i+start_palette] = (unsigned char *)malloc (65536);
memset (InterpolatedPalettes[i+start_palette],0,65536);
for (int y=0 ; y<256 ;y++){
file.Read (InterpolatedPalettes[i+start_palette] + y*256 , y+1);
}
Rebuild_Interpolated_Palette(InterpolatedPalettes[i+start_palette]);
}
PalettesRead = TRUE;
file.Close();
// }
PaletteCounter = 0;
return (num_palettes);
}
void Free_Interpolated_Palettes(void)
{
for (int i=0 ; i<ARRAY_SIZE(InterpolatedPalettes) ; i++){
if (InterpolatedPalettes[i]){
free(InterpolatedPalettes[i]);
InterpolatedPalettes[i]=NULL;
}
}
}
/***********************************************************************************************
* Play_Movie -- Plays a VQ movie. *
* *
* Use this routine to play a VQ movie. It will disptach the specified movie to the *
* VQ player. The routine will not return until the movie has finished playing. *
* *
* INPUT: file -- The file object that contains the movie. *
* *
* anim -- The anim control and configuration structure that controls how the *
* movie will be played. *
* *
* clrscrn -- Set to 1 to clear the screen when the movie is over *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/19/1994 JLB : Created. *
*=============================================================================================*/
extern BOOL InMovie;
extern bool VQPaletteChange;
extern void Suspend_Audio_Thread(void);
extern void Resume_Audio_Thread(void);
//Play
extern void Play_Movie_GlyphX(const char * movie_name, ThemeType theme );
void Play_Movie(char const * name, ThemeType theme, bool clrscrn)
{
#if (1)
if (strcmp(name, "x") == 0 || strcmp(name, "X") == 0) {
return;
}
Play_Movie_GlyphX(name, theme);
return;
#else
/*
** Don't play movies in editor mode
*/
if (Debug_Map) {
return;
}
/*
** Don't play movies in multiplayer mode
*/
if (GameToPlay != GAME_NORMAL) {
return;
}
memset (&PaletteInterpolationTable[0][0],0,65536);
if (name) {
char fullname[_MAX_FNAME+_MAX_EXT];
char palname [_MAX_FNAME+_MAX_EXT];
_makepath(fullname, NULL, NULL, name, ".VQA");
_makepath(palname , NULL, NULL, name, ".VQP");
#ifdef CHEAT_KEYS
Mono_Set_Cursor(0, 0);Mono_Printf("[%s]", fullname);
#endif
/*
** Reset the anim control structure.
*/
Anim_Init();
VQPaletteChange = false;
/*
** Prepare to play a movie. First hide the mouse and stop any score that is playing.
** While the score (if any) is fading to silence, fade the palette to black as well.
** When the palette has finished fading, wait until the score has finished fading
** before launching the movie.
*/
Hide_Mouse();
//Theme.Stop();
//Theme.AI();
Theme.Queue_Song(theme);
if (PreserveVQAScreen == 0) {
Fade_Palette_To(BlackPalette, FADE_PALETTE_MEDIUM, Call_Back);
VisiblePage.Clear();
memset(BlackPalette, 0x01, 768);
Set_Palette(BlackPalette);
memset(BlackPalette, 0x00, 768);
}
PreserveVQAScreen = 0;
Keyboard::Clear();
VQAHandle *vqa = NULL;
if (!Debug_Quiet && Get_Digi_Handle() != -1) {
AnimControl.OptionFlags |= VQAOPTF_AUDIO;
} else {
AnimControl.OptionFlags &= ~VQAOPTF_AUDIO;
}
if ((vqa = VQA_Alloc()) != NULL) {
VQA_Init(vqa, MixFileHandler);
if (VQA_Open(vqa, fullname, &AnimControl) == 0) {
Brokeout = false;
//Suspend_Audio_Thread();
#if (FRENCH | GERMAN | JAPANESE)
/*
** Kludge to use the old palette interpolation table for CC2TEASE
** unless the covert CD is inserted.
*/
if (!stricmp (palname, "CC2TEASE.VQP")){
int cd_index = Get_CD_Index(CCFileClass::Get_CD_Drive(), 1*60);
/*
** If cd_index == 2 then its a covert CD
*/
if (cd_index != 2){
strcpy (palname, "OLDCC2T.VQP");
}
}
#endif //(FRENCH | GERMAN)
#if (GERMAN)
/*
** Kludge to use a different palette interpolation table for RETRO.VQA
** if the covert CD is inserted.
*/
if (!stricmp (palname, "RETRO.VQP")){
int cd_index = Get_CD_Index(CCFileClass::Get_CD_Drive(), 1*60);
/*
** If cd_index == 2 then its a covert CD
*/
if (cd_index == 2){
strcpy (palname, "RETROGER.VQP");
}
}
#endif //GERMAN
Load_Interpolated_Palettes(palname);
//Set_Palette(BlackPalette);
SysMemPage.Clear();
InMovie = TRUE;
VQA_Play(vqa, VQAMODE_RUN);
VQA_Close(vqa);
//Resume_Audio_Thread();
InMovie = FALSE;
Free_Interpolated_Palettes();
Set_Primary_Buffer_Format();
/*
** Any movie that ends prematurely must have the screen
** cleared to avoid any unexpected palette glitches.
*/
if (Brokeout) {
clrscrn = true;
VisiblePage.Clear();
Brokeout = false;
}
}
VQA_Free(vqa);
}
/*
** Presume that the screen is left in a garbage state as well as the palette
** being in an unknown condition. Recover from this by clearing the screen and
** forcing the palette to black.
*/
if (clrscrn) {
VisiblePage.Clear();
memset(BlackPalette, 0x01, 768);
Set_Palette(BlackPalette);
memset(BlackPalette, 0x00, 768);
Set_Palette(BlackPalette);
}
Show_Mouse();
}
#endif
}
/***********************************************************************************************
* Unselect_All -- Causes all selected objects to become unselected. *
* *
* This routine will unselect all objects that are currently selected. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
void Unselect_All(void)
{
//while (CurrentObject.Count()) {
// CurrentObject[0]->Unselect();
//}
//Added some error handling incase there was an issue removing the object - JAS 6/28/2019
while (CurrentObject.Count()) {
int count_before = CurrentObject.Count();
CurrentObject[0]->Unselect();
if (count_before <= CurrentObject.Count()) {
GlyphX_Debug_Print("Unselect_All failed to remove an object");
CurrentObject.Delete(CurrentObject[0]);
}
}
//End of change - JAS 6/28/2019
}
void Unselect_All_Except(ObjectClass* object)
{
int index = 0;
while (index < CurrentObject.Count()) {
if (CurrentObject[index] == object) {
index++;
continue;
}
int count_before = CurrentObject.Count();
CurrentObject[index]->Unselect();
if (count_before <= CurrentObject.Count()) {
GlyphX_Debug_Print("Unselect_All failed to remove an object");
CurrentObject.Delete(CurrentObject[index]);
}
}
}
/***********************************************************************************************
* Fading_Table_Name -- Builds a theater specific fading table name. *
* *
* This routine builds a standard fading table name. This name is dependant on the theater *
* being played, since each theater has its own palette. *
* *
* INPUT: base -- The base name of this fading table. The base name can be no longer than *
* seven characters. *
* *
* theater -- The theater that this fading table is specific to. *
* *
* OUTPUT: Returns with a pointer to the constructed fading table filename. This pointer is *
* valid until this function is called again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
char const * Fading_Table_Name(char const * base, TheaterType theater)
{
static char _buffer[_MAX_FNAME+_MAX_EXT];
char root[_MAX_FNAME];
sprintf(root, "%1.1s%s", Theaters[theater].Root, base);
_makepath(_buffer, NULL, NULL, root, ".MRF");
return(_buffer);
}
/***********************************************************************************************
* Get_Radar_Icon -- Builds and alloc a radar icon from a shape file *
* *
* INPUT: void const * shapefile - pointer to a key framed shapefile *
* int shapenum - shape to extract from shapefile *
* *
* OUTPUT: void const * - 3/3 icon set of shape from file *
* *
* HISTORY: *
* 04/12/1995 PWG : Created. *
* 05/10/1995 JLB : Handles a null shapefile pointer. *
*=============================================================================================*/
void const * Get_Radar_Icon(void const * shapefile, int shapenum, int frames, int zoomfactor)
{
static int _offx[]={ 0, 0, -1, 1, 0, -1, 1, -1, 1};
static int _offy[]={ 0, 0, -1, 1, 0, -1, 1, -1, 1};
int lp,framelp;
char pixel;
char *retval = NULL;
char *buffer = NULL;
void *ptr;
/*
** If there is no shape file, then there can be no radar icon imagery.
*/
if (!shapefile) return(NULL);
/*
** Get the pixel width and height of the frame we built. This will
** be used to extract icons and build pixels.
*/
int pixel_width = Get_Build_Frame_Width( shapefile );
int pixel_height = Get_Build_Frame_Height( shapefile );
/*
** Find the width and height in icons, adjust these by half an
** icon because the artists may be sloppy and miss the edge of an
** icon one way or the other.
*/
int icon_width = (pixel_width + 12) / 24;
int icon_height = (pixel_height + 12) / 24;
/*
** If we have been told to build as many frames as possible, then
** find out how many frames there are to build.
*/
if (frames == -1) frames = Get_Build_Frame_Count( shapefile );
/*
** Allocate a position to store our icons. If the alloc fails then
** we dont add these icons to the set.
**/
buffer = new char[(icon_width * icon_height * 9 * frames)+2];
if (!buffer) return(NULL);
/*
** Save off the return value so that we can return it to the calling
** function.
*/
retval = (char *)buffer;
*buffer++ = (char)icon_width;
*buffer++ = (char)icon_height;
int val = 24/zoomfactor;
for (framelp = 0; framelp < frames; framelp ++) {
/*
** Build the current frame. If the frame can not be built then we
** just need to skip past this set of icons and try to build the
** next frame.
*/
if ((ptr = (void *)(Build_Frame(shapefile, shapenum + framelp, SysMemPage.Get_Buffer()))) != NULL) {
ptr = Get_Shape_Header_Data(ptr);
/*
** Loop through the icon width and the icon height building icons
** into the buffer pointer. When the getx or gety falls outside of
** the width and height of the shape, just insert transparent pixels.
*/
for (int icony = 0; icony < icon_height; icony ++) {
for (int iconx = 0; iconx < icon_width; iconx ++) {
for (int y = 0; y < zoomfactor; y++) {
for (int x = 0; x < zoomfactor; x++) {
int getx = (iconx * 24) + (x * val) + (zoomfactor / 2);
int gety = (icony * 24) + (y * val) + (zoomfactor / 2);
if ((getx < pixel_width) && (gety < pixel_height)) {
for (lp = 0; lp < 9; lp ++) {
pixel = *((char *)(Add_Long_To_Pointer(ptr, ((gety - _offy[lp]) * pixel_width) + getx-_offx[lp])));
if (pixel == LTGREEN) pixel = 0;
if (pixel) {
break;
}
}
*buffer++ = pixel;
} else {
*buffer++ = 0;
}
}
}
}
}
} else {
buffer += icon_width * icon_height * 9;
}
}
return(retval);
}
void CC_Texture_Fill (void const *shapefile, int shapenum, int xpos, int ypos, int width, int height)
{
unsigned char *shape_pointer;
//unsigned char *shape_save;
unsigned long shape_size;
//int x,y;
if (shapefile && shapenum != -1) {
/*
** Build frame returns a pointer now instead of the shapes length
*/
shape_size=Build_Frame(shapefile , shapenum , _ShapeBuffer);
if (Get_Last_Frame_Length() > _ShapeBufferSize) {
Mono_Printf("Attempt to use shape buffer for size %d buffer is only size %d", shape_size, _ShapeBufferSize);
Get_Key();
}
if (shape_size) {
shape_pointer = (unsigned char *)Get_Shape_Header_Data ((void*)shape_size);
int source_width = Get_Build_Frame_Width (shapefile);
int source_height = Get_Build_Frame_Height (shapefile);
LogicPage->Texture_Fill_Rect (xpos, ypos, width, height, shape_pointer, source_width, source_height);
#if (0)
if (LogicPage->Lock()){
for (y = ypos ; y < ypos + MIN(source_height, height) ; y++ ){
shape_save = shape_pointer;
for (x = xpos ; x < xpos + MIN(source_width, width) ; x++ ){
LogicPage->Put_Pixel (x, y, *shape_pointer++);
}
shape_pointer = shape_save + source_width;
}
LogicPage->Unlock();
}
#endif
}
}
}
extern void DLL_Draw_Intercept(int shape_number, int x, int y, int width, int height, int flags, ObjectClass *object, const char *shape_file_name, char override_owner, int scale);
extern void DLL_Draw_Pip_Intercept(const ObjectClass* object, int pip);
extern void DLL_Draw_Line_Intercept(int x, int y, int x1, int y1, unsigned char color, int frame);
void CC_Draw_Shape(ObjectClass *object, void const * shapefile, int shapenum, int x, int y, WindowNumberType window, ShapeFlags_Type flags, void const * fadingdata, void const * ghostdata, int scale)
{
if (window == WINDOW_VIRTUAL) {
int width = Get_Build_Frame_Width(shapefile);
int height = Get_Build_Frame_Height(shapefile);
DLL_Draw_Intercept(shapenum, x, y, width, height, (int)flags, object, NULL, -1, scale);
return;
}
CC_Draw_Shape(shapefile, shapenum, x, y, window, flags, fadingdata, ghostdata);
}
void CC_Draw_Shape(ObjectClass *object, const char *shape_file_name, void const * shapefile, int shapenum, int x, int y, WindowNumberType window, ShapeFlags_Type flags, void const * fadingdata, void const * ghostdata, char override_owner)
{
if (window == WINDOW_VIRTUAL) {
int width = Get_Build_Frame_Width(shapefile);
int height = Get_Build_Frame_Height(shapefile);
DLL_Draw_Intercept(shapenum, x, y, width, height, (int)flags, object, shape_file_name, override_owner, 0x100);
return;
}
CC_Draw_Shape(shapefile, shapenum, x, y, window, flags, fadingdata, ghostdata);
}
void CC_Draw_Pip(ObjectClass *object, void const * shapefile, int shapenum, int x, int y, WindowNumberType window, ShapeFlags_Type flags, void const * fadingdata, void const * ghostdata)
{
if (window == WINDOW_VIRTUAL) {
DLL_Draw_Pip_Intercept(object, shapenum);
return;
}
CC_Draw_Shape(shapefile, shapenum, x, y, window, flags, fadingdata, ghostdata);
}
void CC_Draw_Line(int x, int y, int x1, int y1, unsigned char color, int frame, WindowNumberType window)
{
if (window == WINDOW_VIRTUAL) {
DLL_Draw_Line_Intercept(x, y, x1, y1, color, frame);
return;
}
LogicPage->Draw_Line(x, y, x1, y1, color);
}
/***********************************************************************************************
* CC_Draw_Shape -- Custom draw shape handler. *
* *
* All draw shape calls will route through this function. It handles all draws for *
* C&C. Such draws always occur to the logical page and assume certain things about *
* the parameters passed. *
* *
* INPUT: shapefile -- Pointer to the shape data file. This data file contains all the *
* embedded shapes. *
* *
* shapenum -- The shape number within the shapefile that will be drawn. *
* *
* x,y -- The pixel coordinates to draw the shape. *
* *
* window -- The clipping window to use. *
* *
* flags -- The custom draw shape flags. This controls how the parameters *
* are used (if any). *
* *
* fadingdata -- If SHAPE_FADING is desired, then this points to the fading *
* data table. *
* *
* ghostdata -- If SHAPE_GHOST is desired, then this points to the ghost remap *
* table. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 02/21/1995 JLB : Created. *
*=============================================================================================*/
//#pragma off(unreferenced)
void CC_Draw_Shape(void const * shapefile, int shapenum, int x, int y, WindowNumberType window, ShapeFlags_Type flags, void const * fadingdata, void const * ghostdata)
{
#if(TRUE)
int predoffset;
char *shape_pointer;
unsigned long shape_size;
if (shapefile && shapenum != -1) {
/*
** Build frame returns a pointer now instead of the shapes length
*/
shape_size=Build_Frame(shapefile , shapenum , _ShapeBuffer);
if (Get_Last_Frame_Length() > _ShapeBufferSize) {
Mono_Printf("Attempt to use shape buffer for size %d buffer is only size %d", shape_size, _ShapeBufferSize);
Get_Key();
}
if (shape_size) {
GraphicViewPortClass draw_window(LogicPage->Get_Graphic_Buffer(),
(WindowList[window][WINDOWX] << 3) + LogicPage->Get_XPos(),
WindowList[window][WINDOWY] + LogicPage->Get_YPos(),
WindowList[window][WINDOWWIDTH] << 3,
WindowList[window][WINDOWHEIGHT]);
shape_pointer = (char *)shape_size;
/*
** Special shadow drawing code (used for aircraft and bullets).
*/
if ((flags & (SHAPE_FADING|SHAPE_PREDATOR)) == (SHAPE_FADING|SHAPE_PREDATOR)) {
flags = flags & ~(SHAPE_FADING|SHAPE_PREDATOR);
flags = flags | SHAPE_GHOST;
ghostdata = Map.SpecialGhost;
}
predoffset = Frame;
if (x > ( WindowList[window][WINDOWWIDTH] << 2)) {
predoffset = -predoffset;
}
if (draw_window.Lock()){
if ((flags & (SHAPE_GHOST|SHAPE_FADING)) == (SHAPE_GHOST|SHAPE_FADING)) {
Buffer_Frame_To_Page(x, y, Get_Build_Frame_Width(shapefile), Get_Build_Frame_Height(shapefile),
shape_pointer, draw_window, flags | SHAPE_TRANS, ghostdata, fadingdata, 1, predoffset);
} else {
if (flags & SHAPE_FADING) {
Buffer_Frame_To_Page(x, y, Get_Build_Frame_Width(shapefile), Get_Build_Frame_Height(shapefile),
shape_pointer, draw_window, flags | SHAPE_TRANS, fadingdata, 1, predoffset);
} else {
if (flags & SHAPE_PREDATOR) {
Buffer_Frame_To_Page(x, y, Get_Build_Frame_Width(shapefile), Get_Build_Frame_Height(shapefile),
shape_pointer, draw_window, flags | SHAPE_TRANS, predoffset);
} else {
Buffer_Frame_To_Page(x, y, Get_Build_Frame_Width(shapefile), Get_Build_Frame_Height(shapefile),
shape_pointer, draw_window, flags | SHAPE_TRANS, ghostdata, predoffset);
}
}
}
}
draw_window.Unlock();
// } else {
// Mono_Printf( "Overrun ShapeBuffer!!!!!!!!!\n" );
}
}
#endif
}
/***********************************************************************************************
* Fetch_Techno_Type -- Convert type and ID into TechnoTypeClass pointer. *
* *
* This routine will convert the supplied RTTI type number and the ID value into a valid *
* TechnoTypeClass pointer. If there is an error in conversion, then NULL is returned. *
* *
* INPUT: type -- RTTI type of the techno class object. *
* *
* id -- Integer representation of the techno sub type number. *
* *
* OUTPUT: Returns with a pointer to the techno type class object specified or NULL if the *
* conversion could not occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/08/1995 JLB : Created. *
*=============================================================================================*/
TechnoTypeClass const * Fetch_Techno_Type(RTTIType type, int id)
{
switch (type) {
case RTTI_UNITTYPE:
case RTTI_UNIT:
return(&UnitTypeClass::As_Reference((UnitType)id));
case RTTI_BUILDINGTYPE:
case RTTI_BUILDING:
return(&BuildingTypeClass::As_Reference((StructType)id));
case RTTI_INFANTRYTYPE:
case RTTI_INFANTRY:
return(&InfantryTypeClass::As_Reference((InfantryType)id));
case RTTI_AIRCRAFTTYPE:
case RTTI_AIRCRAFT:
return(&AircraftTypeClass::As_Reference((AircraftType)id));
}
return(NULL);
}
/***************************************************************************
* Trap_Object -- gets a ptr to object of given type & coord *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 06/02/1995 BRR : Created. *
*=========================================================================*/
void Trap_Object(void)
{
int i;
TrapObject.Ptr.All = NULL;
switch (TrapObjType) {
case RTTI_AIRCRAFT:
for (i = 0; i < Aircraft.Count(); i++) {
if (Aircraft.Ptr(i)->Coord == TrapCoord || Aircraft.Ptr(i)==TrapThis) {
TrapObject.Ptr.Aircraft = Aircraft.Ptr(i);
break;
}
}
break;
case RTTI_ANIM:
for (i = 0; i < Anims.Count(); i++) {
if (Anims.Ptr(i)->Coord == TrapCoord || Anims.Ptr(i)==TrapThis) {
TrapObject.Ptr.Anim = Anims.Ptr(i);
break;
}
}
break;
case RTTI_BUILDING:
for (i = 0; i < Buildings.Count(); i++) {
if (Buildings.Ptr(i)->Coord == TrapCoord || Buildings.Ptr(i)==TrapThis) {
TrapObject.Ptr.Building = Buildings.Ptr(i);
break;
}
}
break;
case RTTI_BULLET:
for (i = 0; i < Bullets.Count(); i++) {
if (Bullets.Ptr(i)->Coord == TrapCoord || Bullets.Ptr(i)==TrapThis) {
TrapObject.Ptr.Bullet = Bullets.Ptr(i);
break;
}
}
break;
case RTTI_INFANTRY:
for (i = 0; i < Infantry.Count(); i++) {
if (Infantry.Ptr(i)->Coord == TrapCoord || Infantry.Ptr(i)==TrapThis) {
TrapObject.Ptr.Infantry = Infantry.Ptr(i);
break;
}
}
break;
case RTTI_UNIT:
for (i = 0; i < Units.Count(); i++) {
if (Units.Ptr(i)->Coord == TrapCoord || Units.Ptr(i)==TrapThis) {
TrapObject.Ptr.Unit = Units.Ptr(i);
break;
}
}
break;
/*
** Last-ditch find-the-object-right-now-darnit loop
*/
case RTTI_NONE:
for (i = 0; i < Aircraft.Count(); i++) {
if (Aircraft.Raw_Ptr(i)->Coord == TrapCoord || Aircraft.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Aircraft = Aircraft.Raw_Ptr(i);
TrapObjType = RTTI_AIRCRAFT;
return;
}
}
for (i = 0; i < Anims.Count(); i++) {
if (Anims.Raw_Ptr(i)->Coord == TrapCoord || Anims.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Anim = Anims.Raw_Ptr(i);
TrapObjType = RTTI_ANIM;
return;
}
}
for (i = 0; i < Buildings.Count(); i++) {
if (Buildings.Raw_Ptr(i)->Coord == TrapCoord || Buildings.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Building = Buildings.Raw_Ptr(i);
TrapObjType = RTTI_BUILDING;
return;
}
}
for (i = 0; i < Bullets.Count(); i++) {
if (Bullets.Raw_Ptr(i)->Coord == TrapCoord || Bullets.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Bullet = Bullets.Raw_Ptr(i);
TrapObjType = RTTI_BULLET;
return;
}
}
for (i = 0; i < Infantry.Count(); i++) {
if (Infantry.Raw_Ptr(i)->Coord == TrapCoord || Infantry.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Infantry = Infantry.Raw_Ptr(i);
TrapObjType = RTTI_INFANTRY;
return;
}
}
for (i = 0; i < Units.Count(); i++) {
if (Units.Raw_Ptr(i)->Coord == TrapCoord || Units.Raw_Ptr(i)==TrapThis) {
TrapObject.Ptr.Unit = Units.Raw_Ptr(i);
TrapObjType = RTTI_UNIT;
return;
}
}
default:
break;
}
}
/***********************************************************************************************
* VQ_Call_Back -- Maintenance callback used for VQ movies. *
* *
* This routine is called every frame of the VQ movie as it is being played. If this *
* routine returns non-zero, then the movie will stop. *
* *
* INPUT: buffer -- Pointer to the image buffer for the current frame. *
* *
* frame -- The frame number about to be displayed. *
* *
* OUTPUT: Should the movie be stopped? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/24/1995 JLB : Created. *
*=============================================================================================*/
void VQA_PauseAudio(void) {};
void Check_VQ_Palette_Set(void);
long VQ_Call_Back(unsigned char *, long )
{
// PG_TO_FIX - 1/2/2019 3:59PM
#if (0)
int key = 0;
if (Keyboard::Check()){
key = Keyboard::Get();
Keyboard::Clear();
}
Check_VQ_Palette_Set();
Interpolate_2X_Scale(&SysMemPage,&SeenBuff,NULL);
//Call_Back();
if ((BreakoutAllowed || Debug_Flag) && key == KN_ESC) {
Keyboard::Clear();
Brokeout = true;
return(true);
}
if (!GameInFocus){
VQA_PauseAudio();
while (!GameInFocus){
Keyboard::Check();
Check_For_Focus_Loss();
}
}
#endif
return(false);
}
/***********************************************************************************************
* Handle_Team -- Processes team selection command. *
* *
* This routine will handle creation and selection of pseudo teams that the player can *
* create or control. A team in this sense is an arbitrary grouping of units such that *
* rapid selection control is allowed. *
* *
* INPUT: team -- The logical team number to process. *
* *
* action-- The action to perform on this team: *
* 0 - Toggle the select state for all members of this team. *
* 1 - Select the members of this team. *
* 2 - Make all selected objects members of this team. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/27/1995 JLB : Created. *
*=============================================================================================*/
void Handle_Team(int team, int action)
{
int index;
AllowVoice = true;
switch (action) {
/*
** Toggle the team selection. If the team is selected, then merely unselect it. If the
** team is not selected, then unselect all others before selecting this team.
*/
case 3:
case 0:
/*
** If a non team member is currently selected, then deselect all objects
** before selecting this team.
*/
for (index = 0; index < CurrentObject.Count(); index++) {
ObjectClass * obj = CurrentObject[index];
if (obj->What_Am_I() == RTTI_UNIT || obj->What_Am_I() == RTTI_INFANTRY || obj->What_Am_I() == RTTI_AIRCRAFT) {
if (((FootClass *)obj)->Group != team) {
Unselect_All();
break;
}
}
}
for (index = 0; index < Units.Count(); index++) {
UnitClass * obj = Units.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
for (index = 0; index < Infantry.Count(); index++) {
InfantryClass * obj = Infantry.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
for (index = 0; index < Aircraft.Count(); index++) {
AircraftClass * obj = Aircraft.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
/*
** Center the map around the team if the ALT key was pressed too.
*/
if (action == 3) {
Map.Center_Map();
Map.Flag_To_Redraw(true);
}
break;
/*
** Additive selection of team.
*/
case 1:
for (index = 0; index < Units.Count(); index++) {
UnitClass * obj = Units.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
for (index = 0; index < Infantry.Count(); index++) {
InfantryClass * obj = Infantry.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
for (index = 0; index < Aircraft.Count(); index++) {
AircraftClass * obj = Aircraft.Ptr(index);
if (obj && !obj->IsInLimbo && obj->Group == team && obj->House == PlayerPtr) {
if (!obj->Is_Selected_By_Player()) {
obj->Select();
AllowVoice = false;
}
}
}
break;
/*
** Create the team.
*/
case 2:
for (index = 0; index < Units.Count(); index++) {
UnitClass * obj = Units.Ptr(index);
if (obj && !obj->IsInLimbo && obj->House == PlayerPtr) {
if (obj->Group == team) obj->Group = -1;
if (obj->Is_Selected_By_Player()) obj->Group = team;
}
}
for (index = 0; index < Infantry.Count(); index++) {
InfantryClass * obj = Infantry.Ptr(index);
if (obj && !obj->IsInLimbo && obj->House == PlayerPtr) {
if (obj->Group == team) obj->Group = -1;
if (obj->Is_Selected_By_Player()) obj->Group = team;
}
}
for (index = 0; index < Aircraft.Count(); index++) {
AircraftClass * obj = Aircraft.Ptr(index);
if (obj && !obj->IsInLimbo && obj->House == PlayerPtr) {
if (obj->Group == team) obj->Group = -1;
if (obj->Is_Selected_By_Player()) obj->Group = team;
}
}
break;
}
AllowVoice = true;
}
/***********************************************************************************************
* Handle_View -- Either records or restores the tactical view. *
* *
* This routine is used to record or restore the current map tactical view. *
* *
* INPUT: view -- The view number to work with. *
* *
* action-- The action to perform with this view number. *
* 0 = Restore the view to this previously remembered location. *
* 1 = Record the current view location. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/04/1995 JLB : Created. *
*=============================================================================================*/
void Handle_View(int view, int action)
{
if ((unsigned)view < sizeof(Views)/sizeof(Views[0])) {
if (action == 0) {
Map.Set_Tactical_Position(Cell_Coord(Views[view])&0xFF00FF00L);
Map.Flag_To_Redraw(true);
} else {
Views[view] = Coord_Cell(Map.TacticalCoord);
}
}
}
#ifdef CHEAT_KEYS
void Heap_Dump_Check( char *string )
{
#if 0
struct _heapinfo h_info;
int heap_status;
#endif
if ( !Debug_Trap_Check_Heap ) { // check the heap?
return;
}
// Debug_Heap_Dump = true;
Smart_Printf( "%s\n", string );
Dump_Heap_Pointers();
#if 0
heap_status = _heapset( 0xee );
#if (1)
if ( heap_status == _HEAPOK ||
heap_status == _HEAPEMPTY ) {
Debug_Heap_Dump = false;
return;
}
h_info._pentry = NULL;
for(;;) {
heap_status = _heapwalk( &h_info );
if ( heap_status != _HEAPOK )
break;
}
if (heap_status != _HEAPEND &&
heap_status != _HEAPEMPTY) {
#endif
h_info._pentry = NULL;
for(;;) {
heap_status = _heapwalk( &h_info );
if ( heap_status != _HEAPOK )
break;
Smart_Printf( " %s block at %Fp of size %4.4X\n",
(h_info._useflag == _USEDENTRY ? "USED" : "FREE"),
h_info._pentry, h_info._size );
}
Smart_Printf( " %d block at %Fp of size %4.4X\n",
h_info._useflag, h_info._pentry, h_info._size );
switch ( heap_status ) {
// case _HEAPEND:
// Smart_Printf( "OK - end of heap\n" );
// break;
// case _HEAPEMPTY:
// Smart_Printf( "OK - heap is empty\n" );
// break;
case _HEAPBADBEGIN:
Smart_Printf( "ERROR - heap is damaged\n" );
break;
case _HEAPBADPTR:
Smart_Printf( "ERROR - bad pointer to heap\n" );
break;
case _HEAPBADNODE:
Smart_Printf( "ERROR - bad node in heap\n" );
break;
}
#if (1)
}
#endif
#endif
// Debug_Heap_Dump = false;
}
void Dump_Heap_Pointers( void )
{
// ST - 1/2/2019 4:04PM
#if (0)
char *ptr, *lptr, *nptr, *cptr, *dptr, *wlptr, *nlptr, *aptr, *clptr;
int numallocs, numfrees, sizefree;
static char _freeorused[2][5] = { "FREE", "USED" };
ptr = (char *)__nheapbeg;
while ( ptr ) {
if ( Debug_Heap_Dump ) {
Smart_Printf( "%p pre header\n", (ptr - 8) );
Hex_Dump_Data( (ptr - 8), 0x08);
Smart_Printf( "%p header\n", ptr );
Hex_Dump_Data( ptr, 0x30);
}
dptr = (char *)*(int *)(ptr + 0x0c);
sizefree = *(int *)(ptr + 0x14);
numallocs = *(int *)(ptr + 0x18);
numfrees = *(int *)(ptr + 0x1c);
cptr = (char *)*(int *)(ptr + 0x24);
lptr = (char *)*(int *)(ptr + 0x28);
if ( ((int)cptr & 0xff000000) ||
((int)dptr & 0xff000000) ||
((int)lptr & 0xff000000) ) {
Error_In_Heap_Pointers( "local free heap ptrs too large" );
}
if ( Debug_Heap_Dump ) {
if ( lptr != dptr ||
lptr != cptr ||
cptr != dptr ) {
Smart_Printf( "The pointers are different!!\n" );
}
}
nptr = (char *)*(int *)(ptr + 8); // next block
if ( ((int)nptr & 0xFF000000) ) {
Error_In_Heap_Pointers( "next block ptr too large" );
}
if ( lptr != (ptr + 0x20) ) {
if ( !(*((int *)(ptr + 0x20))) ) { // allocated
aptr = (ptr + 0x2c);
while ( aptr < lptr ) {
if ( (*(int *)(aptr)) == -1) {
// Smart_Printf( "end alloc chain %p.\n", aptr );
// Hex_Dump_Data( aptr, 0x10);
break;
}
if ( Debug_Heap_Dump ) {
Smart_Printf( "%p chain %s, size %X.\n", aptr,
_freeorused[ ((*aptr) & 1) ],
((*(int *)(aptr)) & 0xfffffffe) );
Hex_Dump_Data( aptr, 0x10);
}
if ( ((*(int *)(aptr)) & 0xff000000) ) {
Error_In_Heap_Pointers( "alloc block size way too large" );
}
aptr += ((*(int *)(aptr)) & 0xfffffffe);
if ( ((int)aptr & 0xff000000) ) {
Error_In_Heap_Pointers( "next alloc block ptr way too large" );
}
numallocs--;
if ( aptr > lptr ) {
Error_In_Heap_Pointers( "next alloc block ptr too large" );
}
}
} else {
if ( sizefree != -1 ) {
sizefree -= ((*(int *)(ptr + 0x20)) & 0xfffffffe);
}
numfrees--;
}
wlptr = lptr;
while ( wlptr != (ptr + 0x20) ) {
if ( Debug_Heap_Dump ) {
Smart_Printf( "%p link %s, size %X.\n", wlptr,
_freeorused[ ((*wlptr) & 1) ],
((*(int *)(wlptr)) & 0xfffffffe) );
Hex_Dump_Data( wlptr, 0x10);
}
nlptr = (char *)*(int *)(wlptr + 8);
if ( !(*((int *)(wlptr))) ) { // allocated
aptr = (wlptr + 0x0c);
} else {
if ( sizefree != -1 ) {
sizefree -= ((*(int *)(wlptr)) & 0xfffffffe);
}
numfrees--;
aptr = (wlptr + ((*(int *)(wlptr)) & 0xfffffffe));
}
if (nlptr == (ptr + 0x20) ) {
clptr = nptr;
} else {
clptr = nlptr;
}
while ( aptr < clptr ) {
if ( (*(int *)(aptr)) == -1) {
// Smart_Printf( "end alloc chain %p.\n", aptr );
// Hex_Dump_Data( aptr, 0x10);
break;
}
if ( Debug_Heap_Dump ) {
Smart_Printf( "%p chain %s, size %X.\n", aptr,
_freeorused[ ((*aptr) & 1) ],
((*(int *)(aptr)) & 0xfffffffe) );
Hex_Dump_Data( aptr, 0x10);
}
if ( ((*(int *)(aptr)) & 0xff000000) ) {
Error_In_Heap_Pointers( "alloc block size way too large" );
}
aptr += ((*(int *)(aptr)) & 0xfffffffe);
if ( ((int)aptr & 0xff000000) ) {
Error_In_Heap_Pointers( "next alloc block ptr way too large" );
}
numallocs--;
if ( aptr > clptr ) {
Error_In_Heap_Pointers( "next alloc block ptr too large" );
}
}
wlptr = nlptr;
}
} else {
// Smart_Printf( "only link %s, size %X.\n",
// _freeorused[ ((*lptr) & 1) ],
// ((*(int *)(lptr)) & 0xfffffffe) );
if ( !(*((int *)(lptr))) ) { // allocated
aptr = (ptr + 0x2c);
while ( aptr < nptr ) {
if ( (*(int *)(aptr)) == -1) {
// Smart_Printf( "end alloc chain %p.\n", aptr );
// Hex_Dump_Data( aptr, 0x10);
break;
}
if ( Debug_Heap_Dump ) {
Smart_Printf( "%p chain %s, size %X.\n", aptr,
_freeorused[ ((*aptr) & 1) ],
((*(int *)(aptr)) & 0xfffffffe) );
Hex_Dump_Data( aptr, 0x10);
}
if ( ((*(int *)(aptr)) & 0xff000000) ) {
Error_In_Heap_Pointers( "alloc block size way too large" );
}
aptr += ((*(int *)(aptr)) & 0xfffffffe);
if ( ((int)aptr & 0xff000000) ) {
Error_In_Heap_Pointers( "next alloc block ptr way too large" );
}
numallocs--;
if ( aptr > nptr ) {
Error_In_Heap_Pointers( "next alloc block ptr too large" );
}
}
} else {
if ( sizefree != -1 ) {
sizefree -= ((*(int *)(ptr + 0x20)) & 0xfffffffe);
}
numfrees--;
}
}
if ( sizefree != 0 && sizefree != -1 ) {
Smart_Printf( "sizefree left over %X.\n", sizefree );
}
if ( numallocs != 0 ) {
Smart_Printf( "numallocs unaccounted for %d.\n", numallocs );
}
if ( numfrees != 0 ) {
Smart_Printf( "numfrees unaccounted for %d.\n", numfrees );
}
ptr = nptr;
}
#endif
}
void Error_In_Heap_Pointers( char *string )
{
Smart_Printf( "Error in Heap for %s\n", string );
}
#endif
#ifndef ROR_NOT_READY
#define ROR_NOT_READY 21
#endif
/***********************************************************************************************
* Get_CD_Index -- returns the volume type of the CD in the given drive *
* *
* *
* *
* INPUT: drive number *
* timeout *
* *
* OUTPUT: 0 = gdi *
* 1 = nod *
* 2 = covert *
* -1 = non C&C *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 5/21/96 5:27PM ST : Created *
*=============================================================================================*/
int Get_CD_Index (int cd_drive, int timeout)
{
char volume_name[128];
unsigned filename_length;
unsigned misc_dword;
//unsigned error_code;
int count = 0;
CountDownTimerClass timer;
static char * _volid[] = {
"GDI95",
"NOD95",
"COVERT"
};
static int num_volumes = 3;
char buffer[128];
timer.Set(timeout);
/*
** Get the volume label. If we get a 'not ready' error then retry for the timeout
** period.
*/
do{
sprintf(buffer, "%c:\\", 'A' + cd_drive);
if (GetVolumeInformation ((char const *)buffer,
&volume_name[0] ,
(unsigned long)128 ,
(unsigned long *)NULL ,
(unsigned long *)&filename_length,
(unsigned long *)&misc_dword ,
(char *)NULL ,
(unsigned long)0)) {
/*
** Try opening 'movies.mix' to verify that the CD is really there and is what
** it says it is.
*/
sprintf(buffer, "%c:\\movies.mix", 'A' + cd_drive);
HANDLE handle = CreateFile(buffer, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (handle != INVALID_HANDLE_VALUE) {
CloseHandle(handle);
/*
** Match the volume label to the list of known C&C volume labels.
*/
for (int i=0 ; i<num_volumes ; i++){
if (!stricmp(_volid[i], volume_name)) return (i);
}
}else{
if (count++){
return (-1);
}
}
}else{
/*
** Failed to get the volume label on a known CD drive.
** If this is a CD changer it may require time to swap the disks so dont return
** immediately if the error is ROR_NOT_READY
*/
if (GetLastError() != ROR_NOT_READY || !timer.Time()) return (-1);
}
}while(true);
}
/***********************************************************************************************
* Force_CD_Available -- Ensures that specified CD is available. *
* *
* Call this routine when you need to ensure that the specified CD is actually in the *
* CD-ROM drive. *
* *
* INPUT: cd -- The CD that must be available. This will either be "0" for the GDI CD, or *
* "1" for the Nod CD. If either CD will qualify, then pass in "-1". *
* *
* OUTPUT: Is the CD inserted and available? If false is returned, then this indicates that *
* the player pressed <CANCEL>. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/11/1995 JLB : Created. *
* 05/22/1996 ST : Handles multiple CD drives / CD changers *
*=============================================================================================*/
#pragma warning (disable : 4101)
bool Force_CD_Available(int cd)
{
#if (1) //ST - 1/2/2019 5:44PM
static int _last = -1;
if (_last != cd) {
_last = cd;
Theme.Stop();
if (MoviesMix) {
delete MoviesMix;
MoviesMix = 0;
}
if (GeneralMix) {
delete GeneralMix;
GeneralMix = 0;
}
if (ScoreMix) {
delete ScoreMix;
ScoreMix = 0;
}
MoviesMix = new MixFileClass("MOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("SCORES.MIX");
#if (0)
switch ( cd ) {
case -1:
default:
MoviesMix = new MixFileClass("MOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("SCORES.MIX");
break;
case 0:
MoviesMix = new MixFileClass("GDIMOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("GDISCORES.MIX");
break;
case 1:
MoviesMix = new MixFileClass("NODMOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("NODSCORES.MIX");
break;
case 2:
MoviesMix = new MixFileClass("COVERTMOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("COVERTSCORES.MIX");
break;
}
#endif
ThemeClass::Scan();
}
return true;
#else
#ifndef DEMO
static int _last = -1;
int open_failed;
int file;
#endif
static char _palette[768];
static char _hold[256];
static void *font;
static char * _volid[] = {
"GDI",
"NOD",
"COVERT"
};
int drive;
char volume_name[100];
unsigned filename_length;
unsigned misc_dword;
int new_cd_drive = 0;
int cd_index;
char buffer[128];
int cd_drive;
int current_drive;
int drive_search_timeout;
bool old_in_main_loop;
ThemeType theme_playing = THEME_NONE;
/*
** If the required CD is set to -2 then it means that the file is present
** on the local hard drive and we shouldn't have to worry about it.
*/
if (cd == -2) return(true);
/*
** Find out if the CD in the current drive is the one we are looking for
*/
current_drive = CCFileClass::Get_CD_Drive();
cd_index = Get_CD_Index(current_drive, 1*60);
if (cd_index >= 0){
if (cd == cd_index || cd == -1){
/*
** The required CD is still in the CD drive we used last time
*/
new_cd_drive = current_drive;
}
}
/*
** Flag that we will have to restart the theme
*/
theme_playing = Theme.What_Is_Playing();
Theme.Stop();
if (!new_cd_drive){
/*
** Check the last CD drive we used if its different from the current one
*/
int last_drive = CCFileClass::Get_Last_CD_Drive();
/*
** Make sure the last drive is valid and it isnt the current drive
*/
if (last_drive && last_drive != CCFileClass::Get_CD_Drive()){
/*
** Find out if there is a C&C cd in the last drive and if so is it the one we are looking for
** Give it a nice big timeout so the CD changer has time to swap the discs
*/
cd_index = Get_CD_Index(last_drive, 10*60);
if (cd_index >= 0){
if (cd == cd_index || cd == -1){
/*
** The required CD is in the CD drive we used last time
*/
new_cd_drive = last_drive;
}
}
}
}
/*
** Lordy. No sign of that blimming CD anywhere. Search all the CD drives
** then if we still cant find it prompt the user to insert it.
*/
if (!new_cd_drive){
/*
** Small timeout for the first pass through the drives
*/
drive_search_timeout = 2*60;
for (;;) {
/*
** Search all present CD drives for the required disc.
*/
for (int i=0 ; i<CDList.Get_Number_Of_Drives() ; i++){
cd_drive = CDList.Get_Next_CD_Drive();
cd_index = Get_CD_Index(cd_drive, drive_search_timeout);
if (cd_index>=0){
/*
** We found a C&C cd - lets see if it was the one we were looking for
*/
if (cd == cd_index || cd == -1){
/*
** Woohoo! The disk was in a different cd drive. Refresh the search path list
* and return.
*/
new_cd_drive = cd_drive;
break;
}
}
}
/*
** A new disc has become available so break
*/
if (new_cd_drive) break;
/*
** Increase the timeout for subsequent drive searches.
*/
drive_search_timeout = 5*60;
/*
** Prompt to insert the CD into the drive.
*/
if (cd == -1) {
sprintf(buffer, Text_String(TXT_CD_DIALOG_1), cd+1, _volid[cd]);
} else {
if (cd == 2) {
sprintf(buffer, Text_String(TXT_CD_DIALOG_3));
} else {
sprintf(buffer, Text_String(TXT_CD_DIALOG_2), cd+1, _volid[cd]);
}
}
GraphicViewPortClass * oldpage = Set_Logic_Page(SeenBuff);
theme_playing = Theme.What_Is_Playing();
Theme.Stop();
int hidden = Get_Mouse_State();
font = (void *)FontPtr;
Mem_Copy(CurrentPalette, _palette, 768);
Mem_Copy(Get_Font_Palette_Ptr(), _hold, 256);
/*
** Only set the palette if necessary.
*/
// if (CurrentPalette[3] == 0) {
Set_Palette(GamePalette);
// }
/*
** Pretend we are in the game, even if we arent
*/
old_in_main_loop = InMainLoop;
InMainLoop = true;
Keyboard::Clear();
while (Get_Mouse_State()) Show_Mouse();
if (CCMessageBox().Process(buffer, TXT_OK, TXT_CANCEL, TXT_NONE, TRUE) == 1) {
Set_Logic_Page(oldpage);
Hide_Mouse();
InMainLoop = old_in_main_loop;
return(false);
}
while (hidden--) Hide_Mouse();
Set_Palette(_palette);
Set_Font(font);
Mem_Copy(_hold, Get_Font_Palette_Ptr(), 256);
Set_Logic_Page(oldpage);
InMainLoop = old_in_main_loop;
}
}
#ifndef DEMO
CCFileClass::Set_CD_Drive(new_cd_drive);
CCFileClass::Refresh_Search_Drives();
/*
** If it broke out of the query for CD-ROM loop, then this means that the
** CD-ROM has been inserted.
*/
if (cd > -1 && _last != cd) {
_last = cd;
Theme.Stop();
if (MoviesMix) delete MoviesMix;
if (GeneralMix) delete GeneralMix;
if (ScoreMix) delete ScoreMix;
MoviesMix = new MixFileClass("MOVIES.MIX");
GeneralMix = new MixFileClass("GENERAL.MIX");
ScoreMix = new MixFileClass("SCORES.MIX");
ThemeClass::Scan();
}
#endif
if (theme_playing != THEME_NONE) {
Theme.Queue_Song(theme_playing);
}
return(true);
#endif
}
/***************************************************************************
* DISK_SPACE_AVAILABLE -- returns bytes of free disk space *
* *
* INPUT: none *
* *
* OUTPUT: returns amount of free disk space *
* *
* HISTORY: *
* 08/11/1995 PWG : Created. *
*=========================================================================*/
unsigned long Disk_Space_Available(void)
{
return 0x7fffffff;
#if (0)
struct diskfree_t diskdata;
unsigned drive;
_dos_getdrive(&drive);
_dos_getdiskfree(drive, &diskdata);
return(diskdata.avail_clusters * diskdata.sectors_per_cluster * diskdata.bytes_per_sector);
#endif
}
/***********************************************************************************************
* Validate_Error -- prints an error message when an object fails validation *
* *
* INPUT: *
* name name of object type that failed *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 08/15/1995 BRR : Created. *
*=============================================================================================*/
void Validate_Error(char *name)
{
GlyphX_Debug_Print("Validate_Error");
GlyphX_Debug_Print(name);
#ifdef CHEAT_KEYS
Prog_End(NULL, true);
printf("%s object error!\n",name);
if (!RunningAsDLL) {
exit(0);
}
#else
name = name;
#endif
}
/***********************************************************************************************
* Do_Record_Playback -- handles saving/loading map pos & current object *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* none. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 08/15/1995 BRR : Created. *
*=============================================================================================*/
static void Do_Record_Playback(void)
{
int count;
TARGET tgt;
int i;
COORDINATE coord;
ObjectClass *obj;
unsigned long sum;
unsigned long sum2;
unsigned long ltgt;
/*------------------------------------------------------------------------
Record a game
------------------------------------------------------------------------*/
if (RecordGame) {
/*.....................................................................
For 'SuperRecord', we'll open & close the file with every entry.
.....................................................................*/
if (SuperRecord) {
RecordFile.Open(READ|WRITE);
RecordFile.Seek(0,SEEK_END);
}
/*.....................................................................
Save the map's location
.....................................................................*/
RecordFile.Write(&Map.DesiredTacticalCoord, sizeof (Map.DesiredTacticalCoord));
/*.....................................................................
Save the current object list count
.....................................................................*/
count = CurrentObject.Count();
RecordFile.Write(&count, sizeof(count));
/*.....................................................................
Save a CRC of the selected-object list.
.....................................................................*/
sum = 0;
for (i = 0; i < count; i++) {
ltgt = (unsigned long)(CurrentObject[i]->As_Target());
sum += ltgt;
}
RecordFile.Write (&sum, sizeof(sum));
/*.....................................................................
Save all selected objects.
.....................................................................*/
for (i = 0; i < count; i++) {
tgt = CurrentObject[i]->As_Target();
RecordFile.Write (&tgt, sizeof(tgt));
}
/*.....................................................................
If 'SuperRecord', close the file now.
.....................................................................*/
if (SuperRecord) {
RecordFile.Close();
}
}
/*------------------------------------------------------------------------
Play back a game ("attract" mode)
------------------------------------------------------------------------*/
if (PlaybackGame) {
/*.....................................................................
Read & set the map's location.
.....................................................................*/
if (RecordFile.Read(&coord, sizeof(coord))==sizeof(coord)) {
if (coord != Map.DesiredTacticalCoord) {
Map.Set_Tactical_Position(coord);
}
}
if (RecordFile.Read(&count, sizeof(count))==sizeof(count)) {
/*..................................................................
Compute a CRC of the current object-selection list.
..................................................................*/
sum = 0;
for (i = 0; i < CurrentObject.Count(); i++) {
ltgt = (unsigned long)(CurrentObject[i]->As_Target());
sum += ltgt;
}
/*..................................................................
Load the CRC of the objects on disk; if it doesn't match, select
all objects as they're loaded.
..................................................................*/
RecordFile.Read (&sum2, sizeof(sum2));
if (sum2 != sum)
Unselect_All();
AllowVoice = true;
for (i = 0; i < count; i++) {
if (RecordFile.Read (&tgt, sizeof(tgt))==sizeof(tgt)) {
obj = As_Object(tgt);
if (obj && (sum2 != sum)) {
obj->Select();
AllowVoice = false;
}
}
}
AllowVoice = true;
}
/*.....................................................................
The map isn't drawn in playback mode, so draw it here.
.....................................................................*/
Map.Render();
}
}
/***************************************************************************
* HIRES_RETRIEVE -- retrieves a resolution dependant file *
* *
* INPUT: char * file name of the file to retrieve *
* *
* OUTPUT: none *
* *
* HISTORY: *
* 01/25/1996 : Created. *
*=========================================================================*/
void const * Hires_Retrieve(char *name)
{
char filename[30];
if (SeenBuff.Get_Width() != 320) {
sprintf(filename,"H%s", name);
} else {
strcpy(filename, name);
}
return(MixFileClass::Retrieve(filename));
}
int Get_Resolution_Factor(void)
{
return ((SeenBuff.Get_Width() == 320) ? 0 : 1);
}
/**************************************************************************************************
* Blit_Hid_Page_To_Seen_Buff -- Intercept for when the game refreshes the visible page
*
* In: Command line
*
* Out:
*
*
*
* History: 1/3/2019 11:33AM - ST
**************************************************************************************************/
void Blit_Hid_Page_To_Seen_Buff(void)
{
HidPage.Blit(SeenBuff);
}
/***********************************************************************************************
* Shake_The_Screen -- Dispatcher that shakes the screen. *
* *
* This routine will shake the game screen the number of shakes requested. *
* *
* INPUT: shakes -- The number of shakes to shake the screen. *
* house -- House to perform the shake for (or HOUSE_NONE if all players). *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/04/1996 BWG : Created. *
*=============================================================================================*/
void Shake_The_Screen(int shakes, HousesType house)
{
for (char h = HOUSE_FIRST; h < HOUSE_COUNT; ++h) {
if ((house != HOUSE_NONE) && (h != house)) {
continue;
}
HouseClass* hptr = HouseClass::As_Pointer((HousesType)h);
if ((hptr != nullptr) && hptr->IsActive && hptr->IsHuman) {
hptr->ScreenShakeTime = hptr->ScreenShakeTime + shakes + shakes;
}
}
}
Reference in New Issue View Git Blame Copy Permalink