FishE

This game allows you to explore a fishing village and perform actions in it.

Setup

pip install -r requirements.txt

The game depends on tak — the text-adventure kit that was extracted from FishE and that FishE now runs on: the user-interface contract and its console, server-web and in-browser front-ends, the save slots, the unlock engine and NPC dialogue — and on jsonschema (it validates save files on every load and save). Installing tak needs git on your PATH. This step is required before running any front-end from a local Python interpreter — console or the server-backed web front-end (python3 examples/web_app.py). run.sh runs this for you. The pygame front-end (UIType.PYGAME) additionally needs pip install pygame, kept out of requirements.txt since it's only imported lazily when that front-end is selected.

Running the game

The default front-end is the console. From the repository root:

python3 src/fishE.py

Or use ./run.sh, which also does a git pull, installs the dependencies (pygame and pytest included), and runs the test suite, then starts the game only if the tests pass.

To play in a pygame window instead, install pygame and change INTERFACE_TYPE near the top of src/fishE.py from UIType.CONSOLE to UIType.PYGAME. The two browser front-ends are started differently; see Play in your browser below.

On a Debian-based machine, install.sh (run as root) clones the game into /usr/games/FishE and adds a fishe command that runs ./run.sh there; uninstall.sh removes both. It runs without prompting and is safe to run again: a second run updates the existing clone with git pull rather than cloning over it.

Features

Play in your browser

FishE runs behind a single user-interface contract, so it supports multiple front-ends: the default text/console interface, a pygame window, and two browser-based ones. The entire game — save-file manager, fishing, shop, bank, tavern, and NPC dialogue — plays in the browser either way, and both render from the same client (tak's client.js, served at /tak/), so they look and behave identically. Adding a new front-end means implementing tak's BaseUserInterface (FishE's subclass in src/ui/baseUserInterface.py supplies the village's header) and adding a UIType + factory branch.

In your own browser (UIType.PYODIDE) — the game itself runs in your tab, under Pyodide. Nothing is sent to a server, every tab is its own game, and your save files live in your browser's IndexedDB, so they survive a reload and stay on your machine. This is how the game is deployed:

python3 web/build_zip.py    # bundle the game for the browser (once, and after any src/ change)
python3 web/serve.py
# then open http://127.0.0.1:8080

The Dockerfile packages exactly this: it builds web/game.zip into the image and runs web/serve.py on port 8080, listening on all interfaces (docker build -t fishe . && docker run -p 8080:8080 fishe). The container only serves files, so it needs no volume; saves stay in each player's browser.

Set FISHE_WEB_PORT to serve on a different port (and FISHE_WEB_HOST, e.g. 0.0.0.0, to be reachable from outside the machine); both entry points name that variable if the port they were given is misspelled or already taken.

web/serve.py only serves files — it never runs the game. It does have to send the Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers it sets, though: without them the page is not cross-origin isolated, SharedArrayBuffer is unavailable, and the browser cannot deliver your input to the game. Any proxy placed in front of it must preserve those headers.

On a server (UIType.WEB) — the game runs in the Python process and the browser is a terminal for it, with save files on the server's disk under data/. Handy for playing over a terminal-less machine on your own network, but everyone who opens the page shares one game and one set of saves:

python3 examples/web_app.py
# then open http://127.0.0.1:8000

Both need the Setup step above: the browser build copies the installed tak into web/game.zip and loads jsonschema into the browser sandbox when the page opens, while the server-backed front-end runs on your local Python and needs both installed first. Rebuild web/game.zip after upgrading tak.

Location stills (provisional)

Each of the five places - the docks, the shop, home, the bank and the tavern - has a picture above its menu, rendered offline with the Strata engine from a scene file in art/ and shipped as a PNG in pictures/ (inside web/game.zip for the browser). Both browser front-ends and the pygame window draw it; the console shows none. FishE is set in the same fishing village as Tidewater, so the stills are drawn from Tidewater's scenes and its generated village, with FishE's own props added (the shop's rack of fishing poles, the tavern's dice).

The setting and the art are a provisional first pass (Tidewater's late-September day at 54.5° N, flat-coloured shapes, no people drawn), recorded as provisional in art/stills.json with the reasoning for each choice. All of it, the alt text included, is the author's to change. All the stills · on a phone · in the pygame window.

This is the beginning of the README. Read the rest at the original. Read the full README ↗