TiberianDawn/DEBUG.CPP

/*
**	Command & Conquer(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program 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.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* $Header:   F:\projects\c&c\vcs\code\debug.cpv   2.17   16 Oct 1995 16:49:18   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 : DEBUG.CPP                                                    *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : September 10, 1993                                           *
 *                                                                                             *
 *                  Last Update : July 5, 1994   [JLB]                                         *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   Self_Regulate -- Regulates the logic timer to result in smooth animation.                 *
 *   Debug_Key -- Debug mode keyboard processing.                                              *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "function.h"
#include	<stdarg.h>
#include <filepcx.h>
#include <io.h>
#ifdef CHEAT_KEYS

extern bool ScreenRecording;

/***********************************************************************************************
 * Debug_Key -- Debug mode keyboard processing.                                                *
 *                                                                                             *
 *    If debugging is enabled, then this routine will be called for every keystroke that the   *
 *    game doesn't recognize. These extra keys usually perform some debugging function.        *
 *                                                                                             *
 * INPUT:   input -- The key code that was pressed.                                            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/07/1992 JLB : Created.                                                                 *
 *=============================================================================================*/
void Debug_Key(unsigned input)
{
	static int map_x = -1;
	static int map_y = -1;
	static int map_width = -1;
	static int map_height = -1;

	if (!input || input & KN_BUTTON) return;

	/*
	**	Processing of normal keystrokes.
	*/
	if (Debug_Flag) {

		switch (input) {

			case KN_L:
				extern int NetMonoMode,NewMonoMode;
				if (NetMonoMode)
					NetMonoMode = 0;
				else
					NetMonoMode = 1;
				NewMonoMode = 1;
				break;

			/*
			** Start saving off screens
			*/
			case (int)KN_K|(int)KN_CTRL_BIT:
				ScreenRecording = true;
				break;

			case KN_K:
				/*
				** time to create a screen shot using the PCX code (if it works)
				*/
				{
					GraphicBufferClass temp_page(	SeenBuff.Get_Width(),
															SeenBuff.Get_Height(),
															NULL,
															SeenBuff.Get_Width() * SeenBuff.Get_Height());
					char filename[30];

					SeenBuff.Blit(temp_page);
					for (int lp = 0; lp < 99; lp ++) {
						if (lp < 10) {
							sprintf(filename, "scrsht0%d.pcx", lp);
						} else {
							sprintf(filename, "scrsht%d.pcx", lp);
						}
						if (access(filename, F_OK) == -1)
							break;
					}

					Write_PCX_File(filename, temp_page, (unsigned char *)CurrentPalette);
					//Map.Place_Random_Crate();
				}
				break;

			case KN_P:
				Keyboard::Clear();
				while (!Keyboard::Check()) {
					Self_Regulate();
					Sound_Callback();
				}
				Keyboard::Clear();
				break;

			case KN_O:
				{
					AircraftClass * air = new AircraftClass(AIRCRAFT_ORCA, PlayerPtr->Class->House);
					if (air) {
						air->Altitude = 0;
						air->Unlimbo(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), DIR_N);
					}
				}
				break;

			case (int)KN_B|(int)KN_ALT_BIT:
				{
					Debug_Instant_Build ^= 1;
				}
				break;
			case KN_B:
				{
					AircraftClass * air = new AircraftClass(AIRCRAFT_HELICOPTER, PlayerPtr->Class->House);
					if (air) {
						air->Altitude = 0;
						air->Unlimbo(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), DIR_N);
					}
				}
				break;

			case KN_T:
				{
					AircraftClass * air = new AircraftClass(AIRCRAFT_TRANSPORT, PlayerPtr->Class->House);
					if (air) {
						air->Altitude = 0;
						air->Unlimbo(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), DIR_N);
					}
				}
				break;

			case KN_GRAVE:
				new AnimClass(ANIM_ART_EXP1, Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()));
				Explosion_Damage(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), 250, NULL, WARHEAD_HE);
				break;

			case KN_Z:
//				new AnimClass(ANIM_LZ_SMOKE, Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()));
				GDI_Ending();
				break;

			case KN_C:
				Debug_Cheat = (Debug_Cheat == false);
				PlayerPtr->IsRecalcNeeded = true;
				PlayerPtr->Add_Nuke_Piece();
				PlayerPtr->Add_Nuke_Piece();
				PlayerPtr->Add_Nuke_Piece();

				/*
				**	This placement might affect any prerequisite requirements for construction
				**	lists. Update the buildable options accordingly.
				*/
				if (!ScenarioInit) {
					Map.Recalc();
					for (int index = 0; index < Buildings.Count(); index++) {
						Buildings.Ptr(index)->Update_Buildables();
					}
				}
				break;

			case (int)KN_Z|(int)KN_ALT_BIT:
				if (map_x == -1) {
					map_x = Map.MapCellX;
					map_y = Map.MapCellY;
					map_width = Map.MapCellWidth;
					map_height = Map.MapCellHeight;
					Map.MapCellX = 1;
					Map.MapCellY = 1;
					Map.MapCellWidth = 62;
					Map.MapCellHeight = 62;
				} else {
					Map.MapCellX = map_x;
					Map.MapCellY = map_y;
					Map.MapCellWidth = map_width;
					Map.MapCellHeight = map_height;
					map_x = -1;
					map_y = -1;
					map_width = -1;
					map_height = -1;
				}
				break;

#ifdef NEVER
			case KN_G:
				HouseClass::As_Pointer(HOUSE_GOOD)->Flag_Attach(Map.Click_Cell_Calc(Get_Mouse_X(), Get_Mouse_Y()));
				break;

			case KN_N:
				HouseClass::As_Pointer(HOUSE_BAD)->Flag_Attach(Map.Click_Cell_Calc(Get_Mouse_X(), Get_Mouse_Y()));
				break;
#endif

			case KN_R:
				if (CurrentObject.Count()) {
					((TechnoClass *)CurrentObject[0])->IsCloakable = true;
				}
				break;

			case KN_M:
				if (Debug_Flag) {
					if (MonoClass::Is_Enabled()) {
						MonoClass::Disable();
					} else {
						MonoClass::Enable();
					}
				}
				break;

			case (int)KN_W|(int)KN_ALT_BIT:
				PlayerPtr->Flag_To_Win();
				break;

			case (int)KN_L|(int)KN_ALT_BIT:
				PlayerPtr->Flag_To_Lose();
				break;

			case KN_F:
				Debug_Find_Path ^= 1;
				break;

			case KN_DELETE:
				if (CurrentObject.Count()) {
					Map.Recalc();
					//CurrentObject[0]->Detach_All();
					delete CurrentObject[0];
				}
				break;

			case KN_D:
				if (Teams.Ptr(0)) {
					delete Teams.Ptr(0);
				}
				break;

			case (int)KN_DELETE|(int)KN_SHIFT_BIT:
				if (CurrentObject.Count()) {
					Map.Recalc();
					int damage = 50;
					CurrentObject[0]->Take_Damage(damage, 0, WARHEAD_SA);
				}
				break;

			case KN_INSERT:
				if (CurrentObject.Count()) {
					Map.PendingObject = &CurrentObject[0]->Class_Of();
					if (Map.PendingObject) {
						Map.PendingHouse = CurrentObject[0]->Owner();
						Map.PendingObjectPtr = Map.PendingObject->Create_One_Of(HouseClass::As_Pointer(Map.PendingHouse));
						if (Map.PendingObjectPtr) {
							Map.Set_Cursor_Pos();
							Map.Set_Cursor_Shape(Map.PendingObject->Occupy_List());
						}
					}
				}
				break;

#ifdef NEVER
			case KN_1:
			case KN_2:
			case KN_3:
			case KN_4:
			case KN_5:
			case KN_6:
			case KN_7:
			case KN_8:
			case KN_9:
			case KN_0:
				MonoPage = (input & 0xFF) - KN_1;
				MonoPage %= sizeof(MonoArray)/sizeof(MonoArray[0]);
				MonoArray[MonoPage].View();
				input = 0;
				break;
#endif

#ifdef NEVER
			case ((int)KN_F1 | (int)KN_SHIFT_BIT):
				Special.IsBarOn = (Special.IsBarOn == false);
				Map.Flag_To_Redraw(true);
				break;

			case ((int)KN_F1 | (int)KN_SHIFT_BIT):	// quick load/save for debugging
				if (!Save_Game(0,"Command & Conquer Save Game File")) {
					CCMessageBox().Process("Error saving game!");
					Prog_End();
					exit(EXIT_SUCCESS);
				}
				break;

			case ((int)KN_F2 | (int)KN_SHIFT_BIT):	// quick load/save for debugging
				if (!Load_Game(0)) {
					CCMessageBox().Process("Error loading game!");
					Prog_End();
					exit(EXIT_SUCCESS);
				}
				break;

//#ifdef SCENARIO_EDITOR
			case KN_F2:		// enable/disable the map editor
				Go_Editor(!Debug_Map);
				break;
//#endif
#endif

#ifdef NEVER
			case KN_F2: {
				Debug_Map++;
				Scenario_Editor();
				Debug_Map--;
#ifdef NEVER
				COORDINATE		coord;
				int		index;
				static COORDINATE	_coords[] = {
					0x00010001L,
					0x00800080L,
					0x00810081L,
					0x00010081L,
					0x00810001L,
					0x00800081L,
					0x00800001L,
					0x00010080L,
					0x00810080L,
					0L
				};
				index = 0;
				while (_coords[index]) {
					coord = _coords[index++];
					Mono_Printf("Spillage for %08lX = %d.\r", coord, Coord_Spillage_Number(coord));
				}
				Keyboard::Clear();
				Keyboard::Get();

#endif

#ifdef NEVER
#define MAX_RADIUS	10
					COORDINATE	coord;
					int	x,y;
					COORDINATE	const *ptr;
					int	input;
					int	f1,f2;
					TurnTrackType	const *track;

					#define	XCENTER	160
					#define	YCENTER	100
					for (;;) {
						VisiblePage.Clear();

						// Draw grid.
						{
							static int _gridx[] = {0,64,128,192,0,64,128,192,0,64,128,192};
							static int _gridy[] = {0,0,0,0,64,64,64,64,128,128,128,128};
							int	index;

							for (index = 0; index < 12; index++) {
								LogicPage->Put_Pixel((_gridx[index]+XCENTER)-(32+64),(_gridy[index]+YCENTER)-(32+64), DKGRAY);
							}
						}

						// Get facing #1.
						LogicPage->Print("Facing #1 (0-7)?", 0, 0, WHITE, BLACK);
						input = Keyboard::Get();
						if (input == KA_ESC) break;
						input -= KA_0;
						input = Bound(input, 0, 7);
//						input = MAX(input, 0);
//						input = MIN(input, 7);
						f1 = input;
						Int_Print(f1, 100, 0, WHITE, BLACK);

						// Get facing #2.
						LogicPage->Print("Facing #2 (0-7)?", 0, 10, WHITE, BLACK);
						input = Keyboard::Get();
						if (input == KA_ESC) break;
						input -= KA_0;
						input = Bound(input, 0, 7);
//						input = MAX(input, 0);
//						input = MIN(input, 7);
						f2 = input;
						Int_Print(f2, 100, 10, WHITE, BLACK);

						track = &TrackControl[f1][f2];
						if (track->Track == 0) {
							LogicPage->Print("Undefined track.", 0, 30, WHITE, BLACK);
						} else {
							int	index;	// Track index counter.

							ptr = TrackPointers[track->Track-1];
							index = 0;
							while (ptr[index]) {
								coord = Smooth_Turn(NULL, ptr[index], track->Flag);

								x = (int)(coord & 0xFFFF);
								y = (int)((coord >> 16) & 0xFFFF);
								LogicPage->Put_Pixel(XCENTER + (x>>2), YCENTER + (y>>2), WHITE);
								Delay(1);
								index++;
							}

						}
						input = Keyboard::Get();
						if (input == KA_ESC) break;
					}

					Map.Flag_To_Redraw(true);
#endif
#ifdef NEVER
					FILE	*fh;
					int	index;
					COORDINATE	coord;

					fh = fopen("diagonal.txt", "wt");
					if (fh) {

						fprintf(fh, "track 2\n");
						coord = 0x0100FF00L;
						for (index = 0; index <= 48; index++) {
							fprintf(fh, "0x%08lXL\n", coord);
							coord = Coord_Move(coord, 32, 11);
						}
						fprintf(fh, "\n\n");

						fprintf(fh, "track 1\n");
						coord = 0x01000000L;
						for (index = 0; index <= 40; index++) {
							fprintf(fh, "0x%08lXL\n", coord);
							coord = Coord_Move(coord, 0, 11);
						}
						fprintf(fh, "\n\n");

						fclose(fh);
					}
#endif
#ifdef NEVER
					FILE	*fh;
					int	x,y,radius;
					int	radsize[MAX_RADIUS+2];
					int	count;

					memset(radsize, 0, sizeof(radsize));
					fh = fopen("Range.txt", "wt");
					if (fh) {
						fprintf(fh, "int const RadiusOffset[] = {\n");

						for (radius = 0; radius <= MAX_RADIUS; radius++) {

							fprintf(fh, "\t/* %-2d */\t", radius);
							for (y = -MAX_RADIUS; y <= MAX_RADIUS; y++) {
								for (x = -MAX_RADIUS; x <= MAX_RADIUS; x++) {
									int	xd,yd,dist;

									xd = ABS(x);
									yd = ABS(y);
									if (xd > yd) {
										dist = yd/2 + xd;
									} else {
										dist = xd/2 + yd;
									}
									if (dist == radius) {
										dist = y*MAP_CELL_W + x;

										if (y) {
											if (y < 0) {
												fprintf(fh, "(-MCW*%d)", ABS(y));
											} else {
												fprintf(fh, "(MCW*%d)", ABS(y));
											}
											fprintf(fh, "%c%d,", (x<0) ? '-' : '+', ABS(x));
										} else {
											fprintf(fh, "%d,", x);
										}
										radsize[radius]++;
									}
								}
							}
							fprintf(fh, "\n");
						}
						fprintf(fh, "};\n\n");

						count = 0;
						fprintf(fh, "int const RadiusCount[%d] = {", MAX_RADIUS+1);
						for (radius = 0; radius <= MAX_RADIUS; radius++) {
							count += radsize[radius];
							fprintf(fh, "%d", count);
							if (radius != MAX_RADIUS) {
								fprintf(fh, ",");
							}
						}
						fprintf(fh, "};\n");
						fclose(fh);
					}
#endif
				}
				break;
#endif

#ifdef NEVER
			case ((int)KN_F3 | (int)KN_ALT_BIT):	// quick load/save for debugging
				Debug_Threat = (Debug_Threat == false);
				Map.Flag_To_Redraw(true);
				break;

#endif

			case KN_F3:
				Debug_Icon = (Debug_Icon == false);
				Map.Flag_To_Redraw(true);
				break;


			/*
			**	Reveal entire map to player.
			*/
			case KN_F4:
				if (GameToPlay == GAME_NORMAL) {
					Debug_Unshroud = (Debug_Unshroud == false);
					Map.Flag_To_Redraw(true);
				}
				break;

			/*
			**	Shows sight and fire range in the form of circles emanating from the currently
			**	selected unit. The white circle is for sight range, the red circle is for
			**	fire range.
			*/
			case KN_F7:
				if (CurrentObject.Count() && CurrentObject[0]->Is_Techno()) {
					TechnoTypeClass const & ttype = (TechnoTypeClass const &)CurrentObject[0]->Class_Of();
					int sight = ((int)ttype.SightRange)<<8;
					int weapon = 0;
					if (ttype.Primary != WEAPON_NONE) weapon = Weapons[ttype.Primary].Range;
					Set_Logic_Page(SeenBuff);
					COORDINATE center = CurrentObject[0]->Center_Coord();
					COORDINATE center2 = CurrentObject[0]->Fire_Coord(0);

					for (int r = 0; r < 255; r += 10) {
						int	x,y,x1,y1;
						DirType r1 = (DirType)r;
						DirType r2 = (DirType)((r+10) & 0xFF);

						if (Map.Coord_To_Pixel(Coord_Move(center, r1, sight), x, y)) {
							Map.Coord_To_Pixel(Coord_Move(center, r2, sight), x1, y1);
							LogicPage->Draw_Line(x, y+8, x1, y1+8, WHITE);
						}
						if (Map.Coord_To_Pixel(Coord_Move(center2, r1, weapon), x, y)) {
							Map.Coord_To_Pixel(Coord_Move(center2, r2, weapon), x1, y1);
							LogicPage->Draw_Line(x, y+8, x1, y1+8, RED);
						}
					}
				}
				break;

			case ((int)KN_F4 | (int)KN_CTRL_BIT):
				Debug_Unshroud = (Debug_Unshroud == false);
				Map.Flag_To_Redraw(true);
				break;

#ifdef NEVER
			case KN_F5:
				Special.IsShowPath = (Special.IsShowPath == false);
				//PlayerPtr->Credits += 1000;
				break;

			case KN_F6:
				if (Map.In_Radar(XY_Cell(Map.MapCellX+5, Map.MapCellY - 1))) {
					Mono_Printf("Arrrggggghhhhh!");
				} else {
					Mono_Printf("No Arrrggggghhhhh!");
				}
				break;

			case ((int)KN_F9 | (int)KN_CTRL_BIT):
				if (HouseClass::As_Pointer(HOUSE_GOOD))
					(HouseClass::As_Pointer(HOUSE_GOOD))->Blowup_All();
				break;

			case ((int)KN_F10 | (int)KN_CTRL_BIT):
				if (HouseClass::As_Pointer(HOUSE_BAD))
					(HouseClass::As_Pointer(HOUSE_BAD))->Blowup_All();
				break;
#endif
		}

	}
}


/***********************************************************************************************
 * Self_Regulate -- Regulates the logic timer to result in smooth animation                    *
 *                                                                                             *
 *    The self regulation process checks the number of frames displayed                        *
 *    per second and from this determines the amount of time to devote                         *
 *    to internal logic processing. By adjusting the time allotted to                          *
 *    internal processing, smooth animation can be maintained.                                 *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   In order for this routine to work properly it MUST be                           *
 *             called every display loop.                                                      *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/31/1991 JLB : Created.                                                                 *
 *   07/05/1994 JLB : Handles new monochrome system.                                           *
 *=============================================================================================*/
#define	UPDATE_INTERVAL	TIMER_SECOND
void Self_Regulate(void)
{
	static CountDownTimerClass DebugTimer(BT_SYSTEM);
	static ObjectClass * _lastobject = 0;

	if (!DebugTimer.Time()) {
		DebugTimer.Set(UPDATE_INTERVAL);

		if (MonoClass::Is_Enabled()) {
			MonoClass *mono = MonoClass::Get_Current();
			mono->Set_Default_Attribute(2);

			switch (MonoPage) {
				case 0:
					mono = &MonoArray[0];
					mono->Clear();

					/*
					**	Display the status of the currently selected object.
					*/
					if (CurrentObject.Count()) {
						_lastobject = CurrentObject[0];
					}
					if (_lastobject && !_lastobject->IsActive) {
						_lastobject = 0;
					}
					if (_lastobject) {
						_lastobject->Debug_Dump(mono);
					}
					Logic.Debug_Dump(mono);
					mono->Set_Cursor(0, 20);
					mono->Printf(
						"Heap size:%10ld \r"
						"Largest:  %10ld \r"
						"Ttl Free: %10ld \r"
						"Frag:     %10ld \r",
						Heap_Size(MEM_NORMAL),
						Ram_Free(MEM_NORMAL),
						Total_Ram_Free(MEM_NORMAL),
						Total_Ram_Free(MEM_NORMAL)-Ram_Free(MEM_NORMAL)
					);
					*MonoClass::Get_Current() = *mono;
					break;
			}

			MonoArray[MonoPage] = *mono;
		}
	}
}
#endif