Swordsman Progression

Four ways to make a swordsman stronger, over one shared ladder. Recruit → Footman → Duelist → Blademaster → Sword Saint → Sword Immortal, with identical names, identical powers (10/18/32/55/95/160) and identical grants in every system. Switch tabs and the only thing that changes is how you climb.

That constraint is the whole creation. Comparing progression systems normally fails because each one ships its own numbers, so you end up comparing tuning, not design. Here the tuning is held fixed and the systems are tuned to comparable effort — every one reaches Sword Immortal in 87–106 duels under reasonable play — so any difference you feel is the shape of the climb.

The four

What the shapes actually look like

Mean duel count at which each tier arrives, 500 runs of a competent-but-not-optimal player:

Same destination, same rough cost, four different curves:

• Earned Levels is a metronome — 17 duels per tier, forever. Reliable and completely inert; the readout says decisions made: 0 and means it.
• Use-Mastery front-loads hard (Footman by duel 9) and then rots into a long tail, because skill gain is proportional to remaining headroom. It feels fantastic for ten minutes and then feels like a job.
• Spent Points is lumpy in a way the others aren’t: tiers 3 and 4 arrive nine duels apart because keystone requirements happened to line up, then nothing while you save.
• Acquired Gear is the flattest and the spikiest at once — the longest stretches of zero visible progress, resolved by a single purchase that hands you a whole tier.

The design decisions that carry the whole thing

Power is never off-ladder. In every system power === TIERS[tier].power, always, and there’s a test asserting it. Skill-tree branch nodes pay in xp rate and win odds; they never grant raw power. Without this rule the systems drift apart and the comparison is worthless.

The opponent roster is fixed. Straw Dummy through The Immortal, powers 6/14/26/46/80/140, and it does not scale with you. This is load-bearing: if the world levels alongside the player, no progression system can feel like progress, because the win percentages never move. Watching a Guard Captain go from 4% to 91% is the actual reward — the tier number is just the receipt.

The skill tree needed a point budget to become a real system. The first version had none, and it was a fraud: xp flowed forever, so a bad build was only ever a small time tax, and spending points the instant they arrived turned out to be optimal (early points can only afford the cheap breadth nodes that keystones want anyway). It became a real choice architecture only after three changes — in-branch prerequisites, a keystone that demands depth (5 nodes in one branch and 2 in every branch), and a hard budget of 28 points against a 22-point minimum path. Now a committed build finishes 100% of the time and a scatter-buy build strands under 50%, which is why the respec exists.

Use-Mastery’s exploit is deliberate. The Straw Dummy trains you at 72% rate for zero risk, and mastery’s opponent valuation genuinely prefers easy fights. That degenerate pull — the Oblivion problem, fencing a haystack for an hour — is not a bug to patch out. It’s the honest cost of the archetype and you should feel it tugging.

Verdict, having played all four

Gear is the most fun per event and the worst per minute: the twenty-duel saving stretches are dead air, but the purchase is the biggest single hit of “I am different now” anywhere in the four. Earned Levels is the most reliable and the least memorable. Use-Mastery has the best opening and the worst endgame. Spent Points is the only one where you can be proud of the climb — and the only one where you can ruin it, which is probably the same sentence.

The strongest combination the data suggests is gear’s discontinuity layered on mastery’s early curve: something that grows quietly while you play and occasionally hands you a whole tier at once.

Reuse

src/tiers.js — the ladder, the opponent roster, and duel odds. Framework-free.

src/systems.js — the four systems behind one interface:

sys.tier / sys.power          // power is always TIERS[tier].power
sys.progress()                // { label, value, max, hint } for a bar
sys.worth(opponent)           // how much THIS system values that duel
sys.onDuel(result) -> events  // advance state
sys.actions() / sys.act(id)   // player-facing choices, if any
sys.panel()                   // system-specific display data

Swap a system in or out without touching the harness — that’s the point of the common shape. Adding a fifth archetype (prestige loops, socket loadouts, milestone gates) means one new create*System() and one new panel renderer.

src/swordsman.js — the procedural pixel figure and duel scene. No sprite assets; the character is rects drawn into a 208×76 buffer and blitted up with smoothing off, restyled per tier. node source/render.mjs regenerates thumb.png from it so the art can’t drift from the code.

Gotchas

• demo/ bundles its own copies of all three modules (self-contained by contract, ADR-0002). Touch src/, re-copy into demo/.
• Tests run from the creation directory: node --test. They assert the parity band (60–140 duels, no system more than 1.6× another) — retune the numbers and they’ll tell you when you’ve broken the comparison.
• Each tab keeps its own independent run, so the compare strip at bottom-right is only meaningful once you’ve actually played more than one.
• The pacing table assumes the auto-fighter’s opponent choice. Grinding a foe you’ve outgrown roughly halves your rate in the three economy-driven systems and barely dents Use-Mastery — which is itself the sharpest single demonstration of how differently these systems value your time.