Content reference
Every field of every content file and every name the build knows. For a gentle introduction, read part 1 of the manual first; this page is for looking things up.
All content files are JSONC: JSON with // comments on lines of their own. The build reads them in file-name order (that is why they start with a number), checks every one and writes nothing if any is wrong.
Contents: edition.jsonc · stacks · boons · relics · omens · places · river events · looks · sets · pages and tables · names the engine knows
edition.jsonc
What makes this game this game. One file, in the game’s folder.
| Field | What it is |
|---|---|
name | the game’s name, in the page’s title and the bar |
description | one line about the game: under its name at home, in the app and the desktop programs |
background | the colour behind the page while it loads (the app, the desktop programs) |
formerly | files the game was once built as: a player’s save kept under an older name is carried over |
guard | the game’s own words that must never appear in the engine (besides its name, seasons and boons’ and relics’ names, which the guard knows already) |
version | major.minor.patch; the Android app’s version code is made from it (major × 10000 + minor × 100 + patch) |
android | the Android app’s package name, its name for ever once published |
file | the file the build writes into dist/ |
kinds | the kinds of amulet dealt in free play and the stack of the day, by picture name (images/amulets/<kind>.svg): one list, or several sets of them ([["ankh", ...], ["croc", ...]]), one picked for each deal by its seed, so a player doesn’t always meet the same ones. The first set is the one Customise and How to play show |
more_kinds | kinds kept ready besides those the sets deal. Every picture set must have a picture for every kind any set deals and for more_kinds; only those are put in the page |
look, set, page, table | what a new player sees first: ids from content/looks/, sets/, pages/, tables/ |
music | the music where a stack gives none: { "key": "D3", "scale": "hijaz", "instrument": "harp" } (scales and instruments) |
song | the song that is the music unless a player chooses the calm music in Settings: the id of one of the styles in content/music/styles/ |
vibrate | how long a buzz is for what, in milliseconds, or a pattern [wait, buzz, wait, buzz]: button, choose, pair, wrong, shuffle, clear, uncover, crumble, buy, gems and more; a player may turn it off in Settings |
sounds | which of the engine’s sounds plays for what (below) |
tone | how bright the instruments are: made, or soft (plucks start in 6 ms instead of 2, so they don’t click; the qanun and harp darker; the riq quieter; the top of everything 4 dB softer above 3,500 Hz) |
harmony | the music’s harmony: chords (as made: triads moving through a progression) or drone (no chords: a held drone on the home note and its fifth, the tune turning round the home note and resting on the fifth now and then, as Arabic music does). For music in the maqamat, where chords stacked in thirds come out bent |
balance | how loud the sounds and the music are as made, in decibels, more is louder and 0 as the engine makes them: sounds, music and events (a sound by its event, such as "clear": -6). Each from −24 to 12. The player’s two sliders in Settings (0 off to 150 %) work on top of it |
effects | which of the engine’s effects plays for what: pair (the first), pairs (those a player may choose), wrong, hint, shuffle, deal, clear; prices (a pair effect bought with gems) and proposals (shown only in try-out mode) |
pictures | the pictures the engine’s screens show for the game, by role: goOn (the way on), life (a life), dealing (while a stack is weighed), daily (the daily challenges), askGods (the Gods’ help), journey, free and days (home’s ways to play) and levels (a picture for each level, by its id, on the levels’ slider) |
progress | the bar’s progress mark (below) |
tutorial | the tutorial’s small stack and its steps (below) |
text | every word on screen (below) |
sounds: choose, pair, wrong, hint, shuffle, deal, clear (free play and journeys); go, buy, boon, relic, won, lost, uncover, crumble (journeys); button (any button pressed) and select (a choice made: a tab, a setting, a look). Each names a sound from the list below.
content/settings.jsonc
Every number that tunes the game, as Amulets of Anubis has it; none is written into the engine. Its run (read by the page as EDITION.run):
| Field | What it is |
|---|---|
seasons, rows | how many seasons a journey has (1 unless said) and each one’s rows: a map of rows rows for each, one after another, each ending in its great stack (the place with row: -1), which leads on to all of the next season’s start. Only the last season’s end ends the journey. What a place says of rows (row, from_row, at_least_one_in, fills_rows) is said of each season’s own; depth, start and gems.from count rows over the whole journey. The game names each season in text.seasons (name, line, picture) |
seasonLayers | for each season, [fewest, most] layers its stacks may have |
scenery | what a stack is laid on: seasons (for each season, a picture for each row and the last for its great stack) and free (free play’s, one for each stack). A place may have its own (scenery in its file). Each picture needs a rule in the game’s stylesheet |
hand | the most boons carried at once |
lives | how many stacks may be lost when stuck with no way on (none unless said): each takes one and the stack is left without its reward, or at a place that ends the journey, dealt again; none left, the journey is lost. A level may give its own |
levels | the levels, from the gentlest up, by an id kept in saves: { "gentle": { "shuffles": 6, "coins": 0, "kinds": -2, "lives": 4, "undo": 3, "warn": true, "wins": [99, 95] }, ... }. shuffles and coins to start with; kinds more or fewer kinds of amulet than the row gives; lives in place of the journey’s; undo (pairs that can be put back on each stack); warn (a notice when one pair is left and none after it); askGods (the Gods’ help, in place of the journey’s); gemsWon (gems for a journey won, in place of gems.won); wins (the wins aimed at in a hundred journeys, careful and careless, for difficulty.js). The first level is where a new player starts |
mercy | stuck with so many tiles or fewer left, they are dealt again for nothing |
askGods | how many times a journey, stuck with no way on, the Gods deal the stack again (a level may give its own) |
start | a journey’s gentle start: { "rows": 3, "layouts": [files], "trap": 0 }, its first rows dealing only those layouts, chosen to forgive; the sizes climb from the row after |
free | free play: shuffles, undo, warn, mercy (the last few, if not the journey’s) and how it is dealt: kinds (so many of the journey’s; none, the plain deal of the edition’s kinds), tricky and trap (as in depth) |
days | the daily challenges, in their order, each by an id kept in saves (the first is the stack of the day): the same fields as free, and size and layers ([fewest, most] amulets and layers its stack may have), place (a place whose scenery and cover it takes), omen (true: one of the day), special (as depth has them), gems (what clearing it brings). With no shuffle, being stuck offers the same stack again; the tries are counted. Their words are the edition’s text.days |
tips | tips are shown while so many journeys have been begun (counted again from the tutorial) |
nextAfter | after so many journeys won on a level, home suggests the next |
choose | how a stack is chosen from so many deals: candidates (1: the plain deal), plays (how often each is played) and careless (0 to 1: how often the bot playing it takes a pair at random); the one whose share of plays stuck is nearest the row’s trap is kept |
kinds | the kinds a journey deals, in the order they join as the map climbs: one list, or several sets of them, one picked for each place (the same each time it is dealt). No stack deals more kinds than its set has |
group | kinds that all match one another: { "name": "sons", "kinds": [...] } |
draw | the order the map weighs its places in (each place’s weight is in its own file); it decides which map a seed makes |
map | the map’s shape: first and last (those rows’ widths), widths (the others’, from and to), second_way (how often a place gets a second way up), choose_from (how many layouts of about a row’s size a stack is picked from); pattern, what each row of a season is (a list of rows entries, or one such list for each season): a place’s id fills the whole row, a group’s name (a place’s group) draws each of the row’s places from that group by weight; with a pattern, at_least_one_in and fills_rows are not used. varied: groups whose row has each of its places once before any twice |
crumble | after how many pairs rubble crumbles, at the fewest |
shapes | how each kind of shape deals, so a phone and a computer meet in the middle (a phone’s tall shapes play much easier than wide ones; tools/shapes.js measures it): tall and wide, each { "kinds", "tricky" } added to the stack’s (kinds no more than its set has), and leastKinds, the fewest kinds a stack is brought down to |
crumbleShare | after what share of a stack’s pairs rubble crumbles (a third: 0.33), never fewer than crumble; 0 or none: crumble alone |
covers | what covered amulets may lie under: names of images/cards/cover-<name>.svg (a place may name its own) |
gems | the rare money kept at home: from (the first row a gem pair may be on), chance (of one at a place), pair (what a gem pair brings), won (for a journey won), daily (for the stack of the day) |
coins | pair (each pair), rich (each rich amulet), clear (a cleared stack), noShuffle (cleared without a shuffle), streak and streakEvery (so many for every so many pairs in a row), hint (a hint’s price) and hintRow (so much more for every row up the map) |
shop | what a market asks: prices (every price times this), rise (costs more by this for each thing bought on the journey), bargain (one thing in each market cheaper by this) |
rarity | how often each rarity turns up at a market, a shrine or as a reward, and from which row: { "common": { "weight": 6 }, "rare": { "weight": 3, "from": 3 }, ... } |
coinsLeft | what a careful player should have in hand before the last great stack, [fewest, most], for difficulty.js |
depth | a list, from the bottom of the map up: { "from": 3, "kinds": 9, "rich": 2, "veiled": 4, "group": 2, "covered": 6, "sealed": 3, "rubble": 4, "tricky": 0.3, "trap": 0.35 } means from row 3 on, 9 kinds, 2 rich pairs, 4 veiled amulets, 2 pairs of the group, 6 covered, 3 sealed, 4 stones of rubble, now and then (0 to 1) an amulet laid on one of its own kind, and a deal chosen so a careless player is trapped about so often (with choose) |
content/money.jsonc
The engine’s two moneys, by the game’s names: coins (earned and spent on a journey) and gems (rare, kept at home, spent on looks), each with its name and picture (a card picture or an icon- one).
Back in edition.jsonc
renamed: names an older save may still use, read as the new ones: keys (a field’s old name: its new one, wherever it stands) and values (under a field: an old word: its new one).
text: every word on screen, by a name the engine uses. {n} is a number filled in. Some are groups: effects (the pair effects’ names), levels and levelText (each level’s name and line), mapWords (top, the water’s name at the top of a run’s map, and side, the land’s), daily (the stack of the day’s words), menu (the menu, Settings and Customise: their titles, lines and choices, custom.buy, custom.buyFor and the words of buying, custom.groups: the headings Customise groups things under, mine, find and buy), museumSheet (the museum: its tabs, counts and the deeds, each { id, name, text, gems }; the id is what the game checks: first-won, won-hard, tomb-clean, sons, week, all-stacks, all-relics), seasons, dealing (lines shown while a stack is weighed), log (the play log’s words, needed only by a debug build).
The help for new players and a gentler loss have their words too: tips (name and one line for each of tall, three, buried, stuck), hintWhy (name, many, one, none), warn and mercy (small, strong), askGods (title, line, ask, leave, done), home’s journeyNew, beginJourney, beginOn, freeLine, levelsLine, lastLevel, levelStats (the small word under each of a level’s numbers) and youGet; lostCleared, lostKept, lostAt (title, move, line, better, instead, show, back, looking), undo, startHere, nextLevel and tutorial (title, line, skip, done, doneLine, begin, home). A game without them simply has less of that help.
tutorial (beside text): the tutorial’s small stack, played the first time the game opens and from How to play. layers (as a stack’s), kinds (each tile’s kind, a place in the first set of kinds, in the order readLayout gives: layer by layer, row by row), cover (the tiles under a cover) and steps, each { when, n, at, name, line }: when is its moment (start, chosen, pair with n the pairs taken so far, stuck, shuffled) and at what the label points at (a tile’s number, twin, shuffle or pair). Lay it so one pair can be taken at a time.
text.help, How to play: contents, lede, chapter (Chapter {n} of {of}), next, and chapters, each { title, icon, lede, blocks }. icon is a picture in images/icons/. A block is one of:
| Block | What it shows |
|---|---|
{ "p": "..." } | a paragraph |
{ "h": "..." } | a small heading |
{ "items": [[picture, name, line], ...] } | pictures with a name and a line; a picture is icon-<name> (from images/icons/), a card’s picture or an amulet |
{ "show": "pair", "p": "..." } | a picture made of real tiles beside a line: pair, free, wrong, shuffle |
{ "levels": true } | the levels and their lines |
{ "places": true } | the places of the map, from content/places/ |
{ "coins": true } | how coins are earned, from help.coins with the run’s own numbers (a way worth nothing is left out) |
{ "bar": true } | the bar’s buttons, from help.bar |
{ "specials": true } | the special amulets |
{ "cards": "boons" } | every boon, relic or omen, with its picture |
The game fills in the last six itself, so they are always true.
Stacks (content/layouts/)
| Field | What it is |
|---|---|
name | its name in the settings and on the map |
music | its key, scale and lead instrument (music) |
layers | the layers, bottom first. Each is { "rows": [...], "shift": [x, y] }: # an amulet, . none; shift (optional) moves the layer that many places right and down (halves too) |
tall | optional: the same stack drawn narrower and taller for a phone held upright, dealt when it gives clearly bigger tiles. Keep it within about ten across |
phone | optional: the same idea for a small phone, no more than 7 across and 11 down, so its tiles are at least 42 px on a 360 px phone; dealt when it gives clearly bigger tiles than the others. tools/draw-layouts.py makes one by scaling the stack down unless one is drawn by hand |
found | optional: true keeps it out of free play until a journey has cleared it |
amulets | optional: this stack’s own sets of kinds (as Amulets of Anubis’s places have), dealt in place of the game’s, one picked for each deal |
An amulet is free when nothing lies on it (a tile on the layer above that overlaps it at all) and there is nothing beside it (on its own layer, within half a tile up or down) on its left or on its right. A stack needs an even number of amulets; the build deals it with the rules to prove it can be cleared. Stacks drawn by tools/draw-layouts.py say so in their comment: change them there.
Boons (content/boons/)
| Field | What it is |
|---|---|
id | its own name (small letters, hyphens), kept in saves: don’t change it once played |
name | on the card |
text | one line on the card |
picture | a picture in images/cards/ or images/amulets/, without .svg |
effect | what it does (below) |
price | at a market, in coins |
order | where it comes in lists |
| Effect | What it does | Tiles to choose | Numbers |
|---|---|---|---|
show-pair | shows a free pair | none | |
deal-again | deals what is left again, like a shuffle but free | none | |
put-back | puts the last pair back | none | |
see-veiled | lifts every veil for some pairs | none | pairs (5) |
take-with-kind | takes a free amulet and the most buried one of its kind, covered or not | a free one | |
wild | a free amulet matches any other, once | a free one | |
take-kind | takes every free pair of one kind | a free one of that kind | |
swap | swaps a free amulet with any other | a free one, then any |
Relics (content/relics/)
The same fields as a boon. Kept for the whole journey and at home once found (the museum). opens lists what the relic opens for good the first time it is found: "look:ebony", "set:naqada", "table:night", "effect:fall". What no relic opens and costs nothing is open from the start; the build refuses a thing that is bought with gems, worn by a new player or opened by two relics.
Every number an effect works with is in the relic’s file: the engine has none of its own and the build refuses a relic that leaves one out.
| Effect | What it does | Its numbers |
|---|---|---|
stuck-shuffle | once a stack, being stuck gives shuffles back | shuffles |
top-double | coins for every pair from the top layer | coins |
free-hint | the first hint of every stack is free | |
kind-run-shuffle | so many pairs of one kind in a row give back shuffles | kind, count, shuffles |
pair-coins | more coins for every pair | coins |
every-pairs-boon | every so many pairs bring a boon | every |
streak-forgives | a wrong pair doesn’t break a run of pairs, once | |
group-relic | all of a group taken in one stack brings relics to choose one from | choose |
stack-shuffles | a stack at a place (its at: a place’s id) starts with shuffles more | at, shuffles |
rubble-sooner | rubble crumbles so many pairs sooner (never before two) | pairs |
rich-double | a rich amulet brings its coins so many times | times |
clears-shuffle | every so many stacks cleared give back shuffles | every, shuffles |
gift-more | a place’s gift gives shuffles more | shuffles |
stuck-take-pair | once a journey, stuck with nothing left, a pair is taken away | |
veil-neighbour | a veiled amulet beside one taken shows itself | |
event-coins | an event’s gifts of coins come so many times | times |
shop-cheaper | shops cost less | off (0.2 is a fifth) |
rich-opens-seals | a rich pair opens the seals beside it | |
gems-twice | a gem pair comes so many times as often | times |
Omens (content/omens/)
id, name, text, picture, effect, order and the effect’s numbers. A place whose stack has an omen carries one.
| Effect | What it does | Numbers |
|---|---|---|
more-kinds | more kinds of amulet | kinds |
veil-bottom | the bottom layer is veiled | |
night | covered amulets lie in darkness | |
blind | free amulets aren’t marked | |
seal-ring | a ring of sealed amulets round the middle | |
no-hints | no hints |
Music (content/music/)
The songs (src/audio/40-songs.js) play the game’s music:
| File | What it is |
|---|---|
rhythms.jsonc | the hand drums’ rhythms by name, each 16 steps: D a deep beat, T a high one, k a soft one, . none |
tunes.jsonc | tunes written by hand by name, each two motifs of a bar: "place:step" notes, the step above the chord’s root, - at the end for a note held |
styles/*.jsonc | a style each: id, tempo, level (1 unless said), rhythms, the instruments (tune, answer, bass, and leads to take turns at the tune; with main, one of the leads, every other song goes back to it), busy (how many of a motif’s eight places have a note), walk (the bass fills in), drums and fills (how loud the hand drums are and how often they fill in as a stack grows tense; 1 as made, less for gentler), melody (motifs as made; path: twelve-bar tunes by single steps along the scale’s path, home only at the end; or maqam: tunes built from the maqam’s own figures, its opening, a pause, a sequence, an answer and its closing formula, a new middle each time round), ornament (true: a plucked lead’s short flick of a grace note; the doubling ney slides into its notes), double (ney: the tune doubled an octave down by a light ney that ornaments it its own way, where a section has the answer), tunes and made (written tunes, or now written and now made up) and sections (each the layers it plays: pad, drone, tune, answer, bass, drum, drum-soft, cymbal, riq, bells) |
The build names anything a style asks for that isn’t there. ?try&music=<id> plays another style in try-out mode.
The map (content/map.jsonc)
How a run’s map is drawn: font (its lettering, a CSS font list) and colours, each by its role: ground (three, light to deep), grain (light, dark), ripple, ripple-light, banks, fields, banks-edge, way-edge, way, way-glint, water (two, top to bottom), waves, shore, edge-shade, frame, compass, compass-ring, compass-north, compass-points, compass-ink, top-name, side-name. The build names any role missing.
Special tiles (content/specials/)
What a run may deal (or a boon make) besides plain amulets, one file each: id (one of rich, gems, veiled, sealed, rubble, group, covered, wild), and for a card shown the first time one is met and in How to play its name, text and picture (all three or none). Its colours: colour (the edge drawn inside the face of a rich or gem tile) and glow (round the amulet of a rich or wild tile), each #rrggbb. The stylesheets have them too, as --special-<id> and --special-<id>-glow. The files’ order is the cards’ order.
Places (content/places/)
A place says everything it does in its own file, put together from the engine’s building blocks (as Amulets of Anubis’ chambers and covers are); the engine knows no particular place. id, name, text, picture, order, then:
| Block | What it does |
|---|---|
row | fills this whole row (0 the first, -1 the last, -2 the one before) |
weight, from_row | drawn elsewhere with this weight against the others (in run.draw‘s order), not before this row |
group | with the map’s pattern: the group it is drawn in (“stacks”, “stops” or any name the pattern uses) |
at_least_one_in | "middle": the middle row always has one |
fills_rows | { "from": 2, "to": -3, "counts": [ids] }: each of these rows without one (or a place it counts as) gets one in its first place |
stack | a stack to clear: size (row: as hard as its row; smallest, with choose_from, kinds; largest), covered (at least so many covered), cover (its own cover, or a list, one chosen for the place), omen (true, or { "not": [omen ids] }), optional (played only if the player likes), never_lost (stuck there, it is only left) |
scenery | its own scenery: backdrop (a picture the game’s stylesheet draws) and table |
way | the colour of its way in: the game’s stylesheet styles .act.way-<name> |
enter | what the map’s button says to go there (a tomb’s “Enter by torchlight”); else text.go |
gift | given on arriving: { "shuffles": 1 } |
reward | what clearing the stack pays: coins ("clear": the usual, more with no shuffle used; or a number), relic ({ "choose": 3 }: relics to choose one from) |
shop | sells boons and relics, so many of each |
choose | { "boons": 3 }: boons to choose one from, for nothing |
event | true: something happens (content/events/) |
ends_run | "won": clearing its stack wins the journey |
A place must do something (a stack, a shop, a choice, an event or a gift). The build checks every block and what it names.
Events (content/events/)
| Field | What it is |
|---|---|
id | its own name |
title | at the top of its page |
picture | as for a boon |
text | what happened, in the travellers’ voice |
choices | two or three { "text": ..., "gives": { ... } }. gives may hold coins and shuffles (numbers; below nothing takes away) and boon and relic (an id, or "any" for one by chance). A choice that takes more than there is can’t be chosen |
No event comes twice in one journey.
Deeds (in edition.jsonc, text.museumSheet.deeds)
Each deed: id, name, text, what it brings (gems, or "relic": true) and when it is done: on (the moment: won, cleared, daily, found, relic; none: any), level, place (a place’s id: cleared there), clean (with no shuffle used), group_whole (a group’s kinds all taken in the stack), days (so many stacks of the day cleared, at least), all ("stacks" or "relics" all found).
Tile looks (content/looks/)
id, name, css (a stylesheet in web/looks/), order and optionally set (a set of amulets the look always wears, as Djoser’s tiles do), price (gems to buy it; none is free) and proposal (shown only in try-out mode, until the owner chooses). Sets, pages and tables take price and proposal too.
The stack is painted on a canvas from a photograph of a hidden tile wearing the look, so a look’s .tile rules (background, border radius, shadows, extrude()) and where it puts .pic and .ix are what counts; the special tiles of a run are painted over it by the game.
In the stylesheet, every rule applies to this look only. Lengths are best in --u, a hundredth of a tile’s width (calc(var(--u) * 10)). extrude(depth, face, back, line) writes the tile’s thick side: how deep, the colour of its face, of its back and of the line under it (each like #1d4f86). url(images/...) puts a picture in. A rule starting with :root:not(.corner) applies when the amulet sits in the middle (the usual), which a look with an inlay uses to centre it.
Sets of amulets (content/sets/)
id, name, folder (in images/, with one picture for every kind in kinds and more_kinds), order. Optional: size, how large the amulets are drawn in a tile (0.5 to 1.5): at 1 a picture’s whole square (its viewBox) fills the place an amulet has. A picture whose square leaves room round the drawing for strokes and shadows is drawn larger by as much (a 168 square round a 128 drawing: 1.31), so the drawing keeps its size and nothing is cut off; a set drawn bolder than the others a little smaller; price in gems and proposal (shown only in try-out mode).
Pages and tables (content/pages/, content/tables/)
id, name, css (in web/pages/ or web/tables/), order. A page may name a table it goes with. A page’s stylesheet sets the colours of the bar, the settings, the panels and the map’s lines through variables such as --page, --ink, --control, --control-ink, --control-line, --want (the glow on the button to press next) and --map-line, and for home’s title --title, --title-line and --title-shadow. The shelf of what is carried and the game’s label for names take the page’s stone (--stone-*, --bevel-*).
Names the engine knows
Music
Keys: a note and an octave, such as C3, D3, F#3, Bb2. Scales: hijaz, double harmonic, dorian, minor, major, mixolydian, lydian, phrygian, major pentatonic, minor pentatonic; and since 5 October 2026 the maqamat and the Gypsy scales: kurd (the phrygian), hijaz kar (the double harmonic), nahawand, nikriz, gypsy minor, and with quarter tones (notes between two keys of a piano) bayati, rast and saba. Instruments: harp, lyre, oud, flute, bell, softharp, kalimba, marimba, qanun (a softly plucked zither; held notes get its quick repeats), ney (the reed flute) and handpan.
Sounds
tick, pluck, clack, harp, bells, rattle, clack-harp, knock, low-flute, high-bells, wash, sand, whisper, crumble, harp-run, tiles, harp-bells, gong, flute-phrase, wood (a soft wooden tap for a button, not in key), wood-light (the same a fifth higher and lighter, for a choice), tick-soft (a softer tick for a tile chosen, its little tone in key). Each is made as it plays, in the key of the stack (engine/src/game/20-sound.js).
press, stone, select, page are Amulets of Anubis’ own button, stone button, choice and page sounds, kept as WAV files in the engine (sounds/, made again by tools/make-sounds.html in ~/Code/kiln) so any game can use them; the build puts them in the page.
Effects
| Kind | Names |
|---|---|
| a pair | meet, lift, dust, fall, rise-into (into the bar’s progress mark), ripple (they sink and rings of water spread), turn (each turns over), open, fly-off and drift (each with a picture) |
| a wrong pair | nudge |
| a hint | glint |
| a shuffle | gather |
| a new deal | drop |
| a cleared stack | gild |
effects.pairs lists what the player may choose from, by the game’s own names; effects.uses makes a name one of the engine’s effects with a picture of the game’s (images/cards/): "lotus": { "effect": "open", "picture": "fx-lotus" }. open opens the picture where the pair meet; fly-off sends a few of it off from each; drift lets one of it drift down from each, swaying.
progress (in edition.jsonc): the bar’s progress mark, a vessel that fills as the stack empties: box (its viewBox), body (a path), lid (a path, if it has one) and fills (the level’s bottom and top, in the box).