CodeMirror/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Remastered_Collection synced 2024-04-28 09:22:35 +12:00
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/DEBUG.CPP

558 lines
21 KiB
C++
Raw Normal View History

Initial Source Code commit Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-28 07:16:20 +12:00
//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /CounterStrike/DEBUG.CPP 1 3/03/97 10:24a Joe_bostic $ */
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : DEBUG.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : September 10, 1993 *
* *
* Last Update : July 18, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* Self_Regulate -- Regulates the logic timer to result in smooth animation. *
* Debug_Key -- Debug mode keyboard processing. *
* Bench_Time -- Convert benchmark timer into descriptive string. *
* Benchmarks -- Display the performance tracking benchmarks. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "vortex.h"
#include <stdarg.h>
#ifdef CHEAT_KEYS
static CDTimerClass<SystemTimerClass> DebugTimer;
int VortexFrame = -1;
/***********************************************************************************************
* 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_BACKSPACE:
if (ChronalVortex.Is_Active()) {
ChronalVortex.Disappear();
} else {
int xxxx = Get_Mouse_X() + Map.TacPixelX;
int yyyy = Get_Mouse_Y() + Map.TacPixelY;
CELL cell = Map.DisplayClass::Click_Cell_Calc(xxxx,yyyy);
ChronalVortex.Appear ( Cell_Coord (cell) );
}
break;
#ifdef WIN32
case KN_J:
Debug_MotionCapture = true;
break;
#ifdef OBSOLETE
case KN_K:
/*
** time to create a screen shot using the PCX code (if it works)
*/
if (!Debug_MotionCapture) {
GraphicBufferClass temp_page( SeenBuff.Get_Width(),
SeenBuff.Get_Height(),
NULL,
SeenBuff.Get_Width() * SeenBuff.Get_Height());
CDFileClass file;
char filename[30];
SeenBuff.Blit(temp_page);
for (int lp = 0; lp < 99; lp ++) {
sprintf(filename, "scrsht%02d.pcx", lp);
file.Set_Name(filename);
if (!file.Is_Available()) break;
}
file.Cache(200000);
Write_PCX_File(file, temp_page, & GamePalette);
Sound_Effect(VOC_BEEP);
}
break;
#endif
#endif
case KN_P:
{
for (SpecialWeaponType spc = SPC_FIRST; spc < SPC_COUNT; spc++) {
PlayerPtr->SuperWeapon[spc].Enable(true, true);
PlayerPtr->SuperWeapon[spc].Forced_Charge(true);
Map.Add(RTTI_SPECIAL, spc);
Map.Column[1].Flag_To_Redraw();
}
}
break;
case KN_I:
{
Map.Flash_Power();
Map.Flash_Money();
}
break;
case KN_O:
{
AircraftClass * air = new AircraftClass(AIRCRAFT_HIND, PlayerPtr->Class->House);
if (air) {
air->Height = 0;
air->Unlimbo(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), DIR_N);
}
}
break;
case KN_B:
{
AircraftClass * air = new AircraftClass(AIRCRAFT_LONGBOW, PlayerPtr->Class->House);
if (air) {
air->Height = 0;
air->Unlimbo(Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()), DIR_N);
}
}
break;
case KN_GRAVE:
{
WarheadType warhead = Random_Pick(WARHEAD_HE, WARHEAD_FIRE);
COORDINATE coord = Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y());
int damage = 1000;
new AnimClass(Combat_Anim(damage, warhead, Map[coord].Land_Type()), coord);
Explosion_Damage(coord, damage, NULL, warhead);
}
break;
case KN_C:
Debug_Cheat = (Debug_Cheat == false);
PlayerPtr->IsRecalcNeeded = true;
/*
** 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 = MAP_CELL_W-2;
Map.MapCellHeight = MAP_CELL_H-2;
} 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;
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_DELETE:
if (CurrentObject.Count()) {
Map.Recalc();
//CurrentObject[0]->Detach_All();
if (CurrentObject[0]->What_Am_I() == RTTI_BUILDING) {
((BuildingClass *)CurrentObject[0])->Sell_Back(1);
} else {
ObjectClass * object = CurrentObject[0];
object->Unselect();
object->Limbo();
delete object;
}
}
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;
case KN_LBRACKET:
case KN_F11:
if (MonoPage == DMONO_FIRST) {
MonoPage = DMonoType(DMONO_COUNT-1);
} else {
MonoPage = DMonoType(MonoPage - 1);
}
DebugTimer = 0;
break;
case KN_RBRACKET:
case KN_F12:
MonoPage = DMonoType(MonoPage + 1);
if (MonoPage == DMONO_COUNT) {
MonoPage = DMONO_FIRST;
}
DebugTimer = 0;
break;
case KN_V:
case KN_F3:
Debug_Icon = (Debug_Icon == false);
Map.Flag_To_Redraw(true);
break;
/*
** Reveal entire map to player.
*/
// case KN_F4:
// if (Session.Type == 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.PrimaryWeapon != NULL) weapon = ttype.PrimaryWeapon->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;
default:
break;
}
}
}
/***********************************************************************************************
* Bench_Time -- Convert benchmark timer into descriptive string. *
* *
* This routine will take the values of the benchmark timer specified and build a string *
* that displays the average time each event consumed as well as the ranking of how much *
* time that event took (total) during the tracking duration (one second?). *
* *
* INPUT: btype -- The benchmark to convert to a descriptive string. *
* *
* OUTPUT: Returns with a pointer to the descriptive string of the benchmark specified. *
* *
* WARNINGS: The value returned is a pointer to a static buffer. As such, it is only valid *
* until the next time that this routine is called. *
* *
* HISTORY: *
* 07/18/1996 JLB : Created. *
*=============================================================================================*/
static char const * Bench_Time(BenchType btype)
{
static char buffer[32];
int rootcount = Benches[BENCH_GAME_FRAME].Count();
if (rootcount == 0) rootcount = 1;
int roottime = Benches[BENCH_GAME_FRAME].Value();
int count = Benches[btype].Count();
int time = Benches[btype].Value();
if (count > 0 && count * time > roottime * rootcount) time = roottime / count;
int percent = 0;
if (roottime != 0 && rootcount != 0) {
percent = ((count * time) * 99) / (roottime * rootcount);
}
if (percent > 99) percent = 99;
sprintf(buffer, "%-2d%% %7d", percent, time);
return(buffer);
}
/***********************************************************************************************
* Benchmarks -- Display the performance tracking benchmarks. *
* *
* This will display the benchmarks for the various processes that are being tracked. The *
* display will indicate the fraction that each process is consuming out of the entire *
* process time as well as the time consumed by each individual event. The total fraction *
* is useful for determing what should be optimized. The individual time is useful for *
* guaging the effectiveness of optimization changes. *
* *
* INPUT: mono -- Pointer to the monochrome screen that the display will use. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1996 JLB : Created. *
*=============================================================================================*/
static void Benchmarks(MonoClass * mono)
{
static bool _first = true;
if (_first) {
_first = false;
mono->Clear();
mono->Set_Cursor(0, 0);
mono->Print(Text_String(TXT_DEBUG_PERFORMANCE));
if (Benches == NULL) {
mono->Set_Cursor(20, 15);
mono->Printf(TXT_NO_PENTIUM);
}
}
if (Benches != NULL) {
mono->Set_Cursor(1, 2);mono->Printf("%s", Bench_Time(BENCH_FINDPATH));
mono->Set_Cursor(1, 4);mono->Printf("%s", Bench_Time(BENCH_GREATEST_THREAT));
mono->Set_Cursor(1, 6);mono->Printf("%s", Bench_Time(BENCH_AI));
mono->Set_Cursor(1, 8);mono->Printf("%s", Bench_Time(BENCH_PCP));
mono->Set_Cursor(1, 10);mono->Printf("%s", Bench_Time(BENCH_EVAL_OBJECT));
mono->Set_Cursor(1, 12);mono->Printf("%s", Bench_Time(BENCH_EVAL_CELL));
mono->Set_Cursor(1, 14);mono->Printf("%s", Bench_Time(BENCH_EVAL_WALL));
mono->Set_Cursor(1, 16);mono->Printf("%s", Bench_Time(BENCH_MISSION));
mono->Set_Cursor(14, 2);mono->Printf("%s", Bench_Time(BENCH_CELL));
mono->Set_Cursor(14, 4);mono->Printf("%s", Bench_Time(BENCH_OBJECTS));
mono->Set_Cursor(14, 6);mono->Printf("%s", Bench_Time(BENCH_ANIMS));
mono->Set_Cursor(27, 2);mono->Printf("%s", Bench_Time(BENCH_PALETTE));
mono->Set_Cursor(40, 2);mono->Printf("%s", Bench_Time(BENCH_GSCREEN_RENDER));
mono->Set_Cursor(40, 4);mono->Printf("%s", Bench_Time(BENCH_SIDEBAR));
mono->Set_Cursor(40, 6);mono->Printf("%s", Bench_Time(BENCH_RADAR));
mono->Set_Cursor(40, 8);mono->Printf("%s", Bench_Time(BENCH_TACTICAL));
mono->Set_Cursor(40, 10);mono->Printf("%s", Bench_Time(BENCH_POWER));
mono->Set_Cursor(40, 12);mono->Printf("%s", Bench_Time(BENCH_SHROUD));
mono->Set_Cursor(40, 14);mono->Printf("%s", Bench_Time(BENCH_TABS));
mono->Set_Cursor(40, 16);mono->Printf("%s", Bench_Time(BENCH_BLIT_DISPLAY));
mono->Set_Cursor(66, 2);mono->Printf("%7d", Benches[BENCH_RULES].Value());
mono->Set_Cursor(66, 4);mono->Printf("%7d", Benches[BENCH_SCENARIO].Value());
for (BenchType index = BENCH_FIRST; index < BENCH_COUNT; index++) {
if (index != BENCH_RULES && index != BENCH_SCENARIO) Benches[index].Reset();
}
}
}
/***********************************************************************************************
* 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 ObjectClass * _lastobject = 0;
static bool _first=true;
if (DebugTimer == 0) {
DebugTimer = UPDATE_INTERVAL;
if (MonoClass::Is_Enabled()) {
if (_first) {
_first = false;
for (DMonoType index = DMONO_FIRST; index < DMONO_COUNT; index++) {
MonoArray[index].Clear();
}
}
/*
** Always update the stress tracking mono display even if it
** currently isn't visible.
*/
Logic.Debug_Dump(&MonoArray[DMONO_STRESS]);
MonoClass * mono = &MonoArray[MonoPage];
mono->Set_Default_Attribute(MonoClass::NORMAL);
mono->View();
switch (MonoPage) {
case DMONO_EVENTS:
Benchmarks(mono);
break;
case DMONO_OBJECT:
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);
}
break;
case DMONO_STRESS:
#ifdef OBSOLETE
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)
);
#endif
break;
case DMONO_HOUSE:
mono->Clear();
if (CurrentObject.Count()) {
_lastobject = CurrentObject[0];
}
if (_lastobject && !_lastobject->IsActive) {
_lastobject = 0;
}
if (_lastobject && _lastobject->Is_Techno()) {
((TechnoClass *)_lastobject)->House->Debug_Dump(mono);
}
break;
default:
break;
}
mono->Set_Cursor(0, 0);
}
}
}
#endif
Reference in a new issue Copy permalink