CydandClaude Fable 5
7b57f6b059
The combat-effectiveness census (@0049fa1c, the master perf's opening call) runs at the top of every Simulate frame: a mech is combat- INEFFECTIVE when its working weapons fall below the ctor-hardcoded minimum of 2 (+0x448, part_012.c:15749 -- a weapon works when not destroyed and not a dry launcher, fire state 7 == our NoAmmoState exactly), when no generator survives (state != 1 and generator state != GeneratorFailed -- the binary's +0x210 != 4, our enum value matching), when the aggregate bank's coolant fraction drops below 0.05 (@0049fb50), or when limping without the crouch cell held. Census corrections over the first read: 0xBBE is the AGGREGATE HEATSINK BANK (coolant fraction, not generator charge) and 0xBC1 is the GENERATOR (count, not coolant units) -- both re-pinned through our own classID map. EjectPilot (@0049f854, id 0x19) consumes it: only a CRIPPLED mech that is not already dying may eject -- mode 10 (EJECTED, the reason IsMechDestroyed tests >= 9), the mapper's eject latch (+0x258), and a self-dispatched explosive TakeDamage (type 2, zone -1 through the cylinder resolver at the mech's own position). Staged with the decode recorded: the damage amount (the binary reads a bound cell through mapper+0x208 -- no game-side writer exists, the mapper binding-loop decode will name it) and the score notify (@00429078 + app+0x20 vcall, event code 5). Soak (pod_render_eject.conf, BT_FORCE_CRIPPLED + BT_PRESS_EJECT): the census reads the real roster (weapons=6 generators=4 bank=1.0), the press runs the whole chain -- eject, vital kill through the cylinder table, VehicleDead, +5s respawn, HEALED at a fresh drop zone -- crash-sig 0. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
360 lines
11 KiB
C++
360 lines
11 KiB
C++
//===========================================================================//
|
|
// File: mechmppr.cpp //
|
|
// Project: BattleTech //
|
|
// Contents: Implementation details for the mech controls mapper //
|
|
//---------------------------------------------------------------------------//
|
|
// Copyright (C) 1995, Virtual World Entertainment, Inc. //
|
|
// All Rights reserved worldwide //
|
|
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL //
|
|
//===========================================================================//
|
|
|
|
#include <bt.hpp>
|
|
#pragma hdrstop
|
|
|
|
#if !defined(MECHMPPR_HPP)
|
|
# include <mechmppr.hpp>
|
|
#endif
|
|
|
|
#if !defined(MECH_HPP)
|
|
# include <mech.hpp>
|
|
#endif
|
|
|
|
#if !defined(TORSO_HPP)
|
|
# include <torso.hpp>
|
|
#endif
|
|
|
|
Derivation
|
|
MechControlsMapper::ClassDerivations(
|
|
Subsystem::ClassDerivations,
|
|
"MechControlsMapper"
|
|
);
|
|
|
|
//
|
|
//#############################################################################
|
|
// Published control-input attributes. The streamed control mappings bind (by
|
|
// name) to these; the pad entry fills the chain-vs-id gap at id 2.
|
|
//#############################################################################
|
|
//
|
|
const MechControlsMapper::IndexEntry
|
|
MechControlsMapper::AttributePointers[]=
|
|
{
|
|
{ (int)MechControlsMapper::MechControlsMapperPadFirstAttributeID,
|
|
"MechControlsMapperPad02",
|
|
(Simulation::AttributePointer)&MechControlsMapper::throttlePosition },
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, StickPosition, stickPosition),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, ThrottlePosition, throttlePosition),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, PedalsPosition, pedalsPosition),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, ReverseThrust, reverseThrust),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, SpeedDemand, speedDemand),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TurnDemand, turnDemand),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, LookForward, lookForward),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, LookLeft, lookLeft),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, LookRight, lookRight),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, LookBehind, lookBehind),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, LookDown, lookDown),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TorsoUp, torsoUp),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TorsoDown, torsoDown),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TorsoLeft, torsoLeft),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TorsoRight, torsoRight),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TorsoCenter, torsoCenter),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, ControlMode, controlMode),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, DisplayMode, displayMode),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, PilotArrayPage, pilotArrayPage),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, PilotArray, pilotArray),
|
|
ATTRIBUTE_ENTRY(MechControlsMapper, TargetRangeExponent,
|
|
targetRangeExponent)
|
|
};
|
|
|
|
MechControlsMapper::AttributeIndexSet
|
|
MechControlsMapper::AttributeIndex(
|
|
ELEMENTS(MechControlsMapper::AttributePointers),
|
|
MechControlsMapper::AttributePointers,
|
|
Subsystem::AttributeIndex
|
|
);
|
|
|
|
MechControlsMapper::SharedData
|
|
MechControlsMapper::DefaultData(
|
|
MechControlsMapper::ClassDerivations,
|
|
Subsystem::MessageHandlers,
|
|
MechControlsMapper::AttributeIndex,
|
|
1
|
|
);
|
|
|
|
MechControlsMapper::MechControlsMapper(
|
|
Mech *owner,
|
|
int subsystem_ID,
|
|
CString subsystem_name,
|
|
RegisteredClass::ClassID class_ID,
|
|
SharedData &shared_data
|
|
):
|
|
Subsystem(
|
|
(Entity *)owner,
|
|
subsystem_ID,
|
|
subsystem_name,
|
|
class_ID,
|
|
shared_data
|
|
)
|
|
{
|
|
duckCommand = 0;
|
|
ejectLatch = 0;
|
|
Check(owner);
|
|
//
|
|
// Prime the published control inputs to neutral. Per-frame interpretation
|
|
// (InterpretControls) is reconstructed with the mech2/3/4 sim (phase 5.3).
|
|
//
|
|
stickPosition.x = 0.0f;
|
|
stickPosition.y = 0.0f;
|
|
throttlePosition = 0.0f;
|
|
pedalsPosition = 0.0f;
|
|
reverseThrust = 0;
|
|
speedDemand = 0.0f;
|
|
turnDemand = 0.0f;
|
|
lookForward = 0;
|
|
lookLeft = 0;
|
|
lookRight = 0;
|
|
lookBehind = 0;
|
|
lookDown = 0;
|
|
torsoUp = 0;
|
|
torsoDown = 0;
|
|
torsoLeft = 0;
|
|
torsoRight = 0;
|
|
torsoCenter = 0;
|
|
controlMode = BasicMode;
|
|
displayMode = 0;
|
|
pilotArrayPage = 0;
|
|
pilotArray = 0;
|
|
targetRangeExponent = 0.0f; // staged: bound by an authored watcher
|
|
lookState = LookNone;
|
|
previousLookState = LookNone;
|
|
{
|
|
//
|
|
// ELEMENTS(), never a literal -- this said 22 against reserved[21]
|
|
// and wrote 4 bytes off the end of every mapper. Found by a sweep
|
|
// after the same mistake surfaced in Torso (5.3.78).
|
|
//
|
|
int
|
|
i;
|
|
for (i = 0; i < (int)ELEMENTS(reserved); ++i)
|
|
{
|
|
reserved[i] = 0;
|
|
}
|
|
}
|
|
//
|
|
// Install the per-frame control-interpretation Performance.
|
|
//
|
|
SetPerformance(&MechControlsMapper::InterpretControls);
|
|
|
|
static int s_mpprLog = -1;
|
|
if (s_mpprLog < 0) { s_mpprLog = (getenv("BT_MECH_LOG") != NULL); }
|
|
if (s_mpprLog)
|
|
{
|
|
DEBUG_STREAM << "[mapper] ctor id=" << subsystem_ID
|
|
<< " throttleAttr=" << GetAttributePointer(ThrottlePositionAttributeID)
|
|
<< " controlModeAttr=" << GetAttributePointer(ControlModeAttributeID)
|
|
<< endl << flush;
|
|
}
|
|
Check_Fpu();
|
|
}
|
|
|
|
MechControlsMapper::~MechControlsMapper()
|
|
{
|
|
}
|
|
|
|
//
|
|
//#############################################################################
|
|
// InterpretControls -- the mapper's per-frame Performance. Reads the raw input
|
|
// attributes (the engine controls push refreshes throttle/stick/pedals/buttons
|
|
// from the RIO/keyboard before this runs) and publishes the locomotion demands
|
|
// (speedDemand in world-u/s, turnDemand [-1..1]) the mech drive consumes.
|
|
//
|
|
// Reconstructs the authentic demand math (mechmppr.cpp @004afd10):
|
|
// * throttle -> forward speed: speedDemand = topSpeed * throttle * fwdScale
|
|
// (reverse thrust inverts and drops the forward scale);
|
|
// * soft stick response: square the yaw (sign preserved), cube the pedals;
|
|
// * Basic: stick yaw = turn; Standard/Veteran: pedals = turn;
|
|
// * speed is clamped down while turning hard (max_turn ramp).
|
|
//
|
|
// DEV hook (headless verification, no RIO/keyboard): BT_FORCE_THROTTLE /
|
|
// BT_FORCE_TURN override the pushed raw inputs so the demand math + mech drive
|
|
// are exercisable without hardware. The torso-aim / free-look interpretation
|
|
// (torso analog axes, look/eyepoint commit) is the aiming wave, deferred.
|
|
//#############################################################################
|
|
//
|
|
void
|
|
MechControlsMapper::InterpretControls(Scalar time_slice)
|
|
{
|
|
Check(this);
|
|
|
|
Mech *mech = GetMech();
|
|
Check(mech);
|
|
|
|
//
|
|
// DEV forced-input override. Parsed ONCE -- this block used to run four
|
|
// getenv scans plus atof parses EVERY FRAME in the control path, part of
|
|
// why the build lagged the shipped exe.
|
|
//
|
|
{
|
|
static int s_forceParsed = 0;
|
|
static int s_hasThrottle = 0, s_hasTurn = 0, s_hasElev = 0, s_hasLook = 0;
|
|
static Scalar s_throttle = 0.0f, s_turn = 0.0f, s_elev = 0.0f;
|
|
static int s_look = 0;
|
|
if (!s_forceParsed)
|
|
{
|
|
s_forceParsed = 1;
|
|
const char *e;
|
|
e = getenv("BT_FORCE_THROTTLE");
|
|
if (e != NULL) { s_hasThrottle = 1; s_throttle = (Scalar)atof(e); }
|
|
e = getenv("BT_FORCE_TURN");
|
|
if (e != NULL) { s_hasTurn = 1; s_turn = (Scalar)atof(e); }
|
|
e = getenv("BT_FORCE_ELEV");
|
|
if (e != NULL) { s_hasElev = 1; s_elev = (Scalar)atof(e); }
|
|
e = getenv("BT_FORCE_LOOK");
|
|
if (e != NULL) { s_hasLook = 1; s_look = atoi(e); }
|
|
}
|
|
if (s_hasThrottle)
|
|
{
|
|
throttlePosition = (s_throttle >= 0.0f) ? s_throttle : -s_throttle;
|
|
reverseThrust = (s_throttle < 0.0f) ? 1 : 0;
|
|
}
|
|
if (s_hasTurn)
|
|
{
|
|
stickPosition.x = s_turn;
|
|
}
|
|
if (s_hasElev)
|
|
{
|
|
stickPosition.y = s_elev;
|
|
}
|
|
if (s_hasLook)
|
|
{
|
|
int state = s_look;
|
|
lookLeft = (state == (int)LookLeftState) ? 1 : 0;
|
|
lookRight = (state == (int)LookRightState) ? 1 : 0;
|
|
lookBehind = (state == (int)LookBehindState) ? 1 : 0;
|
|
lookDown = (state == (int)LookDownState) ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
Torso *torso = (Torso *)mech->GetTorsoSubsystem();
|
|
|
|
Scalar topSpeed = mech->GetReverseStrideLength();
|
|
Scalar walkSpeed = mech->GetWalkStrideLength();
|
|
|
|
//
|
|
// Throttle -> forward speed demand.
|
|
//
|
|
if (reverseThrust < 1)
|
|
{
|
|
speedDemand = topSpeed * throttlePosition * mech->GetForwardThrottleScale();
|
|
}
|
|
else
|
|
{
|
|
speedDemand = -topSpeed * throttlePosition;
|
|
}
|
|
|
|
//
|
|
// Soft response: square the stick yaw (sign preserved), cube the pedals.
|
|
//
|
|
Scalar stick_x = stickPosition.x * stickPosition.x;
|
|
if (stickPosition.x < 0.0f)
|
|
{
|
|
stick_x = -stick_x;
|
|
}
|
|
Scalar stick_y = stickPosition.y * stickPosition.y;
|
|
if (stickPosition.y < 0.0f)
|
|
{
|
|
stick_y = -stick_y;
|
|
}
|
|
Scalar pedal_3 = pedalsPosition * pedalsPosition * pedalsPosition;
|
|
|
|
turnDemand = 0.0f;
|
|
|
|
//
|
|
// Torso aim. Every control mode routes the stick pitch (stick_y) into the
|
|
// torso weapon-elevation axis. In Basic the stick yaw is the turn (legs);
|
|
// in Standard/Veteran the stick yaw is the torso twist (free aim) and the
|
|
// pedals steer. (The HUD free-aim slew + look/eyepoint commit are the
|
|
// aiming/camera wave, deferred.)
|
|
//
|
|
if (controlMode == BasicMode)
|
|
{
|
|
turnDemand = stick_x;
|
|
if (torso != NULL)
|
|
{
|
|
torso->SetAnalogElevationAxis(stick_y);
|
|
torso->SetAnalogTwistAxis(0.0f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
turnDemand = pedal_3;
|
|
if (torso != NULL)
|
|
{
|
|
torso->SetAnalogElevationAxis(stick_y);
|
|
torso->SetAnalogTwistAxis(stick_x);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clamp forward speed down while turning hard (except VeteranMode, which has
|
|
// no speed-dependent turn clamp). max_turn ramps from topSpeed (no turn) to
|
|
// walkSpeed (full turn).
|
|
//
|
|
if (controlMode != VeteranMode)
|
|
{
|
|
Scalar turn_mag = (turnDemand < 0.0f) ? -turnDemand : turnDemand;
|
|
if (turn_mag > 0.001f)
|
|
{
|
|
Scalar max_turn = (topSpeed - walkSpeed) * (1.0f - turn_mag) + walkSpeed;
|
|
if (speedDemand > max_turn) speedDemand = max_turn;
|
|
if (speedDemand < -max_turn) speedDemand = -max_turn;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Look / eyepoint selection. Choose a look direction from the buttons;
|
|
// when it changes, commit it -- the mech re-aims the eyepoint from its
|
|
// authored look angles (and, once the weapon wave lands, re-arms the
|
|
// per-view weapon fire enables through the same commit).
|
|
//
|
|
previousLookState = lookState;
|
|
if (lookLeft > 0) lookState = LookLeftState;
|
|
else if (lookRight > 0) lookState = LookRightState;
|
|
else if (lookBehind > 0) lookState = LookBehindState;
|
|
else if (lookDown > 0) lookState = LookDownState;
|
|
else lookState = LookNone;
|
|
|
|
if (lookState != previousLookState)
|
|
{
|
|
mech->CommitLookState(lookState);
|
|
}
|
|
|
|
static int s_mpprLog = -1;
|
|
if (s_mpprLog < 0) { s_mpprLog = (getenv("BT_MECH_LOG") != NULL); }
|
|
if (s_mpprLog)
|
|
{
|
|
static Scalar reportAccum = 0.0f;
|
|
reportAccum += time_slice;
|
|
if (reportAccum >= 1.0f)
|
|
{
|
|
reportAccum = 0.0f;
|
|
DEBUG_STREAM << "[mppr] thr=" << throttlePosition
|
|
<< " rev=" << reverseThrust
|
|
<< " stickX=" << stickPosition.x
|
|
<< " stickY=" << stickPosition.y
|
|
<< " mode=" << controlMode
|
|
<< " -> speedDemand=" << speedDemand
|
|
<< " turnDemand=" << turnDemand
|
|
<< " torsoElev=" << (torso ? torso->CurrentElevation() : 0.0f)
|
|
<< endl << flush;
|
|
}
|
|
}
|
|
|
|
Check_Fpu();
|
|
}
|
|
|
|
Logical
|
|
MechControlsMapper::TestInstance() const
|
|
{
|
|
return IsDerivedFrom(ClassDerivations);
|
|
}
|