The chain decides the card.

simulate(teamA, teamB, seed, options) -> { winner, actions, log }

The consequence of that signature is the whole product. Because the function is pure, the same inputs give the same output on any machine, forever, which is what makes a match something a stranger can recompute rather than something we assert. The database stores results so pages load quickly. It is a cache. The hash is the record.

Inputs per card

2

The inscription id and its number. Nothing else.

Bytes that matter

12

Of the 32 the digest returns.

Divisions per hit

1

Every multiplication happens first, in integers.

Action cap

60

A match cannot fail to end.

Why progression is cosmetic, in one table

The eighth rule is the one that costs the most to keep, because a card game with no power progression gives up the easiest retention loop there is. It was measured before it was decided. A veteran carrying a flat stat bonus against a newcomer carrying none:

In a small audience that closes the front door. So progression buys frames, titles, emblems and a public record, and never a point of attack.

seed = sha256( utf8(inscription_id) || uint64BE(inscription_number) )

Why the number is in the hash

The inscription id alone would be enough to derive a card, and it would be a serious mistake. An id is chosen by the person inscribing: they can grind candidate transactions offline until one produces a card they like, and at that point stats stop being drawn and start being selected. The inscription number is assigned by the indexer at confirmation and cannot be picked, so mixing it in is what keeps the draw a draw. Negative numbers, the cursed inscriptions, encode as two’s complement so that two implementations cannot disagree about them.

One real card, byte by byte

Below is a genuine inscription, its genuine digest, and the card the engine derives from it. Nothing here is an example filled with plausible numbers: the stat line is recomputed on every request from the two values printed beside it.

Figure 02

da

0

5d

1

1c

2

6c

3

20

4

be

5

67

6

52

7

99

8

03

9

97

10

dd

11

0d

12

93

13

2a

14

c4

15

f5

16

e1

17

61

18

c5

19

8f

20

0c

21

04

22

bc

23

95

24

95

25

0f

26

cb

27

5b

28

85

29

ba

30

37

31

• b[0..1]HP 75 + (u16 % 31)
• b[2..3]ATK 28 + (u16 % 15)
• b[4..5]DEF 15 + (u16 % 11)
• b[6]SPD 9 + (b % 8)
• b[7]CRT 8 + (b % 5)
• b[8]TIE queue tiebreak
• b[9]ELEM b % 5
• b[10]ABIL walks the weighted table
• b[11]MAG magnitude, budgeted
• b[12..31]RESERVED unread by combat

The card

RunestoneAIR

COMMONN° 63.140.674

HP83

ATK29

DEF15

SPD16

CRT10

ABILITYINITIATIVEACTS FIRST · EVERY ROUND

◆ COMMON SAT
NO EXOTIC PROVENANCE

ed76bf35…2a0i0ORDCARDS

Number

63,140,674

Element

AIR

Ability

INITIATIVE

Tier

COMMON

da5d1c6c20be6752990397dd0d932ac4f5e161c58f0c04bc95950fcb5b85ba37

The stat line

The element, and the wheel it sits in

This is the most valuable decision in the game, and it is not close. Playing the wheel, which means putting each of your cards where it has the edge and away from the ones that have it over them, measures 91.6% against 54.3% for ignoring the element and pairing on the numbers alone. That is +37 points, against +12 for ordering well and +1.3 for choosing the right tool.

The tier does not come from the hash

Rarity is read off the inscription number directly, on a fixed ladder, and it never reaches resolution. This is the asymmetry worth understanding before anything else on the page: two cards with the same stats and different tiers are the same card in a match, and the engine has a test that proves it by running an identical match with every tier inverted and comparing the logs byte for byte.

The ability, and the budget it is drawn against

Byte 10 walks a weighted table to pick which of the sixteen abilities the card carries. Byte 11 sets the magnitude, but not on its own: the magnitude is scored against the stat line the same digest already produced, so a card that rolled well on stats lands lower in its ability’s range. The correlation is deliberately negative, around minus zero point three, with a hard cap. A card does not get to be both the strongest body and the strongest effect.

percentile = weighted_position_of(hp, atk, def, spd, crit)
position   = clamp( b[11]/255 * 0.6  +  (1 - percentile) * 0.4 )
magnitude  = lo + round( position * (hi - lo) )

Five of the sixteen abilities are binary. They have no magnitude at all, and the engine represents that absence explicitly rather than as a zero, so nothing downstream can accidentally read a missing value as a very weak one. This card holds INITIATIVE, which is one of them.

A plain modulo would hand every ability 6.25% of all cards. That reads fair and plays badly: the effects that need reading, the ones that fire on death or change the queue, would be as common as the ones you can learn in a sentence, and the first match a new player watches would be a knot. Weighting is how the simple effects carry the introduction and the complicated ones stay worth finding.

Reference

The store is locked out by structure, not by promise

A match takes a loadout, and the loadout is filtered against the kit before anything else happens. An item that is not one of these three is not a weaker item in resolution: it is discarded, silently, and the slot resolves empty. There is no argument, no configuration and no code path by which a sold item reaches the damage expression. The specification predicted that this rule would be pushed on every quarter revenue dipped, so it was made a test instead of a memo.

How much the kit is worth, measured

Those two numbers together are what licenses a shop to exist at all. Access to the kit matters; breadth of catalogue does not. So the kit is given away, and anything sold on top of it is decorative in fact rather than decorative in the marketing copy.

1. 01DrawUp to 5 cards come out of your eligible collection, by a published algorithm from a published seed.
2. 02Keep threeYou choose the team out of what you were dealt, never out of the whole wallet.
3. 03OrderYou arrange the three. Yours line up against theirs, position by position, so this is the decision the match turns on.
4. 04ResolveThe server runs the engine. Integer arithmetic, no floating point, no roll that is not derived from the seed.
5. 05PublishThe log, the seed and the teams come back together, which is everything a stranger needs to recompute it.

hand_size = max(3, min(5, collection - 1))

Draw from the collection, keep 3, order them. The subtraction is what stops a collection from ever dealing itself entirely, and the clamp is what stops a collection of three from being dealt a hand too small to field a team.

The left plot is the mechanism the game ships and the right one is the same match if players simply picked their three strongest. Free choice never becomes fair: even fifty cards against a hundred, a difference of only two to one, still hands the bigger wallet 55.4%. The drawn hand arrives at symmetry at six cards and stays there no matter how large the other wallet grows.

What a small collection actually costs

A draw anyone can check

A shuffle you cannot verify is a shuffle the house could have dealt. So three things are published with every hand and all three are required together: the seed the draw came from, the eligible collection frozen and ordered at the moment of the draw, and the algorithm itself, which is a partial Fisher-Yates driven by a hash stream. With all three, anyone can redo the draw and confirm that nobody chose anybody’s hand.

The queue

Speed descending, then the tiebreak byte ascending, then the inscription id lexicographically, then the side. Four keys, and after the fourth there is nothing left that can tie, because two cards with the same id on the same side are the same card. The tempo ability is a partition of that queue rather than a bonus inside it: cards holding it form a block at the front, sorted among themselves by the same chain, in every round.

Who gets hit

Position against position. Your first card fights their first card, your second fights their second, and when a lane empties the next living card behind it steps across. This is the newest structural rule in the engine, and it is what lets the player work out who will face whom by looking, instead of by simulating.

Lane assignment measured higher and was not adopted. The click budget for a first match is six clicks and the replay runs twenty-five seconds, and “the front card takes the hits” is legible in one sentence and visible on screen as it happens, while lanes have to be taught before the first blow lands. Two points of ceiling do not pay that teaching debt.

The damage expression

Integer arithmetic with every multiplication before the single division. This is not fastidiousness: floating point would give different results on different architectures, and the reproducibility that makes the whole product checkable would quietly stop being true.

1. 01Attackatk = floor(base * (100 + charge) / 100) + rally + vengeance + legacy + formationAttrition has already cut the base at setup. The multiplier resolves before the additive band, so an ability that adds attack is never multiplied by one that scales it.
2. 02Rawraw = floor(atk * force * element * crit / 1000000)Four integers multiplied, then divided once. Force is the strike's share of full power, element is 118, 100 or 85, crit is 150 or 100.
3. 03Defensedamage = raw - floor(defense / 2)Halved before it is subtracted, so defense slows a hit and never cancels one. Pierce skips this line entirely.
4. 04Mitigationdamage = floor(damage * (100 - armor) / 100)Armor reduces attacks and splash damage alike. It is the only percentage applied after the division.
5. 05Floordamage = max(1, damage)Applied after mitigation, not before. A card can never be immune by arithmetic, only by an ability that says so.
6. 06Barrierif barrier and damage >= 1 then damage -= floor(damage * m / 100), barrier spentChecked last, so a barrier is spent on a hit that would have hurt rather than on one the floor had already reduced to nothing. Version 4 gave it a magnitude: it used to cancel the hit outright, which is binary and therefore impossible to tune.

Deaths, and the end of a match

Deaths are processed through a first-in-first-out queue, so effects that fire on death, and effects those effects trigger in turn, resolve in a defined order rather than in whatever order the interpreter happened to walk an array. A match ends when one side has no living cards, copies included. If it reaches 60actions it ends anyway, decided by the higher sum of remaining health as a percentage, then by the lower sum of tiebreak bytes, then by the ordered concatenation of the side’s inscription ids. Nothing is ever re-rolled.

r(i) = sha256( seed || uint32BE(i) )      // i is monotonic and never reused

Every roll the match makes comes out of that stream, and the counter only ever moves forward. The published log records the counter range each action consumed, so a replay that diverges by a single roll is visible rather than mysterious.

The control run, no ability against no ability, measures 50.1% with no side bias, which is the zero the whole table is read against. All sixteen abilities sit inside the band, between 55.9% and 58.8%. The spread between the strongest and the weakest is 2.9 points, against 6.4 in version 3 and 16.1 immediately after version 4 changed the ranges and before the recalibration caught up.

How a balance change is actually made

Version 4 is not a patch, it is a reform, and it shipped as one version for the same reason every version does here: the frozen fixture is regenerated once instead of once per change. What drove it was a measurement nobody had taken. Under the old ranges, in 63% of matches either all six orderings won or none did, which means the result was already decided by the cards and the player's choice changed nothing in almost two thirds of the games.

Two changes fixed that and neither works alone. The stat ranges were halved around their own centres, so two teams are rarely far apart on raw numbers; and targeting became positional, so the player can see who will face whom. Together they take the share of matches where the ordering decides the result from 36.7% to 61.1%, and what playing well is worth from 62.9% to 70.1%. Compressing alone actually makes things worse under the old targeting, which is why the pair is the unit.

import { createHash } from "node:crypto";

const id = "ed76bf35918948b8b78be0e6397ad4916d926dd3d65679a8b7e67d8699a672a0i0";
const number = 63140674;

const n = Buffer.alloc(8);
n.writeBigInt64BE(BigInt(number));
const b = createHash("sha256").update(id, "utf8").update(n).digest();
const u16 = (i) => (b[i] << 8) | b[i + 1];

console.log({
  hp:   75 + (u16(0) % 31),   // 83
  atk:  28 + (u16(2) % 15),   // 29
  def:  15 + (u16(4) % 11),   // 15
  spd:   9 + (b[6]  % 8),     // 16
  crit:  8 + (b[7]  % 5),     // 10
});

The comments are the values this page derived for that inscription on this request. If your run disagrees with them, one of us has a bug, and the disagreement is the whole point of publishing the expression.

The regression the test suite used to allow

This is worth telling because it is what “deterministic” costs in practice. For a long time every test in the engine compared the engine to itself. One derived a card twice and checked the two results matched. Another ran the same match twice in the same process. A third checked stats fell between their minimum and maximum. All of them passed, and not one of them would have failed if somebody had swapped which bytes of the digest became which stat. An innocent refactor could have silently rewritten every card in the universe with the suite still green.

So the suite now holds a frozen fixture: 17 cards pinned with their exact hashes, stats, abilities and magnitudes, covering every rarity band, every element, binary and scaled abilities, the cursed case and a numeric edge, plus one entire 16 action match with the counter range of each action. The fix was validated by injecting a regression on purpose, swapping two bytes in the health calculation. Every older test still passed. Only the fixture broke, and it broke card by card.

Tests

22

All passing, in under two seconds.

Frozen cards

17

Every tier, element and ability shape.

Frozen match

16

Actions, with the counter range of each.

Engine version

4

Old matches replay under their own version.

What versioning means here

A card is never edited in a database, because a card was never in a database. When a rule changes, the version increments and matches that already ran stay valid and replayable under the version they ran on. That is the only honest way to change a deterministic engine, and it is also why changes are batched and measured first: every version is a promise that has to be kept forever.