arcattackandClaude Opus 5
373889760c
Found while sweeping the shipped launchers for the PATH-shadowing bug class.
Previously recorded ONLY as row 10 of docs/INPUT_PATH_AUDIT.md and never
filed, so it was invisible on the tracker.
joyconfig.bat sets BOTH `BT_JOYCONFIG=1` and `BT_FE_SOLO=1`, so after the
wizard writes bindings.txt the boot continues into the FRONT END, which hands
off by CreateProcessW()ing the next generation with the CURRENT environment.
That clear-list (btl4console.cpp) covers only BT_FE_EGG/PODS/SECS/LOOP --
BT_JOYCONFIG is never cleared -- so the handed-off generation re-entered
BTJoyConfigWizard() and blocked on _getch() BEHIND the 3D window: an
unrecoverable hang, hitting exactly the players most likely to run that bat
(flight stick / HOTAS / pedals).
Fix: SetEnvironmentVariableA("BT_JOYCONFIG", NULL) immediately after the
wizard returns. Cleared in the WIN32 environment (what CreateProcess
inherits, matching the console's own pattern) rather than the CRT copy, so
exactly one generation ever runs it. Chosen over extending the console's
clear-list because it also covers any future relaunch path.
NOT YET REBUILT: the exe was locked by a live play session when this landed.
Must be rebuilt + verified (run joyconfig.bat, finish the wizard, confirm no
second "=== BattleTech joystick setup ===" banner and that the game proceeds
into the menu) before the next zip is cut.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
969 lines
41 KiB
C++
969 lines
41 KiB
C++
//===========================================================================//
|
|
// File: btl4main.cpp //
|
|
// Project: BattleTech Brick: BattleTech LBE Application launcher //
|
|
//---------------------------------------------------------------------------//
|
|
// Win32 entry point for the reconstructed BattleTech port. //
|
|
// //
|
|
// Reconstructed/adapted from the Red Planet launcher RP_L4\RPL4.CPP -- the //
|
|
// only game-specific differences are the application class (BTL4Application //
|
|
// vs RPL4Application), the resource file (BTL4.RES), and the program name. //
|
|
// The RP-only mission-review / spool playback branch is intentionally //
|
|
// dropped for the first single-player bring-up. //
|
|
//===========================================================================//
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#define _WIN32_WINNT 0x0500
|
|
#define WINVER 0x0500
|
|
|
|
// #define BT_HEAPCHECK // enable to validate the heap on every alloc (heap-corruption hunt)
|
|
#include <windows.h>
|
|
#include <shellapi.h> // CommandLineToArgvW
|
|
#include <btversion.h> // generated: 4.11.<commit count> (<hash>)
|
|
#include <crtdbg.h> // _CrtSetDbgFlag (heap validation, gated by BT_HEAPCHECK)
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime> // BT_EXPIRE tripwire (time)
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <bgfload.h> // LoadBgfFile (BGF probe) -- via game/fwd shim
|
|
#include <bt.hpp> // BT umbrella -- engine Entity/Application chain (matches btl4app.cpp)
|
|
#include "btl4app.hpp" // BTL4Application (pulls L4Application / Application chain)
|
|
#include "appmgr.hpp" // ApplicationManager
|
|
#include "resource.hpp" // StreamableResourceFile
|
|
#include "memreg.hpp" // Start_Registering / Register_Object / Stop_Registering
|
|
|
|
// Data version. The check (RESOURCE.cpp StreamableResourceFile ctor) compares our
|
|
// version[i] against the file's versionArray[i+1] (it skips the format byte), and the
|
|
// file is v1.1.0.6 → versionArray[1..3] = {1,0,6}. So our 3 bytes must be {1,0,6}.
|
|
Byte version[3] = { 1, 0, 6 };
|
|
|
|
extern const char* const ProgName;
|
|
const char* const ProgName = "btl4";
|
|
|
|
Application *btl4App = NULL;
|
|
HWND hWnd = NULL;
|
|
|
|
// Set by Application::StopMissionMessageHandler (APP.cpp): the round ended by
|
|
// operator/clock (NOT a window close) -- drives the between-rounds auto-rejoin.
|
|
int gBTMissionStoppedByConsole = 0;
|
|
|
|
// GLASS: resolvers for the per-display windows (declared in l4vb16.h), defined
|
|
// HERE off the launcher's own app + window pointers. They deliberately do NOT
|
|
// touch the `application`/`ghWnd` globals: those are duplicate-defined and bind
|
|
// non-deterministically per link under /FORCE (CMakeLists.txt:186), so a fresh
|
|
// engine TU (L4GLASSWIN) can read the NULL copy. btl4App/hWnd live in THIS obj
|
|
// and are the real, assigned pointers -- always correct.
|
|
class GaugeRenderer;
|
|
GaugeRenderer *BTResolveGaugeRenderer()
|
|
{
|
|
return btl4App ? btl4App->GetGaugeRenderer() : 0;
|
|
}
|
|
void *BTResolveMainWindow()
|
|
{
|
|
return (void *)hWnd;
|
|
}
|
|
|
|
//===========================================================================//
|
|
// Bring-up player DRIVE input (Tier 2 locomotion).
|
|
// Populated by the keyboard handler in WndProc below (WASD / arrow keys)
|
|
// and consumed each frame by Mech::PerformAndWatch
|
|
// (decomp/reconstructed/mech4.cpp), which walks the player mech and advances
|
|
// its localToWorld -- the matrix the render tree AND the chase camera are
|
|
// bound to, so the mech moves and the camera follows.
|
|
//
|
|
// throttle: +1 full ahead .. -1 full reverse turn: +1 right .. -1 left
|
|
// Both are the OUTPUT of the virtual-control integrator in mech4.cpp
|
|
// (dt-scaled, fps-independent) -- the pod's real inputs were an ABSOLUTE
|
|
// analog throttle LEVER + turn stick, which momentary 0/1 keys can't
|
|
// express directly (and at 60fps every key tap = full demand = the "too
|
|
// sensitive controls" report). The WndProc only records KEY STATE
|
|
// (keyFwd/keyBack/keyLeft/keyRight); mech4 integrates:
|
|
// W/S = move the persistent throttle lever (tap ~= +/-0.07 fine step,
|
|
// hold sweeps full range in ~1.4s, DETENT at zero: braking stops
|
|
// AT 0 -- release and press S again to engage reverse)
|
|
// A/D = ramped momentary stick (deflects over ~0.4s, auto-centers)
|
|
// X = all stop (lever -> 0)
|
|
// forced : DEBUG toggle (env BT_FORCE_THROTTLE), default OFF. When set the
|
|
// mech walks full-ahead with NO keypress -- used only for headless
|
|
// autonomous verification (you can't press keys in a headless run).
|
|
//===========================================================================//
|
|
// fire: weapon trigger held (1 while the fire key is down).
|
|
// fireForced: DEBUG auto-fire (env BT_FORCE_FIRE) -- fires on cooldown with no
|
|
// keypress, for headless verification.
|
|
struct BTDriveInput { float throttle; float turn; int forced; int fire; int fireForced; float forcedThrottle;
|
|
int keyFwd; int keyBack; int keyLeft; int keyRight; int allStop; };
|
|
BTDriveInput gBTDrive = { 0.0f, 0.0f, 0, 0, 0, 1.0f, 0, 0, 0, 0, 0 };
|
|
|
|
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_KEYDOWN:
|
|
case WM_KEYUP:
|
|
// Drive keys are NOT read here: the engine's keyboard reader
|
|
// (L4CTRL.cpp:1506) GetMessage()s every WM_KEYUP / WM_CHAR out of the
|
|
// queue for its key-command channel, so this WndProc only ever saw the
|
|
// KEYDOWNs -- key state latched on and never released (the "controls
|
|
// incoherent" bug). The virtual-control integrator in mech4.cpp polls
|
|
// GetAsyncKeyState per frame instead (with a foreground guard), which
|
|
// is immune to message stealing.
|
|
return 0;
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
// COCKPIT SURROUND: route clicks on the composited panel buttons to the
|
|
// RIO (glass build) via the layout hit-test. No-op in other modes.
|
|
{
|
|
extern int gBTGaugeCockpit;
|
|
extern int BTCockpitMouseDown(int, int, int, int, int);
|
|
if (gBTGaugeCockpit)
|
|
{
|
|
RECT rc; GetClientRect(hWnd, &rc);
|
|
int consumed = BTCockpitMouseDown(
|
|
(int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam),
|
|
(int)(rc.right - rc.left), (int)(rc.bottom - rc.top),
|
|
uMsg == WM_RBUTTONDOWN);
|
|
if (consumed && uMsg == WM_LBUTTONDOWN)
|
|
SetCapture(hWnd); // a release outside the button still clears it
|
|
}
|
|
}
|
|
return 0;
|
|
case WM_LBUTTONUP:
|
|
{
|
|
extern int gBTGaugeCockpit;
|
|
extern void BTCockpitMouseUp(void);
|
|
if (gBTGaugeCockpit) { BTCockpitMouseUp(); ReleaseCapture(); }
|
|
}
|
|
return 0;
|
|
case WM_SIZE:
|
|
// Window-resize aspect fix (task #20): rebuild the projection for the
|
|
// new client aspect so the scene doesn't stretch fat/skinny (the D3D9
|
|
// backbuffer stays at the configured size and is stretched into the
|
|
// client area; rendering with the client aspect cancels the stretch).
|
|
if (wParam != SIZE_MINIMIZED && LOWORD(lParam) > 0 && HIWORD(lParam) > 0)
|
|
{
|
|
extern void L4NotifyWindowResized(int client_w, int client_h);
|
|
L4NotifyWindowResized((int)LOWORD(lParam), (int)HIWORD(lParam));
|
|
}
|
|
return 0;
|
|
case WM_CLOSE:
|
|
DestroyWindow(hWnd);
|
|
return 0;
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
}
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
#ifdef BT_GLASS
|
|
#include "btl4fe.hpp"
|
|
#include "btl4console.hpp"
|
|
#endif
|
|
|
|
//
|
|
// CRASH SELF-REPORT (2026-07-24, the #35/#41 heisenbug hunt): every unhandled
|
|
// exception logs its code, address, and an EBP-chain stack walk as
|
|
// MODULE-RELATIVE offsets ("btl4+0x1234") into BT_LOG before the process
|
|
// dies -- so any field crash on any machine hands us a resolvable stack (we
|
|
// hold the PDB). The walker is guarded per-dereference; a corrupt frame
|
|
// chain just truncates the walk.
|
|
//
|
|
static LONG WINAPI
|
|
BTCrashFilter(EXCEPTION_POINTERS *info)
|
|
{
|
|
unsigned long base = (unsigned long)GetModuleHandleA(NULL);
|
|
unsigned long code = info->ExceptionRecord->ExceptionCode;
|
|
unsigned long addr = (unsigned long)info->ExceptionRecord->ExceptionAddress;
|
|
|
|
std::cout << "\n[crash] UNHANDLED EXCEPTION code=0x" << std::hex << code
|
|
<< " addr=0x" << addr;
|
|
if (addr >= base && addr < base + 0x2000000UL)
|
|
std::cout << " (btl4+0x" << (addr - base) << ")";
|
|
if (code == 0xC0000005 && info->ExceptionRecord->NumberParameters >= 2)
|
|
std::cout << " access=" << std::dec
|
|
<< (int)info->ExceptionRecord->ExceptionInformation[0]
|
|
<< std::hex << " target=0x"
|
|
<< (unsigned long)info->ExceptionRecord->ExceptionInformation[1];
|
|
std::cout << "\n[crash] stack:";
|
|
|
|
unsigned long eip = info->ContextRecord->Eip;
|
|
unsigned long ebp = info->ContextRecord->Ebp;
|
|
for (int depth = 0; depth < 24; ++depth)
|
|
{
|
|
std::cout << " ";
|
|
if (eip >= base && eip < base + 0x2000000UL)
|
|
std::cout << "btl4+0x" << std::hex << (eip - base);
|
|
else
|
|
std::cout << "0x" << std::hex << eip;
|
|
MEMORY_BASIC_INFORMATION mbi;
|
|
if (ebp == 0 || (ebp & 3) != 0
|
|
|| VirtualQuery((void *)ebp, &mbi, sizeof(mbi)) == 0
|
|
|| mbi.State != MEM_COMMIT
|
|
|| (mbi.Protect & (PAGE_READWRITE | PAGE_READONLY)) == 0)
|
|
break;
|
|
unsigned long next_eip = ((unsigned long *)ebp)[1];
|
|
unsigned long next_ebp = ((unsigned long *)ebp)[0];
|
|
if (next_eip == 0 || next_ebp <= ebp)
|
|
break;
|
|
eip = next_eip;
|
|
ebp = next_ebp;
|
|
}
|
|
std::cout << std::dec << "\n" << std::flush;
|
|
return EXCEPTION_EXECUTE_HANDLER; // die (after the evidence is out)
|
|
}
|
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
|
|
{
|
|
// Boot tick for the relaunch storm damper (btl4console.cpp, issue #33):
|
|
// generations that die young relaunch with a 5 s pause.
|
|
{
|
|
extern unsigned long gBTBootTick;
|
|
gBTBootTick = GetTickCount();
|
|
}
|
|
|
|
// Crash self-report (see BTCrashFilter above) -- armed before anything
|
|
// else so even boot crashes leave a stack in the log.
|
|
SetUnhandledExceptionFilter(BTCrashFilter);
|
|
|
|
// BT_CRASHTEST=1: deliberately AV after the log opens -- verifies the
|
|
// crash filter's forensic path end-to-end on any machine.
|
|
|
|
// Heap-corruption hunt (env BT_HEAPCHECK=1; default OFF -- ~100x slower): validate
|
|
// the whole debug heap on EVERY alloc/free, so an out-of-bounds write is caught at
|
|
// the very next heap op (a stack near the culprit) instead of much later at some
|
|
// unrelated free. Route the CRT report to the debugger so cdb breaks at detection.
|
|
if (getenv("BT_HEAPCHECK"))
|
|
{
|
|
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF);
|
|
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG);
|
|
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
|
|
}
|
|
|
|
// Bring-up: route CRT asserts (e.g. fread stream!=nullptr) to the debugger
|
|
// instead of a modal MessageBox, so cdb breaks at the assert and we can dump
|
|
// the faulting stack in a headless run. Gated; default OFF (no behavior change).
|
|
if (getenv("BT_ASSERT_TO_DEBUGGER"))
|
|
{
|
|
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
|
|
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG);
|
|
}
|
|
|
|
// Redirect the engine's std::cout/DEBUG_STREAM to a log file. BT_LOG names the
|
|
// file (default btl4.log) -- REQUIRED for multi-instance runs from one cwd
|
|
// (instance 2 would truncate instance 1's log).
|
|
std::ofstream logfile;
|
|
// BT_LOG_APPEND=1: keep prior generations' lines (the lobby-loop
|
|
// relaunch truncates the shared BT_LOG otherwise -- multi-generation
|
|
// forensics need the whole trail).
|
|
logfile.open(getenv("BT_LOG") ? getenv("BT_LOG") : "btl4.log",
|
|
(getenv("BT_LOG_APPEND") != NULL && *getenv("BT_LOG_APPEND") == '1')
|
|
? (std::ios::out | std::ios::app) : std::ios::out);
|
|
std::cout.rdbuf(logfile.rdbuf());
|
|
|
|
if (getenv("BT_CRASHTEST") != NULL && *getenv("BT_CRASHTEST") == '1')
|
|
{
|
|
*(volatile int *)0 = 0; // BT_CRASHTEST: exercise BTCrashFilter
|
|
}
|
|
|
|
// FIRST-BREATH line, flushed IMMEDIATELY (field 2026-07-23: a player's
|
|
// exe died repeatedly with a 0-byte join.log -- indistinguishable from
|
|
// "never ran"). After this line, an empty log can only mean the exe was
|
|
// killed before WinMain (antivirus / loader) -- an external cause, not
|
|
// ours. Cheap forensics: version, PID, args, generation markers.
|
|
std::cout << "[boot] btl4 " << BT_VERSION_STRING << " pid="
|
|
<< (unsigned)GetCurrentProcessId()
|
|
<< " args='" << (lpCmdLine ? lpCmdLine : "") << "'"
|
|
<< (getenv("BT_FE_LOOP") ? " (relaunched generation)" : " (first process)")
|
|
<< std::endl << std::flush;
|
|
|
|
// BT_JOYCONFIG=1: the generic-joystick capture wizard (flight sticks /
|
|
// HOTAS / pedals -- L4JOY.h). Console prompts detect which device/axis
|
|
// the player moves for each pod control and write the joystick section
|
|
// of content\bindings.txt, then the boot continues into the game with
|
|
// the new bindings live (PadRIO loads the file after this point).
|
|
if (getenv("BT_JOYCONFIG") != NULL && *getenv("BT_JOYCONFIG") != '0')
|
|
{
|
|
extern int BTJoyConfigWizard(void);
|
|
BTJoyConfigWizard();
|
|
//
|
|
// ONE-SHOT (input-path audit row 10): joyconfig.bat sets BT_JOYCONFIG=1
|
|
// *and* BT_FE_SOLO=1, so the wizard's process hands off to the front end,
|
|
// which CreateProcess()es the next generation with the CURRENT environment
|
|
// (btl4console.cpp clears only BT_FE_EGG/PODS/SECS/LOOP). The child then
|
|
// re-entered the wizard and blocked on console input BEHIND the 3D window
|
|
// -- an unrecoverable hang for anyone who configures a joystick. Clear it
|
|
// in the Win32 environment (what CreateProcess inherits, matching the
|
|
// console's own SetEnvironmentVariableA pattern) the moment the wizard is
|
|
// done, so exactly one generation ever runs it.
|
|
//
|
|
SetEnvironmentVariableA("BT_JOYCONFIG", NULL);
|
|
}
|
|
|
|
// MP wire-format probe (env BT_NET_PROBE=1): print the exact packet constants
|
|
// the console emulator (tools/btconsole.py) must speak, computed from OUR build
|
|
// (message IDs chain across class enums at compile time -- never hand-compute).
|
|
if (getenv("BT_NET_PROBE"))
|
|
{
|
|
std::cout << "[netprobe] ReceiveEggFileMessageID=" << (int)NetworkManager::ReceiveEggFileMessageID
|
|
<< " sizeof(NetworkPacketHeader)=" << sizeof(NetworkPacketHeader)
|
|
<< " sizeof(Receiver__Message)=" << sizeof(Receiver__Message)
|
|
<< " sizeof(ReceiveEggFileMessage)=" << sizeof(NetworkManager::ReceiveEggFileMessage)
|
|
<< " sizeof(Time)=" << sizeof(Time)
|
|
<< " NetworkManagerClientID=" << (int)NetworkClient::NetworkManagerClientID
|
|
<< " RunMissionMessageID=" << (int)Application::RunMissionMessageID
|
|
<< " sizeof(RunMissionMessage)=" << sizeof(Application::RunMissionMessage)
|
|
<< " ApplicationClientID=" << (int)NetworkClient::ApplicationClientID
|
|
<< "\n" << std::flush;
|
|
return 0;
|
|
}
|
|
|
|
// BGF loader probe (env BT_PROBE_BGF=<name>[,<name>...] or =ALL): load the named
|
|
// model(s) directly through the engine's LoadBgfFile -- NO app, NO renderer, NO
|
|
// mechs -- then exit. Isolates the loader: if this crashes/corrupts, the bug is
|
|
// in bgfload.cpp itself (H1); if hundreds of iterations are clean, the in-game
|
|
// corruption comes from elsewhere and the loader's frees only DETECT it (H2).
|
|
// Repeats each load BT_PROBE_N times (default 8). cwd must be the pod BT dir
|
|
// (the loader indexes VIDEO\ relative to cwd). Combine with BT_HEAPCHECK=1.
|
|
if (const char *probe = getenv("BT_PROBE_BGF"))
|
|
{
|
|
const int reps = getenv("BT_PROBE_N") ? atoi(getenv("BT_PROBE_N")) : 8;
|
|
std::vector<std::string> names;
|
|
if (_stricmp(probe, "ALL") == 0)
|
|
{
|
|
WIN32_FIND_DATAA fd;
|
|
HANDLE h = FindFirstFileA("VIDEO\\GEO\\*.BGF", &fd);
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
{
|
|
do { names.push_back(fd.cFileName); } while (FindNextFileA(h, &fd));
|
|
FindClose(h);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::string s(probe);
|
|
size_t p = 0;
|
|
while (p < s.size())
|
|
{
|
|
size_t c = s.find(',', p);
|
|
if (c == std::string::npos) c = s.size();
|
|
if (c > p) names.push_back(s.substr(p, c - p));
|
|
p = c + 1;
|
|
}
|
|
}
|
|
std::cout << "[probe] BGF probe: " << names.size() << " model(s) x " << reps
|
|
<< " reps, heapcheck=" << (getenv("BT_HEAPCHECK") ? 1 : 0) << "\n" << std::flush;
|
|
int fails = 0;
|
|
for (size_t i = 0; i < names.size(); ++i)
|
|
{
|
|
for (int r = 0; r < reps; ++r)
|
|
{
|
|
BgfData data;
|
|
bool ok = LoadBgfFile(names[i], data);
|
|
if (r == 0 || !ok)
|
|
std::cout << "[probe] " << names[i] << " rep " << r
|
|
<< (ok ? " OK" : " FAIL") << " verts=" << data.verts.size()
|
|
<< " idx=" << data.indices.size() << " tris=" << data.tris
|
|
<< (ok ? "" : (" err=" + data.error)) << "\n" << std::flush;
|
|
if (!ok) ++fails;
|
|
if (!_CrtCheckMemory())
|
|
{
|
|
std::cout << "[probe] *** HEAP CORRUPT after " << names[i]
|
|
<< " rep " << r << " ***\n" << std::flush;
|
|
return 3;
|
|
}
|
|
}
|
|
}
|
|
std::cout << "[probe] DONE: heap clean, fails=" << fails << "\n" << std::flush;
|
|
return 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// PLATFORM PROFILE -- dev (default) vs pod. This is NOT a code fork: the
|
|
// profile just selects WHICH environment preset the existing video/gauge/input
|
|
// code reads (the pod multi-surface path already exists -- FindBestAdapterIndices
|
|
// / SVGA16::BuildWindows / L4GaugeRenderer -- gated on these env vars).
|
|
// dev = single 800x600 window + keyboard (no L4GAUGE -> MakeGaugeRenderer
|
|
// returns NULL, btl4app.cpp:353). The working dev build.
|
|
// pod = multi-surface gauges/MFDs (L4GAUGE set) + RIO cockpit I/O, mirroring
|
|
// content/SETENV.BAT (the authentic pod preset). The `if getenv==NULL`
|
|
// guard lets a real pod environment (SETENV.BAT) override every value.
|
|
// Select with env BT_PLATFORM=pod|dev (robust; primary) or a `-platform pod`
|
|
// launcher arg. ⚠ A FULL pod run needs the pod's 2 adapters / 7 monitors + RIO
|
|
// & plasma serial + GAUGE\L4GAUGE.INI (Phase-8, on real hardware). On a dev box
|
|
// `-platform pod` ATTEMPTS the path (FindBestAdapterIndices degrades to the
|
|
// primary adapter) -- selectable for bring-up, not fully validated off-pod.
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
// MENU-MODE detection FIRST (glass): the front-end process must NOT
|
|
// apply a platform profile -- its putenv()s would leak into the
|
|
// relaunched mission child and defeat the child's own preset (found
|
|
// live: a direct btl4.exe start ran the menu under the DEV profile,
|
|
// the child inherited L4CONTROLS=KEYBOARD, and the glass preset could
|
|
// never select PAD -- no PadRIO, no panel, plasma only).
|
|
//
|
|
int gBTPlatformPod = 0;
|
|
int gBTPlatformGlass = 0;
|
|
{
|
|
const char *pe = getenv("BT_PLATFORM");
|
|
int platform_dev = 0;
|
|
if (pe && _stricmp(pe, "pod") == 0) gBTPlatformPod = 1;
|
|
if (pe && _stricmp(pe, "glass") == 0) gBTPlatformGlass = 1;
|
|
if (pe && _stricmp(pe, "dev") == 0) platform_dev = 1;
|
|
// Convenience: also accept a raw `-platform pod` on the command line,
|
|
// parsed off lpCmdLine independently of L4Application::ParseCommandLine.
|
|
const char *pf = lpCmdLine ? strstr(lpCmdLine, "-platform") : 0;
|
|
if (pf)
|
|
{
|
|
char pv[16] = { 0 };
|
|
if (sscanf(pf + 9, " %15s", pv) == 1 && _stricmp(pv, "pod") == 0)
|
|
gBTPlatformPod = 1;
|
|
if (pv[0] && _stricmp(pv, "glass") == 0)
|
|
gBTPlatformGlass = 1;
|
|
if (pv[0] && _stricmp(pv, "dev") == 0)
|
|
platform_dev = 1;
|
|
}
|
|
//
|
|
// DESKTOP DEFAULT = GLASS (2026-07-22, "competing keymaps" fix): every
|
|
// launcher that forgot BT_PLATFORM=glass booted the DEV profile -- no
|
|
// PadRIO, the bring-up keyboard bridge owning the keys ("the old
|
|
// keymap again": play bats, steam bat, then the operator console,
|
|
// each needed the same one-line fix). Glass is now the DEFAULT when
|
|
// no platform is chosen, so omission can never resurrect the old
|
|
// input stack. BT_PLATFORM=dev opts back into the legacy DEV profile
|
|
// for debugging; the FUTURE pod cabinet must set BT_PLATFORM=pod in
|
|
// its SETENV.BAT (contract recorded in context/glass-cockpit.md --
|
|
// note this changes the old "bare boot == cabinet shape" assumption).
|
|
//
|
|
if (!gBTPlatformPod && !gBTPlatformGlass && !platform_dev)
|
|
gBTPlatformGlass = 1;
|
|
}
|
|
|
|
// MENU GATE (2026-07-21, amended 2026-07-22): the miniconsole menu runs
|
|
// on a zero-arg GLASS boot. With glass now the desktop DEFAULT, a bare
|
|
// double-click of btl4.exe opens the menu -- the desired desktop UX.
|
|
// The pod cabinet opts out via BT_PLATFORM=pod (SETENV.BAT contract);
|
|
// BT_PLATFORM=dev keeps the old bare-boot wait-for-egg shape.
|
|
int fe_menu_mode = 0;
|
|
{
|
|
int fe_has_egg = lpCmdLine && strstr(lpCmdLine, "-egg") != NULL;
|
|
int fe_has_net = lpCmdLine && strstr(lpCmdLine, "-net") != NULL;
|
|
fe_menu_mode = !fe_has_egg && !fe_has_net && getenv("BT_FE_EGG") == NULL
|
|
&& (gBTPlatformGlass || getenv("BT_FE_MENU") != NULL);
|
|
}
|
|
|
|
if (fe_menu_mode)
|
|
{
|
|
// the front end owns this process; no profile putenvs (see above)
|
|
}
|
|
else if (gBTPlatformPod)
|
|
{
|
|
// POD profile. RIO cockpit input, which falls back to KEYBOARD when the
|
|
// serial port isn't present (e.g. a dev box: "RIO initialization failed!
|
|
// Shutting Down Serial Port!" -> keyboard).
|
|
if (getenv("L4CONTROLS") == NULL) putenv("L4CONTROLS=RIO,KEYBOARD");
|
|
|
|
// The multi-surface gauges/MFDs are a POD-HARDWARE capability: each surface
|
|
// needs its OWN fullscreen D3D device on one of the pod's 2 video cards
|
|
// (separate adapters), which can't be created on a typical dev box -- the
|
|
// L4GaugeRenderer/SVGA16 path bails there. So `-platform pod` does NOT
|
|
// auto-enable them; it stays bootable everywhere as single-window + the pod
|
|
// INPUT profile. On the REAL pod the gauges come from content/SETENV.BAT
|
|
// (which sets L4GAUGE + the gauge/adapter env); the existing, untouched
|
|
// FindBestAdapterIndices / SVGA16 / L4GaugeRenderer path then runs.
|
|
// To force-test the surfaces off-pod, set L4GAUGE explicitly (needs >=2 real
|
|
// display ADAPTERS, not just monitors). FOLLOW-UP for a dev-visible pod HUD:
|
|
// composite the MFDs/gauges into the single window ("MFD compositing on dev").
|
|
if (getenv("L4GAUGE") != NULL && getenv("L4PLASMA") == NULL)
|
|
putenv("L4PLASMA=com2"); // only when the pod env already asked for gauges
|
|
}
|
|
#ifdef BT_GLASS
|
|
else if (gBTPlatformGlass)
|
|
{
|
|
// GLASS profile (dev tooling, step 2e): the desktop cockpit --
|
|
// PadRIO input (XInput+keyboard, content\bindings.txt), the
|
|
// dev-composited MFD surfaces, and the desktop plasma window.
|
|
// Each only when not already set, so a developer env overrides.
|
|
if (getenv("L4CONTROLS") == NULL) putenv("L4CONTROLS=PAD,KEYBOARD");
|
|
if (getenv("BT_DEV_GAUGES") == NULL) putenv("BT_DEV_GAUGES=1");
|
|
if (getenv("L4PLASMA") == NULL) putenv("L4PLASMA=SCREEN");
|
|
|
|
// DEFAULT LAYOUT = the COCKPIT SURROUND (single window: the six gauge
|
|
// surfaces + clickable button lamps composited AROUND the centered 3D
|
|
// view). Opt out with BT_COCKPIT=0 (dock-bottom strip) or
|
|
// BT_GLASS_PANELS=1 (the per-display windows). When cockpit is the
|
|
// default the buttons live IN the main window, so no separate pad/panel
|
|
// window is created (leave BT_PAD_PANEL / BT_GLASS_PANELS unset).
|
|
int cockpitDefault = 1;
|
|
if (getenv("BT_COCKPIT") && getenv("BT_COCKPIT")[0] == '0') cockpitDefault = 0;
|
|
if (getenv("BT_GLASS_PANELS") && getenv("BT_GLASS_PANELS")[0] != '0') cockpitDefault = 0;
|
|
if (getenv("BT_DEV_GAUGES_WINDOW") || getenv("BT_DEV_GAUGES_DOCK")) cockpitDefault = 0;
|
|
if (!cockpitDefault)
|
|
{
|
|
if (getenv("BT_PAD_PANEL") == NULL) putenv("BT_PAD_PANEL=1");
|
|
if (getenv("BT_GLASS_PANELS") == NULL) putenv("BT_GLASS_PANELS=1");
|
|
}
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
// DEV profile (default): keyboard controls, single 800x600 window.
|
|
if (getenv("L4CONTROLS") == NULL) putenv("L4CONTROLS=KEYBOARD");
|
|
}
|
|
|
|
// Shared renderer/config defaults (both profiles). L4DPLCFG=BTDPL.INI gives
|
|
// DPLReadEnvironment the real BT environment (paths/fog/lights/ambient) instead
|
|
// of the dpldflt.ini fallback.
|
|
if (getenv("L4DPLCFG") == NULL) putenv("L4DPLCFG=BTDPL.INI");
|
|
if (getenv("DPLARG") == NULL) putenv("DPLARG=1");
|
|
if (getenv("MULTISAMPLE") == NULL) putenv("MULTISAMPLE=0");
|
|
if (getenv("TARGETFPS") == NULL) putenv("TARGETFPS=60");
|
|
if (getenv("MAXPARTICLES")== NULL) putenv("MAXPARTICLES=8192");
|
|
|
|
// DEV-COMPOSITE GAUGES (opt-in, default OFF): BT_DEV_GAUGES wakes the (otherwise
|
|
// dormant) gauge renderer so the pod's gauges/MFDs render + can be composited into
|
|
// the dev window. Setting L4GAUGE makes MakeGaugeRenderer build the renderer; on a
|
|
// dev box the pod multi-surface (SVGA16 per-adapter fullscreen devices) stays at 0
|
|
// surfaces (guarded in SVGA16::Update), and a composite pass in the main renderer
|
|
// blits the CPU-rastered pixelBuffer as a window inset. See docs/GAUGE_COMPOSITE.md.
|
|
if (getenv("BT_DEV_GAUGES") != NULL && getenv("L4GAUGE") == NULL)
|
|
putenv("L4GAUGE=640x480x16");
|
|
|
|
std::cout << "[boot] platform profile: "
|
|
<< (fe_menu_mode ? "MENU (front end -- no profile applied)"
|
|
: gBTPlatformPod ? "POD (RIO cockpit input; multi-surface gauges/MFDs via pod hardware or explicit L4GAUGE)"
|
|
: gBTPlatformGlass ? "GLASS (PadRIO + per-display cockpit windows [BT_GLASS_PANELS] + plasma window)"
|
|
: "DEV (single window + keyboard)")
|
|
<< std::endl << std::flush;
|
|
|
|
#ifdef BT_GLASS
|
|
//
|
|
// MINICONSOLE FRONT END (glass step 3): a zero-mission-arg launch (no
|
|
// -egg, no -net) runs the menu INSTEAD of the game, then RELAUNCHES
|
|
// this exe with the chosen mission's real arguments -- the per-mission
|
|
// process-relaunch pattern (reconstructed gBT* globals do not survive
|
|
// in-process re-init). BT_FE_* env vars arm the mission process's
|
|
// LocalConsole marshal; BT_FE_LOOP returns post-mission exits to the
|
|
// menu. The console-wire ladder itself is 100% stock -- the engine
|
|
// sees a real connected console (btl4console.cpp).
|
|
//
|
|
{
|
|
if (fe_menu_mode)
|
|
{
|
|
BTFeLaunchSpec fe_spec;
|
|
if (BTFrontEnd_Run(&fe_spec) != 0 || fe_spec.mode == BTFeLaunchNone)
|
|
{
|
|
return 0; // quit from the menu
|
|
}
|
|
char fe_arguments[192];
|
|
char fe_value[64];
|
|
SetEnvironmentVariableA("BT_FE_LOOP", "1");
|
|
SetEnvironmentVariableA("BT_PLATFORM", "glass");
|
|
switch (fe_spec.mode)
|
|
{
|
|
case BTFeLaunchRawSolo:
|
|
SetEnvironmentVariableA("BT_FE_EGG", NULL);
|
|
sprintf(fe_arguments, "-egg %s -platform glass", fe_spec.eggPath);
|
|
break;
|
|
case BTFeLaunchJoinLan:
|
|
SetEnvironmentVariableA("BT_FE_EGG", NULL);
|
|
sprintf(fe_arguments, "-net %d -platform glass", fe_spec.consolePort);
|
|
break;
|
|
case BTFeLaunchJoinRelay:
|
|
// BT_FE_JOIN (join.bat): the callsign/mech request rides env
|
|
// into the relaunched pod; L4NET's SEAT_REQUEST carries it to
|
|
// the relay, which writes it into the session egg. Args = the
|
|
// universal join contract (OPERATOR.EGG + port 1501); the
|
|
// operator console overrides the port per LOCAL instance via
|
|
// BT_FE_JOINPORT (two instances on one box can't share -net).
|
|
SetEnvironmentVariableA("BT_FE_EGG", NULL);
|
|
SetEnvironmentVariableA("BT_CALLSIGN", fe_spec.joinCallsign);
|
|
SetEnvironmentVariableA("BT_MECH", fe_spec.joinVehicle);
|
|
{
|
|
const char *join_port = getenv("BT_FE_JOINPORT");
|
|
sprintf(fe_arguments, "-egg OPERATOR.EGG -net %d -platform glass",
|
|
join_port != NULL ? atoi(join_port) : 1501);
|
|
}
|
|
break;
|
|
#ifdef BT_STEAM
|
|
case BTFeLaunchJoinSteam:
|
|
SetEnvironmentVariableA("BT_FE_EGG", NULL);
|
|
SetEnvironmentVariableA("BT_STEAM_NET", "1");
|
|
SetEnvironmentVariableA("BT_FE_MYFAKE", fe_spec.steamMyToken);
|
|
SetEnvironmentVariableA("BT_FE_STEAMMAP", fe_spec.steamMap);
|
|
sprintf(fe_arguments, "-net %d -platform glass", fe_spec.consolePort);
|
|
break;
|
|
case BTFeLaunchHostSteam:
|
|
SetEnvironmentVariableA("BT_STEAM_NET", "1");
|
|
SetEnvironmentVariableA("BT_FE_MYFAKE", fe_spec.steamMyToken);
|
|
SetEnvironmentVariableA("BT_FE_STEAMMAP", fe_spec.steamMap);
|
|
// falls into the marshal-armed default
|
|
#endif
|
|
default: // Solo / HostLan: the marshal armed via env handoff
|
|
SetEnvironmentVariableA("BT_FE_EGG", fe_spec.eggPath);
|
|
SetEnvironmentVariableA("BT_FE_PODS", fe_spec.podList);
|
|
sprintf(fe_value, "%d", fe_spec.missionSeconds);
|
|
SetEnvironmentVariableA("BT_FE_SECS", fe_value);
|
|
sprintf(fe_arguments, "-net %d -platform glass", fe_spec.consolePort);
|
|
break;
|
|
}
|
|
{
|
|
// The user just clicked JOIN/LAUNCH in the menu -- never
|
|
// storm-damp a human (btl4console.cpp, issue #33).
|
|
extern int gBTRelaunchUserInitiated;
|
|
gBTRelaunchUserInitiated = 1;
|
|
}
|
|
BTFE_RelaunchSelfAndExit(fe_arguments); // never returns
|
|
}
|
|
#ifdef BT_STEAM
|
|
//
|
|
// The Steam transport (step 4b): BT_STEAM_NET=1 (set by the lobby
|
|
// launch path, or by hand for testing) brings up FakeIP + SDR
|
|
// before the engine opens any connection. Degrades to Winsock.
|
|
//
|
|
if (getenv("BT_STEAM_NET") != NULL && *getenv("BT_STEAM_NET") != '0')
|
|
{
|
|
extern int BTSteamNet_Install();
|
|
BTSteamNet_Install();
|
|
}
|
|
#endif
|
|
//
|
|
// A marshal-armed mission process: start the LocalConsole worker
|
|
// (it retries until our own console listener is up).
|
|
//
|
|
const char *fe_egg = getenv("BT_FE_EGG");
|
|
if (fe_egg != NULL && fe_egg[0])
|
|
{
|
|
const char *fe_pods = getenv("BT_FE_PODS");
|
|
const char *fe_secs = getenv("BT_FE_SECS");
|
|
BTLocalConsole_Start(fe_egg,
|
|
fe_pods ? fe_pods : "",
|
|
fe_secs ? atoi(fe_secs) : 600);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// DEBUG (bring-up, default OFF): force the player mech to walk full-ahead with
|
|
// no keypress so locomotion + camera-follow can be verified in a headless run.
|
|
// BT_FORCE_THROTTLE may carry a VALUE: +1 full run, ~0.3 walk, -1 reverse (default 1.0).
|
|
if (getenv("BT_FORCE_THROTTLE") != NULL)
|
|
{
|
|
gBTDrive.forced = 1;
|
|
float v = (float)atof(getenv("BT_FORCE_THROTTLE"));
|
|
gBTDrive.forcedThrottle = (v != 0.0f) ? v : 1.0f; // bare "1"/empty -> full ahead
|
|
}
|
|
if (getenv("BT_FORCE_FIRE") != NULL) gBTDrive.fireForced = 1;
|
|
|
|
// Optional environ.ini overrides (same convention as RP).
|
|
FILE *file;
|
|
char line[1024];
|
|
if (fopen_s(&file, "environ.ini", "r") == 0)
|
|
{
|
|
while (!feof(file))
|
|
{
|
|
if (fgets(line, sizeof(line), file))
|
|
{
|
|
for (int i = (int)strlen(line); i >= 0; i--)
|
|
if (line[i] == '\n' || line[i] == '\r') line[i] = 0;
|
|
putenv(line);
|
|
}
|
|
}
|
|
fclose(file);
|
|
}
|
|
|
|
// Version scheme: 4.10 = the 1995 arcade release; 4.11 = this win32
|
|
// reconstruction; build = git commit count, hash pins exact source
|
|
// ('+' = built from an uncommitted tree). Stamped by tools/btversion.cmake.
|
|
std::cout << "BattleTech " << BT_VERSION_FULL
|
|
<< " (win32 reconstruction of Tesla 4.10)" << std::endl << std::flush;
|
|
|
|
#ifdef BT_EXPIRE
|
|
// TESTER-BUILD EXPIRY TRIPWIRE (compile gate BT_EXPIRE, default ON --
|
|
// see CMakeLists). Distributed zips go stale and stray; refuse to run
|
|
// BT_EXPIRE_DAYS after the build day (btversion.h BT_BUILD_UNIX, UTC
|
|
// midnight). Dev builds re-stamp every build, so this never fires
|
|
// locally. Quality gate, not DRM.
|
|
{
|
|
const time_t expires = (time_t)BT_BUILD_UNIX
|
|
+ (time_t)BT_EXPIRE_DAYS * 86400;
|
|
const time_t now = time(0);
|
|
if (now >= expires)
|
|
{
|
|
std::cout << "[boot] TEST BUILD EXPIRED (built " << BT_BUILD_DATE
|
|
<< ", " << BT_EXPIRE_DAYS << "-day test window)"
|
|
<< std::endl << std::flush;
|
|
char expired_text[256];
|
|
sprintf(expired_text,
|
|
"This BattleTech test build (%s, built %s) has expired.\n\n"
|
|
"Test builds stop working %d days after they are made so\n"
|
|
"stale copies don't wander around.\n\n"
|
|
"Ask the operator for the current build.",
|
|
BT_VERSION_STRING, BT_BUILD_DATE, (int)BT_EXPIRE_DAYS);
|
|
MessageBoxA(NULL, expired_text,
|
|
"BattleTech -- test build expired", MB_OK | MB_ICONWARNING);
|
|
return 0;
|
|
}
|
|
int days_left = (int)((expires - now + 86399) / 86400);
|
|
std::cout << "[boot] test build window: " << days_left
|
|
<< " day(s) left (built " << BT_BUILD_DATE << ")"
|
|
<< std::endl << std::flush;
|
|
}
|
|
#endif
|
|
|
|
// CPU pin (timing stability). BT_AFFINITY overrides the mask; =0 disables --
|
|
// required for multi-instance runs (two instances pinned to core 0 starve
|
|
// each other, and the L4NET connect-retry loop busy-waits).
|
|
{
|
|
DWORD_PTR mask = getenv("BT_AFFINITY")
|
|
? (DWORD_PTR)strtoul(getenv("BT_AFFINITY"), 0, 0) : (DWORD_PTR)1;
|
|
if (mask != 0)
|
|
SetThreadAffinityMask(GetCurrentThread(), mask);
|
|
}
|
|
|
|
// Parse the command line so the egg (mission descriptor) source is set:
|
|
// btl4.exe -egg <file.egg>
|
|
// With no network common address (single-user mode), L4NetworkManager reads
|
|
// GetEggNotationFileName() and posts the egg locally -- no real net needed.
|
|
int argc;
|
|
LPWSTR *argv = CommandLineToArgvW(GetCommandLineW(), &argc);
|
|
if (!L4Application::ParseCommandLine(argc, argv, L4Application::ParseToken))
|
|
{
|
|
std::cout << "ParseCommandLine failed (need: -egg <file>)" << std::endl << std::flush;
|
|
return 1;
|
|
}
|
|
|
|
Start_Registering();
|
|
|
|
// Create the main window (single 800x600 view for dev; pod multi-monitor is Phase 8).
|
|
WNDCLASS wc;
|
|
if (!hPrevInstance)
|
|
{
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = (WNDPROC)WndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = LoadIcon((HINSTANCE)NULL, IDI_APPLICATION);
|
|
wc.hCursor = LoadCursor((HINSTANCE)NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = L"MainWndClass";
|
|
if (!RegisterClass(&wc)) return FALSE;
|
|
}
|
|
|
|
//
|
|
// Window/backbuffer resolution (task #20): the engine already parses
|
|
// `-res W H` (L4APP.cpp:165) for the D3D backbuffer; the window must match
|
|
// or the render is stretched. Parse the same args here for the WINDOW
|
|
// (client area = render size); default stays the authentic pod 800x600.
|
|
// Launch with e.g. `-egg DEV.EGG -res 1600 1200` for a 4x-pixel view.
|
|
//
|
|
int winW = 800, winH = 600;
|
|
{
|
|
const char *rp = lpCmdLine ? strstr(lpCmdLine, "-res") : 0;
|
|
if (rp != 0)
|
|
{
|
|
int w = 0, h = 0;
|
|
if (sscanf(rp + 4, " %d %d", &w, &h) == 2 && w >= 320 && h >= 240)
|
|
{
|
|
winW = w;
|
|
winH = h;
|
|
}
|
|
}
|
|
}
|
|
// DOCK-BOTTOM (single-window gauges, 2026-07-12): under BT_DEV_GAUGES the
|
|
// gauge strip is APPENDED below the world view in THIS window (strip height
|
|
// = width x 480/1320, the panel's design aspect); BT_DEV_GAUGES_WINDOW=1
|
|
// restores the old separate MFD window.
|
|
{
|
|
extern int gBTGaugeDockBottom;
|
|
extern int gBTGaugeCockpit;
|
|
extern int gBTCockpitCanvasW, gBTCockpitCanvasH;
|
|
extern int BTGaugeStripHeightFor(int width);
|
|
extern void BTCockpitCanvasFor(int viewW, int viewH, int *cw, int *ch);
|
|
// BT_GLASS_PANELS breaks the gauges into their own per-display windows, so
|
|
// the world window keeps its normal size (no cockpit / bottom strip).
|
|
int glassOwnsGauges = 0;
|
|
#ifdef BT_GLASS
|
|
{ extern int BTGlassPanelsActive(); glassOwnsGauges = BTGlassPanelsActive(); }
|
|
#endif
|
|
if (!glassOwnsGauges && getenv("BT_DEV_GAUGES") != 0)
|
|
{
|
|
// Mode resolution (precedence): explicit BT_COCKPIT > separate-window /
|
|
// legacy-inset opt-out > COCKPIT SURROUND default under BT_DEV_GAUGES.
|
|
int cockpitOn;
|
|
const char *ck = getenv("BT_COCKPIT");
|
|
if (ck != NULL)
|
|
cockpitOn = (ck[0] != '0');
|
|
else
|
|
cockpitOn = (getenv("BT_DEV_GAUGES_WINDOW") == 0 &&
|
|
getenv("BT_DEV_GAUGES_DOCK") == 0);
|
|
|
|
if (cockpitOn)
|
|
{
|
|
gBTGaugeCockpit = 1;
|
|
// -res W H = the WORLD VIEW size in cockpit mode; default 900x500.
|
|
int viewW = 900, viewH = 500;
|
|
if (strstr(lpCmdLine ? lpCmdLine : "", "-res") != 0) { viewW = winW; viewH = winH; }
|
|
// Clamp the CANVAS to the work area (minus the window frame): shrink
|
|
// viewH (floor 400) then viewW (floor 640) until it fits (1080p tight).
|
|
RECT wa = { 0, 0, 1920, 1080 };
|
|
SystemParametersInfo(SPI_GETWORKAREA, 0, &wa, 0);
|
|
RECT fr = { 0, 0, 1000, 1000 };
|
|
AdjustWindowRect(&fr, WS_OVERLAPPEDWINDOW, FALSE);
|
|
int availW = (wa.right - wa.left) - ((fr.right - fr.left) - 1000);
|
|
int availH = (wa.bottom - wa.top) - ((fr.bottom - fr.top) - 1000);
|
|
int cw, ch;
|
|
BTCockpitCanvasFor(viewW, viewH, &cw, &ch);
|
|
while (ch > availH && viewH > 400) { viewH -= 20; BTCockpitCanvasFor(viewW, viewH, &cw, &ch); }
|
|
while (cw > availW && viewW > 640) { viewW -= 20; BTCockpitCanvasFor(viewW, viewH, &cw, &ch); }
|
|
winW = cw; winH = ch;
|
|
gBTCockpitCanvasW = winW; // windowed backbuffer = client canvas
|
|
gBTCockpitCanvasH = winH;
|
|
std::cout << "[cockpit] view " << viewW << "x" << viewH
|
|
<< " canvas " << winW << "x" << winH << std::endl << std::flush;
|
|
}
|
|
else if (getenv("BT_DEV_GAUGES_WINDOW") == 0)
|
|
{
|
|
gBTGaugeDockBottom = 1;
|
|
// Readability default (user-reported: the strip at 800 wide is a
|
|
// 0.6x downscale, hard to read): a WIDER world region (the
|
|
// projection is aspect-correct for any shape) buys strip pixels --
|
|
// 1100x600 world + 1100x400 strip = a 1000-tall window that fits a
|
|
// 1080p desktop with the panel at 83% of design size. -res still
|
|
// overrides both.
|
|
if (strstr(lpCmdLine ? lpCmdLine : "", "-res") == 0)
|
|
{
|
|
winW = 1100;
|
|
winH = 600;
|
|
}
|
|
winH += BTGaugeStripHeightFor(winW);
|
|
}
|
|
}
|
|
}
|
|
RECT wr = { 0, 0, winW, winH };
|
|
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
|
|
|
|
//
|
|
// Window identity (MP dev): tag the title with the -net port so a player
|
|
// running two nodes side-by-side can tell the windows apart when
|
|
// reporting ("node 1501" = A / player 1, "node 1601" = B / player 2).
|
|
//
|
|
wchar_t winTitle[64];
|
|
{
|
|
int netPort = 0;
|
|
const char *np = lpCmdLine ? strstr(lpCmdLine, "-net") : 0;
|
|
if (np != 0)
|
|
sscanf(np + 4, " %d", &netPort);
|
|
if (netPort > 0)
|
|
swprintf(winTitle, 64, L"BattleTech %S \x2014 node %d",
|
|
BT_VERSION_STRING, netPort);
|
|
else
|
|
swprintf(winTitle, 64, L"BattleTech %S", BT_VERSION_STRING);
|
|
}
|
|
hWnd = CreateWindowEx(0, L"MainWndClass", winTitle, WS_OVERLAPPEDWINDOW,
|
|
0, 0, wr.right - wr.left, wr.bottom - wr.top,
|
|
(HWND)NULL, (HMENU)NULL, hInstance, (LPVOID)NULL);
|
|
if (!hWnd) return FALSE;
|
|
|
|
ShowWindow(hWnd, nShowCmd);
|
|
|
|
{
|
|
std::cout << "[boot] opening btl4.res..." << std::endl << std::flush;
|
|
StreamableResourceFile resources("btl4.res", version);
|
|
Check(&resources);
|
|
std::cout << "[boot] resources OK; creating ApplicationManager..." << std::endl << std::flush;
|
|
|
|
// Frame rate (task #20 perf): TARGETFPS was read with no null check --
|
|
// atoi(NULL) when unset -> garbage frameRate -> the APPMGR frame pacer
|
|
// (end_of_frame = now + 1/frameRate) degenerated and the game ran at a
|
|
// timer-quantized ~15 FPS (66-70ms frames measured) on ANY hardware.
|
|
// Default 60; env TARGETFPS still overrides (clamped to sanity).
|
|
int target_fps = 30; // the pod's authentic rate; frame work (~20-40ms in
|
|
// this build) misses 60Hz beats -> jitter, but holds
|
|
// 30 rock-steady. TARGETFPS env still overrides.
|
|
{
|
|
const char *tf = getenv("TARGETFPS");
|
|
if (tf != 0)
|
|
{
|
|
int v = atoi(tf);
|
|
if (v >= 15 && v <= 240)
|
|
target_fps = v;
|
|
}
|
|
}
|
|
std::cout << "[boot] target frame rate: " << target_fps << " fps" << std::endl << std::flush;
|
|
ApplicationManager *app_manager =
|
|
new ApplicationManager(hInstance, hWnd, (Scalar)target_fps);
|
|
Register_Object(app_manager);
|
|
std::cout << "[boot] ApplicationManager OK; creating BTL4Application..." << std::endl << std::flush;
|
|
|
|
Application *new_app = new BTL4Application(hInstance, hWnd, &resources);
|
|
btl4App = new_app;
|
|
Register_Object(new_app);
|
|
std::cout << "[boot] BTL4Application OK; StartApplication..." << std::endl << std::flush;
|
|
app_manager->StartApplication(new_app);
|
|
std::cout << "[boot] StartApplication returned; entering RunMissions..." << std::endl << std::flush;
|
|
|
|
app_manager->RunMissions();
|
|
std::cout << "[boot] RunMissions returned (mission loop exited)." << std::endl << std::flush;
|
|
|
|
// MATCHLOG AUTO-UPLOAD (2026-07-22): in relay mode, send this peer's
|
|
// match forensic log back to the operator's relay (saved under the
|
|
// relay's matchlogs\ folder). No-op for mesh/solo or when the
|
|
// matchlog never armed; the local file stays either way.
|
|
{
|
|
extern void BTRelayUploadMatchLog(void);
|
|
BTRelayUploadMatchLog();
|
|
}
|
|
|
|
// LOBBY LOOP (2026-07-23): a round ended by the operator/clock
|
|
// relaunches this pod straight back into the join wait -- the arcade
|
|
// between-rounds flow (pods rebooted to attract mode; players stayed
|
|
// put). BT_SEAT_CLAIM carries our seat tag so the relay gives us the
|
|
// SAME seat back (static ordering, real-pod style); BT_CALLSIGN /
|
|
// BT_MECH ride the inherited environment so the choice persists.
|
|
// Closing the window still exits for good (flag set only by
|
|
// StopMission).
|
|
if (gBTMissionStoppedByConsole && getenv("BT_RELAY") != NULL)
|
|
{
|
|
extern const char *BTRelaySelfTag(void);
|
|
const char *seat_tag = BTRelaySelfTag();
|
|
if (seat_tag != NULL && seat_tag[0] != 0)
|
|
SetEnvironmentVariableA("BT_SEAT_CLAIM", seat_tag);
|
|
char rejoin_arguments[512];
|
|
int m = 0;
|
|
for (const char *s2 = lpCmdLine;
|
|
s2 != NULL && *s2 && m < (int)sizeof(rejoin_arguments) - 1; ++s2)
|
|
rejoin_arguments[m++] = *s2;
|
|
rejoin_arguments[m] = 0;
|
|
std::cout << "[boot] round ended -- relaunching into the join wait"
|
|
<< std::endl << std::flush;
|
|
BTFE_RelaunchSelfAndExit(rejoin_arguments); // never returns
|
|
}
|
|
|
|
#ifdef BT_GLASS
|
|
//
|
|
// Front-end loop (glass step 3): a menu-launched mission returns
|
|
// to the menu on exit. (Marshal missions normally relaunch from
|
|
// the marshal thread at clock expiry; this tail covers raw-solo
|
|
// and early exits.)
|
|
//
|
|
if (getenv("BT_FE_LOOP") != NULL)
|
|
{
|
|
std::cout << "[fe] mission over -- relaunching the menu"
|
|
<< std::endl << std::flush;
|
|
BTFE_RelaunchSelfAndExit("");
|
|
}
|
|
#endif
|
|
|
|
btl4App = NULL;
|
|
Unregister_Object(app_manager);
|
|
delete app_manager;
|
|
}
|
|
|
|
Stop_Registering();
|
|
return Exit_Code;
|
|
}
|