Kevin
d40bc09867
Turns the Phase 0 deployment shell into a playable async multiplayer game:
- shared/game.js + shared/board.js: pure reducer (reduce(state, action) ->
newState) over a small branching board subset mirroring the sketched
design (Career/Education fork, Relationship/Investment fork, High-Risk/Safe
fork, race to Finish). Dice randomness is generated server-side and shipped
inside the ROLL action payload, so the reducer itself stays fully pure and
is identically importable by both server and browser.
- server/db.js: SQLite (better-sqlite3) schema for games/players/tokens,
config and state stored as JSON. tokens covers both room invite links and
per-player reconnect secrets.
- server/rooms.js: in-memory room registry that is the only place the shared
reducer is invoked server-side — validates intents, applies actions,
persists, and broadcasts to every socket in the room.
- server/index.js: REST endpoints to create/join/inspect a game, and a
room-aware /ws that authenticates via a first {type:'AUTH'} message rather
than a URL query param (keeps session tokens out of access/proxy logs).
- public/client.js + public/index.html: NetworkTransport wrapping the
WebSocket, localStorage-backed session persistence so a reload resumes as
the same player, and a lobby/waiting-room/game-view UI.
- Dockerfile: adds python3/make/g++ so better-sqlite3's node-gyp fallback
builds on Alpine when a prebuilt binary isn't available for the exact
Node/musl combo.
Verified: shared/game.test.js (node --test) covers the full rules engine;
a scripted two-client run over real HTTP+WS confirms both clients converge
on identical state through create/join/start/play-to-finish; a server
restart mid-game preserves state and reconnect resumes the same player
without creating a duplicate.
84 lines
3.3 KiB
Markdown
84 lines
3.3 KiB
Markdown
# Life Journey — Phase 1
|
|
|
|
An async multiplayer, Game-of-Life-style board game. Phase 0 proved the
|
|
deployment path (Docker → Nginx Proxy Manager → HTTPS → WebSocket). Phase 1
|
|
adds the actual game: a pure shared reducer, SQLite persistence, and
|
|
rooms with shareable invite links, so a few people can play together across
|
|
devices and tab closes.
|
|
|
|
The server is the sole authority over game state. It generates the only
|
|
source of randomness (the dice roll) and applies it through the exact same
|
|
reducer (`shared/game.js`) the browser imports — client and server can never
|
|
disagree about the rules.
|
|
|
|
## What's here
|
|
|
|
```
|
|
lifegame/
|
|
├── docker-compose.yml
|
|
├── Dockerfile
|
|
├── package.json / package-lock.json
|
|
├── shared/
|
|
│ ├── board.js # the Phase 1 board graph + movement helper
|
|
│ ├── game.js # pure reducer: reduce(state, action) -> newState
|
|
│ └── game.test.js # node --test coverage of the whole rules engine
|
|
├── server/
|
|
│ ├── index.js # REST + WebSocket, static hosting
|
|
│ ├── rooms.js # in-memory room registry, applies/broadcasts actions
|
|
│ ├── db.js # SQLite schema + data access (games/players/tokens)
|
|
│ └── ids.js # id/token/join-code generation
|
|
└── public/
|
|
├── index.html # lobby / waiting room / game UI
|
|
└── client.js # REST wrappers + NetworkTransport (WebSocket)
|
|
```
|
|
|
|
## Running locally
|
|
|
|
```bash
|
|
npm install
|
|
npm test # reducer unit tests — no server needed
|
|
npm run dev # starts on :3000, creates data/lifegame.db on first game
|
|
```
|
|
|
|
Open two browser tabs at `http://localhost:3000`. Create a game in one tab,
|
|
copy the invite link, open it in the other tab, join, and start the game once
|
|
both players are in the lobby.
|
|
|
|
## The board (Phase 1 subset)
|
|
|
|
The full hand-drawn board (`assets/game_board.png`) has ~150 spaces across two
|
|
thematic passes (Career, Education, Gap Year, Relationship/Family,
|
|
Investment, High Risk). Phase 1 encodes a small subset with the same shape —
|
|
a Career-vs-Education fork, a Relationship-vs-Investment fork, a
|
|
High-Risk-vs-Safe fork, converging to Finish — enough to prove the reducer,
|
|
persistence, and rooms all work end to end. More spaces can be inserted into
|
|
any branch later without touching the reducer or database schema.
|
|
|
|
## Deploying on the homelab
|
|
|
|
Same as Phase 0 — see `homelab-config.md` for the full infrastructure
|
|
reference. Set `PUBLIC_URL` in `.env` (or the compose environment) to your
|
|
public domain so invite links generated by the server are shareable rather
|
|
than pointing at an internal address:
|
|
|
|
```bash
|
|
cd ~/homelab/lifegame
|
|
docker compose up -d --build
|
|
docker compose logs -f # expect: "Life Journey (Phase 1) listening on :3000"
|
|
```
|
|
|
|
## Data & backups
|
|
|
|
The `lifegame-data` volume (mounted at `/app/data`) holds `lifegame.db` —
|
|
every game, player, and token. Back it up like your other self-hosted data;
|
|
losing it loses every in-progress and finished game.
|
|
|
|
## What's next
|
|
|
|
- Expand `shared/board.js` toward the full sketched board
|
|
- Richer board rendering (the current UI is a functional list view, not the
|
|
illustrated board)
|
|
- Tighter reconnection/presence handling (who's online right now, not just
|
|
who's joined)
|
|
- Admin page (`ADMIN_PASSWORD`, already stubbed in `.env.example`)
|