Part 1: Making things

Part 1 of the manual of Sema-tawy. If you’re a developer and want to know the inner workings, see part 2.

This part is for anyone who’d like to make the game their own: new stacks, new pictures, different words, a harder journey up the Nile or a kinder one. You don’t need to be a programmer to do any of that. Nearly all of it is plain text in small files that explain themselves. A few things need a little code and chapter 9 walks you through that line by line.

Don’t worry about breaking anything! Every time you build the game, it checks all of your work first. If something is wrong, it tells you which file and line the mistake is in and what to do about it. Your last working game stays exactly as it was until you’ve fixed it.

Where else to look

• Part 2 is for developers. It explains how the game works on the inside.
• The content reference lists every setting of every kind of file. It’s handy when you need the exact name of something.
• How hard it is says what makes a journey hard and what each number was measured to do.
• Reading the code is a gentle way into the code itself.

Contents

1. Getting ready
2. The quick way
3. How the game is put together
4. The words the game uses
5. Pictures
6. Words and numbers
7. Adding something new
8. Is it fair? Checking the balance
9. When the list isn’t enough: a little code
10. If something goes wrong
11. Sharing your version

1. Getting ready

What you’ll do: install two programs and build the game. Time: about 15 minutes.

You need two programs and a third is good to have. All of them are free.

A text editor. This is a program for changing plain text files.

• We’d recommend VS Code. It works on every computer and colours the text for you, which makes a missing quote mark much easier to spot.
• Notepad++ on Windows or TextEdit on a Mac work too. In TextEdit, choose Format → Make Plain Text before you save.
• Please don’t use Word or Pages! They add hidden formatting that the build can’t read.

Python 3. This is the programming language the build is written in, so your computer needs it to build the game.

• On Windows, double-click build.bat. If a window tells you that Python can’t be found, download it from python.org. While it installs, make sure to tick the box that says Add Python to PATH.
• On a Mac or on Linux, it is often already there. Open the Terminal app, type python3 --version and press Enter. If you see a version number such as Python 3.12.4, you’re ready.

Node.js (good to have). With it, the build deals every stack with the game’s own rules and checks that each one can be cleared and the balance tools of chapter 8 can run. Get it from nodejs.org. Without it the game still builds.

Building the game

“Building” turns all of the small files into the game.

• On Windows: double-click build.bat.
• On a Mac or on Linux: open Terminal, type cd (with a space after it), drag the game’s folder onto the window and press Enter. Then type python3 build.py and press Enter.

You should see: a few lines ending with one that starts Done: dist/sema-tawy.html. The game has been built! Open that file (in the dist folder) in your browser and play a stack.

That one file is the whole game. You can copy it anywhere, send it to a friend or keep it for twenty years and it will still work. It never goes online.

Keep a copy before you start. Duplicate the whole folder. If you ever get lost, you can always go back to the copy.

2. The quick way

What you’ll do: make a new boon and see it in the game. Time: about 5 minutes.

This is the way we’d recommend for adding anything new.

1. Let new.py start it for you. On Windows, double-click tools/new.bat and answer its two questions. On a Mac or Linux, type:

python3 engine/tools/new.py boon "Eye of Ra"

You should see: Made content/boons/9-eye-of-ra.jsonc. Open that file. It already works: every line has a comment above it saying what it is for, so you can build and see it before you change anything at all. These are the things new.py can start:

2. Let the game build itself. Type python3 build.py --watch and leave the window open. From now on, every time you save a file, the game is built again by itself. If you make a mistake, you’ll know at once. To stop it, close the window or press Ctrl+C.

3. Try it out in try-out mode. Add ?try to the end of the game’s address in your browser’s address bar: dist/sema-tawy.html?try. Try-out mode is a copy of the game meant for testing, with a save of its own, so your real journey is never touched. Every stack is open in it and a small red label in the corner reminds you where you are. After each change, simply reload the page.

3. How the game is put together

Before you start changing things, it helps to know what each folder is for and what the build does with it.

Inside content/:

What the build does

When you build, engine/build.py goes through five steps:

If step 2 or 3 finds a problem, step 5 never happens. Instead, the build tells you the file, the line and what to do about it.

This is also why the code never needs to know that your new boon exists. Once its file is there, it turns up in markets and shrines, in the satchel and in How to play, all by itself.

New players meet the game a bit at a time. The first time the game opens, a short tutorial plays on a small stack of its own. In the first journeys, tips point at the bar, the shuffles and each special amulet the first time it turns up. Try-out mode has all of that too, so you can see a new special amulet’s card the way a new player would.

In the engine: part 2, chapter 5, The build says more about each step.

4. The words the game uses

The files and this manual use the game’s own names for its pieces all the time, so here they are.

A tomb on a journey. The bar at the top has the jar that fills as the stack empties, the deben, the stack’s name and its omen, then the satchel of boons, the shuffles, a hint and the menu. On the stack are gold, veiled, sealed and covered amulets and a stone of rubble.

5. Pictures

Every picture in the game is a file in images/. To change one, replace the file with your own, keeping the same name and build.

Try it first

1. Open images/amulets/scarab.svg in a text editor. It’s a drawing written as text.
2. Find a colour in it, such as fill="#f5d04e" (the gold) and change it to fill="#c0392b", a red.
3. Save, build and play a stack.

You should see: every scarab’s gold is now red. Change the colour back (or copy the file back from your copy of the folder) to undo it.

Where each picture goes

The pictures are SVG files: drawings made of shapes rather than dots, so they stay sharp at any size. You can open one in Inkscape, which is free, change it and save it under the same name.

Make amulets easy to tell apart. Players know amulets by their colour first and their shape second. Two kinds of the same colour in one set are hard to play, even when their shapes differ. The build checks nothing of this: look at a whole stack before you keep a new picture.

To give a boon another picture, change its "picture" to the name of any file in images/cards/ or images/amulets/, without .svg.

Pictures drawn by a script

Some pictures are made by scripts in tools/ and the top of each file says so:

If you edit one of those pictures by hand, don’t run its script again, or it draws the old picture right back. Better still, change the script.

A word on sizes. Every picture goes inside the game’s one file, so keep them small: a big picture makes the game bigger to download and uses more of a phone’s memory. SVGs are usually tiny. If you use a photo, make it no bigger than it needs to be.

6. Words and numbers

How a content file is written

Almost everything you’ll change is a small text file in a format called JSON. (Strictly, JSONC: “JSON with comments”, which is why the files end in .jsonc.)

Here is a boon:

// A boon: used once, when the player chooses.
{
	"id": "eye",
	"name": "Eye of Horus",
	"text": "Shows a pair.",
	"picture": "eye",
	"effect": "show-pair",
	"price": 18
}

Each line between the curly brackets { } is one setting, in two halves with a colon between them:

• The left side is the key ("price"). It is the game’s own name for this piece. Don’t change it: the game looks for exactly that name.
• The right side is the value (18). This is the part you change.

Values come in a few kinds:

A few rules keep a file readable for the build:

• Put a comma after each setting, except the last one before a } or a ].
• A line that starts with // is a comment: a note for people, which the game ignores.
• Every { has its } and every [ its ].
• An apostrophe inside text is fine (Khufu’s). A double quote (") is not, as it would end the text early. Use the curly ones (“ ”) instead.

If you get one of these wrong, don’t worry: the build tells you the file and the line.

The id. Most files start with an "id". Once people have played, leave it alone: saves remember things by their id.

Every word on screen: edition.jsonc

Every word the game’s own screens show is in edition.jsonc, under "text". Find the words, change them between their quotes, save and build.

"text": {
	"new": "New deal",
	"shuffle": "Shuffle",
	"left": "{n} amulets left",

Change the text on the right and leave the key on the left alone. Words in curly brackets, such as {n} or {season}, are filled in by the game: keep them, but move them around the sentence as you like.

The names and lines of boons, relics, omens and places are in their own files in content/ and the river’s stories in content/events/.

How we write. British English, short and plain: a card has room for one line. Buttons and rules are read in a hurry, so they stay in the present tense and to the point. The river’s stories and How to play’s openings can have more flavour: the river’s in the travellers’ voice (“we”), How to play speaking to the player.

How to play

How to play is in edition.jsonc too, under "text", "help": a list of chapters, each with a title, an icon, a first line ("lede") and its blocks.

{
	"title": "Taking pairs",
	"icon": "amulets",
	"lede": "Two alike, both free: that is the whole rule.",
	"blocks": [
		{ "show": "pair", "p": "Tap an amulet, then its twin. Off they go." },
		{ "h": "Choosing well" },
		{ "p": "Every stack can be cleared, but not in every order." }
	]
}

To add a chapter, copy one and change it.

The tutorial is in edition.jsonc as well, under "tutorial": its small stack and its steps, each with a line the game’s label shows when its moment comes. Change the words freely. If you change the stack, keep it so that only one pair can be taken at a time, or the steps point at the wrong amulets. How to play’s “Learn by playing” plays it again.

The numbers that tune the game: content/settings.jsonc

Every number that makes a journey easy or hard is in content/settings.jsonc, under "run", each with a comment. These are the ones you’re most likely to change:

Important: never rename a level’s id (gentle, standard, demanding, fierce). Saves rely on them.

An example: a gentler Normal. Give Normal one more shuffle:

"standard": { "shuffles": 3, "coins": 0, "undo": 0, "warn": true, "wins": [95, 70] },

Build, then check the balance (chapter 8). Measured, one shuffle more on Normal lets a careless player win about 19 more journeys in a hundred on a phone. How hard it is lists what each number was measured to do, so you can pick the one that moves the game as much as you want.

Prices and the places on the map

• Boons and relics each have a "price" in their own file and a "rarity" (common, rare or wondrous): the rarer ones turn up less often and only higher on the map.
• Looks for sale have a "price" in turquoise in their own file.
• The places (content/places/) say how often each turns up ("weight"), from which row ("from_row"), what it gives, sells or asks and its scenery. A place is put together from the engine’s building blocks; the content reference lists them.

7. Adding something new

Whatever you add, it’s always done the same way:

1. Make it with new.py (chapter 2), or copy the nearest file by hand.
2. Rename a copy with the next number and a new name. new.py does this for you.
3. Change its id and whatever else you like.
4. Build and try it in try-out mode.

The number at the front of a file name decides its place in lists. 9-eye-of-ra.jsonc comes after 8-bes.jsonc.

A stack

What you’ll do: draw a new stack and play it. Time: about 15 minutes.

python3 engine/tools/new.py stack "The ibis"

Open the new file in content/layouts/. A stack is drawn in layers, from the table up. In each row, # is an amulet and . is an empty place:

"layers": [
	{ "rows": ["########", "########", "########", "########"] },
	{ "shift": [1, 1], "rows": ["######", "######"] },
	{ "shift": [1.5, 1.5], "rows": ["#####"] }
]

Seen from above, that stack looks like this, the numbers being how high each spot is piled:

1 1 1 1 1 1 1 1
1 2 2 2 2 2 2 1
1 2 2 2 2 2 2 1
1 1 1 1 1 1 1 1

(with the top five sitting between the second layer’s amulets).

• The first layer lies on the table. Each next one lies on top of it.
• "shift": [1, 1] moves a layer one place right and one down. Half places (0.5) set an amulet between two below it, as in a real mahjong stack.
• A stack must have an even number of amulets: they go in pairs.
• "tall" (optional) is the same stack drawn narrower, for a phone held upright. Keep it to about ten across, or the amulets grow small. A "phone" shape can be narrower still, for small phones.
• "found": true keeps it out of free play until a journey has cleared it. Remove the line to offer it at once.
• "music" gives the stack its key, scale and lead instrument (harp, lyre, oud, flute or bell): the music is made as you play, in that key.

Build. The build deals your stack with the game’s own rules and tells you if it can’t be cleared. Then try it: dist/sema-tawy.html?try&layout=ibis.

Most stacks are drawn by a script instead, tools/draw-layouts.py: you draw only the bottom layer and it raises the layers above, the way a mahjong stack is built. Its comments say how.

Easy or hard? A stack is harder when it is one wide piece, with long rows that only open from their ends. A stack that falls into several separate piles is easier: each pile comes apart by itself. node engine/tools/sim.js (chapter 8) tells you how often the bot clears it.

A boon, a relic or an omen

What you’ll do: add a relic that gives a shuffle back at every oasis.

python3 engine/tools/new.py relic "Water of the oasis"

The file explains every line. The most important one is "effect": what it does. You choose it from the engine’s list, which the file names. This one wants "gift-more", which gives more at a place’s gift, with the number it works with:

{
	"id": "oasis-water",
	"name": "Water of the oasis",
	"text": "An oasis gives one shuffle more.",
	"picture": "lotus",
	"effect": "gift-more",
	"shuffles": 1,
	"price": 40,
	"rarity": "rare",
	"opens": ["table:marsh"]
}

"opens" is the look this relic opens for good when a journey carrying it is won: look: (tiles), set:, table: or effect: (a pair effect), then its id.

The effects the engine knows:

• Boons: show-pair, deal-again, put-back, see-veiled, take-with-kind, wild, take-kind, swap
• Relics: stuck-shuffle, top-double, free-hint, kind-run-shuffle, pair-coins, every-pairs-boon, streak-forgives, group-relic, stack-shuffles, rubble-sooner, rich-double, clears-shuffle, gift-more, stuck-take-pair, veil-neighbour, event-coins, shop-cheaper, rich-opens-seals, gems-twice
• Omens: more-kinds, veil-bottom, night, blind, seal-ring, no-hints

The content reference says what each does and which numbers it takes. A new boon or relic turns up in markets, shrines and tombs at once and its card appears in How to play.

If the effect you’d like isn’t in the list, chapter 9 shows you how to add one.

Something on the river

python3 engine/tools/new.py event "A lost goat"

Write what happened in the travellers’ voice (“we”, a dry smile, two or three sentences), then two or three choices. Each choice "gives" deben, shuffles, a boon or a relic, or takes them (a number below nothing):

"text": "A goat stood on the bank, bleating at us as if we owed it money. Perhaps we did.",
"choices": [
	{ "text": "Take it aboard", "gives": { "coins": -5, "boon": "any" } },
	{ "text": "Sail on", "gives": {} }
]

"any" gives one chosen by chance. A choice that would take more than the player has can’t be chosen, so always keep one that costs nothing.

Keep the facts true. The travellers look, ask and learn. What they tell is history: documented, never invented.

A place on the map

Each kind of place is a file in content/places/, put together from the engine’s building blocks: a stack, a shop, a choose (boons to take one from), a gift, an event and a reward. A tomb, for example, is a stack with an omen and a relic as its reward:

"stack": { "size": "row", "omen": true, "cover": ["sand", "bandages"], "covered": 6 },
"reward": { "coins": "clear", "relic": { "choose": 3 } }

A new file is a new kind of place. Give it a "weight" (how often it’s drawn), a "group" (which rows of the map’s pattern it can fill) and a picture. The content reference lists every block.

A cover

Covered amulets lie under something: alabaster, glass, beads, amber, sand, bandages, water, vines. A cover is only a picture, images/cards/cover-<name>.svg. To add one, draw it (or let tools/draw-covers.py draw it) and add its name to "covers" in content/settings.jsonc, or to a place’s own "cover" list. No code at all.

New looks

Looks change only how the game looks. Each is a file and a look for sale has a "price" in turquoise; one without a price is everyone’s, unless a relic opens it.

• A tile look (new.py look "Carnelian") makes a content file and a stylesheet in web/looks/. The stylesheet is CSS; its comments explain the one special word, extrude(), which draws a tile’s thick side.
• A set of amulets is a folder images/amulet-sets/<id>/ with a picture for every kind, named after it and a file in content/sets/ naming the folder. A kind you leave out keeps its plain picture. tools/amulet-sets/draw.py draws a whole set in a style of its own from every amulet’s outline.
• A table is a picture in images/tables/ and a file in content/tables/.
• A page style is a file in content/pages/ and a stylesheet in web/pages/.

Your own music

The music is made as you play, in each stack’s own key. A style of song (content/music/styles/) says its tempo, its rhythms, which instruments play and how its sections follow each other; its comments explain each line. Hear one with ?try&music=<its id>. The tunes the songs come back to are written by hand in content/music/tunes.jsonc.

8. Is it fair? Checking the balance

What you’ll do: let a bot play many journeys, to find out how hard the game is.

Judging difficulty by playing is hard: you get better as you go and a few games are too few to tell. So the game comes with pretend players that play thousands of times and count. They need Node.js. In Terminal, in the game’s folder:

node engine/tools/sim.js 200

plays every stack 200 times and says how often the bot clears it alone and with one shuffle. Most stacks should be cleared well over half the time alone and nearly always with a shuffle.

SHAPES=phone node engine/tools/difficulty.js 200

is the one to run after changing a level. A careful player and a careless one play 200 whole journeys at every level. It takes twenty minutes to half an hour and keeps every core of your computer busy.

You should see: a table of how many journeys each player won, against the "wins" each level aims at, the lives lost and the deben left; then how often each row of a journey is cleared without getting stuck, how stacks are lost and how often the help was needed. The levels are tuned on a phone’s shapes; SHAPES=wide plays a computer’s.

What to aim for: within 7 of each level’s aim. On Normal now, a careful player wins about 94 journeys in a hundred and a careless one 64.

node tools/levers.js 200

changes one number at a time on a copy of your content (your own files are never touched) and says how much each moves the wins on Normal. Put a level’s id after the number to try another.

How you really play can be measured too. Build with python3 build.py --debug and play dist/sema-tawy-debug.html: it notes everything you do, on your own device (nothing is sent anywhere). Its menu’s Play log saves it as a file and

node engine/tools/play-log.js sema-tawy-log.json

says what you pick and pass over, how long a pair takes you, where you get stuck and, for every stack lost, the pair after which it could no longer be cleared.

A pretend player can then play like you:

node engine/tools/fit-player.js sema-tawy-log.json
PLAYER=player.json node engine/tools/run-sim.js 200

The first learns from your logs what you look at when you choose a pair, how often you see a trap coming, where you go on the map and how quickly you play; the second plays journeys that way and says how many you would win and how long one would take you. The more logs you give it, the surer it is.

How hard it is has the results we measured and what we learned from them.

9. When the list isn’t enough: a little code

Everything so far uses what the engine already knows: a boon’s "effect" is one name from a list. Now and then you may want something we didn’t think of: a boon that lifts every cover at once, say. That takes a few lines of JavaScript, the language the engine is written in.

You don’t need to be a programmer. Most new things start as a copy of something that already does something similar and we’ll explain every line. The code is written plainly on purpose, with small functions that say what they do.

The bits of JavaScript you’ll come across

Here are the few things you’ll see again and again. You don’t need to learn them by heart: come back here whenever a line doesn’t make sense.

The dot: “the part of … called …”. A dot opens a bundle and picks one thing out of it:

stack.gone        // the part of the stack called gone
JOURNEY.run.coins // the coins of the journey under way

Square brackets: “item number … of a list”.

stack.gone[7]     // whether tile number 7 has been taken
stack.kinds[i]    // the kind of tile number i, whichever tile i is

Names for things. const gives a name to something worked out, so it can be used again below. let does the same for something that changes:

const free = freeOnes(stack);   // free is now the list of free tiles
let count = 0;                  // count starts at 0 and may change

Changing something. A single = means “becomes”:

Asking questions. These give true or false, for if:

Choosing and repeating.

if (run.coins < 10) {
	// only when there are fewer than 10 deben
}
for (let i = 0; i < stack.places.length; i++) {
	// once for every tile of the stack, i being its number
}
for (const i of free) {
	// once for every tile in the list free
}

A function is a set of steps with a name, given what it needs between its brackets:

// whether a tile has a cover
function isCovered(stack, i) {
	return stack.cover[i] !== null;
}

return hands back the answer. Everything after // is a comment: a note for people.

A stack, as the code sees it

This is the one idea to hold on to: a tile is a number. The stack keeps a list for each thing a tile can have and tile i‘s is at place i in each list.

In the game, press F12, choose Console and type GAME.stack to see them for the stack you’re playing.

Helpers: the words the rules are written in

A helper is a small function with a plain name that does one thing the rules need. A new rule is usually two or three helpers in a row. These are in engine/src/01-core.js:

And in engine/src/02-run.js, for a journey:

Reading a boon that already exists

A boon’s file names which effect it uses. The effect itself is written in useBoon, in engine/src/07-run-boons.js. This is the part behind the Ankh, which makes one free amulet match any other:

} else if (boon.effect === 'wild') {
	stack.wild[targets[0]] = true;
	out = { wild: targets[0] };

Which tiles a boon needs tapped first is in BOON_TARGETS, at the top of the same file: wild: ['free'] means one free tile.

After useBoon, the page draws the stack again (applyBoon, in engine/src/game/65-satchel.js), so the change shows at once.

Making your own: the Breath of the North Wind

What you’ll do: make a boon that lifts every cover at once. Time: about 20 minutes.

The north wind blew up the Nile and carried the boats against the current. Let’s give its name to a boon that blows every cover off the stack: sand, water, beads, all of it.

Step 1: name the effect. Open engine/src/02-run.js and find RUN_EFFECTS. Add 'lift-covers' to the end of the boons’ list:

boons: ['show-pair', 'deal-again', 'put-back', 'see-veiled', 'take-with-kind', 'wild', 'take-kind', 'swap', 'lift-covers'],

The build now accepts "effect": "lift-covers" in a boon’s file.

Step 2: say what it does. Open engine/src/07-run-boons.js and find useBoon. Its effects are a chain of if and else if, one for each. The last is the swap’s, ending with the line out = { swapped: [i, j] };. Straight after that line (before the } that closes the chain), add:

} else if (boon.effect === 'lift-covers') {
	const lifted = [];
	for (let i = 0; i < stack.places.length; i++) {
		if (stack.cover[i] && !stack.gone[i]) {
			stack.cover[i] = null;
			lifted.push(i);
		}
	}
	if (lifted.length) out = { lifted: lifted };

It needs no tile tapped first, so BOON_TARGETS stays as it is.

Step 3: make the boon. Type:

python3 engine/tools/new.py boon "Breath of the North Wind"

and in the new file set:

"text": "Lifts every cover.",
"picture": "feather",
"effect": "lift-covers",
"price": 20,

Step 4: check it.

1. Build. If the build says the effect is unknown, check that it’s spelled the same in both places.

2. Run the rules tests and the smoke test:

   node engine/tools/rules-test.js
   node engine/tools/smoke.js

   The smoke test plays the game at four screen sizes and uses every boon on a journey, yours too.

3. Play: start a journey in try-out mode (?try&run), buy the boon at a market and use it on a stack with covered amulets.

You should see: the covers vanish and the smoke test ends with All checks passed. Your boon works!

These steps change the engine. The engine lives in its own folder, Plinth and is copied into the game’s engine/: part 2 says how to keep the two together.

When it doesn’t work

• The build says the effect is unknown. The spelling differs between the boon’s file and RUN_EFFECTS, or the name isn’t inside the list’s square brackets.
• The game shows a blank page. A bracket or a comma is probably missing. Press F12, choose Console and read the red message: it names the file and the line.
• Nothing seems to happen. Check the if: maybe no tile passed its test. console.log(lifted) just before if (lifted.length) writes the list into the console, so you can see what it found.

The other lists

Keep the rules and the show apart. The rules (engine/src/*.js) have no drawing or sound in them, so the bots of chapter 8 can play them on their own. How something looks and sounds goes in engine/src/game/. Reading the code is a good next step.

10. If something goes wrong

Things go wrong now and then; that’s perfectly normal! These are the situations you’re most likely to meet and what to do.

The build stops with Nothing was written. Please fix these first:

1. Read the lines it prints. Each names a file (and a line, if it can) and what is wrong.
2. Fix that one thing.
3. Build again.

For example:

content/boons/9-eye-of-ra.jsonc, line 12: Expecting ',' delimiter

Line 12 is missing a comma, or the line before it is. Or:

content/layouts/53-ibis.jsonc (wide): a layout needs an even number of tiles (this one has 107)

Add or take away one #.

Nothing is built until it’s fixed and the game you had before keeps working in the meantime. The most common slips:

1. a missing comma between two settings, or a missing quote mark,
2. a key the build doesn’t know (it suggests the nearest one it does),
3. a bracket deleted by accident when copying a file.

The game looks the same after a change. Did the build say Done? Reload the page. Still the same? Your browser may be showing an old copy: hold Shift while you reload.

Try-out mode shows nothing of my journey. That’s on purpose: it keeps a save of its own. Open the game without ?try for your real one. To start try-out mode afresh, use Menu → Settings → Start afresh while in it: that clears only the try-out save.

The game shows a blank page, even though the build said Done.

1. Press F12 (on a Mac, ⌥⌘I) to open the browser’s developer tools.
2. Choose the Console tab.
3. Read the red message. It names the problem and usually the line.

When in doubt, change one thing at a time: change it, build, check it, then move on to the next.

11. Sharing your version

• The file itself. dist/sema-tawy.html is the whole game. Send it, put it on a USB stick or on any website. It needs no server and loads nothing from the internet.
• On a phone. Copy the file to the phone and open it in its browser.
• As an app. python3 engine/tools/build-android.py makes the Android app and python3 engine/tools/build-desktop.py the programs for Windows, macOS and Linux. The build guide says what each of them needs.
• Before you share. Keep your recordings and pictures to ones you’re allowed to share and note where each came from in images/CREDITS.md.