JackForge: WarMachine to Pathfinder 'Jack Converter

Desktop app with three conversion modes (PF1e, PF2e, and an APF1e hit-location
box-out system), an embeddable single-file web version, and Foundry SBC /
Bestiary Import export. Recalibrated to legal Pathfinder ranges and validated
against sixteen reference jacks across all six factions.

Author: DatJavaClass

.gitignore

@@ -0,0 +1,16 @@
+# Build output
+bin/
+obj/
+dist/
+publish/
+*.user
+*.suo
+
+# IDE
+.vs/
+.idea/
+*.DotSettings.user
+
+# OS cruft
+Thumbs.db
+.DS_Store

DESIGN.md

@@ -0,0 +1,81 @@
+# JackForge — WarMachine to Pathfinder 'Jack Converter (reforged)
+
+A cross-platform (Avalonia/.NET) reimagining of Victor's 2013 "'Jack Converter"
+(`Warmachine to Iron Kingdoms d20 'Jack Converter`, recovered by reverse-engineering the
+original ClickOnce .NET assembly). Gritty steampunk "schematic review tool" GUI.
+
+## Tabs
+1. **PF1e** — Pathfinder 1st Edition. Faithful port of the recovered 3.5-era logic (PF1 was
+   largely a 3.5 update). See `Conversion/Pf1Converter.cs`.
+2. **PF2e** — Pathfinder 2nd Edition. New system. Built by the **benchmark-via-CR** method
+   (Victor's choice): PF1 CR -> clamped creature level -> read Paizo "Building Creatures"
+   benchmark numbers by assigned High/Moderate/Low role. See `Conversion/Pf2Converter.cs`,
+   `Conversion/Pf2Benchmarks.cs`.
+3. **APF1e** — Advanced PF1e. Victor's dream "box-out" system: HP spread across hit locations
+   (Head, Torso, 2 Arms, 2 Legs) like a WarMachine damage grid. See `Conversion/BoxOut.cs`.
+
+## Locked design decisions (from Victor)
+- **APF1e HP split:** fixed ruleset-wide percentages. Current constants (tunable in
+  `BoxOutConverter`): Head 12%, Torso 34%, each Arm 15%, each Leg 12%. Torso absorbs rounding.
+- **Box-out consequences (formalized):**
+  - Arm destroyed -> that arm's weapon unusable; both arms -> no melee.
+  - Leg destroyed -> Speed halved; both -> immobilized/prone.
+  - Head/Cortex destroyed -> 'jack inert (wrecked).
+  - Torso/Boiler destroyed -> wrecked + boiler explosion (Reflex save, AoE fire).
+  - Myrmidon Energy Field = temp HP, depleted before any location can be hit.
+  - Colossals = two structures (Left/Right); wrecked when both Torsos (or both Heads) gone.
+- **PF2e method:** benchmark via CR.
+- **Exports:** PF1e -> Foundry **SBC** (Paizo DEFENSE/OFFENSE/STATISTICS text, `Con —`).
+  PF2e -> Foundry **pf2e-bestiary-import** (bracketed action costs, blank-line separators,
+  ability *modifiers*, construct immunities; `Mindless` only for cortex-less vectors).
+
+## Tunable "house" numbers (defaults, flagged for Victor's review)
+- Box-out percentages (above).
+- Boiler explosion: Light 6d6/10ft, Heavy 10d6/15ft, Colossal 20d6/20ft; DC = 10 + HD/2 + size.
+- PF2e Hardness = clamp(ARM - 11, 3, 25).
+- PF2e stat-role thresholds (Str/AC/attack tiers off WM stats) in `Pf2Converter`.
+
+## Calibration — RESOLVED (Victor: "recalibrate outright")
+The original formula is kept only as a displayed **raw score**. `Pf1Converter.Calibrate` derives the
+playable CR from clean threat signals - chassis base (L5/H8/Col16) + hit-box adjustment + armor bump,
+clamped to per-type bands (L 4-8, H 7-12, Col 15-21) - then draws AC/HP/attack/saves from Pathfinder's
+Monster-Statistics-by-CR table (`Pf1ByCr.cs`). PF2e level = calibrated CR.
+
+Earlier attempt (`raw x 0.38`) was replaced after full-roster validation: it inherited the original's
+arc-node and Cyriss-vector inflation (Lancer CR10 vs identical Charger CR6; Prime Axiom CR22 > Stormwall).
+The clean formula is immune to that. **All 16 reference jacks validate** (`--validate`): lights CR4-6,
+heavies CR7-10, colossals CR16-17; Juggernaut==Destroyer; box-out HP sums exact.
+
+### Open tuning (surfaced by validation)
+- Energy Field values (33 light / 55 heavy, from the original tool) are now oversized vs recalibrated
+  HP (Griffon: 33 field on 40 HP). Consider rescaling to ~30-40% of body HP (real-WM proportion).
+- Field coverage: only Retribution jacks get one; Cyriss vectors (incl. colossal Prime Axiom) do not.
+  Victor's vision mentioned "Myrmidon Colossals" having a field - decision pending.
+
+## Status
+- [x] Reverse-engineer original (source saved to `Apps & Scripts/Jack/*.RECOVERED.cs`)
+- [x] Conversion engine: PF1e, PF2e, APF1e — verified via `JackForge.exe --selftest`
+- [x] Foundry exporters (SBC + bestiary-import)
+- [x] Steampunk GUI (3 icon tabs, shared input, IK logo header, Convert + Send-to-Foundry) — runs
+- [x] Recalibration to legal Pathfinder ranges (anchored to PF Monster-by-CR table)
+- [x] Box-out split retuned to real WM grid proportions (torso ~54%)
+- [x] Full-roster validation: all 16 real jacks pass (`--validate`); caught + fixed node/vector CR inflation
+- [x] Unique/character jacks: "Unique 'Jack?" toggle + manual CR adjustment (applies after band clamp, cascades to all tabs)
+- [x] Serric Steel = IK adamantine: export keeps clean `DR #/adamantine`; flavor shown only in app readout
+- [x] Energy Field: myrmidon-only, temp HP = jack HP rounded to nearest 10; per-myrmidon "Field Power"
+      text field (special power active while the field holds), shown in the box-out
+- [x] Vector hover: per-vector dropdown (None / Clumsy / Average), shown for Cyriss vectors. Grants
+      a low Fly speed = land Speed (ignores ground terrain) and +1 CR. Clumsy = light trimodal vectors;
+      Average = purpose-built hovering vectors; heavy trimodal = None. Fly line flows to both exports.
+- [ ] (Optional) "Induction Trait" text field for vectors — offered, not yet built
+- [ ] Polish; self-contained publish per-OS
+- [ ] Optional: pull official Iron Kingdoms d20 warjack stats as a second cross-check
+
+## Build / run
+```
+cd src/JackForge
+dotnet build
+dotnet run                 # launches the app
+dotnet run -- --selftest   # headless engine check
+```
+Reference research (gitignored scratch): WarMachine test jacks, PF2e benchmarks, Foundry formats.

EVOLUTION.md

@@ -0,0 +1,116 @@
+# The 'Jack Converter: Twenty Years of Evolution
+
+A history of one small program, from a middle-school project built off a d20 sourcebook to a
+cross-platform, three-system conversion bench. This is the lineage of what is now **JackForge**.
+
+---
+
+## Act I - Origins (circa 2005): the Liber Mechanika era
+
+In 2005 Privateer Press published **Liber Mechanika** (PIP 403), a d20 3.5 supplement for the
+Iron Kingdoms setting. Among its rules was a system for expressing WarMachine WarJacks as d20 /
+Iron Kingdoms stat blocks: the conversion logic that would become the seed of this whole project.
+
+Right around then, as he was **finishing high school**, Victor built the **first version of the
+'Jack Converter**. The language and the exact build are lost to history (this predates any surviving
+binary), but the intent was already the one that survives to today: type in a WarJack's WarMachine
+stat line, get back a playable d20 stat block. The core formulas, the MAT/RAT handling, the
+armor-to-DR relationship, and the hit-box-to-power scaling all trace back to that Liber-Mechanika
+reading of how a warjack should feel in a d20 game.
+
+No artifact from this era survives. It lives on only as the conceptual and mathematical ancestor of
+everything below.
+
+---
+
+## Act II - The 2013 Rebuild: "JackCalculator"
+
+The earliest surviving version is a **2013 rebuild**, recovered in 2026 by reverse-engineering an
+old installer. It is a **C# .NET Framework 4.0 Windows Forms application** named `JackCalculator.exe`,
+titled in-app **"Warmachine to Iron Kingdoms d20 'Jack Converter Ver. 1.0"**, self-signed
+`CN=Clarke\Victor` with a certificate valid from **2013-08-05**. The date on the files (2013) is
+when they were copied to a new machine; the certificate confirms the actual compile was 2013.
+
+Why a rebuild in 2013 and not the original? A tell in the code: it supports **Colossals**, and
+WarMachine Colossals did not exist until the 2012 *WARMACHINE: Colossals* release. So the 2013
+build is a C# port of the older original, brought current with the game as it stood then.
+
+### How it was packaged (and recovered)
+The program shipped as a Russian-doll installer, which is why recovering it in 2026 took some work:
+
+```
+Jack Converter Setup.exe   (ClickTeam Install Creator, "wwgT" PackData overlay)
+  -> UPX-compressed PE stub
+     -> bzip2 / zlib members
+        -> a Visual Studio ClickOnce deployment
+           -> JackCalculator.exe   (357,376-byte .NET 4.0 assembly)  <- the actual program
+```
+
+The recovery: identify the ClickTeam container, walk the overlay, inflate every zlib member and
+bzip2-decompress the two large ones, pick out the 357 KB .NET assembly, then decompile it back to
+C# with ILSpy. The recovered source is preserved in `Apps & Scripts/Jack/*.RECOVERED.cs`.
+
+### What the 2013 version did
+A single WinForms window, two columns (WarMachine in, Iron Kingdoms d20 out), a Convert button.
+Inputs: SPD, STR, MAT, RAT, DEF, ARM, hit boxes, TYPE (Light/Heavy/Colossal), a 26-entry CLASS
+list of faction chassis, an arc-node option, and special attacks. Outputs: Speed, STR, DEX, melee
+and ranged attack strings, grapple, saves, DR, AC, HP, size, INT/WIS, and a CR. It even special-
+cased Cyriss Convergence vectors (relabeling MAT/RAT to caster stats).
+
+It was, in Victor's own words, "likely terrible jank" - and it was, in the charming way of a
+self-taught first program: unbounded CR math, a BAB table that pinned at +20, a redundant
+copy-pasted branch, no input validation, and spellings frozen in amber ("Scryah", "Bezerker",
+"Chasis"). It also worked, and it was precious.
+
+---
+
+## Act III - The 2026 Reforge: "JackForge"
+
+In 2026 the recovered logic was carried forward into a brand-new application: **JackForge**, a
+**cross-platform C# / .NET (Avalonia) desktop app** with a gritty steampunk "schematic bench" look.
+It keeps faith with the original's math where that math was sound, and rebuilds it where it wasn't.
+
+### What changed, at a glance
+
+| Dimension | 2013 JackCalculator | 2026 JackForge |
+|---|---|---|
+| Platform | Windows only (WinForms, .NET 4.0) | Windows / macOS / Linux (Avalonia, .NET 10) |
+| Systems | Iron Kingdoms d20 (3.5) only | PF1e, PF2e, and Advanced PF1e (box-out) |
+| UI | Two-column form | Themed 3-tab bench, IK-logo header, live example |
+| CR math | Unbounded (a Juggernaut hit CR 26+) | Recalibrated to legal Pathfinder ranges |
+| Export | None | Foundry SBC (PF1) and Bestiary Import (PF2) |
+| Damage | Single HP pool | Optional hit-location "box-out" system |
+| Character jacks | Not handled | "Unique 'Jack?" CR-adjust toggle |
+| Myrmidon fields | Fixed made-up values | Energy Field = HP rounded to nearest 10 + power text |
+| Vectors | Given fake fields as a stand-in | Mindless, caster-driven, optional hover (Fly) |
+| Input safety | Crashed on empty fields | Validated; chassis constrains valid weights |
+
+### The three modes
+- **PF1e** - Pathfinder 1st Edition. A faithful port of the original 3.5-era logic (PF1 was largely
+  a 3.5 update), then recalibrated: the original formula is kept as a displayed "raw score", while
+  the playable CR is derived from clean threat signals (chassis, hit-boxes, armor) and the combat
+  stats are drawn from Pathfinder's official Monster-Statistics-by-CR table.
+- **PF2e** - Pathfinder 2nd Edition. A new system entirely. Built by "benchmark via CR": the PF1 CR
+  becomes a creature level, and every stat is read off Paizo's "Building Creatures" benchmark tables.
+- **APF1e** - Advanced PF1e. The feature Victor "always dreamed of but was never skilled enough to
+  do": a WarMachine-style **box-out** damage system. HP spreads across Head, Torso, two Arms and two
+  Legs; destroy an arm and its weapon is gone, destroy the head and the jack goes inert, destroy the
+  torso and the boiler explodes. Myrmidons layer an Energy Field of temp HP on top; colossals get
+  two independent structures.
+
+### Validation
+All 16 reference jacks from the WarMachine faction books (Charger, Juggernaut, Stormwall, Prime
+Axiom and the rest) run clean through every mode. That validation pass is what caught and fixed a
+CR-inflation bug inherited from the original's node and vector math.
+
+---
+
+## The through-line
+
+The math has a clear bloodline: **Liber Mechanika's d20 3.5 conversion rules (2005)** -> the lost
+original -> the **2013 C# formulas** -> **recalibrated against Pathfinder 1e's own monster tables**
+for PF1e, and **re-expressed through Pathfinder 2e's benchmark tables** for PF2e. Twenty years, one
+idea, three rule systems, and the same question every time: *what would this WarJack be, at the
+table?*
+
+*Serric Steel is the Iron Kingdoms' adamantine. Some things never change.*