Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
1666 lines
36 KiB
C++
1666 lines
36 KiB
C++
|
|
#include "MW4Headers.hpp"
|
|
|
|
#include "MWDebugHelper.hpp"
|
|
|
|
#include "MWPlayer.hpp"
|
|
#include "Adept\NameTable.hpp"
|
|
#include "VehicleInterface.hpp"
|
|
#include "Vehicle.hpp"
|
|
#include "MWDamageObject.hpp"
|
|
#include "MWPlayer.hpp"
|
|
#include "AI_DebugRenderer.hpp"
|
|
#include "AI_FireStyle.hpp"
|
|
#include "AI_CombatTacticInterface.hpp"
|
|
#include "ablprofiler.hpp"
|
|
#include "rail_move.hpp"
|
|
#include "ai.hpp"
|
|
#include "moverai.hpp"
|
|
#include "combatai.hpp"
|
|
#include "mwmission.hpp"
|
|
#include "CameraShip.hpp"
|
|
#include "MWApplication.hpp"
|
|
#include "DamageDispatch.hpp"
|
|
#include "NonCom.hpp"
|
|
|
|
const unsigned int max_switch_entries = 39;
|
|
|
|
using namespace MW4AI;
|
|
using namespace MechWarrior4;
|
|
|
|
|
|
DebugHelper* DebugHelper::m_Instance = 0;
|
|
bool DebugHelper::m_AIOff = false;
|
|
|
|
DebugHelper::DebugHelper()
|
|
: m_FollowCamera(false)
|
|
, m_PlayerID(0xFFFFFFFF)
|
|
, m_SwitchTo_Page(0)
|
|
, m_BreakInCurrentVehicle(false)
|
|
{
|
|
Verify(m_Instance == 0);
|
|
m_Instance = this;
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show AI Stats",
|
|
Check_ShowAIStats,
|
|
Activate_ShowAIStats,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show AI Stats (Current Vehicle Only)",
|
|
Check_ShowAIStatsCurrentVehicleOnly,
|
|
Activate_ShowAIStatsCurrentVehicleOnly,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Damage Info",
|
|
Check_ShowDamageInfo,
|
|
Activate_ShowDamageInfo,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Disable AI",
|
|
Checked_DisableAI,
|
|
Activate_DisableAI,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Disable Combat Movement",
|
|
Checked_DisableCombatMovement,
|
|
Activate_DisableCombatMovement,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Disable Combat Firing",
|
|
Checked_DisableCombatFiring,
|
|
Activate_DisableCombatFiring,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Num Path Requests",
|
|
Check_ShowNumPathRequests,
|
|
Activate_ShowNumPathRequests,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Movement Lines",
|
|
Check_ShowMovementLines,
|
|
Activate_ShowMovementLines,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Movement Paths",
|
|
Check_ShowMovementPaths,
|
|
Activate_ShowMovementPaths,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Dead Reckoning (0.5s)",
|
|
Check_ShowDeadReckoning05s,
|
|
Activate_ShowDeadReckoning05s,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Dead Reckoning (1s)",
|
|
Check_ShowDeadReckoning1s,
|
|
Activate_ShowDeadReckoning1s,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Show Dead Reckoning (2s)",
|
|
Check_ShowDeadReckoning2s,
|
|
Activate_ShowDeadReckoning2s,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Hide Dead Reckoning",
|
|
Check_HideDeadReckoning,
|
|
Activate_HideDeadReckoning,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Global Invulnerability",
|
|
Check_InvulnerabilityGlobal,
|
|
Activate_InvulnerabilityGlobal,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Ignore Current Vehicle",
|
|
Check_IgnoreCurrentVehicle,
|
|
Activate_IgnoreCurrentVehicle,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Enable AI Heat Management",
|
|
Check_EnableAIHeatManagement,
|
|
Activate_EnableAIHeatManagement,
|
|
0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\AI\\Break In Current Vehicle",
|
|
Checked_BreakInCurrentVehicle,
|
|
Activate_BreakInCurrentVehicle,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\ABL\\Profile",
|
|
Check_ABLProfile,
|
|
Activate_ABLProfile,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\In Mech",
|
|
Check_CameraInMech,
|
|
Activate_CameraInMech,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\External",
|
|
Check_CameraExternal,
|
|
Activate_CameraExternal,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\Top Down",
|
|
Check_CameraTopDown,
|
|
Activate_CameraTopDown,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\Top Down (Follow)",
|
|
Check_CameraTopDownFollow,
|
|
Activate_CameraTopDownFollow,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Camera\\Attach to Next",
|
|
Check_CameraAttachToNext,
|
|
Activate_CameraAttachToNext,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Switch To >>\\ NEXT PAGE -->",0,0,0,Activate_SwitchToNextPage);
|
|
|
|
{for (int i = 0;
|
|
i < max_switch_entries;
|
|
++i)
|
|
{
|
|
std::string s = GetMenuItemName(i);
|
|
AddDebuggerMenuItem((char*)s.c_str(),0,0,0,SwitchCallback);
|
|
}}
|
|
|
|
// AddDebuggerMenuItem("Libraries\\Mech\\Pushup Off",
|
|
// Check_TestPushupOff,
|
|
// Activate_TestPushupOff,
|
|
// 0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Reset",0,
|
|
Activate_TestReset,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Arm Disabled",
|
|
Check_TestArmActivation,
|
|
Activate_TestArmActivation,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Left Gimp",
|
|
Check_TestLeftGimp,
|
|
Activate_TestLeftGimp,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Right Gimp",
|
|
Check_TestRightGimp,
|
|
Activate_TestRightGimp,
|
|
0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Fall Forward",0,
|
|
Activate_TestFallForward,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Fall Backward",0,
|
|
Activate_TestFallBackward,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Fall Left",0,
|
|
Activate_TestFallLeft,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Fall Right",0,
|
|
Activate_TestFallRight,0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\SpringHit1",0,
|
|
Activate_TestHit1,0);
|
|
AddDebuggerMenuItem("Libraries\\Mech\\SpringHit2",0,
|
|
Activate_TestHit2,0);
|
|
AddDebuggerMenuItem("Libraries\\Mech\\SpringHit3",0,
|
|
Activate_TestHit3,0);
|
|
AddDebuggerMenuItem("Libraries\\Mech\\SpringHit4",0,
|
|
Activate_TestHit4,0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Fast Stand Transition",Check_TestFastTransition,
|
|
Activate_TestFastTransition,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\No Blend",Check_NoBlend,
|
|
Activate_NoBlend,0);
|
|
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\ ",0,0,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Leave Torso Alone",Check_AlwaysLeaveTorsoAlone,
|
|
Activate_AlwaysLeaveTorsoAlone,0);
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Always Center Torso",Check_AlwaysCenterTorsoToLegs,
|
|
Activate_AlwaysCenterTorsoToLegs,0);
|
|
AddDebuggerMenuItem("Libraries\\Mech\\Always Center Legs To Torso",Check_AlwaysCenterLegsToTorso,
|
|
Activate_AlwaysCenterLegsToTorso,0);
|
|
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Throttle Enabled",Check_ThrottleEnabled,Activate_ThrottleEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Turn Enabled",Check_TurnEnabled,Activate_TurnEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Torso Enabled",Check_TorsoEnabled,Activate_TorsoEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Firing Enabled",Check_FiringEnabled,Activate_FiringEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\View Modes Enabled",Check_ViewModesEnabled,Activate_ViewModesEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Target Selection Enabled",Check_TargetSelectionEnabled,Activate_TargetSelectionEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Zoom Enabled",Check_ZoomEnabled,Activate_ZoomEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Heat Enabled",Check_HeatEnabled,Activate_HeatEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Nav Switching Enabled",Check_NavSwitchingEnabled,Activate_NavSwitchingEnabled,0);
|
|
AddDebuggerMenuItem("Libraries\\InputTrainer\\Misc Enabled",Check_MiscEnabled,Activate_MiscEnabled,0);
|
|
}
|
|
|
|
DebugHelper::~DebugHelper()
|
|
{
|
|
Verify(m_Instance != 0);
|
|
m_Instance = 0;
|
|
}
|
|
|
|
VehicleInterface* GetVehicleInterface()
|
|
{
|
|
if (NameTable::GetInstance() == 0)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
if (Adept::Player::GetInstance() == NULL)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
MWPlayer* p = Cast_Object(MWPlayer*,Adept::Player::GetInstance());
|
|
Check_Object(p);
|
|
|
|
if (p->GetInterface() == NULL)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
return (p->GetInterface());
|
|
}
|
|
|
|
Vehicle* GetVehicle()
|
|
{
|
|
if (GetVehicleInterface() == 0)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
return (GetVehicleInterface()->vehicle);
|
|
}
|
|
|
|
Mech* GetMech()
|
|
{
|
|
Vehicle* v = GetVehicle();
|
|
|
|
if (v == 0)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
if (v->IsDerivedFrom(Mech::DefaultData) == true)
|
|
{
|
|
return (Cast_Object(Mech*,v));
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
void DebugHelper::Execute()
|
|
{
|
|
|
|
|
|
|
|
if ((m_FollowCamera == true) &&
|
|
(Check_CameraTopDownFollow() == true) &&
|
|
(GetVehicle() != 0))
|
|
{
|
|
NetMissionParameters::MWNetMissionParameters *params = MWApplication::GetInstance()->GetLocalNetParams();
|
|
if (!params->m_allow3rdPerson)
|
|
return;
|
|
|
|
Point3D camera = GetVehicleInterface()->cameraOffset;
|
|
Point3D vehicle = (Point3D)GetVehicle()->GetLocalToWorld();
|
|
|
|
camera.x = vehicle.x;
|
|
camera.z = vehicle.z;
|
|
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::TopDownCameraView,&camera);
|
|
}
|
|
}
|
|
|
|
DebugHelper* DebugHelper::GetInstance()
|
|
{
|
|
return (m_Instance);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_CameraInMech()
|
|
{
|
|
if (GetVehicleInterface() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetVehicleInterface()->cameraView == VehicleInterface::InMechCameraView);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_CameraInMech()
|
|
{
|
|
if (GetVehicleInterface() != 0)
|
|
{
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::InMechCameraView);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_CameraExternal()
|
|
{
|
|
if (GetVehicleInterface() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetVehicleInterface()->cameraView == VehicleInterface::ExternalCameraAttachedView);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_CameraExternal()
|
|
{
|
|
if (GetVehicleInterface() != 0)
|
|
{
|
|
NetMissionParameters::MWNetMissionParameters *params = MWApplication::GetInstance()->GetLocalNetParams();
|
|
if (!params->m_allow3rdPerson)
|
|
return;
|
|
|
|
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::ExternalCameraAttachedView);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_CameraTopDown()
|
|
{
|
|
if (GetVehicleInterface() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
if ((GetVehicleInterface()->cameraView == VehicleInterface::TopDownCameraView) &&
|
|
(GetInstance()->m_FollowCamera == false))
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_CameraTopDown()
|
|
{
|
|
if (GetVehicleInterface() != 0)
|
|
{
|
|
NetMissionParameters::MWNetMissionParameters *params = MWApplication::GetInstance()->GetLocalNetParams();
|
|
if (!params->m_allow3rdPerson)
|
|
return;
|
|
|
|
Stuff::Point3D p = (Point3D)GetVehicle()->GetLocalToWorld();
|
|
p.y = 200.0f;
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::TopDownCameraView,&p);
|
|
GetInstance()->m_FollowCamera = false;
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_CameraTopDownFollow()
|
|
{
|
|
if (GetVehicleInterface() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
if ((GetVehicleInterface()->cameraView == VehicleInterface::TopDownCameraView) &&
|
|
(GetInstance()->m_FollowCamera == true))
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_CameraTopDownFollow()
|
|
{
|
|
if (GetVehicleInterface() != 0)
|
|
{
|
|
NetMissionParameters::MWNetMissionParameters *params = MWApplication::GetInstance()->GetLocalNetParams();
|
|
if (!params->m_allow3rdPerson)
|
|
return;
|
|
|
|
Stuff::Point3D p = (Point3D)GetVehicle()->GetLocalToWorld();
|
|
p.y = 200.0f;
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::TopDownCameraView,&p);
|
|
GetInstance()->m_FollowCamera = true;
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_InvulnerabilityGlobal()
|
|
{
|
|
return (DamageDispatch::GetGlobalInvulnerability());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_InvulnerabilityGlobal()
|
|
{
|
|
if (DamageDispatch::GetGlobalInvulnerability())
|
|
{
|
|
DamageDispatch::SetGlobalInvulnerability(false);
|
|
}
|
|
else
|
|
{
|
|
DamageDispatch::SetGlobalInvulnerability(true);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_CameraAttachToNext()
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_CameraAttachToNext()
|
|
{
|
|
if ((GetVehicle() == 0) ||
|
|
(GetVehicleInterface() == 0))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GetInstance()->m_PlayerID == 0xFFFFFFFF)
|
|
{
|
|
GetInstance()->m_PlayerID = GetVehicle()->objectID;
|
|
}
|
|
|
|
Adept::NameTable::NameTableEntryArray& vehicle_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::VehicleArray];
|
|
|
|
int index = vehicle_array.GetLength();
|
|
{for (int i = 0;
|
|
i < vehicle_array.GetLength();
|
|
++i)
|
|
{
|
|
if (vehicle_array[i].GetObjectID() == GetInstance()->m_PlayerID)
|
|
{
|
|
index = i + 1;
|
|
|
|
if (index >= vehicle_array.GetLength())
|
|
{
|
|
index = 0;
|
|
}
|
|
|
|
if (index < vehicle_array.GetLength())
|
|
{
|
|
Adept::Entity* entity = vehicle_array[index].dataPointer->GetCurrent();
|
|
|
|
while ((index < vehicle_array.GetLength()) &&
|
|
((entity == 0) ||
|
|
(entity->IsDerivedFrom(Vehicle::DefaultData) == false)))
|
|
{
|
|
++index;
|
|
if (index < vehicle_array.GetLength())
|
|
{
|
|
entity = vehicle_array[index].dataPointer->GetCurrent();
|
|
}
|
|
else
|
|
{
|
|
index = 0;
|
|
}
|
|
|
|
if (index == i)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}}
|
|
|
|
if ((index >= vehicle_array.GetLength()) ||
|
|
(vehicle_array[index].dataPointer->GetCurrent()->IsDerivedFrom(Vehicle::DefaultData) == false))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Vehicle* v = Cast_Object(Vehicle*,vehicle_array[index].dataPointer->GetCurrent());
|
|
Check_Object(v);
|
|
SwitchToObject(*v);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_IgnoreCurrentVehicle()
|
|
{
|
|
if ((GetVehicleInterface()) &&
|
|
(GetVehicleInterface()->vehicle))
|
|
{
|
|
return (GetVehicleInterface()->vehicle->GetTargetDesirability() == MWObject::desirability_never);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_IgnoreCurrentVehicle()
|
|
{
|
|
if ((GetVehicleInterface()) &&
|
|
(GetVehicleInterface()->vehicle))
|
|
{
|
|
MWObject* v = GetVehicleInterface()->vehicle;
|
|
|
|
Stuff::Scalar invuln = v->GetTargetDesirability();
|
|
|
|
if (invuln == MWObject::desirability_never)
|
|
{
|
|
v->SetTargetDesirability(MWObject::desirability_invalid);
|
|
}
|
|
else
|
|
{
|
|
v->SetTargetDesirability(MWObject::desirability_never);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Checked_DisableAI ()
|
|
{
|
|
return m_AIOff;
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_DisableAI ()
|
|
{
|
|
if (!MWMission::GetInstance())
|
|
return;
|
|
|
|
if (!m_AIOff)
|
|
{
|
|
int i,j;
|
|
m_AIOff = true;
|
|
int size;
|
|
Check_Object (MWMission::GetInstance());
|
|
MWMission *mission = Cast_Object (MWMission*,MWMission::GetInstance());
|
|
|
|
mission->UnloadScript ();
|
|
|
|
NameTable *table = NameTable::GetInstance();
|
|
Check_Object (table);
|
|
i = NameTable::AIArray;
|
|
{
|
|
size = table->nameTableArray[i].GetLength ();
|
|
for (j=0;j<size;j++)
|
|
{
|
|
NameTableEntry *data;
|
|
Entity *who;
|
|
|
|
data = &table->nameTableArray [i][j];
|
|
|
|
AI *ai;
|
|
MoverAI *moverai;
|
|
CombatAI *combatai;
|
|
|
|
who = data->dataPointer->GetCurrent ();
|
|
|
|
if (!who)
|
|
continue;
|
|
if (who->IsDerivedFrom (AI::DefaultData))
|
|
{
|
|
ai = Cast_Object (AI *,who);
|
|
ai->UnloadScript ();
|
|
}
|
|
if (who->IsDerivedFrom (MoverAI::DefaultData))
|
|
{
|
|
moverai = Cast_Object (MoverAI *,who);
|
|
moverai->ClearMoveOrder ();
|
|
}
|
|
if (who->IsDerivedFrom (CombatAI::DefaultData))
|
|
{
|
|
combatai = Cast_Object (CombatAI *,who);
|
|
combatai->OrderStopAttacking ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowAIStats()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetAIStatsRendering() == DebugRenderer::STATS_ALL);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowAIStats()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (instance->GetAIStatsRendering() != DebugRenderer::STATS_ALL)
|
|
{
|
|
instance->SetAIStatsRendering(DebugRenderer::STATS_ALL);
|
|
}
|
|
else
|
|
{
|
|
instance->SetAIStatsRendering(DebugRenderer::STATS_NONE);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowAIStatsCurrentVehicleOnly()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetAIStatsRendering() == DebugRenderer::STATS_CURRENT_VEHICLE);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowAIStatsCurrentVehicleOnly()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (instance->GetAIStatsRendering() != DebugRenderer::STATS_CURRENT_VEHICLE)
|
|
{
|
|
instance->SetAIStatsRendering(DebugRenderer::STATS_CURRENT_VEHICLE);
|
|
}
|
|
else
|
|
{
|
|
instance->SetAIStatsRendering(DebugRenderer::STATS_NONE);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowDamageInfo()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (instance->GetDamageInfoRendering());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowDamageInfo()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (instance->GetDamageInfoRendering() == true)
|
|
{
|
|
instance->SetDamageInfoRendering(false);
|
|
}
|
|
else
|
|
{
|
|
instance->SetDamageInfoRendering(true);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowMovementLines()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (instance->GetMovementLineRendering());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowMovementLines()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (instance->GetMovementLineRendering() == true)
|
|
{
|
|
instance->SetMovementLineRendering(false);
|
|
}
|
|
else
|
|
{
|
|
instance->SetMovementLineRendering(true);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowMovementPaths()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (instance->GetMovementPathRendering());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowMovementPaths()
|
|
{
|
|
DebugRenderer* instance = DebugRenderer::GetInstance();
|
|
|
|
if (instance == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (instance->GetMovementPathRendering() == true)
|
|
{
|
|
instance->SetMovementPathRendering(false);
|
|
}
|
|
else
|
|
{
|
|
instance->SetMovementPathRendering(true);
|
|
}
|
|
}
|
|
|
|
DWORD __stdcall DebugHelper::SwitchCallback(char* name, DWORD function)
|
|
{
|
|
if ((GetInstance() == 0) ||
|
|
(GetVehicle() == 0))
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
gos_PushCurrentHeap(Heap);
|
|
|
|
unsigned int index = GetMenuItemIndex(name);
|
|
|
|
switch (function)
|
|
{
|
|
case gosMenu_Name:
|
|
{
|
|
GetInstance()->m_PublicString = GetMenuItemName(index,false);
|
|
GetInstance()->m_PublicString += " ";
|
|
GetInstance()->m_PublicString += GetObjectName(index);
|
|
gos_PopCurrentHeap();
|
|
|
|
return (DWORD)(GetInstance()->m_PublicString.c_str()); // Override name
|
|
}
|
|
case gosMenu_Activated:
|
|
{
|
|
SwitchToObject(index);
|
|
|
|
gos_PopCurrentHeap();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
gos_PopCurrentHeap();
|
|
|
|
return (0);
|
|
}
|
|
|
|
std::string DebugHelper::GetMenuItemName(unsigned int index, bool fIncludePrefix)
|
|
{
|
|
Verify(index < 100);
|
|
|
|
std::string rv;
|
|
|
|
if (fIncludePrefix == true)
|
|
{
|
|
rv = GetSwitchToPrefix();
|
|
}
|
|
|
|
char s[80];
|
|
if (index < 10)
|
|
{
|
|
sprintf(s,"0%d",index);
|
|
}
|
|
else
|
|
{
|
|
sprintf(s,"%d",index);
|
|
}
|
|
|
|
rv += s;
|
|
return (rv);
|
|
}
|
|
|
|
unsigned int DebugHelper::GetMenuItemIndex(const std::string& name)
|
|
{
|
|
Verify(name.size() >= GetSwitchToPrefix().size() + 2);
|
|
|
|
std::string n = name;
|
|
n.erase(0,GetSwitchToPrefix().size());
|
|
|
|
return (10 * (n[0] - '0')) + (n[1] - '0');
|
|
}
|
|
|
|
std::string DebugHelper::GetSwitchToPrefix()
|
|
{
|
|
return ("Libraries\\Switch To >>\\");
|
|
}
|
|
|
|
unsigned int DebugHelper::GetNumObjectNames()
|
|
{
|
|
Adept::NameTable::NameTableEntryArray& vehicle_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::VehicleArray];
|
|
|
|
int count = 0;
|
|
|
|
{for (int i = 0;
|
|
i < vehicle_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = vehicle_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(Vehicle::DefaultData) == true))
|
|
{
|
|
++count;
|
|
}
|
|
}}
|
|
|
|
Adept::NameTable::NameTableEntryArray& cultural_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::CulturalArray];
|
|
|
|
{for (int i = 0;
|
|
i < cultural_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = cultural_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(NonCom::DefaultData) == true))
|
|
{
|
|
++count;
|
|
}
|
|
}}
|
|
|
|
|
|
if (count > max_switch_entries)
|
|
{
|
|
return (max_switch_entries);
|
|
}
|
|
|
|
return (count);
|
|
}
|
|
|
|
std::string DebugHelper::GetObjectName(unsigned int index)
|
|
{
|
|
Adept::NameTable::NameTableEntryArray& vehicle_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::VehicleArray];
|
|
Adept::NameTable::NameTableEntryArray& cultural_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::CulturalArray];
|
|
|
|
int count = 0;
|
|
index += GetInstance()->m_SwitchTo_Page * max_switch_entries;
|
|
|
|
if (index >= vehicle_array.GetLength() + cultural_array.GetLength())
|
|
{
|
|
return ("");
|
|
}
|
|
|
|
{for (unsigned int i = 0;
|
|
i < vehicle_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = vehicle_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(Vehicle::DefaultData) == true))
|
|
{
|
|
if (count == index)
|
|
{
|
|
return (entity->instanceName);
|
|
}
|
|
|
|
++count;
|
|
}
|
|
}}
|
|
|
|
{for (unsigned int i = 0;
|
|
i < cultural_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = cultural_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(NonCom::DefaultData) == true))
|
|
{
|
|
if (count == index)
|
|
{
|
|
return (entity->instanceName);
|
|
}
|
|
|
|
++count;
|
|
}
|
|
}}
|
|
|
|
return ("");
|
|
}
|
|
|
|
void DebugHelper::SwitchToObject(unsigned int index)
|
|
{
|
|
Adept::NameTable::NameTableEntryArray& vehicle_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::VehicleArray];
|
|
Adept::NameTable::NameTableEntryArray& cultural_array = Adept::NameTable::GetInstance()->nameTableArray[Adept::NameTable::CulturalArray];
|
|
|
|
int count = 0;
|
|
index += GetInstance()->m_SwitchTo_Page * max_switch_entries;
|
|
|
|
if (index >= vehicle_array.GetLength() + cultural_array.GetLength())
|
|
{
|
|
return;
|
|
}
|
|
|
|
{for (unsigned int i = 0;
|
|
i < vehicle_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = vehicle_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(Vehicle::DefaultData) == true))
|
|
{
|
|
if (count == index)
|
|
{
|
|
Vehicle* v = Cast_Object(Vehicle*,entity);
|
|
|
|
SwitchToObject(*v);
|
|
return;
|
|
}
|
|
|
|
++count;
|
|
}
|
|
}}
|
|
|
|
{for (unsigned int i = 0;
|
|
i < cultural_array.GetLength();
|
|
++i)
|
|
{
|
|
Adept::Entity* entity = cultural_array[i].dataPointer->GetCurrent();
|
|
|
|
if ((entity != 0) &&
|
|
(entity->IsDerivedFrom(NonCom::DefaultData) == true))
|
|
{
|
|
if (count == index)
|
|
{
|
|
MWObject* v = Cast_Object(MWObject*,entity);
|
|
|
|
SwitchToObject(*v);
|
|
return;
|
|
}
|
|
|
|
++count;
|
|
}
|
|
}}
|
|
}
|
|
|
|
void DebugHelper::SwitchToObject(MWObject& v)
|
|
{
|
|
Check_Object(&v);
|
|
|
|
// no one is allowed to switch unless they are the server
|
|
if ((!Network::GetInstance()->AmIServer()) ||
|
|
(CameraShipManager::Instance == 0))
|
|
return;
|
|
|
|
NetMissionParameters::MWNetMissionParameters *params = MWApplication::GetInstance()->GetLocalNetParams();
|
|
if (!params->m_allow3rdPerson)
|
|
return;
|
|
|
|
GetInstance()->m_PlayerID = v.objectID;
|
|
|
|
Stuff::UnitVector3D unit_backward;
|
|
v.GetLocalToWorld().GetLocalBackwardInWorld(&unit_backward);
|
|
|
|
Stuff::Point3D backward(unit_backward);
|
|
backward *= 16;
|
|
|
|
Stuff::LinearMatrix4D matrix(v.GetLocalToWorld());
|
|
backward += (Stuff::Point3D)matrix;
|
|
matrix.BuildTranslation(backward);
|
|
|
|
GetVehicleInterface()->SetCameraMode(VehicleInterface::ExternalCameraDetachedView);
|
|
GetVehicleInterface()->cameraOffset = matrix;
|
|
GetVehicleInterface()->cameraOffset.y += 5;
|
|
GetVehicleInterface()->cameraRotation = YawPitchRoll(matrix);
|
|
}
|
|
|
|
DWORD __stdcall DebugHelper::Activate_SwitchToNextPage(char* name, DWORD function)
|
|
{
|
|
switch (function)
|
|
{
|
|
case gosMenu_Activated:
|
|
{
|
|
const unsigned int max_pages = GetNumObjectNames() / max_switch_entries;
|
|
|
|
if (GetInstance()->m_SwitchTo_Page >= max_pages)
|
|
{
|
|
GetInstance()->m_SwitchTo_Page = 0;
|
|
}
|
|
else
|
|
{
|
|
++(GetInstance()->m_SwitchTo_Page);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowDeadReckoning05s()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetDeadReckoningRenderTime() == 0.5f);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowDeadReckoning05s()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
DebugRenderer::GetInstance()->SetDeadReckoningRenderTime(0.5f);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowDeadReckoning1s()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetDeadReckoningRenderTime() == 1);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowDeadReckoning1s()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
DebugRenderer::GetInstance()->SetDeadReckoningRenderTime(1);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowDeadReckoning2s()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetDeadReckoningRenderTime() == 2);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowDeadReckoning2s()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
DebugRenderer::GetInstance()->SetDeadReckoningRenderTime(2);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_HideDeadReckoning()
|
|
{
|
|
if (DebugRenderer::GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (DebugRenderer::GetInstance()->GetDeadReckoningRenderTime() == 0);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_HideDeadReckoning()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
DebugRenderer::GetInstance()->SetDeadReckoningRenderTime(0);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ShowNumPathRequests()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
return (DebugRenderer::GetInstance()->GetShowNumPathRequests());
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ShowNumPathRequests()
|
|
{
|
|
if (DebugRenderer::GetInstance() != 0)
|
|
{
|
|
if (DebugRenderer::GetInstance()->GetShowNumPathRequests() == true)
|
|
{
|
|
DebugRenderer::GetInstance()->SetShowNumPathRequests(false);
|
|
}
|
|
else
|
|
{
|
|
DebugRenderer::GetInstance()->SetShowNumPathRequests(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_EnableAIHeatManagement()
|
|
{
|
|
return (MW4AI::FireStyles::FireStyle::gHeatManagementEnabled == true);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_EnableAIHeatManagement()
|
|
{
|
|
if (MW4AI::FireStyles::FireStyle::gHeatManagementEnabled == true)
|
|
{
|
|
MW4AI::FireStyles::FireStyle::gHeatManagementEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
MW4AI::FireStyles::FireStyle::gHeatManagementEnabled = true;
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Checked_DisableCombatMovement()
|
|
{
|
|
return (MW4AI::CombatTacticInterface::g_DisableMovement);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_DisableCombatMovement()
|
|
{
|
|
if (MW4AI::CombatTacticInterface::g_DisableMovement == true)
|
|
{
|
|
MW4AI::CombatTacticInterface::g_DisableMovement = false;
|
|
}
|
|
else
|
|
{
|
|
MW4AI::CombatTacticInterface::g_DisableMovement = true;
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Checked_DisableCombatFiring()
|
|
{
|
|
return (MW4AI::CombatTacticInterface::g_DisableFiring);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_DisableCombatFiring()
|
|
{
|
|
if (MW4AI::CombatTacticInterface::g_DisableFiring == true)
|
|
{
|
|
MW4AI::CombatTacticInterface::g_DisableFiring = false;
|
|
}
|
|
else
|
|
{
|
|
MW4AI::CombatTacticInterface::g_DisableFiring = true;
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TestArmActivation()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->Test_GetArmActivation());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestArmActivation()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_ArmActivation();
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TestPushupOff()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->Test_GetPushupOff());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestPushupOff()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_PushupOff();
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TestLeftGimp()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->Test_GetLeftGimp());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestLeftGimp()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_LeftGimp();
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TestRightGimp()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->Test_GetRightGimp());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestRightGimp()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_RightGimp();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestLeftArmRecoil()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_LeftArmRecoil();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestRightGunRecoil()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_RightGunRecoil();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestHit1()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_Hit1();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestHit2()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_Hit2();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestHit3()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_Hit3();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestHit4()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_Hit4();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestReset()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_Reset();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestFallForward()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_FallForward();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestFallBackward()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_FallBackward();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestFallLeft()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_FallLeft();
|
|
}
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestFallRight()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->Test_FallRight();
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Checked_BreakInCurrentVehicle()
|
|
{
|
|
if (GetInstance() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetInstance()->m_BreakInCurrentVehicle);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_BreakInCurrentVehicle()
|
|
{
|
|
if (GetInstance() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GetInstance()->m_BreakInCurrentVehicle == true)
|
|
{
|
|
GetInstance()->m_BreakInCurrentVehicle = false;
|
|
}
|
|
else
|
|
{
|
|
GetInstance()->m_BreakInCurrentVehicle = true;
|
|
}
|
|
}
|
|
|
|
bool DebugHelper::ShouldBreakInCurrentVehicle() const
|
|
{
|
|
return (m_BreakInCurrentVehicle);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TestFastTransition()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->GetFastTransition());
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TestFastTransition()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
GetMech()->FastTransition();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool __stdcall DebugHelper::Check_NoBlend()
|
|
{
|
|
return Mech::DontLoadBlends;
|
|
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_NoBlend()
|
|
{
|
|
Mech::DontLoadBlends = !Mech::DontLoadBlends;
|
|
}
|
|
|
|
|
|
|
|
|
|
bool __stdcall DebugHelper::Check_AlwaysLeaveTorsoAlone()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
if (GetMech()->vehicleInterface == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->vehicleInterface->GetPerminateTorsoMode() == VehicleInterface::LeaveTorsoAlone);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_AlwaysLeaveTorsoAlone()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
if (GetMech()->vehicleInterface != 0)
|
|
{
|
|
GetMech()->vehicleInterface->SetPerminateTorsoMode(VehicleInterface::LeaveTorsoAlone);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_AlwaysCenterTorsoToLegs()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
if (GetMech()->vehicleInterface == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->vehicleInterface->GetPerminateTorsoMode() == VehicleInterface::CenterTorsoToLegs);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_AlwaysCenterTorsoToLegs()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
if (GetMech()->vehicleInterface != 0)
|
|
{
|
|
GetMech()->vehicleInterface->SetPerminateTorsoMode(VehicleInterface::CenterTorsoToLegs);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_AlwaysCenterLegsToTorso()
|
|
{
|
|
if (GetMech() == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
if (GetMech()->vehicleInterface == 0)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
return (GetMech()->vehicleInterface->GetPerminateTorsoMode() == VehicleInterface::CenterLegsToTorso);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_AlwaysCenterLegsToTorso()
|
|
{
|
|
if (GetMech() != 0)
|
|
{
|
|
if (GetMech()->vehicleInterface != 0)
|
|
{
|
|
GetMech()->vehicleInterface->SetPerminateTorsoMode(VehicleInterface::CenterLegsToTorso);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ABLProfile()
|
|
{
|
|
if ((ABL::Profiler::Instance() != 0) &&
|
|
(ABL::Profiler::Instance()->GetActive() == true))
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ABLProfile()
|
|
{
|
|
if (ABL::Profiler::Instance() != 0)
|
|
{
|
|
if (ABL::Profiler::Instance()->GetActive() == true)
|
|
{
|
|
ABL::Profiler::Instance()->SetActive(false);
|
|
}
|
|
else
|
|
{
|
|
ABL::Profiler::Instance()->SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InputTrainer_ToggleEnabled(InputTrainer::InputType t)
|
|
{
|
|
if (InputTrainer::GetInstance()->GetEnabled(t) == true)
|
|
{
|
|
InputTrainer::GetInstance()->SetEnabled(t,false);
|
|
}
|
|
else
|
|
{
|
|
InputTrainer::GetInstance()->SetEnabled(t,true);
|
|
}
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ThrottleEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::THROTTLE));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ThrottleEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::THROTTLE);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TurnEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::TURN));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TurnEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::TURN);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TorsoEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::TORSO));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TorsoEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::TORSO);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_FiringEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::FIRING));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_FiringEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::FIRING);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ViewModesEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::VIEW_MODES));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ViewModesEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::VIEW_MODES);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_TargetSelectionEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::TARGET_SELECTION));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_TargetSelectionEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::TARGET_SELECTION);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_ZoomEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::ZOOM));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_ZoomEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::ZOOM);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_HeatEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::HEAT));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_HeatEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::HEAT);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_NavSwitchingEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::NAV_SWITCHING));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_NavSwitchingEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::NAV_SWITCHING);
|
|
}
|
|
|
|
bool __stdcall DebugHelper::Check_MiscEnabled()
|
|
{
|
|
return (InputTrainer::GetInstance()->GetEnabled(InputTrainer::MISC));
|
|
}
|
|
|
|
void __stdcall DebugHelper::Activate_MiscEnabled()
|
|
{
|
|
InputTrainer_ToggleEnabled(InputTrainer::MISC);
|
|
}
|
|
|