Merge pull request 'Katan: open trade offers and counter-offers' (#6) from feature/catan-open-trades-counter into dev

- Offers can go to the whole table (asked in seat order, empty hands skipped) or one seat.
- The asked seat may accept (trade happens at once), decline, or counter with new terms.
- If nobody accepts and there are counters, the offerer takes one or turns them all down (new TRADE_COUNTERS phase).
- AI: fixes an inverted accept test (it weighed what it gives against what it gets backwards), picks the best counter.
- UI: Everyone option in the offer dialog, Counter… in the reply dialog, a counter-choice dialog.
- Tests and docs updated.

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_018njn2eMPAYqAoE49hGRg2X

.github/scripts/stage-pages-site.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Assembles the Cloudflare Pages site for plg.wallacenet.ca into ./pages-out.
+#
+# Usage: stage-pages-site.sh <prod|dev> <tag> <apk-path>
+#
+# A Pages deploy replaces the whole site, and both channels live in one site,
+# so this stages the channel being published and then re-fetches the *other*
+# channel's current files from the live site so the deploy does not erase them.
+set -euo pipefail
+
+channel="$1"; tag="$2"; apk="$3"
+base="${PAGES_BASE_URL:-https://plg.wallacenet.ca}"
+out="pages-out"
+limit=$((25 * 1024 * 1024)) # Cloudflare Pages: 25 MiB per file
+
+case "$channel" in prod) other=dev ;; dev) other=prod ;; *) echo "bad channel: $channel" >&2; exit 2 ;; esac
+
+rm -rf "$out"
+mkdir -p "$out/$channel" "$out/$other"
+cp site/index.html site/404.html site/_headers "$out/"
+
+name="$(basename "$apk")"
+cp "$apk" "$out/$channel/$name"
+cp "$apk" "$out/$channel/ProLibertateGames.apk"
+# node rather than jq: the Gitea runner's image has node but not jq.
+node -e 'console.log(JSON.stringify({tag: process.argv[1], apkName: process.argv[2], apkUrl: process.argv[3], channel: process.argv[4]}, null, 2))' \
+  "$tag" "$name" "$base/$channel/$name" "$channel" > "$out/$channel/latest.json"
+
+# PLG_SKIP_OTHER=1 is for the very first deploy, when the site does not exist
+# yet and the domain answers 403 (Cloudflare error 1014) instead of 404.
+if [ -n "${PLG_SKIP_OTHER:-}" ]; then
+  echo "PLG_SKIP_OTHER set; not carrying over $other."
+  rm -rf "$out/$other"
+  find "$out" -type f | sort
+  exit 0
+fi
+
+# Carry the other channel over. 404 means it was never published; any other
+# failure must stop the deploy rather than silently dropping that channel.
+code="$(curl -sS -o "$out/$other/latest.json" -w '%{http_code}' "$base/$other/latest.json" || true)"
+: "${code:=000}"
+# Cloudflare error 1014 (403 + "error code: 1014") means the domain's CNAME
+# points at a Pages project that does not exist yet, so there is nothing to
+# preserve — the same as a 404, and what a push-triggered first deploy sees.
+if [ "$code" = 403 ] && grep -q 'error code: 1014' "$out/$other/latest.json" 2>/dev/null; then
+  code=404
+fi
+if [ "$code" = 404 ]; then
+  echo "No $other channel published yet; skipping."
+  rm -rf "$out/$other"
+elif [ "$code" = 200 ] && ! other_name="$(node -p 'const j = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8")); if (!j.apkName) process.exit(1); j.apkName' "$out/$other/latest.json" 2>/dev/null)"; then
+  # A 200 that is not our JSON: Pages without a 404.html answers unknown paths
+  # with index.html. Nothing is published on that channel.
+  echo "No $other channel published yet (200 but no latest.json); skipping."
+  rm -rf "$out/$other"
+elif [ "$code" = 200 ]; then
+  curl -fsS -o "$out/$other/$other_name" "$base/$other/$other_name"
+  cp "$out/$other/$other_name" "$out/$other/ProLibertateGames.apk"
+else
+  echo "Fetching $other/latest.json returned HTTP $code; refusing to deploy." >&2
+  exit 1
+fi
+
+find "$out" -name '*.apk' -size +"${limit}c" -print | grep . >&2 && {
+  echo "APK exceeds Cloudflare Pages' 25 MiB per-file limit." >&2; exit 1; } || true
+find "$out" -type f | sort

.github/workflows/ci.yml

@@ -1,27 +1,28 @@
 name: CI
 
 # Pre-merge checks. Runs on the dev branch and on every pull request aimed at
-# dev or main, so breakage is caught before it reaches main.
+# dev or main, so breakage is caught before it reaches main and triggers a
+# release.
 #
-# On a push to dev it also publishes the build as a dev-channel prerelease on
-# this Gitea instance, so the in-app updater can offer it to anyone on the dev
-# channel. Prereleases are used deliberately: the "latest release" endpoint
-# skips them, so a production-channel user never sees a dev build. Pull
-# requests only build and check — they never publish, which keeps a PR from a
-# fork from shipping anything.
-#
-# These files live in .github/workflows/ on purpose: Gitea Actions reads that
-# path as well as .gitea/workflows/, so one file serves both. Publishing goes
-# through Gitea's REST API (the same routes the app's updater reads) rather
-# than the `gh` CLI, which a runner image need not carry.
+# On a push to dev it also publishes the build as a dev-channel prerelease, so
+# the in-app updater can offer it to anyone who has switched to that channel.
+# Prereleases are used deliberately: GitHub's "latest release" endpoint skips
+# them, so a production-channel user never sees a dev build. Pull requests only
+# build and check — they never publish, which keeps a PR from a fork from
+# shipping anything.
 on:
   push:
     branches: [ dev ]
   pull_request:
     branches: [ main, dev ]
   workflow_dispatch:
+    inputs:
+      first_deploy:
+        description: "First Cloudflare deploy: skip carrying over the other channel (the site does not exist yet)"
+        type: boolean
+        default: false
 
-# Needed by the job token to create the release and attach the APK.
+# Needed to publish the dev-channel prerelease below.
 permissions:
   contents: write
 
@@ -34,6 +35,8 @@ jobs:
   build:
     name: Build and check
     runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.stage.outputs.version }}
     env:
       # Stamp the APK as a dev-channel build exactly when it is a build of the
       # dev branch, which is exactly when it can be published below. Pull
@@ -41,7 +44,10 @@ jobs:
       # <series>.0-dev: they are never published and must not claim a channel
       # version.
       #
-      # This condition has to stay in step with the publish steps' own.
+      # This condition has to stay in step with the publish steps' own. Stamping
+      # a build the publish steps would ship, or shipping one this left
+      # unstamped, both end the same way — an APK claiming versionCode 1, which
+      # the updater can never see as an upgrade over anything.
       PLG_CHANNEL: ${{ github.ref == 'refs/heads/dev' && 'dev' || '' }}
     steps:
       - name: Checkout
@@ -69,17 +75,30 @@ jobs:
       - name: Upload debug APK
         uses: actions/upload-artifact@v4
         with:
-          name: PilgrimsOfKatan-debug-apk
+          name: ProLibertateGames-debug-apk
           path: app/build/outputs/apk/debug/app-debug.apk
           if-no-files-found: error
           retention-days: 14
 
+      - name: Upload JVM crash logs
+        # A JVM crash writes hs_err_pid*.log into the workspace, which dies
+        # with the job container; keep it so the failing frame can be read.
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ProLibertateGames-jvm-crash
+          path: |
+            hs_err_pid*.log
+            replay_pid*.log
+          if-no-files-found: ignore
+          retention-days: 14
+
       - name: Upload lint and test reports
         # Reports are most useful precisely when a step above failed.
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: PilgrimsOfKatan-reports
+          name: ProLibertateGames-reports
           path: |
             app/build/reports/
           if-no-files-found: ignore
@@ -89,39 +108,74 @@ jobs:
       # branch itself, after it has built, tested and linted clean above.
       #
       # Gated on the branch alone rather than on the event, which is how
-      # release.yml gates main. A pull request is still excluded without
-      # needing to name it: a PR build runs against refs/pull/N/merge, never
-      # refs/heads/dev, so a fork still cannot ship anything.
+      # release.yml has always gated main. A pull request is still excluded
+      # without needing to name it: a PR build runs against refs/pull/N/merge,
+      # never refs/heads/dev, so a fork still cannot ship anything.
       - name: Stage dev APK
         id: stage
         if: github.ref == 'refs/heads/dev'
         run: |
           set -euo pipefail
-          # The series and the offset come from gradle.properties, which is
-          # the same file the build read when it stamped the APK — so the tag
-          # and what is inside it cannot name different versions. The number
-          # is run number + offset, exactly the arithmetic build.gradle.kts
-          # did for versionCode.
+          # The series comes from gradle.properties, which is the same file the
+          # build read when it stamped the APK — so the tag and what is inside
+          # it cannot name different versions.
           series="$(sed -n 's/^plgVersionSeries=//p' gradle.properties)"
-          offset="$(sed -n 's/^plgVersionRunOffset=//p' gradle.properties)"
           test -n "$series"
+          offset="$(sed -n 's/^plgVersionRunOffset=//p' gradle.properties)"
           test -n "$offset"
-          stamp="$(( ${{ github.run_number }} + offset ))"
-          version="v${series}.${stamp}-dev"
+          # Same arithmetic as build.gradle.kts, so the tag names the APK's own number.
+          version="v${series}.$(( ${{ github.run_number }} + offset ))-dev"
           src="app/build/outputs/apk/debug/app-debug.apk"
-          dest="PilgrimsOfKatan-${version}.apk"
+          dest="ProLibertateGames-${version}.apk"
           cp "$src" "$dest"
           echo "version=$version" >> "$GITHUB_OUTPUT"
           echo "apk=$dest" >> "$GITHUB_OUTPUT"
 
-      - name: Publish dev channel prerelease
+      - name: Upload staged dev APK for the Pages deploy
         if: github.ref == 'refs/heads/dev'
+        uses: actions/upload-artifact@v4
+        with:
+          name: plg-dev-staged
+          path: ${{ steps.stage.outputs.apk }}
+          if-no-files-found: error
+          retention-days: 1
+
+  # Publishes the build to https://plg.wallacenet.ca (Cloudflare Pages), which is
+  # the only release channel: the in-app updater reads latest.json from there.
+  #
+  # Both workflows deploy into one Pages site, and a deploy replaces the whole
+  # site, so they share a concurrency group and never run at the same time.
+  deploy-pages:
+    name: Deploy to Cloudflare Pages
+    needs: build
+    if: github.ref == 'refs/heads/dev'
+    runs-on: ubuntu-latest
+    concurrency:
+      group: plg-pages-deploy
+      cancel-in-progress: false
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download staged APK
+        uses: actions/download-artifact@v4
+        with:
+          name: plg-dev-staged
+          path: staged
+
+      - name: Assemble site
         env:
-          # The job's built-in token: contents: write is declared above.
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-          RELEASE_TAG: ${{ steps.stage.outputs.version }}
-          RELEASE_APK: ${{ steps.stage.outputs.apk }}
-          RELEASE_KIND: prerelease
-          RELEASE_TARGET: ${{ github.sha }}
-        # One script, also runnable by hand — see docs/CI.md.
-        run: ./scripts/publish-release.sh
+          PLG_SKIP_OTHER: ${{ inputs.first_deploy && '1' || '' }}
+        run: .github/scripts/stage-pages-site.sh dev "${{ needs.build.outputs.version }}" "staged/ProLibertateGames-${{ needs.build.outputs.version }}.apk"
+
+      - name: Deploy
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+        run: |
+          set -euo pipefail
+          # Creates the project on first run; fails harmlessly if it exists.
+          npx --yes wrangler@3 pages project create plg --production-branch main || true
+          # --branch main makes this the production deployment, which is what
+          # plg.wallacenet.ca serves, whichever branch the workflow ran on.
+          npx --yes wrangler@3 pages deploy pages-out --project-name plg --branch main --commit-dirty=true

.github/workflows/release.yml

@@ -1,17 +1,18 @@
 name: Build and Release APK
 
-# Production-channel build. Runs on a push to main, or by hand
-# (workflow_dispatch), and publishes to this Gitea instance's releases — which
-# is the channel the in-app updater reads. See docs/CI.md.
-#
-# Publishing goes through Gitea's REST API rather than the `gh` CLI, which a
-# runner image need not carry.
+# Build an APK and publish it as a GitHub Release whenever commits land on main
+# (for example when a pull request is merged). Can also be run manually.
 on:
   push:
     branches: [ main ]
   workflow_dispatch:
+    inputs:
+      first_deploy:
+        description: "First Cloudflare deploy: skip carrying over the other channel (the site does not exist yet)"
+        type: boolean
+        default: false
 
-# Needed by the job token to create the release and attach the APK.
+# Allow the built-in token to create releases and upload the APK.
 permissions:
   contents: write
 
@@ -23,13 +24,16 @@ concurrency:
 jobs:
   build:
     name: Build APK and publish release
-    # workflow_dispatch can be aimed at any branch from the Actions UI. The
-    # production stamp belongs to main alone — anything else is a no-op rather
-    # than shipping unreviewed code to everybody.
+    # workflow_dispatch can be aimed at any branch from the Actions UI. Releases
+    # are what the in-app updater installs, so only main may produce one —
+    # anything else is a no-op rather than shipping unreviewed code to everyone.
     if: github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.stage.outputs.version }}
     env:
-      # Stamps the APK as a production-channel build.
+      # Stamps the APK as a production-channel build, versioned with the run
+      # number that matches the tag published below.
       PLG_CHANNEL: production
     steps:
       - name: Checkout
@@ -45,44 +49,76 @@ jobs:
       - name: Set up Android SDK
         uses: android-actions/setup-android@v4
 
-      - name: Build production APK
+      - name: Build debug APK
         run: ./gradlew assembleDebug --no-daemon --stacktrace
 
-      - name: Stage APK
+      - name: Stage APK for release
         id: stage
         run: |
           set -euo pipefail
-          # The series and the offset come from gradle.properties, which is
-          # the same file the build read when it stamped the APK — so the tag
-          # and what is inside it cannot name different versions. The number
-          # is run number + offset, exactly the arithmetic build.gradle.kts
-          # did for versionCode.
+          # The series comes from gradle.properties, which is the same file the
+          # build read when it stamped the APK — so the tag and what is inside
+          # it cannot name different versions.
           series="$(sed -n 's/^plgVersionSeries=//p' gradle.properties)"
-          offset="$(sed -n 's/^plgVersionRunOffset=//p' gradle.properties)"
           test -n "$series"
+          offset="$(sed -n 's/^plgVersionRunOffset=//p' gradle.properties)"
           test -n "$offset"
-          stamp="$(( ${{ github.run_number }} + offset ))"
-          version="v${series}.${stamp}"
+          # Same arithmetic as build.gradle.kts, so the tag names the APK's own number.
+          version="v${series}.$(( ${{ github.run_number }} + offset ))"
           src="app/build/outputs/apk/debug/app-debug.apk"
-          dest="PilgrimsOfKatan-${version}.apk"
+          dest="ProLibertateGames-${version}.apk"
           cp "$src" "$dest"
+          # The same build again under a name that never changes. GitHub's
+          # /releases/latest/download/<name> redirect needs a constant file
+          # name, so this second copy is what makes a permanent download link
+          # possible — the versioned copy stays as the traceable one.
+          cp "$src" "ProLibertateGames.apk"
           echo "version=$version" >> "$GITHUB_OUTPUT"
           echo "apk=$dest" >> "$GITHUB_OUTPUT"
 
       - name: Upload APK as workflow artifact
         uses: actions/upload-artifact@v4
         with:
-          name: PilgrimsOfKatan-apk
+          name: plg-prod-staged
           path: ${{ steps.stage.outputs.apk }}
           if-no-files-found: error
 
-      - name: Publish production release
+  # Publishes the build to https://plg.wallacenet.ca (Cloudflare Pages), which is
+  # the only release channel: the in-app updater reads latest.json from there.
+  #
+  # Both workflows deploy into one Pages site, and a deploy replaces the whole
+  # site, so they share a concurrency group and never run at the same time.
+  deploy-pages:
+    name: Deploy to Cloudflare Pages
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    concurrency:
+      group: plg-pages-deploy
+      cancel-in-progress: false
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download staged APK
+        uses: actions/download-artifact@v4
+        with:
+          name: plg-prod-staged
+          path: staged
+
+      - name: Assemble site
         env:
-          # The job's built-in token: contents: write is declared above.
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-          RELEASE_TAG: ${{ steps.stage.outputs.version }}
-          RELEASE_APK: ${{ steps.stage.outputs.apk }}
-          RELEASE_KIND: release
-          RELEASE_TARGET: ${{ github.sha }}
-        # One script, also runnable by hand — see docs/CI.md.
-        run: ./scripts/publish-release.sh
+          PLG_SKIP_OTHER: ${{ inputs.first_deploy && '1' || '' }}
+        run: .github/scripts/stage-pages-site.sh prod "${{ needs.build.outputs.version }}" "staged/ProLibertateGames-${{ needs.build.outputs.version }}.apk"
+
+      - name: Deploy
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+        run: |
+          set -euo pipefail
+          # Creates the project on first run; fails harmlessly if it exists.
+          npx --yes wrangler@3 pages project create plg --production-branch main || true
+          # --branch main makes this the production deployment, which is what
+          # plg.wallacenet.ca serves, whichever branch the workflow ran on.
+          npx --yes wrangler@3 pages deploy pages-out --project-name plg --branch main --commit-dirty=true

CLAUDE.md

@@ -1,93 +1,120 @@
-# Working on this repo (agent notes)
+> **Moved to Gitea.** CI now runs on Gitea Actions at
+> `git.wallacenet.ca/devadmin/ProLibertateGames`, publishing to Cloudflare Pages
+> (`plg.wallacenet.ca`) only. The sandbox notes below describe the earlier GitHub
+> setup (no CI run from session pushes, `workflow_dispatch` as the workaround);
+> re-verify them against Gitea before relying on them.
 
-Pilgrims of Katan — an Android collection of card and board games, playable
-against AI or over Wi-Fi (LAN). Bootstrapped from
-[adrianoftyriel/ProLibertateGames](https://github.com/adrianoftyriel/ProLibertateGames)
-(GPL-3.0, kept as the `upstream` remote) for Wallacenet. Canonical repo:
-<https://git.wallacenet.ca/devadmin/PilgrimsOfKatan>.
+# Working on this repo with Claude
 
-## Ground rules
+## Nothing a session does triggers CI. Dispatch it explicitly.
 
-- **Licences travel.** `LICENSE` is GPL-3.0 and must stay. The Uncial Antiqua
-  font ships with its OFL licence at `docs/licenses/UncialAntiqua-OFL.txt`;
-  never delete or edit either. Attribution to the upstream lives in the README.
-- **No Catan trademarks or brand assets**, and none of the upstream's Wallace
-  clan branding (it was removed in the rebrand; see README → Branding). The
-  brand is: *Pilgrims of Katan*, `ca.wallacenet.pilgrimsofkatan` (+ `.dev`),
-  slate blue / dev green, hexagon emblem.
-- **The existing catalogue is the regression safety net.** Keep every game
-  green; new games (Catan) arrive as separate tasks, not edits to old ones.
-  All 22 games are `available = true`.
-- **Docs conventions**: every game gets `docs/RULES-<id>.md` (index and gaps in
-  `docs/README.md`); build/CI/release decisions go in `docs/CI.md`. Update the
-  docs when behaviour changes — they are the check against the rules code.
+GitHub creates **no workflow run** for anything this sandbox does — pushing a
+branch, opening a pull request, or merging one. All of it goes through the same
+integration, and GitHub suppresses event-triggered runs from it. The pull
+request will say it was opened by the repo owner; that is only how the UI
+attributes it, and it does not change the suppression.
 
-## Build
+This was measured, not assumed:
 
-```sh
-export JAVA_HOME=...   # JDK 17
-export ANDROID_HOME=...  # SDK with platform 34, build-tools 34
-./gradlew assembleDebug            # dev-channel APK (default)
-PLG_CHANNEL=production ./gradlew assembleDebug   # production APK
-./gradlew testDebugUnitTest        # JVM unit tests (rules/AI/net/score)
-./gradlew lintDebug                # Android lint (CI runs it)
-```
+| Action | Result |
+| --- | --- |
+| Human pushes a Claude-authored commit (`d165e5ef`, `469c900e`) | CI runs |
+| Session pushes `dev` / `main` (`43394b8`, `742add4`) | no run |
+| Session opens a PR against `dev` (#1) | no run |
+| Session calls `workflow_dispatch` | **runs** |
 
-On the Wallacenet project workspace a ready toolchain sits at
-`../.toolchain/` (`jdk17/`, `android-sdk/`) — export `JAVA_HOME` and
-`ANDROID_HOME` to it rather than installing again. Both variants must build:
-they install side by side (different applicationId, launcher name, colour).
+`workflow_dispatch` works because it creates a run directly instead of relying
+on an event. It is the only mechanism available from a session, so every build
+has to be asked for by hand.
 
-## Channels and OTA
+## Verify before merging, without publishing
 
-One flag — `isDevBuild` in `app/build.gradle.kts` — drives applicationId,
-launcher name and brand colour together. Never set them individually.
+`ci.yml` builds, tests and lints on any ref, but its staging and publishing
+steps are gated on `github.ref == 'refs/heads/dev'`. Dispatching it on a
+**feature branch** therefore gives the full check — build, unit tests, Android
+lint — and publishes nothing.
 
-In-app OTA points at this repo's own Gitea releases
-(`/api/v1/repos/devadmin/PilgrimsOfKatan/releases…`) and is **on**:
-`BuildConfig.OTA_ENABLED` is `true`. The channel is a decision already made and
-recorded — `docs/CI.md` documents the endpoints, the build-number scheme, and
-what publishing requires. Setting the flag to `false` is the kill switch.
+So the working loop is:
 
-## CI
+1. Commit and push the feature branch.
+2. Dispatch `ci.yml` on that branch. Wait for green. This is the real review
+   gate, and it is the only verification that exists (see below).
+3. Open the PR through the API and merge it there, so the change is reviewable
+   and the merge commit is honest about what happened. Neither step builds
+   anything.
+4. Dispatch the target branch's workflow to actually build and publish:
+   `ci.yml` on `dev`, `release.yml` on `main`.
 
-`.github/workflows/` — Actions-compatible so the Gitea instance runs them.
-`ci.yml`: build + test + lint + artifact, and a dev prerelease from `dev`.
-`release.yml`: production release from `main`. Both publish through
-`scripts/publish-release.sh` (Gitea REST API), which is also runnable by hand.
+Skipping step 4 leaves a branch whose head was never built and no release.
 
-**No Actions runner is registered on the instance yet**, so the workflows are
-idle until one is — the local gradle commands above are the source of truth,
-and CI green means those plus lint. Do not treat a workflow that has never run
-as evidence.
+## Merging is a shipping action
 
-## Code map
+Both long-lived branches publish, so a merge is a release, not just an
+integration:
 
-- `game/` — rules engines and AI, **pure Kotlin, no Android types**, unit
-  tested. `Catalog.kt` is the registry (id, title, blurb, options, `available`).
-- `net/` — wire protocol, LAN transport (mDNS + TCP), lobby, host-authoritative
-  match driver; `score/` the scorekeeper sheet, also pure.
-- `ui/` — Compose screens; `ui/theme/Theme.kt` holds the brand palette
-  (`BrandField`/`BrandDeep`/`BrandAccent`) and table accents.
-- `update/` — OTA policy (`UpdatePolicy.kt`, pure and tested) and the gated
-  fetch (`Updater.kt`).
-- `settings/` — DataStore preferences.
+- **`dev`** → `ci.yml` publishes a `v<series>.N-dev` **prerelease**, offered by the
+  in-app updater to anyone on the Dev channel.
+- **`main`** → `release.yml` publishes a **production** release, which the
+  updater installs for everyone on the Production channel.
 
-Host is authoritative over the wire; clients send intents, host re-validates
-against the rules. Keep `game/` free of Android imports — the JVM tests depend
-on it.
+Confirm before shipping to `main`. Note that `release.yml` runs `assembleDebug`
+only — no tests, no lint — so a `main` release is only as verified as the `dev`
+build it replays.
 
-## Git
+## Gradle does not run in the sandbox
 
-- Branches: `main` (production), `dev` (integration). Feature branches → PR
-  into `dev`.
-- Commits by Paperclip agents end with
-  `Co-Authored-By: Paperclip <[email protected]>`.
-- Pull upstream fixes with `git pull upstream` (the GitHub source); do not
-  point `origin` anywhere but this repo's Gitea URL.
+`./gradlew` cannot resolve the Android plugin here: the proxy blocks
+`dl.google.com` with a 403. No local build, no local test run, no local lint. A
+dispatched CI run is the only way to find out whether a change compiles.
 
-## Legacy files
+## A permanent fix, if you want one
 
-`.claude/` and `.rtk/` are the upstream author's assistant tooling, harmless
-and left as inherited. This file supersedes the upstream's CLAUDE.md (which
-documented their GitHub sandbox; that history is still in git).
+The suppression is a property of the sandbox's credential, so it cannot be
+fixed from inside a session. Giving the environment a personal access token to
+push with would make pushes and PRs behave normally for everyone. Until then,
+the dispatch step above is the workaround.
+
+## Bash output is filtered before it reaches the model
+
+`.claude/settings.json` registers a `PreToolUse` hook on `Bash` that rewrites
+each command through [rtk](https://github.com/rtk-ai/rtk): `git status` runs as
+`rtk git status`, and rtk compresses the output. Write commands normally — the
+rewrite is transparent and costs nothing to invoke.
+
+Measured on this repo rather than quoted from rtk's README:
+
+| Command | Raw | Filtered | Saved |
+| --- | --- | --- | --- |
+| `git diff HEAD~3` | 521 KB | 28 KB | 95% |
+| `grep -rn "fun " app/src/main` | 117 KB | 19 KB | 84% |
+| `find . -name "*.kt"` | 7.7 KB | 1.7 KB | 79% |
+| `git log -20` | 20 KB | 5.3 KB | 74% |
+| `git diff --stat` | 4.0 KB | 4.0 KB | 1% |
+| `ls` of a single package | 50 B | 62 B | −24% |
+
+The saving is all in the large outputs, which is the point — a full diff of a
+few commits is otherwise most of a context window. Already-compact output grows
+slightly, because rtk adds a header; at those sizes it does not matter. `rtk
+gain` reports what the current session has actually saved.
+
+Two limits are worth knowing. The `Read`, `Grep` and `Glob` tools are not
+`Bash`, so they never reach the hook and are unaffected; a deliberate `rg` or
+`find` in a shell *is* filtered. And filtering never truncates a file: `cat`
+becomes `rtk read`, which was checked byte-for-byte against this repo's longest
+Kotlin source (`GameSetupScreen.kt`, 946 lines) and came back identical. Commit
+messages survive the rewrite intact, quotes and colons included. To bypass
+filtering for one command, run `rtk proxy <cmd>`.
+
+## rtk is reinstalled at the start of every session
+
+The container starts empty, so `.claude/hooks/session-start.sh` installs rtk
+before the session does anything. It pins `RTK_VERSION`, because the installer
+otherwise asks `api.github.com` for the latest tag and the proxy answers 403 for
+every repository except this one — the lookup fails and takes the install with
+it. Bump that variable by hand.
+
+The hook is written not to matter when it fails. Outside the sandbox it installs
+nothing and just prints the command to run, since dropping a binary into
+someone's `~/.local/bin` uninvited is not its business; if the download fails it
+says so and exits clean. With rtk absent the rewrite hook no-ops, and the only
+consequence is verbose output.

README.md

@@ -1,14 +1,8 @@
-# Pilgrims of Katan
+# Pro Libertate Games
 
 A collection of card and board games for Android, playable against the computer
 or against other people over Wi-Fi (LAN).
 
-Derived from [ProLibertateGames](https://github.com/adrianoftyriel/ProLibertateGames)
-by adrianoftyriel, used under the GNU GPL v3 — see [LICENSE](LICENSE). Game
-rules documentation lives under [docs/](docs/README.md); build, CI and release
-decisions live in [docs/CI.md](docs/CI.md). Catan itself arrives in later work;
-this app ships the reference catalogue unchanged as the regression safety net.
-
 ## What works today
 
 The app shell is complete and every game in the catalogue is playable end to end:
@@ -117,52 +111,55 @@ it: every rule above is a pure function and unit-tested on the JVM.
 - **Sound** on/off.
 - **Animation speed**, 0.5×–2×. One multiplier drives card movement and how long
   the computer appears to think.
-- **Updates** — check on launch, or check on demand. The channel is this
-  project's own Gitea releases ([docs/CI.md](docs/CI.md)), and **there is no
-  channel to choose**: a build updates from its own channel and no other. The
-  settings screen states which one is running rather than offering a switch.
-  `BuildConfig.OTA_ENABLED` is the kill switch, not a preference.
+- **Updates** — check on launch, or check on demand. **There is no channel to
+  choose**: a build updates from its own channel and no other. A production
+  install is offered production builds from `main`; a dev install is offered dev
+  builds from `dev`. The settings screen states which one is running rather than
+  offering a switch.
 
   The check on launch **only ever speaks when there is a build to install**. It
   runs behind the splash and waits for it to clear, and an app that is already
-  current — or a phone that cannot reach the release server — says nothing,
-  because opening the app was not a question. The button in Settings is a
-  question, so it answers every time, including "you're on the latest" and
-  whatever went wrong.
+  current — or a phone that cannot reach GitHub — says nothing, because opening
+  the app was not a question. The button in Settings is a question, so it
+  answers every time, including "you're on the latest" and whatever went wrong.
 
   Wanting both means installing both — they are separate apps and each updates
   itself, see [Both channels on one device](#both-channels-on-one-device).
 
 ## Branding
 
-Neutral, original, and deliberately *not* Catan's: no third-party marks or
-trade dress ship in this app (rebrand scope: WALA-118). The launcher icon is a
-hexagonal ring around a solid core — a game tile, not any game's logo — drawn
-as vector drawables so it stays sharp at every density and needs no PNGs. The
-app opens on the brand field fading to its deep shade, the name set in a Celtic
-uncial hand for two seconds before it fades into the menu.
+The launcher icon is a single square of the Wallace tartan set on the bias, and
+the app opens on the same cloth carrying the name in a Celtic uncial hand for two
+seconds before fading into the menu.
 
-A dev build wears the **dev green** field where production wears **slate
-blue**, and installs as *Pilgrims of Katan DEV*. That is what tells the two
-copies apart when both are on the phone; see
-[Both channels on one device](#both-channels-on-one-device). The palette lives
-in `ui/theme/Theme.kt` (`BrandField`, `BrandDeep`, `BrandAccent`) and the two
-channel colours are generated per build by `resValue` in `app/build.gradle.kts`
-— the icon vectors reference `@color/brand_field` rather than a literal, which
-is how one set of vectors serves both colourways.
+A dev build wears **Wallace Hunting** instead — the same threadcount with green
+where the clan sett has red — and installs as *Pro Libertate Games DEV*. That is
+what tells the two copies apart when both are on the phone; see
+[Both channels on one device](#both-channels-on-one-device).
+
+The tartan is drawn, not an image: `ui/theme/Tartan.kt` lays the sett down as
+warp and then as weft at half opacity, which is what produces the blended
+squares instead of a flat grid. The icon is the same construction as a vector
+drawable, so it stays sharp at every density and needs no PNGs.
 
 Two honest caveats:
 
+- **The sett is the published threadcount: `K/4 R32 K32 Y/4`.** The slashes are
+  pivots, so `WallaceSett` holds the half-sett and reflects it out to
+  `K4 R32 K32 Y4 K32 R32` — 136 threads, about half black, half red, with a
+  yellow line worth 3%. Two details define the pattern and are easy to get
+  backwards: the yellow overstripe runs down the *centre of a wide black band*,
+  and the narrow black guard sits *between two red blocks*. The icon is
+  generated from the same numbers, so the icon and the splash cannot drift.
+  Weave scale is derived from the sett rather than fixed, so changing the
+  threadcount rescales both instead of silently zooming in. The hunting
+  colourway is the same threadcount passed a different field colour, not a
+  second copy of the numbers, so it cannot fall out of step either.
 - **The typeface is bundled under a licence.** Uncial Antiqua, © 2011 Brian J.
   Bonislawsky DBA Astigmatic, Reserved Font Name "Uncial Antiqua", used under
   the SIL Open Font License 1.1. The full licence is at
   [docs/licenses/UncialAntiqua-OFL.txt](docs/licenses/UncialAntiqua-OFL.txt) and
   must stay with the font — the OFL requires it to be distributed alongside.
-- **The upstream's clan tartan is gone; its code is not.** The Wallace tartan
-  was the upstream's brand and left with the rebrand. The GPL-licensed history
-  that produced this app remains in git, and the source stays at
-  [adrianoftyriel/ProLibertateGames](https://github.com/adrianoftyriel/ProLibertateGames)
-  as the `upstream` remote.
 
 ## Screen sizes
 
@@ -186,70 +183,122 @@ smaller than a fingertip.
 
 Requires JDK 17 and the Android SDK (compileSdk 34).
 
-A local build is a dev build: it installs as
-`ca.wallacenet.pilgrimsofkatan.dev` under the name *Pilgrims of Katan DEV* on
-the dev green field, so it goes on beside a production copy rather than over it.
-Set `PLG_CHANNEL=production` to build the production package
-(`ca.wallacenet.pilgrimsofkatan`, slate blue).
+A local build is a dev build: it installs as `org.prolibertate.games.dev` under
+the name *Pro Libertate Games DEV* in the hunting sett, so it goes on beside an
+installed release rather than over it. Set `PLG_CHANNEL=production` to build the
+production package instead.
 
 ## CI
 
-Full decision record: [docs/CI.md](docs/CI.md).
-
 - `.github/workflows/ci.yml` — builds, tests and lints on `dev` and on pull
-  requests into `dev` or `main`, and publishes a dev prerelease from `dev`.
-- `.github/workflows/release.yml` — builds and publishes the production release
-  on push to `main`, or by hand (`workflow_dispatch`).
-- Both publish through [scripts/publish-release.sh](scripts/publish-release.sh)
-  against Gitea's REST API, which is also runnable by hand. **No Actions runner
-  is registered on the instance yet**, so until one is, the local build is the
-  guaranteed path (`./gradlew assembleDebug && ./gradlew testDebugUnitTest`)
-  and releases go out via the script.
+  requests into `dev` or `main`. Its APK artifact is a dev build, versioned
+  `<series>.0-dev` — the series being whatever `plgVersionSeries` says in
+  `gradle.properties`, currently **1.3**.
+- `.github/workflows/release.yml` — on push to `main`, builds the APK and
+  publishes it as a GitHub Release tagged `v<series>.<run-number>`. The in-app updater
+  reads that tag, which is why the APK's `versionCode` is the same run number.
+
+### Hosting: plg.wallacenet.ca
+
+Both channels are also deployed to one Cloudflare Pages project (`plg`), served at
+`https://plg.wallacenet.ca`:
+
+```
+/                        landing page (reads both latest.json files)
+/prod/latest.json        {tag, apkName, apkUrl, channel} — what the updater reads
+/prod/ProLibertateGames.apk, /prod/ProLibertateGames-v<series>.<n>.apk
+/dev/...                 same, for the dev channel
+```
+
+Each workflow's `deploy-pages` job runs `.github/scripts/stage-pages-site.sh`,
+which stages its own channel and re-fetches the other channel from the live site,
+because a Pages deploy replaces everything. The two share a concurrency group so
+they cannot race. Needs repo secrets `CLOUDFLARE_API_TOKEN` (Account → Cloudflare
+Pages → Edit) and `CLOUDFLARE_ACCOUNT_ID`. Pages caps files at 25 MiB.
+
+**First deploy:** the site does not exist yet, so the domain answers 403 (Cloudflare error 1014) and the carry-over fetch would abort. Dispatch the workflow once with `first_deploy` ticked, then attach `plg.wallacenet.ca` as a custom domain on the new `plg` Pages project. Later runs need no input.
+
+The in-app updater reads these `latest.json` files, and this is the only release
+channel: the workflows no longer create GitHub or Gitea releases. They run on
+Gitea Actions (`https://git.wallacenet.ca/devadmin/ProLibertateGames`); the GitHub
+repository is frozen and should stay public with its last releases, because
+installs that predate the Cloudflare updater still read them to reach it.
+
+Build numbers are `run number + plgVersionRunOffset` (1000, in `gradle.properties`),
+so moving CI hosts, which restarts run numbers, can never publish a `versionCode`
+lower than one already installed.
+
+### Installing without the app
+
+The newest production build is always at **https://plg.wallacenet.ca/prod/ProLibertateGames.apk** (dev: `/dev/ProLibertateGames.apk`). The GitHub link below is the frozen pre-migration release:
+
+**https://github.com/adrianoftyriel/ProLibertateGames/releases/latest/download/ProLibertateGames.apk**
+
+Every release carries the same APK twice — once named for its version, and once
+as plain `ProLibertateGames.apk`, because GitHub's `/releases/latest/download/`
+redirect needs a file name that stays put. The in-app updater deliberately picks
+the versioned copy, so an installed build can always be traced back to its tag.
+
+There is no equivalent link for the dev channel: `/releases/latest` skips
+prereleases by design, and that is exactly what keeps a production install from
+being handed a dev build. A dev build is reached by the in-app updater of a dev
+install — which looks at the prerelease list rather than that endpoint — or from
+the releases page.
 
 ### The version series
 
-A version is **`<series>.<build number>`**. Both values are set by hand, once,
-in `gradle.properties`:
+A version is **`<series>.<run number>`**. The series is set by hand, once, in
+`gradle.properties`:
 
 ```properties
-plgVersionSeries=1.4
-plgVersionRunOffset=1000
+plgVersionSeries=1.3
 ```
 
-Both workflows read those same properties when they name a release tag, and the
-build reads them when it stamps the APK, so the tag and what is inside it cannot
-name different versions. Changing either is a one-line change to that file and
-nothing else — but they are not equivalent:
+Both workflows read that same property when they name a release tag, and the
+build reads it when it stamps the APK, so the tag and what is inside it cannot
+name different versions. Bumping a series is a one-line change to that file and
+nothing else.
 
-- The **series** is a name for people. Bumping it changes nothing about
-  ordering.
-- The **build number** is what the machines compare: `versionCode`, the tag's
-  trailing number, and the number in `versionName`, all the same figure —
-  `CI run number + plgVersionRunOffset`. Because the offset never changes and
-  the run number only climbs, going from 1.4 to 1.5 never looks like a downgrade
-  to Android and never interrupts an OTA update.
-
-The offset exists because Gitea Actions restarts run numbers at 1 for each
-workflow: without a floor, the first release of a fresh instance would collide
-with the `versionCode 1` every unstamped local build carries, and a counter
-reset would make Android refuse the next build outright. Full reasoning in
-[docs/CI.md](docs/CI.md).
+The number after it is the CI run number and keeps climbing on its own, which is
+what makes a series bump safe: `versionCode` is the run number *alone*, so
+going from 1.0 to 1.1 never looks like a downgrade to Android and never
+interrupts an OTA update. The series is a name for people; the run number is
+what the machines compare.
 
 ### Update channels
 
-`ci.yml` stamps builds of `dev` as dev-channel, `release.yml` stamps `main` as
-production, so an APK's identity is decided where it is built. Publishing goes
-to this project's Gitea releases, and the rules it keeps:
+Both pipelines publish, to two separate channels:
 
-- production comes only from `main` (`release.yml` refuses any other branch);
-- dev prereleases are marked so the "latest release" endpoint can never hand one
-  to a production install;
-- pull requests build and check but never publish.
+| Channel | Published by | Tag | Marked |
+| --- | --- | --- | --- |
+| Production | `release.yml`, push to `main` | `v<series>.<n>` | release |
+| Dev | `ci.yml`, any build of `dev` | `v<series>.<n>-dev` | prerelease |
+
+Dev builds are published as **prereleases** deliberately: GitHub's "latest
+release" endpoint skips prereleases, so a production-channel install can never
+be handed a dev build even by accident. Pull requests build and check but never
+publish, so a PR from a fork cannot ship anything.
+
+**Both pipelines gate publishing on the branch rather than on what triggered
+the build**, so a manual run from the Actions tab publishes exactly as a push
+does — useful when a push cannot fire the workflow itself, which is the case
+for anything pushed by an automation token. The safety property is unchanged,
+because publishing still happens only after that same job has built, tested and
+linted clean. A pull request is still excluded without having to be named: a PR
+build runs against `refs/pull/<n>/merge`, never `refs/heads/dev`.
+
+In `ci.yml` the `PLG_CHANNEL` stamp is gated on the same condition as the
+publish steps, and the two have to stay in step. Stamping a build that then
+ships, or shipping one that was left unstamped, both end with an APK claiming
+`versionCode` 1 — which the updater can never see as an upgrade over anything.
+
+`release.yml` refuses to run off any branch but `main`, so a manual dispatch
+aimed elsewhere does nothing rather than shipping unreviewed code.
 
 **The two channels have independent version sequences** — a build's `versionCode`
-is the build number of the workflow that produced it (run number + offset), and
-the two workflows count separately, so the numbers say nothing across the
-divide.
+is the run number of the workflow that produced it, and the two workflows count
+separately. Dev is on 69 while production is on 40, so the numbers say nothing
+across the divide.
 
 That is why **an install only ever updates within its own channel**, and why
 there is no setting for it. The app reads the `-dev` suffix in its own
@@ -261,18 +310,18 @@ unit-tested on the JVM like the rules engines are.
 
 ### Both channels on one device
 
-A dev build installs under its own `applicationId`,
-`ca.wallacenet.pilgrimsofkatan.dev`, so it is a separate app as far as Android
-is concerned and can sit beside the production copy rather than replacing it. Each channel still updates itself
+A dev build installs under its own `applicationId`, `org.prolibertate.games.dev`,
+so it is a separate app as far as Android is concerned and can sit beside the
+production copy rather than replacing it. Each channel still updates itself
 normally, because an update within a channel keeps the same package.
 
 Three things move together, all off `isDevBuild` in `app/build.gradle.kts`:
 
 | | Production | Dev |
 | --- | --- | --- |
-| `applicationId` | `ca.wallacenet.pilgrimsofkatan` | `ca.wallacenet.pilgrimsofkatan.dev` |
-| Launcher name | Pilgrims of Katan | Pilgrims of Katan DEV |
-| Brand field | slate blue | deep green |
+| `applicationId` | `org.prolibertate.games` | `org.prolibertate.games.dev` |
+| Launcher name | Pro Libertate Games | Pro Libertate Games DEV |
+| Sett | Wallace (red) | Wallace Hunting (green) |
 
 Anything that is not an explicit `PLG_CHANNEL=production` build is a dev build,
 so a local `assembleDebug` is a dev build too and installs alongside a release
@@ -282,11 +331,11 @@ They have to move together. A dev package wearing the production name and
 colours is precisely the mix-up that having both installed is meant to prevent,
 which is why one flag drives all three rather than each being set by hand. The
 name and the colours reach the resources through `resValue`, so `app_name`,
-`brand_field` and `splash_background` are generated by the build and are
-deliberately *not* in `res/values/` — the icon vectors reference
-`@color/brand_field` rather than a literal, which is how one set of vectors
-serves both colourways. `BuildConfig.DEV_BUILD` carries the same flag into
-Kotlin, where `BrandField` picks the matching Compose colour for the splash.
+`tartan_field`, `splash_background` and `ic_launcher_background` are generated
+by the build and are deliberately *not* in `res/values/` — the icon vectors
+reference `@color/tartan_field` rather than a literal, which is how one set of
+vectors serves both colourways. `BuildConfig.DEV_BUILD` carries the same flag
+into Kotlin, where `AppSett` picks the matching Compose sett for the splash.
 
 Because they are separate apps, having both is a matter of installing both, and
 each then updates itself down its own line. Nothing in the app moves a phone
@@ -300,7 +349,7 @@ for a signature mismatch.
 ## Rules
 
 The exact rules implemented, and the options that vary them, are documented per
-game (index: [docs/README.md](docs/README.md)):
+game:
 
 - [Euchre](docs/RULES-euchre.md)
 - [Sequence](docs/RULES-sequence.md) — **note the caveat about the board layout**
@@ -323,6 +372,8 @@ game (index: [docs/README.md](docs/README.md)):
 - [Ta Yü](docs/RULES-tayu.md) — **note the caveats about the reconstruction**:
   the game is out of print and the rulebook could not be obtained, so the
   document says which parts are attested and which were derived
+- [Katan](docs/RULES-catan.md) — the island game (catalogue id `catan`); the
+  rules engine and AI are in place, the screen lands with its own task
 
 ## Layout
 
@@ -345,11 +396,11 @@ game/          rules engines and AI — pure Kotlin, no Android, unit-tested
   mastermind/  Mastermind codes, scoring, and a code breaker
   pirates/     Pirates and Bulgars — the cross board, the hunt, search
   tayu/        Ta Yü tile geometry, river rules, scoring, AI
+  catan/       Katan island geometry, production, trade, dev cards, heuristic AI
 net/           wire protocol, LAN transport, lobby, match driver
 score/         scorekeeper sheet — pure Kotlin, unit-tested — and its store
 settings/      DataStore-backed preferences
-update/        OTA updater against this repo's Gitea releases, and the
-              channel rule — pure, tested
+update/        Cloudflare Pages OTA updater, and the channel rule — pure, tested
 ui/            Compose screens
 ```
 

app/build.gradle.kts

@@ -16,18 +16,10 @@ val buildChannel = System.getenv("PLG_CHANNEL").orEmpty()
 val runNumber = (System.getenv("GITHUB_RUN_NUMBER") ?: "").toIntOrNull() ?: 0
 val stampVersion = buildChannel.isNotEmpty() && runNumber > 0
 
-// The fixed floor every stamped build number is measured from, in
-// gradle.properties. Gitea Actions restarts its run numbers at 1 for each
-// workflow, so an unstamped build (versionCode 1) and the first release of a
-// fresh instance would otherwise collide — and once a phone has installed
-// versionCode N, Android refuses anything smaller as a downgrade. Adding a
-// permanent offset is what makes "the counter never resets" true by
-// construction: it is read from one place, it never changes, and the tag,
-// versionName and versionCode all get the same number (see docs/CI.md).
+// See plgVersionRunOffset in gradle.properties: the stamped build number is the
+// CI run number plus a permanent floor, so a counter that restarts on a new CI
+// host can never produce a lower versionCode than one already installed.
 val runOffset = (project.findProperty("plgVersionRunOffset") as String?)?.toIntOrNull() ?: 0
-
-// The stamped build number: what the release tag, the versionName and the
-// versionCode are all named after.
 val buildNumber = runNumber + runOffset
 
 // The version series, from gradle.properties. Both workflows read the same
@@ -40,36 +32,31 @@ val versionSeries = (project.findProperty("plgVersionSeries") as String?) ?: "1.
 //
 // This one flag drives everything that makes a dev build a separate app rather
 // than a replacement for the production one — its own applicationId, its own
-// launcher name, and its own brand colour. They have to move together: a dev
-// package wearing the production name and colours is exactly the confusion
-// having both installed is meant to avoid.
+// launcher name, and the hunting sett in place of the clan sett. They have to
+// move together: a dev package wearing the production name and colours is
+// exactly the confusion having both installed is meant to avoid.
 val isDevBuild = buildChannel != "production"
 
 android {
-    // Deliberately left at the upstream source package: R and BuildConfig stay
-    // in org.prolibertate.games for both channels, so no source file has to
-    // care which applicationId it ended up installed as. The *installed*
-    // identity is the applicationId below — that is what the rebrand changes
-    // (WALA-118), not the JVM package names.
     namespace = "org.prolibertate.games"
     compileSdk = 34
 
     defaultConfig {
         // A dev build installs under its own package, so a dev copy and a
         // production copy can sit side by side on one device instead of one
-        // replacing the other.
-        applicationId = if (isDevBuild) "ca.wallacenet.pilgrimsofkatan.dev" else "ca.wallacenet.pilgrimsofkatan"
+        // replacing the other. The namespace above is deliberately left alone:
+        // R and BuildConfig stay in org.prolibertate.games for both, so no
+        // source has to care which package it ended up installed as.
+        applicationId = if (isDevBuild) "org.prolibertate.games.dev" else "org.prolibertate.games"
         minSdk = 24
         targetSdk = 34
         // The -dev suffix in versionName is what the installed app reads to
         // know its own channel, so it must survive into the shipped APK. It
         // tracks isDevBuild rather than the stamp alone, so an unstamped local
         // build cannot end up claiming a channel its applicationId contradicts.
-        // versionCode is the stamped build number and nothing else, so it keeps
+        // versionCode stays the run number and nothing else, so it keeps
         // climbing across a change of series: bumping 1.0 to 1.1 must not make
-        // an update look like a downgrade to Android. An unstamped build is 1,
-        // below every release, which is the honest answer for a build nobody
-        // stamped.
+        // an update look like a downgrade to Android.
         versionCode = if (stampVersion) buildNumber else 1
         versionName = when {
             stampVersion && buildChannel == "production" -> "$versionSeries.$buildNumber"
@@ -83,27 +70,23 @@ android {
         resValue(
             "string",
             "app_name",
-            if (isDevBuild) "Pilgrims of Katan DEV" else "Pilgrims of Katan",
+            if (isDevBuild) "Pro Libertate Games DEV" else "Pro Libertate Games",
         )
 
-        // The one colour that separates the two installs: slate blue on
-        // production, deep green on dev. The launcher icon and the splash are
-        // both built from it, so the drawer shows at a glance which of the two
-        // copies is which — the two have to stay in step or the icon and the
-        // splash it opens on would be different brands.
-        resValue("color", "brand_field", if (isDevBuild) "#2A6B54" else "#2B4A78")
-        // A darker shade of the same hue, held behind the window for the
-        // instant before the splash draws, so a launch never flashes the wrong
-        // colour.
-        resValue("color", "splash_background", if (isDevBuild) "#153B2F" else "#182A44")
+        // The one colour that separates the two setts: Wallace red for
+        // production, Wallace Hunting green for dev. The icon vectors reference
+        // this rather than a literal, and Tartan.kt picks the matching Compose
+        // colour off DEV_BUILD below — the two have to stay in step or the
+        // launcher icon and the splash it opens on would be different cloth.
+        resValue("color", "tartan_field", if (isDevBuild) "#1E7A3C" else "#E01B24")
+        // Shades of the same field, so a launch does not flash the wrong colour
+        // before the tartan is drawn: splash_background is held behind the
+        // window for that instant, ic_launcher_background is the icon's flat
+        // fallback.
+        resValue("color", "splash_background", if (isDevBuild) "#0D2E17" else "#4A0B10")
+        resValue("color", "ic_launcher_background", if (isDevBuild) "#145C2D" else "#B3121B")
 
         buildConfigField("boolean", "DEV_BUILD", isDevBuild.toString())
-
-        // In-app OTA updates, pointed at this project's own Gitea releases
-        // (docs/CI.md). True in this build — the channel exists. Flipping it
-        // false is the kill switch: every check then reports that and fetches
-        // nothing, with the machinery and its tests still compiled.
-        buildConfigField("boolean", "OTA_ENABLED", "true")
     }
 
     signingConfigs {
@@ -131,7 +114,7 @@ android {
 
     buildFeatures {
         compose = true
-        // For DEV_BUILD, which is how the Compose splash picks its brand colour.
+        // For DEV_BUILD, which is how the Compose tartan picks its sett.
         buildConfig = true
     }
 

app/src/main/AndroidManifest.xml

@@ -1,9 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
-    <!-- LAN play over TCP sockets, plus hand-a-down permission for in-app
-         installs — the OTA updater installs releases published on this repo's
-         Gitea; see docs/CI.md. -->
+    <!-- OTA updates from plg.wallacenet.ca, plus LAN play over TCP sockets. -->
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <!-- Network Service Discovery needs multicast to see hosts on the LAN. -->
@@ -25,7 +23,7 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.PilgrimsOfKatan">
+        android:theme="@style/Theme.ProLibertateGames">
 
         <!-- No fixed orientation: the UI adapts to portrait, landscape and
              tablet widths. configChanges keeps Compose state across rotation

app/src/main/java/org/prolibertate/games/MainActivity.kt

@@ -12,7 +12,7 @@ import org.prolibertate.games.score.ScorekeeperRepository
 import org.prolibertate.games.settings.SettingsRepository
 import org.prolibertate.games.ui.AppEnv
 import org.prolibertate.games.ui.AppRoot
-import org.prolibertate.games.ui.theme.PilgrimsTheme
+import org.prolibertate.games.ui.theme.ProLibertateTheme
 import org.prolibertate.games.update.Updater
 import java.util.UUID
 
@@ -43,7 +43,7 @@ class MainActivity : ComponentActivity() {
         )
 
         setContent {
-            PilgrimsTheme {
+            ProLibertateTheme {
                 AppRoot(env)
             }
         }

app/src/main/java/org/prolibertate/games/game/Catalog.kt

@@ -42,7 +42,20 @@ data class GameDescriptor(
     val teamBased: Boolean,
     val blurb: String,
     val available: Boolean,
+    /**
+     * Playable on a dev build while still hidden from production.
+     *
+     * [available] is the release gate: it is what a production build lists and
+     * lets people open. A game that has an engine and a screen but has not yet
+     * been verified on real devices sets this instead, so it can be played and
+     * tested from the dev channel without being offered to everyone. Flip
+     * [available] on (and this off) once it has been verified.
+     */
+    val devPreview: Boolean = false,
 ) {
+    /** Whether the menu should let this game be opened in the given kind of build. */
+    fun playableIn(devBuild: Boolean): Boolean = available || (devBuild && devPreview)
+
     /**
      * The one menu this game is listed under.
      *
@@ -94,6 +107,13 @@ object GameCatalog {
     const val MORRIS = "morris"
     const val PIRATES = "pirates"
 
+    /**
+     * The island game the collection is named for. Listed under Board Games
+     * and marked *Coming soon*; the engine and its screen land with the game
+     * task, and `available` flips on once two-device play is verified.
+     */
+    const val CATAN = "catan"
+
     val all: List<GameDescriptor> = listOf(
         GameDescriptor(
             id = EUCHRE,
@@ -333,6 +353,21 @@ object GameCatalog {
                 "because your score multiplies them.",
             available = true,
         ),
+        GameDescriptor(
+            id = CATAN,
+            title = "Katan",
+            menus = setOf(GameMenu.BOARD),
+            minPlayers = 3,
+            maxPlayers = 4,
+            teamBased = false,
+            blurb = "Trade, build, and settle the island.",
+            // Engine and screen exist but have not been verified on two real
+            // devices yet. Dev builds can open it as a *Preview*; a production
+            // build does not list it. Flip `available` on, and `devPreview`
+            // off, once two-device play has been verified.
+            available = false,
+            devPreview = true,
+        ),
     )
 
     fun byId(id: String): GameDescriptor? = all.firstOrNull { it.id == id }

app/src/main/java/org/prolibertate/games/game/catan/CatanAi.kt

@@ -0,0 +1,336 @@
+package org.prolibertate.games.game.catan
+
+import org.prolibertate.games.game.engine.GameAi
+
+/**
+ * A heuristic Catan opponent.
+ *
+ * It plays a legal, mildly strategic game: it settles on the best-producing
+ * intersections it can reach, raises cities, chases Largest Army with its
+ * knights, spends its progress cards when they complete something, trades
+ * its surplus to the bank or the table to close a one-card gap, and robs
+ * whoever is winning.
+ *
+ * Honesty is a design constraint, not an accident: this runs on the host,
+ * where the authoritative state is fully visible. It reads only public
+ * information — terrain, numbers, buildings, roads, resource counts,
+ * dev-card counts, knights played — plus its own hand, and never looks
+ * into the deck, another seat's development cards, or the seed beyond the
+ * roll the rules derive from it.
+ */
+class CatanAi : GameAi<CatanState, CatanMove> {
+
+    override fun chooseMove(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
+        require(legal.isNotEmpty() || state.phase == CatanPhase.PLAYING) {
+            "No legal move for seat $seat"
+        }
+        return when (state.phase) {
+            CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND ->
+                chooseSetup(state, seat, legal.filterIsInstance<SetupPlace>())
+
+            CatanPhase.AWAIT_ROLL -> legal.first { it is RollDice }
+
+            CatanPhase.DISCARDING -> chooseDiscard(state, seat, legal.filterIsInstance<Discard>())
+
+            CatanPhase.ROBBER -> chooseRobber(state, seat, legal.filterIsInstance<MoveRobber>())
+
+            CatanPhase.FREE_ROADS -> chooseFreeRoad(state, seat, legal)
+
+            CatanPhase.TRADE_PENDING -> chooseResponse(state, seat, legal)
+
+            CatanPhase.TRADE_COUNTERS -> chooseCounter(state, legal)
+
+            CatanPhase.PLAYING -> choosePlaying(state, seat, legal)
+
+            CatanPhase.GAME_OVER -> legal.firstOrNull()
+                ?: error("The game is over; nobody chooses a move")
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Setup
+    // -----------------------------------------------------------------------
+
+    private fun chooseSetup(state: CatanState, seat: Int, places: List<SetupPlace>): SetupPlace {
+        require(places.isNotEmpty()) { "No legal settlement placement" }
+        return places.maxByOrNull { place ->
+            spotValue(state, place.vertex) +
+                0.25 * placeDirection(state, place)
+        } ?: places.first()
+    }
+
+    /**
+     * Where the setup road points: the best settlement spot two edges out
+     * through the far end of the road. The vertex next to the new
+     * settlement can never hold one (the distance rule), so what a road is
+     * worth is what it reaches past it.
+     */
+    private fun placeDirection(state: CatanState, place: SetupPlace): Double {
+        val far = CatanBoard.otherEnd(place.edge, place.vertex)
+        return CatanBoard.VERTEX_NEIGHBORS[far]
+            .filter { it != place.vertex && it !in CatanBoard.VERTEX_NEIGHBORS[place.vertex] }
+            .maxOfOrNull { spotValue(state, it) }
+            ?: 0.0
+    }
+
+    // -----------------------------------------------------------------------
+    // Dice, discards and the robber
+    // -----------------------------------------------------------------------
+
+    private fun chooseDiscard(state: CatanState, seat: Int, discards: List<Discard>): Discard {
+        require(discards.isNotEmpty()) { "No legal discard" }
+        // Throw away what it wants least; grain and ore are the city, wool
+        // is mostly a dev-card tax.
+        return discards.minByOrNull { discard ->
+            discard.cards.sumOf { want(it) }
+        } ?: discards.first()
+    }
+
+    private fun chooseRobber(state: CatanState, seat: Int, moves: List<MoveRobber>): MoveRobber {
+        require(moves.isNotEmpty()) { "No legal robber move" }
+        val points = CatanRules.publicVictoryPoints(state)
+        return moves.maxByOrNull { move ->
+            val hex = CatanBoard.hexIndex.getValue(move.hex)
+            var score = 0.0
+            for (v in CatanBoard.HEX_CORNERS[hex]) {
+                val building = state.buildings[v] ?: continue
+                if (building.owner == seat) continue
+                val worth = if (building.type == BuildingType.CITY) 2 else 1
+                score += worth * CatanBoard.numberOdds(state.numbers[hex]) / 36.0
+            }
+            if (move.victim != null) {
+                score += 0.15 * state.resourceCount(move.victim) +
+                    0.3 * points[move.victim]
+            }
+            score
+        } ?: moves.first()
+    }
+
+    // -----------------------------------------------------------------------
+    // The main phase
+    // -----------------------------------------------------------------------
+
+    private fun choosePlaying(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
+        // A city doubles the best production the seat already owns.
+        legal.filterIsInstance<BuildCity>().maxByOrNull {
+            spotValue(state, it.vertex)
+        }?.let { return it }
+
+        legal.filterIsInstance<BuildSettlement>().maxByOrNull {
+            spotValue(state, it.vertex)
+        }?.let { return it }
+
+        // A knight is worth playing whenever one is playable: it blocks an
+        // opponent's best hex and marches toward Largest Army.
+        legal.filterIsInstance<PlayKnight>().firstOrNull()?.let { return it }
+
+        yearOfPlenty(state, legal)?.let { return it }
+
+        monopoly(state, legal)?.let { return it }
+
+        // Road Building is worth two free segments whenever there is
+        // somewhere to put them.
+        if (legal.filterIsInstance<PlayRoadBuilding>().isNotEmpty() &&
+            legal.filterIsInstance<BuildRoad>().size >= 2
+        ) {
+            return legal.filterIsInstance<PlayRoadBuilding>().first()
+        }
+
+        legal.filterIsInstance<BuyDevCard>().firstOrNull()?.let { return it }
+
+        // A paid road only when it reaches toward a spot worth settling.
+        legal.filterIsInstance<BuildRoad>()
+            .filter { roadValue(state, it) > 0.1 }
+            .maxByOrNull { roadValue(state, it) }
+            ?.let { return it }
+
+        // A bank trade only when it completes a build this turn; trading
+        // four for one on spec is how hands evaporate.
+        legal.filterIsInstance<MaritimeTrade>()
+            .filter { completesBuild(state, seat, it) }
+            .maxByOrNull { CatanRules.bestPortRatio(state, seat, it.give) * -1.0 }
+            ?.let { return it }
+
+        offer(state, seat)?.let { return it }
+
+        return legal.lastOrNull { it is EndTurn } ?: legal.first()
+    }
+
+    /** Year of Plenty: two of whatever the nearest build is shortest of. */
+    private fun yearOfPlenty(state: CatanState, legal: List<CatanMove>): PlayYearOfPlenty? {
+        val takes = legal.filterIsInstance<PlayYearOfPlenty>()
+        if (takes.isEmpty()) return null
+        val shortage = shortage(state) ?: return null
+        return takes.maxByOrNull { take ->
+            take.take.count { it == shortage } * 2 + take.take.size
+        }
+    }
+
+    /** Monopoly: declare the resource everyone else is hoarding, of the ones wanted. */
+    private fun monopoly(state: CatanState, legal: List<CatanMove>): PlayMonopoly? {
+        val plays = legal.filterIsInstance<PlayMonopoly>()
+        if (plays.isEmpty()) return null
+        val best = plays.maxByOrNull {
+            19 - CatanRules.bankSupply(state, it.resource) + want(it.resource)
+        } ?: return null
+        // Only worth the card when the table is actually holding a pile.
+        return if (19 - CatanRules.bankSupply(state, best.resource) >= 10) best else null
+    }
+
+    /** What the seat is shortest of for its next city, else its next settlement. */
+    private fun shortage(state: CatanState): Resource? {
+        val seat = state.turn
+        val targets = listOf(CatanRules.CITY_COST, CatanRules.SETTLEMENT_COST)
+        for (cost in targets) {
+            val missing = cost.entries.filter { (res, need) ->
+                (state.resources[seat][res] ?: 0) < need
+            }
+            if (missing.isNotEmpty()) {
+                return missing.maxByOrNull { (res, need) -> need - (state.resources[seat][res] ?: 0) }?.key
+            }
+        }
+        return null
+    }
+
+    private fun completesBuild(state: CatanState, seat: Int, move: MaritimeTrade): Boolean {
+        val hand = state.resources[seat].toMutableMap()
+        val ratio = CatanRules.bestPortRatio(state, seat, move.give)
+        hand[move.give] = (hand[move.give] ?: 0) - ratio
+        hand[move.get] = (hand[move.get] ?: 0) + 1
+        return covers(hand, CatanRules.CITY_COST) || covers(hand, CatanRules.SETTLEMENT_COST)
+    }
+
+    private fun covers(hand: Map<Resource, Int>, cost: Map<Resource, Int>): Boolean =
+        cost.all { (res, need) -> (hand[res] ?: 0) >= need }
+
+    /**
+     * A domestic offer for exactly the card that closes a build, paid for
+     * with two of the surplus — offered to whoever visibly holds the most
+     * of what is missing. Constructed rather than enumerated (see
+     * [OfferTrade]), so it is checked against the rules before it is spoken.
+     *
+     * At most one offer a turn: a declined offer changes nothing, so
+     * re-offering it would only bounce between the same two seats forever.
+     */
+    private fun offer(state: CatanState, seat: Int): OfferTrade? {
+        if (offeredThisTurn(state, seat)) return null
+        val seatHand = state.resources[seat]
+        val builds = listOf(CatanRules.CITY_COST, CatanRules.SETTLEMENT_COST)
+        for (cost in builds) {
+            val missing = cost.entries.filter { (res, need) -> (seatHand[res] ?: 0) < need }
+            if (missing.size != 1) continue
+            val need = missing.first().key
+            val surplus = Resource.entries
+                .filter { it != need }
+                .filter { (seatHand[it] ?: 0) > (cost[it] ?: 0) }
+                .sortedByDescending { seatHand[it] ?: 0 }
+            if (surplus.isEmpty()) continue
+            val target = (0 until state.playerCount)
+                .filter { it != seat }
+                .filter { (state.resources[it][need] ?: 0) > 0 }
+                .maxByOrNull { state.resources[it][need] ?: 0 }
+                ?: continue
+            val give = listOf(surplus.first(), surplus.first())
+            val trade = OfferTrade(to = target, give = give, get = listOf(need))
+            if (CatanRules.isLegalMove(state, seat, trade)) return trade
+        }
+        return null
+    }
+
+    /**
+     * Whether [seat] has already put an offer on the table this turn, read
+     * from the public log: the lines after this seat's last roll are this
+     * turn's, and an offer can only be spoken on the offerer's own turn.
+     */
+    private fun offeredThisTurn(state: CatanState, seat: Int): Boolean {
+        val sinceRoll = state.log
+            .drop(state.log.indexOfLast { it.startsWith("Seat $seat rolls") } + 1)
+        return sinceRoll.any { it.startsWith("Seat $seat offers") }
+    }
+
+    // -----------------------------------------------------------------------
+    // Free roads and trade responses
+    // -----------------------------------------------------------------------
+
+    private fun chooseFreeRoad(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
+        val roads = legal.filterIsInstance<BuildRoad>()
+            .filter { roadValue(state, it) > 0.05 }
+            .maxByOrNull { roadValue(state, it) }
+        return roads ?: legal.firstOrNull { it is EndFreeRoads }
+            ?: legal.filterIsInstance<BuildRoad>().firstOrNull()
+            ?: legal.first()
+    }
+
+    private fun chooseResponse(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
+        val accept = legal.filterIsInstance<AcceptTrade>().firstOrNull()
+        val offer = state.pendingTrade
+        if (accept == null || offer == null) return legal.first { it is DeclineTrade }
+        // Accept when what arrives (the offerer's give) is worth more than what
+        // leaves (the offerer's get): a mild table, not a shark.
+        val incoming = offer.give.sumOf { want(it) }
+        val outgoing = offer.get.sumOf { want(it) }
+        return if (incoming > outgoing) accept else legal.first { it is DeclineTrade }
+    }
+
+    /**
+     * Picks the counter-offer that gains the most by the same valuation, or
+     * turns them all down. The AI never counters itself: it only answers.
+     */
+    private fun chooseCounter(state: CatanState, legal: List<CatanMove>): CatanMove {
+        val offer = state.pendingTrade ?: return legal.first()
+        val best = legal.filterIsInstance<AcceptCounter>()
+            .map { choice -> choice to offer.counters.first { it.by == choice.seat } }
+            .maxByOrNull { (_, c) -> c.give.sumOf { want(it) } - c.get.sumOf { want(it) } }
+        if (best != null) {
+            val (choice, c) = best
+            if (c.give.sumOf { want(it) } > c.get.sumOf { want(it) }) return choice
+        }
+        return legal.first { it is DismissCounters }
+    }
+
+    // -----------------------------------------------------------------------
+    // Valuations
+    // -----------------------------------------------------------------------
+
+    /** What a seat would think of building on [vertex]: production and ports. */
+    private fun spotValue(state: CatanState, vertex: Int): Double {
+        if (state.buildings[vertex] != null) return -1.0
+        var value = 0.0
+        val kinds = mutableSetOf<Resource>()
+        for (h in CatanBoard.VERTEX_HEXES[vertex]) {
+            val resource = state.terrains[h].produces ?: continue
+            value += CatanBoard.numberOdds(state.numbers[h]) / 36.0 * want(resource)
+            kinds += resource
+        }
+        value += 0.12 * kinds.size // variety keeps a build plan alive
+        for (e in CatanBoard.VERTEX_EDGES[vertex]) {
+            val port = state.ports.firstOrNull { it.edge == e } ?: continue
+            value += if (port.resource == null) 0.1 else 0.2
+        }
+        return value
+    }
+
+    /**
+     * What a road on this edge leads to: the best settlement spot it brings
+     * within reach, discounted for being one step further out.
+     */
+    private fun roadValue(state: CatanState, move: BuildRoad): Double {
+        var best = 0.0
+        val (from, to) = CatanBoard.EDGE_VERTICES[move.edge]
+        for (endpoint in listOf(from, to)) {
+            for (near in CatanBoard.VERTEX_NEIGHBORS[endpoint]) {
+                best = maxOf(best, spotValue(state, near) * 0.8)
+            }
+        }
+        return best
+    }
+
+    /** How much the AI wants to hold one card of [resource]. */
+    private fun want(resource: Resource): Double = when (resource) {
+        Resource.ORE -> 1.20 // the city
+        Resource.GRAIN -> 1.15 // the city and the dev cards
+        Resource.LUMBER -> 1.0 // every road and settlement
+        Resource.BRICK -> 0.95
+        Resource.WOOL -> 0.85 // abundant and only half of a dev card
+    }
+}

app/src/main/java/org/prolibertate/games/game/catan/CatanBoard.kt

@@ -0,0 +1,322 @@
+package org.prolibertate.games.game.catan
+
+import kotlinx.serialization.Serializable
+import kotlin.math.atan2
+import kotlin.random.Random
+
+/**
+ * The island as geometry: the 19 hexes, the 54 shared vertices, the 72
+ * shared edges, the coast and the nine harbour positions.
+ *
+ * Everything is derived once, deterministically, from axial coordinates —
+ * there is no randomness and no state here; the layout of a particular
+ * game (which terrain and number sits on which hex) is [generate], and the
+ * live state lives in [CatanState].
+ *
+ * Coordinates: hexes are addressed axially ((q, r), pointy-top). Every
+ * position is kept on an exact integer lattice so vertices shared by
+ * neighbouring hexes are recognised by position instead of by floating
+ * point: the centre of hex (q, r) is at lattice point (2q + r, 3r), and its
+ * six corners follow the offsets in [CORNER_OFFSETS]. Vertex positions are
+ * in half-units of the hex grid; rendering scales and flips them (lattice
+ * +Y is toward the top of the board).
+ */
+object CatanBoard {
+
+    /** The 19 hexes: every (q, r) within distance 2 of the centre. */
+    val HEXES: List<HexCoord> = buildList {
+        for (r in -2..2) {
+            for (q in -2..2) {
+                if (hexDistance(q, r, 0, 0) <= 2) add(HexCoord(q, r))
+            }
+        }
+    }
+
+    val HEX_COUNT: Int = HEXES.size
+
+    val hexIndex: Map<HexCoord, Int> = HEXES.withIndex().associate { (i, hex) -> hex to i }
+
+    /**
+     * Corner k of a hex, as a lattice offset from its centre. Pointy-top:
+     * corner 0 is the top corner, then clockwise.
+     */
+    private val CORNER_OFFSETS = listOf(
+        0 to 2, 1 to 1, 1 to -1, 0 to -2, -1 to -1, -1 to 1,
+    )
+
+    /** Unit steps to a hex's six neighbours, matching the corner order. */
+    private val NEIGHBOR_STEPS = listOf(
+        0 to 1, 1 to 0, 1 to -1, 0 to -1, -1 to 0, -1 to 1,
+    )
+
+    /** The six board-corner hexes: pairwise non-adjacent by construction. */
+    private val CORNER_HEXES = listOf(
+        HexCoord(2, 0), HexCoord(0, 2), HexCoord(-2, 2),
+        HexCoord(-2, 0), HexCoord(0, -2), HexCoord(2, -2),
+    )
+
+    // -----------------------------------------------------------------------
+    // Vertices and edges
+    // -----------------------------------------------------------------------
+
+    /** Lattice position of each vertex, by vertex id. */
+    val VERTEX_POS: List<Pair<Int, Int>>
+
+    val VERTEX_COUNT: Int
+
+    /** Vertex ids of hex h's six corners, corner 0 first (see [CORNER_OFFSETS]). */
+    val HEX_CORNERS: List<List<Int>>
+
+    /** Both endpoints of each edge, as vertex ids, low id first. */
+    val EDGE_VERTICES: List<Pair<Int, Int>>
+
+    val EDGE_COUNT: Int
+
+    /** Edges touching each vertex. */
+    val VERTEX_EDGES: List<List<Int>>
+
+    /** Vertices one edge away from each vertex: the distance rule's horizon. */
+    val VERTEX_NEIGHBORS: List<List<Int>>
+
+    /** Hexes touching each vertex. */
+    val VERTEX_HEXES: List<List<Int>>
+
+    /** Hexes touching each edge: two for interior edges, one on the coast. */
+    val EDGE_HEXES: List<List<Int>>
+
+    /** Edges adjacent to each edge (sharing a vertex). */
+    val EDGE_NEIGHBORS: List<List<Int>>
+
+    /** Hexes adjacent to each hex, in [NEIGHBOR_STEPS] order. */
+    val HEX_NEIGHBORS: List<List<Int>>
+
+    /** The coastal edges (those with only one hex) in ring order. */
+    val COASTAL: List<Int>
+
+    /** The nine fixed harbour positions, spread around the coast. */
+    val PORT_POSITIONS: List<Int>
+
+    init {
+        // Vertices: assign ids in first-seen order over hexes then corners.
+        val vertexIds = mutableMapOf<Pair<Int, Int>, Int>()
+        val vertexPos = mutableListOf<Pair<Int, Int>>()
+        val hexCorners = HEXES.map { hex ->
+            val cx = 2 * hex.q + hex.r
+            val cy = 3 * hex.r
+            CORNER_OFFSETS.map { (dx, dy) ->
+                val pos = (cx + dx) to (cy + dy)
+                vertexIds.getOrPut(pos) {
+                    vertexPos += pos
+                    vertexPos.size - 1
+                }
+            }
+        }
+        VERTEX_POS = vertexPos
+        VERTEX_COUNT = vertexPos.size
+        HEX_CORNERS = hexCorners
+
+        // Edges between a hex's consecutive corners, deduplicated by the
+        // pair of vertex ids.
+        val edgeIds = mutableMapOf<Pair<Int, Int>, Int>()
+        val edgeVertices = mutableListOf<Pair<Int, Int>>()
+        hexCorners.forEach { corners ->
+            for (k in 0..5) {
+                val a = corners[k]
+                val b = corners[(k + 1) % 6]
+                val key = minOf(a, b) to maxOf(a, b)
+                edgeIds.getOrPut(key) {
+                    edgeVertices += key
+                    edgeVertices.size - 1
+                }
+            }
+        }
+        EDGE_VERTICES = edgeVertices
+        EDGE_COUNT = edgeVertices.size
+
+        val vertexEdges = List(VERTEX_COUNT) { mutableListOf<Int>() }
+        val vertexHexes = List(VERTEX_COUNT) { mutableSetOf<Int>() }
+        val edgeHexes = List(EDGE_COUNT) { mutableSetOf<Int>() }
+        hexCorners.forEachIndexed { h, corners ->
+            corners.forEach { v -> vertexHexes[v] += h }
+            for (k in 0..5) {
+                val a = corners[k]
+                val b = corners[(k + 1) % 6]
+                val key = minOf(a, b) to maxOf(a, b)
+                val e = edgeIds.getValue(key)
+                edgeHexes[e] += h
+                vertexEdges[a] += e
+                vertexEdges[b] += e
+            }
+        }
+        // Distinct: an interior edge is walked once from each of the two hexes
+        // it separates, so without this every shared edge would be counted
+        // twice and an interior vertex would appear to have six edges.
+        VERTEX_EDGES = vertexEdges.map { it.distinct() }
+        VERTEX_HEXES = vertexHexes.map { it.sorted() }
+        EDGE_HEXES = edgeHexes.map { it.sorted() }
+        VERTEX_NEIGHBORS = List(VERTEX_COUNT) { v ->
+            VERTEX_EDGES[v].map { otherEnd(it, v) }.distinct().sorted()
+        }
+        EDGE_NEIGHBORS = List(EDGE_COUNT) { e ->
+            val (a, b) = EDGE_VERTICES[e]
+            (VERTEX_EDGES[a] + VERTEX_EDGES[b]).distinct().filter { it != e }.sorted()
+        }
+        HEX_NEIGHBORS = HEXES.map { hex ->
+            NEIGHBOR_STEPS.mapNotNull { (dq, dr) ->
+                hexIndex[HexCoord(hex.q + dq, hex.r + dr)]
+            }
+        }
+
+        // The coast in walking order: sort the coastal edges by the angle of
+        // their midpoint around the board centre, which is the lattice
+        // origin. The board is a hexagon, so this yields one closed ring.
+        COASTAL = EDGE_HEXES.withIndex()
+            .filter { it.value.size == 1 }
+            .map { (e, _) -> e }
+            .sortedBy { e -> angleOf(midpoint(e)) }
+        // Harbours sit roughly every third or fourth coastal edge, like the
+        // physical frame: nine positions, steps summing to the whole ring.
+        PORT_POSITIONS = buildList {
+            var at = 0
+            for (step in listOf(3, 4, 3, 3, 4, 3, 3, 4, 3)) {
+                add(COASTAL[at % COASTAL.size])
+                at += step
+            }
+        }.distinct()
+
+        check(HEX_COUNT == 19) { "A Catan island has 19 hexes, found $HEX_COUNT" }
+        check(VERTEX_COUNT == 54) { "A Catan island has 54 vertices, found $VERTEX_COUNT" }
+        check(EDGE_COUNT == 72) { "A Catan island has 72 edges, found $EDGE_COUNT" }
+        check(COASTAL.size == 30) { "The coast has 30 edges, found ${COASTAL.size}" }
+        check(PORT_POSITIONS.size == 9) { "Nine harbours, found ${PORT_POSITIONS.size}" }
+        check(PORT_POSITIONS.all { EDGE_HEXES[it].size == 1 }) { "Harbours must be coastal" }
+    }
+
+    /** The other endpoint of [edge], given one [vertex] on it. */
+    fun otherEnd(edge: Int, vertex: Int): Int {
+        val (a, b) = EDGE_VERTICES[edge]
+        return if (vertex == a) b else a
+    }
+
+    /** Lattice position of hex h's centre. */
+    fun hexCenter(h: Int): Pair<Int, Int> {
+        val hex = HEXES[h]
+        return (2 * hex.q + hex.r) to (3 * hex.r)
+    }
+
+    /** Whether two hexes share an edge. */
+    fun hexesAdjacent(a: Int, b: Int): Boolean = b in HEX_NEIGHBORS[a]
+
+    /** Hex-grid distance between two axial positions. */
+    fun hexDistance(q1: Int, r1: Int, q2: Int, r2: Int): Int {
+        val dq = q1 - q2
+        val dr = r1 - r2
+        return maxOf(kotlin.math.abs(dq), kotlin.math.abs(dr), kotlin.math.abs(dq + dr))
+    }
+
+    /**
+     * How often a number is expected to come up, in thirty-sixths. A 6 or an
+     * 8 comes up five times in thirty-six, a 2 or a 12 once.
+     */
+    fun numberOdds(number: Int): Int = 6 - kotlin.math.abs(7 - number)
+
+    private fun midpoint(edge: Int): Pair<Double, Double> {
+        val (a, b) = EDGE_VERTICES[edge]
+        val pa = VERTEX_POS[a]
+        val pb = VERTEX_POS[b]
+        return ((pa.first + pb.first) / 2.0) to ((pa.second + pb.second) / 2.0)
+    }
+
+    private fun angleOf(point: Pair<Double, Double>): Double =
+        atan2(point.second, point.first)
+
+    // -----------------------------------------------------------------------
+    // Island generation
+    // -----------------------------------------------------------------------
+
+    /**
+     * The island layout for one game: terrain and number per hex, the robber
+     * on the desert, and the nine harbours.
+     */
+    @Serializable
+    data class Generated(
+        val terrains: List<Terrain>,
+        /** 0 where there is no token (the desert). */
+        val numbers: List<Int>,
+        val robber: Int,
+        val ports: List<Port>,
+    )
+
+    /** The terrain tile mix: four forests, four pastures, four fields, three hills, three mountains, one desert. */
+    private val TERRAIN_TILES: List<Terrain> = listOf(
+        Terrain.FOREST, Terrain.FOREST, Terrain.FOREST, Terrain.FOREST,
+        Terrain.PASTURE, Terrain.PASTURE, Terrain.PASTURE, Terrain.PASTURE,
+        Terrain.FIELDS, Terrain.FIELDS, Terrain.FIELDS, Terrain.FIELDS,
+        Terrain.HILLS, Terrain.HILLS, Terrain.HILLS,
+        Terrain.MOUNTAINS, Terrain.MOUNTAINS, Terrain.MOUNTAINS,
+        Terrain.DESERT,
+    )
+
+    /** The 18 number tokens, the two hardest numbers withheld: 7 never appears. */
+    private val RED_TOKENS = listOf(6, 6, 8, 8)
+    private val OTHER_TOKENS = listOf(2, 3, 3, 4, 4, 5, 5, 9, 9, 10, 10, 11, 11, 12)
+
+    /** Shuffle attempts before falling back to the corner placement for 6s and 8s. */
+    private const val RED_ATTEMPTS = 60
+
+    /**
+     * Generates the island from [seed].
+     *
+     * Terrain is shuffled over the hexes, exactly as shuffling the land
+     * tiles face down does. Number tokens are shuffled over the land hexes
+     * with one repair rule: no two of the red tokens (6 and 8) may sit on
+     * adjacent hexes, the balance convention the published game asks for.
+     * The robber starts on the desert. Harbour *positions* are fixed (the
+     * physical frame is not shuffled); the nine harbour *types* — five
+     * 2:1 resource ports and four 3:1 ports — are shuffled onto them.
+     *
+     * The 6/8 separation is guaranteed, not merely probable: if no shuffled
+     * placement separates them (about one shuffle in five does), the red
+     * tokens go to four of the six board-corner hexes, which are pairwise
+     * non-adjacent, and at most one corner can be desert.
+     */
+    fun generate(seed: Long): Generated {
+        val random = Random(seed)
+        val terrains = TERRAIN_TILES.shuffled(random)
+        val desert = terrains.indexOf(Terrain.DESERT)
+        val land = terrains.indices.filter { it != desert }
+
+        var redHexes: List<Int>? = null
+        var attempt = 0
+        while (redHexes == null && attempt < RED_ATTEMPTS) {
+            val candidate = land.shuffled(random).take(4)
+            val separated = candidate.withIndex().all { (i, a) ->
+                candidate.drop(i + 1).none { hexesAdjacent(a, it) }
+            }
+            if (separated) redHexes = candidate
+            attempt++
+        }
+        val reds = redHexes ?: CORNER_HEXES
+            .mapNotNull { hexIndex[it] }
+            .filter { it != desert }
+            .shuffled(random)
+            .take(4)
+
+        val numbers = IntArray(HEX_COUNT)
+        RED_TOKENS.forEachIndexed { i, token -> numbers[reds[i]] = token }
+        val rest = land.filter { it !in reds }.shuffled(random)
+        OTHER_TOKENS.forEachIndexed { i, token -> numbers[rest[i]] = token }
+
+        val portTypes = (
+            listOf(
+                Resource.LUMBER, Resource.BRICK, Resource.WOOL, Resource.GRAIN, Resource.ORE,
+            ) + List(4) { null }
+            ).shuffled(random)
+        val ports = PORT_POSITIONS.mapIndexed { i, edge ->
+            val resource = portTypes[i]
+            if (resource == null) Port(edge, null, 3) else Port(edge, resource, 2)
+        }
+
+        return Generated(terrains, numbers.toList(), desert, ports)
+    }
+}

app/src/main/java/org/prolibertate/games/game/catan/CatanModel.kt

@@ -0,0 +1,352 @@
+package org.prolibertate.games.game.catan
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/** Sentinel stored in [CatanState.roads] for an unclaimed road position. */
+const val NO_PLAYER = -1
+
+/** Road segments required to hold Longest Road. */
+const val LONGEST_ROAD_MIN = 5
+
+/** Knights required to take Largest Army. */
+const val LARGEST_ARMY_MIN = 3
+
+/** Pieces each player has: a player who has laid them all cannot build another. */
+const val MAX_ROADS = 15
+const val MAX_SETTLEMENTS = 5
+const val MAX_CITIES = 4
+
+/** Resource cards of each type the bank starts with. */
+const val BANK_PER_RESOURCE = 19
+
+/**
+ * The five resources the island produces.
+ *
+ * Catan names two of them after the terrain rather than the commodity
+ * (wood becomes lumber, sheep become wool); those names travel with the
+ * trademark, so the engine speaks in resources only.
+ */
+@Serializable
+enum class Resource { LUMBER, BRICK, WOOL, GRAIN, ORE }
+
+/** One terrain type per hex; the desert produces nothing. */
+@Serializable
+enum class Terrain(val produces: Resource?) {
+    FOREST(Resource.LUMBER),
+    PASTURE(Resource.WOOL),
+    FIELDS(Resource.GRAIN),
+    HILLS(Resource.BRICK),
+    MOUNTAINS(Resource.ORE),
+    DESERT(null),
+}
+
+/** Axial coordinate of one hex on the board. See [CatanBoard]. */
+@Serializable
+data class HexCoord(val q: Int, val r: Int)
+
+@Serializable
+enum class BuildingType { SETTLEMENT, CITY }
+
+/** What stands on one vertex: a settlement or city owned by one seat. */
+@Serializable
+data class CatanBuilding(val type: BuildingType, val owner: Int)
+
+/**
+ * One harbour. A port sits on a coastal edge: a player who owns a
+ * settlement or city on *either* endpoint vertex of [edge] may trade at
+ * [ratio] (2 or 3) instead of the bank's 4:1. A resource port trades at 2:1
+ * for its own resource only; [resource] is null for a generic 3:1 harbour.
+ */
+@Serializable
+data class Port(val edge: Int, val resource: Resource?, val ratio: Int)
+
+@Serializable
+enum class DevCardType { KNIGHT, ROAD_BUILDING, MONOPOLY, YEAR_OF_PLENTY, VICTORY_POINT }
+
+/**
+ * One development card. [id] is stable for the life of the game (the deck
+ * is built once from the seed), so moves can name a card by id even after
+ * it moves from the deck into a hand. [boughtTurn] records when it was
+ * drawn: a card cannot be played on the turn it was bought.
+ */
+@Serializable
+data class DevCard(val id: Int, val type: DevCardType, val boughtTurn: Int = 0)
+
+/**
+ * A counter-proposal to a [TradeOffer]: seat [by] would [give] these cards to
+ * the offerer if the offerer would hand over [get].
+ */
+@Serializable
+data class TradeCounter(val by: Int, val give: List<Resource>, val get: List<Resource>)
+
+/**
+ * A domestic trade offer on the table. [by] is the offering seat. [to] is the
+ * one seat it is addressed to, or null for an open offer to the whole table.
+ * Seats are asked one at a time, in seat order after the offerer; [asking] is
+ * the seat that may answer now. Each may accept (the trade happens at once),
+ * decline, or counter; counters are kept in [counters] and, if nobody accepts,
+ * the offerer chooses among them in [CatanPhase.TRADE_COUNTERS].
+ */
+@Serializable
+data class TradeOffer(
+    val by: Int,
+    val to: Int?,
+    val give: List<Resource>,
+    val get: List<Resource>,
+    val asking: Int = to ?: -1,
+    val counters: List<TradeCounter> = emptyList(),
+)
+
+/**
+ * Where the game stands. The phases that involve more than the player
+ * whose turn it is carry their own bookkeeping: [discardSeat] during
+ * [CatanPhase.DISCARDING], [pendingTrade] during [CatanPhase.TRADE_PENDING] and [CatanPhase.TRADE_COUNTERS].
+ */
+@Serializable
+enum class CatanPhase {
+    /** Snake order forward: settlement + road each, seats 0..n-1. */
+    SETUP_FIRST,
+
+    /** Snake order back: settlement + road each, seats n-1..0, plus income. */
+    SETUP_SECOND,
+
+    /** The player whose turn it is must roll the dice. */
+    AWAIT_ROLL,
+
+    /** Players holding more than 7 resource cards discard half. */
+    DISCARDING,
+
+    /** The roller must move the robber and steal. */
+    ROBBER,
+
+    /** Build, trade, buy and play development cards, or end the turn. */
+    PLAYING,
+
+    /** A played Road Building card: up to two roads remain to be placed. */
+    FREE_ROADS,
+
+    /** The [TradeOffer.asking] seat must accept, decline or counter. */
+    TRADE_PENDING,
+
+    /** Nobody accepted but some seats countered: the offerer picks one or none. */
+    TRADE_COUNTERS,
+
+    GAME_OVER,
+}
+
+@Serializable
+data class CatanOptions(
+    val playerCount: Int = 3,
+    val pointsToWin: Int = 10,
+) {
+    init {
+        require(playerCount in 3..4) { "The island seats three or four players" }
+        require(pointsToWin >= 2) { "pointsToWin must be at least 2" }
+    }
+}
+
+/**
+ * The whole game as one immutable value.
+ *
+ * Public information (terrain, numbers, ports, buildings, roads, resource
+ * counts, dev-card counts, knights played) is stored directly. Hidden
+ * information — the deck's order and every hand's development cards — is
+ * here in full because the host owns the truth; [CatanRules.viewFor] is
+ * what keeps it off the wire.
+ */
+@Serializable
+data class CatanState(
+    val options: CatanOptions,
+    val seed: Long,
+    val phase: CatanPhase,
+    /**
+     * The seat whose turn it is — not always the seat expected to move:
+     * during [CatanPhase.DISCARDING] and [CatanPhase.TRADE_PENDING] another
+     * seat acts on the turn owner's behalf.
+     */
+    val turn: Int,
+    /** How many setup placements are done, 0 until 2 * playerCount. */
+    val setupIndex: Int,
+    /** Monotonic turn counter, 0 during setup, 1 from the first real turn. */
+    val turnNumber: Int,
+    /** Terrain per hex, indexed like [CatanBoard.HEXES]. */
+    val terrains: List<Terrain>,
+    /** Number token per hex, 0 where there is none (the desert). */
+    val numbers: List<Int>,
+    /** Hex the robber currently occupies. */
+    val robber: Int,
+    val ports: List<Port>,
+    /** What stands on each vertex, or null. */
+    val buildings: List<CatanBuilding?>,
+    /** Owning seat per edge, or [NO_PLAYER]. */
+    val roads: List<Int>,
+    /** Resource cards per seat. Card counts are public in Catan. */
+    val resources: List<Map<Resource, Int>>,
+    /** The bank's development cards, top first. Order is hidden. */
+    val devDeck: List<DevCard>,
+    /** Development cards per seat. Hidden from everyone but the holder. */
+    val devHands: List<List<DevCard>>,
+    /** Public mirror of the dev-hand sizes, for views and scoreboards. */
+    val devHandCounts: List<Int>,
+    /** Knights played (not merely held) per seat. */
+    val knightsPlayed: List<Int>,
+    /** Whether the turn owner has already played a development card. */
+    val devCardPlayedThisTurn: Boolean,
+    val pendingTrade: TradeOffer?,
+    /** Roads still owed on a played Road Building card. */
+    val pendingFreeRoads: Int,
+    /** Seat due to discard during [CatanPhase.DISCARDING]. */
+    val discardSeat: Int?,
+    val longestRoadOwner: Int?,
+    val largestArmyOwner: Int?,
+    /** The dice as last rolled, for the table display. */
+    val lastDice: List<Int>,
+    /**
+     * How many dice rolls and steals have happened so far. Random events are
+     * derived from the seed and this counter, so the same game replays
+     * identically without storing a random generator in the state.
+     */
+    val rngStep: Int,
+    val winner: Int?,
+    val log: List<String>,
+) {
+    val playerCount: Int get() = options.playerCount
+
+    /** Total resource cards held by [seat]. */
+    fun resourceCount(seat: Int): Int = resources[seat].values.sum()
+
+    /** [seat]'s resource cards as a flat list, one entry per card. */
+    fun handOf(seat: Int): List<Resource> =
+        Resource.entries.flatMap { res -> List(resources[seat][res] ?: 0) { res } }
+
+    /** Whether [seat] holds every card in [cards], counting duplicates. */
+    fun holdsAll(seat: Int, cards: List<Resource>): Boolean {
+        val need = cards.groupingBy { it }.eachCount()
+        return need.all { (res, n) -> (resources[seat][res] ?: 0) >= n }
+    }
+}
+
+@Serializable
+sealed interface CatanMove
+
+/** Setup placement: a settlement on [vertex] plus a road on [edge]. */
+@Serializable
+@SerialName("setup")
+data class SetupPlace(val vertex: Int, val edge: Int) : CatanMove
+
+/**
+ * Roll the dice.
+ *
+ * With [forced] null the roll is derived from the game seed, which is what
+ * the AI, the UI and the network always send. [forced] exists so tests and
+ * offline reviews can stage a specific number; it is not part of the
+ * enumerated move list, so the network driver's "is this move in the legal
+ * list" check rejects any forced roll a client tries to sneak through —
+ * only code holding the state directly (the host's own tests) can use it.
+ */
+@Serializable
+@SerialName("roll")
+data class RollDice(val forced: List<Int>? = null) : CatanMove
+
+/** Discard exactly these cards. */
+@Serializable
+@SerialName("discard")
+data class Discard(val cards: List<Resource>) : CatanMove
+
+/** Move the robber to [hex] and steal from [victim], if anyone can be robbed. */
+@Serializable
+@SerialName("robber")
+data class MoveRobber(val hex: HexCoord, val victim: Int? = null) : CatanMove
+
+/** Build a road on [edge] — paid normally, or free during FREE_ROADS. */
+@Serializable
+@SerialName("road")
+data class BuildRoad(val edge: Int) : CatanMove
+
+@Serializable
+@SerialName("settlement")
+data class BuildSettlement(val vertex: Int) : CatanMove
+
+@Serializable
+@SerialName("city")
+data class BuildCity(val vertex: Int) : CatanMove
+
+@Serializable
+@SerialName("buyCard")
+data object BuyDevCard : CatanMove
+
+/**
+ * Play a knight. The card is named by [card] id; the robber move follows as
+ * its own move once the phase has advanced.
+ */
+@Serializable
+@SerialName("knight")
+data class PlayKnight(val card: Int) : CatanMove
+
+@Serializable
+@SerialName("roadBuilding")
+data class PlayRoadBuilding(val card: Int) : CatanMove
+
+@Serializable
+@SerialName("monopoly")
+data class PlayMonopoly(val card: Int, val resource: Resource) : CatanMove
+
+/** Take [take] (up to two cards) from the bank. */
+@Serializable
+@SerialName("plenty")
+data class PlayYearOfPlenty(val card: Int, val take: List<Resource>) : CatanMove
+
+/**
+ * Offer a domestic trade to [to] (null: everyone, asked in turn): [give] of
+ * ours for [get] of theirs.
+ *
+ * Like a forced dice roll this is a free-form intent rather than an
+ * enumerated move — the space of two card multisets is combinatorial — so
+ * it is validated structurally by [CatanRules.isLegalMove] instead of
+ * appearing in [CatanRules.legalMoves].
+ */
+@Serializable
+@SerialName("offer")
+data class OfferTrade(val to: Int?, val give: List<Resource>, val get: List<Resource>) : CatanMove
+
+@Serializable
+@SerialName("accept")
+data object AcceptTrade : CatanMove
+
+@Serializable
+@SerialName("decline")
+data object DeclineTrade : CatanMove
+
+/**
+ * Answer the offer on the table with different terms: we would [give] these
+ * cards if the offerer handed over [get]. Free-form like [OfferTrade], so
+ * validated by [CatanRules.isLegalMove] rather than listed.
+ */
+@Serializable
+@SerialName("counter")
+data class CounterTrade(val give: List<Resource>, val get: List<Resource>) : CatanMove
+
+/** The offerer takes the counter-proposal made by [seat]. */
+@Serializable
+@SerialName("acceptCounter")
+data class AcceptCounter(val seat: Int) : CatanMove
+
+/** The offerer takes none of the counter-proposals. */
+@Serializable
+@SerialName("dismissCounters")
+data object DismissCounters : CatanMove
+
+/** Bank trade: [give] at the best ratio this seat can trade at for [get]. */
+@Serializable
+@SerialName("bank")
+data class MaritimeTrade(val give: Resource, val get: Resource) : CatanMove
+
+@Serializable
+@SerialName("endTurn")
+data object EndTurn : CatanMove
+
+/** Forfeit any remaining free roads from a played Road Building card. */
+@Serializable
+@SerialName("endFreeRoads")
+data object EndFreeRoads : CatanMove

app/src/main/java/org/prolibertate/games/game/engine/Engine.kt

@@ -64,6 +64,21 @@ interface GameRules<S : Any, M : Any> {
 
     fun legalMoves(state: S, seat: Int): List<M>
 
+    /**
+     * Whether [move] is currently legal for [seat].
+     *
+     * Defaults to membership in [legalMoves], which is everything a game
+     * with a small, enumerable move set needs. A game whose move space is
+     * combinatorial — Catan's trade offers name any two multisets of cards —
+     * overrides this and validates structurally instead, because enumerating
+     * every intent would explode the list the UI and the network driver work
+     * from. Gates that check a specific move should call this method rather
+     * than testing list membership directly, so both kinds of game behave the
+     * same way.
+     */
+    fun isLegalMove(state: S, seat: Int, move: M): Boolean =
+        move in legalMoves(state, seat)
+
     /**
      * Applies [move] on behalf of [seat].
      *

app/src/main/java/org/prolibertate/games/net/LanTransport.kt

@@ -308,6 +308,6 @@ class LanTransport(private val context: Context) : Transport {
             }
 
         const val CONNECT_TIMEOUT_MS = 8_000
-        const val WIFI_LOCK_TAG = "PilgrimsOfKatan:lan"
+        const val WIFI_LOCK_TAG = "ProLibertateGames:lan"
     }
 }

app/src/main/java/org/prolibertate/games/net/MatchController.kt

@@ -349,7 +349,7 @@ class MatchController<S : Any, M : Any>(
                 seatPeers[seat]?.let { peers[it]?.send(Rejected("It is not your turn.")) }
                 return
             }
-            if (move !in rules.legalMoves(current, seat)) {
+            if (!rules.isLegalMove(current, seat, move)) {
                 seatPeers[seat]?.let { peers[it]?.send(Rejected("That move is not legal.")) }
                 return
             }
@@ -424,7 +424,7 @@ class MatchController<S : Any, M : Any>(
                 // throws on a move that is no longer legal, and there is nothing
                 // above this to catch it.
                 if (rules.currentSeat(live) != seat) return@withLock false
-                if (move !in rules.legalMoves(live, seat)) return@withLock false
+                if (!rules.isLegalMove(live, seat, move)) return@withLock false
                 authoritative = rules.applyMove(live, seat, move)
                 publish()
                 true

app/src/main/java/org/prolibertate/games/net/Protocol.kt

@@ -33,7 +33,7 @@ const val PURPOSE_SCOREKEEPER = "scorekeeper"
 
 /** Service type and name advertised over mDNS. */
 const val SERVICE_TYPE = "_plgames._tcp"
-const val SERVICE_NAME = "PilgrimsOfKatan"
+const val SERVICE_NAME = "ProLibertateGames"
 
 val protocolJson: Json = Json {
     ignoreUnknownKeys = true

app/src/main/java/org/prolibertate/games/ui/AppRoot.kt

@@ -364,7 +364,11 @@ fun SectionScreen(
                 }
             }
             items(games) { game ->
-                GameTile(game = game, onClick = { onPickGame(game) })
+                GameTile(
+                    game = game,
+                    playable = game.playableIn(devBuild = showComingSoon),
+                    onClick = { onPickGame(game) },
+                )
             }
         }
     }
@@ -403,12 +407,12 @@ private fun SectionTile(menu: GameMenu, count: Int, onClick: () -> Unit) {
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-private fun GameTile(game: GameDescriptor, onClick: () -> Unit) {
+private fun GameTile(game: GameDescriptor, playable: Boolean, onClick: () -> Unit) {
     Card(
         onClick = onClick,
-        enabled = game.available,
+        enabled = playable,
         colors = CardDefaults.cardColors(
-            containerColor = if (game.available) {
+            containerColor = if (playable) {
                 MaterialTheme.colorScheme.surfaceVariant
             } else {
                 MaterialTheme.colorScheme.surface
@@ -427,13 +431,18 @@ private fun GameTile(game: GameDescriptor, onClick: () -> Unit) {
                 style = MaterialTheme.typography.bodySmall,
                 modifier = Modifier.padding(top = 4.dp),
             )
+            val players = when {
+                // A puzzle for one, rather than "1 players".
+                game.maxPlayers == 1 -> "On your own"
+                game.minPlayers == game.maxPlayers -> "${game.minPlayers} players"
+                else -> "${game.minPlayers}–${game.maxPlayers} players"
+            }
             Text(
                 text = when {
-                    !game.available -> "Coming soon"
-                    // A puzzle for one, rather than "1 players".
-                    game.maxPlayers == 1 -> "On your own"
-                    game.minPlayers == game.maxPlayers -> "${game.minPlayers} players"
-                    else -> "${game.minPlayers}–${game.maxPlayers} players"
+                    !playable -> "Coming soon"
+                    // Playable on this dev build only; production hides it.
+                    !game.available -> "Preview · $players"
+                    else -> players
                 },
                 style = MaterialTheme.typography.labelSmall,
                 modifier = Modifier.padding(top = 8.dp),

app/src/main/java/org/prolibertate/games/ui/GameSetupScreen.kt

@@ -57,6 +57,7 @@ import org.prolibertate.games.game.morris.MorrisOptions
 import org.prolibertate.games.game.pirates.PiratesLevel
 import org.prolibertate.games.game.pirates.PiratesOptions
 import org.prolibertate.games.game.president.PresidentOptions
+import org.prolibertate.games.game.catan.CatanOptions
 import org.prolibertate.games.game.sequence.SequenceOptions
 import org.prolibertate.games.game.tayu.TayuLevel
 import org.prolibertate.games.game.tayu.TayuOptions
@@ -104,6 +105,7 @@ fun GameSetupScreen(
     var freecell by remember { mutableStateOf(FreeCellOptions()) }
     var spider by remember { mutableStateOf(SpiderOptions()) }
     var pyramid by remember { mutableStateOf(PyramidOptions()) }
+    var catan by remember { mutableStateOf(CatanOptions()) }
     // Not an engine option: which seat the local player takes. Seat 0 is
     // always White, so choosing Black means sitting in seat 1.
     var playWhite by remember { mutableStateOf(true) }
@@ -134,6 +136,7 @@ fun GameSetupScreen(
         GameCatalog.FREECELL -> setupJson.encodeToString(freecell)
         GameCatalog.SPIDER -> setupJson.encodeToString(spider)
         GameCatalog.PYRAMID -> setupJson.encodeToString(pyramid)
+        GameCatalog.CATAN -> setupJson.encodeToString(catan)
         else -> "{}"
     }
     val seatCount = seatCountFor(descriptor.id, optionsJson)
@@ -199,6 +202,8 @@ fun GameSetupScreen(
 
                 GameCatalog.PYRAMID -> PyramidOptionsEditor(pyramid) { pyramid = it }
 
+                GameCatalog.CATAN -> CatanOptionsEditor(catan) { catan = it }
+
                 else -> Text("No options yet for this game.")
             }
 
@@ -303,6 +308,9 @@ fun seatCountFor(gameId: String, optionsJson: String): Int {
             GameCatalog.TAYU ->
                 setupJson.decodeFromString<TayuOptions>(optionsJson).playerCount
 
+            GameCatalog.CATAN ->
+                setupJson.decodeFromString<CatanOptions>(optionsJson).playerCount
+
             else -> fallback
         }
     }.getOrDefault(fallback)
@@ -326,6 +334,27 @@ fun teamForSeat(gameId: String, seat: Int, seatCount: Int): Int = when (gameId)
     else -> seat
 }
 
+@Composable
+private fun CatanOptionsEditor(options: CatanOptions, onChange: (CatanOptions) -> Unit) {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        ChipRow(
+            label = "Players",
+            values = listOf(3, 4),
+            selected = options.playerCount,
+            display = { "$it players" },
+            onSelect = { onChange(options.copy(playerCount = it)) },
+        )
+        ChipRow(
+            label = "Game to",
+            // Five is a short game for trying things out; ten is the published target.
+            values = listOf(5, 8, 10, 12),
+            selected = options.pointsToWin,
+            display = { "$it points" },
+            onSelect = { onChange(options.copy(pointsToWin = it)) },
+        )
+    }
+}
+
 @Composable
 private fun EuchreOptionsEditor(options: EuchreOptions, onChange: (EuchreOptions) -> Unit) {
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {

app/src/main/java/org/prolibertate/games/ui/LaunchUpdateCheck.kt

@@ -49,7 +49,7 @@ fun LaunchUpdateCheck(env: AppEnv, visible: Boolean) {
     }
 
     // Held back behind the splash, so an update prompt cannot appear over the
-    // splash before the app itself has.
+    // tartan before the app itself has.
     val pending = release
     if (pending == null || dismissed || !visible) return
 

app/src/main/java/org/prolibertate/games/ui/PlayScreen.kt

@@ -13,6 +13,10 @@ import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import org.prolibertate.games.game.GameCatalog
+import org.prolibertate.games.game.catan.CatanAi
+import org.prolibertate.games.game.catan.CatanMove
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
 import org.prolibertate.games.game.chess.ChessAi
 import org.prolibertate.games.game.chess.ChessMove
 import org.prolibertate.games.game.chess.ChessRules
@@ -110,6 +114,7 @@ import org.prolibertate.games.game.wizard.WizardState
 import org.prolibertate.games.net.MatchController
 import org.prolibertate.games.settings.Settings
 import org.prolibertate.games.ui.game.BackgammonScreen
+import org.prolibertate.games.ui.game.catan.CatanScreen
 import org.prolibertate.games.ui.game.CheckersScreen
 import org.prolibertate.games.ui.game.ChessScreen
 import org.prolibertate.games.ui.game.CrazyEightsScreen
@@ -668,6 +673,30 @@ fun PlayScreen(
             ChessScreen(controller = controller, localSeat = route.localSeat, onExit = onExit)
         }
 
+        GameCatalog.CATAN -> {
+            val controller = remember(route) {
+                MatchController<CatanState, CatanMove>(
+                    rules = CatanRules,
+                    ai = CatanAi(),
+                    config = route.config,
+                    scope = scope,
+                    role = role,
+                    localSeats = setOf(route.localSeat),
+                    primarySeat = route.localSeat,
+                    // A computer's turn is several small moves (roll, build,
+                    // trade, end), so the pause is per move, not per turn.
+                    aiThinkingMillis = { settings.scaled(450L) },
+                )
+            }
+            StartMatch(env, controller, route)
+            CatanScreen(
+                controller = controller,
+                localSeat = route.localSeat,
+                seatNames = route.config.seats.sortedBy { it.seat }.map { it.name },
+                onExit = onExit,
+            )
+        }
+
         else -> Text("That game isn't playable yet.")
     }
 }

app/src/main/java/org/prolibertate/games/ui/SplashScreen.kt

@@ -4,6 +4,7 @@ import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -19,7 +20,6 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.Shadow
 import androidx.compose.ui.text.TextStyle
@@ -30,9 +30,8 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import kotlinx.coroutines.delay
 import org.prolibertate.games.R
-import org.prolibertate.games.ui.theme.BrandAccent
-import org.prolibertate.games.ui.theme.BrandDeep
-import org.prolibertate.games.ui.theme.BrandField
+import org.prolibertate.games.ui.theme.TartanBackground
+import org.prolibertate.games.ui.theme.threadWidthFor
 
 /** How long the splash holds at full opacity before fading. */
 private const val SPLASH_HOLD_MILLIS = 2_000L
@@ -46,11 +45,7 @@ private const val SPLASH_FADE_MILLIS = 600
 val CelticFontFamily = FontFamily(Font(R.font.uncial_antiqua))
 
 /**
- * The launch screen: the brand field under the name of the game.
- *
- * The gradient runs from the same hue as the window's `splash_background`
- * held behind it, so the first frame and the splash are one brand in two
- * shades rather than a colour change.
+ * The launch screen: Wallace tartan under the name of the house.
  *
  * Drawn as an overlay rather than a separate destination, so the menu is
  * already composed and ready behind it and the fade reveals a live screen
@@ -75,17 +70,30 @@ fun SplashScreen(
         onFinished()
     }
 
-    BoxWithConstraints(
-        modifier = modifier
-            .fillMaxSize()
-            .alpha(alpha)
-            .background(Brush.verticalGradient(listOf(BrandField, BrandDeep))),
-    ) {
+    BoxWithConstraints(modifier = modifier.fillMaxSize().alpha(alpha)) {
         // Read the constraints here and hold them in locals: inside Column the
         // implicit receiver becomes ColumnScope, and maxWidth/maxHeight are no
         // longer in scope.
         val shortestSide = minOf(maxWidth, maxHeight).value
+
+        // Weave scale is derived from the sett, not a fixed fraction, so a
+        // couple of full repeats are always on screen whatever the threadcount
+        // says and whatever the display is.
+        val threadWidth = threadWidthFor(across = shortestSide.dp, repeats = 2f)
         val titleSize = (shortestSide * 0.13f).sp
+        TartanBackground(
+            modifier = Modifier.fillMaxSize(),
+            threadWidth = threadWidth,
+            // On the bias, matching the icon.
+            rotationDegrees = 45f,
+        )
+
+        // A scrim keeps the lettering legible over the busiest part of the sett.
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(Color.Black.copy(alpha = 0.45f))
+        )
 
         Column(
             modifier = Modifier
@@ -95,7 +103,7 @@ fun SplashScreen(
             horizontalAlignment = Alignment.CenterHorizontally,
         ) {
             Text(
-                text = "Pilgrims",
+                text = "Pro Libertate",
                 style = TextStyle(
                     fontFamily = CelticFontFamily,
                     fontSize = titleSize,
@@ -109,11 +117,11 @@ fun SplashScreen(
                 ),
             )
             Text(
-                text = "of Katan",
+                text = "Games",
                 style = TextStyle(
                     fontFamily = CelticFontFamily,
                     fontSize = titleSize,
-                    color = BrandAccent,
+                    color = Color(0xFFF2C200),
                     textAlign = TextAlign.Center,
                     shadow = Shadow(
                         color = Color.Black,

app/src/main/java/org/prolibertate/games/ui/game/CardTable.kt

@@ -19,7 +19,7 @@ import androidx.compose.ui.unit.dp
 import org.prolibertate.games.ui.common.CARD_ASPECT
 import org.prolibertate.games.ui.theme.FeltGreenDark
 import org.prolibertate.games.ui.theme.Parchment
-import org.prolibertate.games.ui.theme.AccentGold
+import org.prolibertate.games.ui.theme.WallaceGold
 
 /**
  * The furniture every patience table needs.
@@ -48,7 +48,7 @@ fun TableSlot(
         modifier = modifier
             .width(width)
             .border(
-                border = BorderStroke(if (highlighted) 3.dp else 0.dp, AccentGold),
+                border = BorderStroke(if (highlighted) 3.dp else 0.dp, WallaceGold),
                 shape = RoundedCornerShape(4.dp),
             )
             .clickable { onClick() },

app/src/main/java/org/prolibertate/games/ui/game/KlondikeScreen.kt

@@ -48,7 +48,7 @@ import org.prolibertate.games.ui.common.CardBackView
 import org.prolibertate.games.ui.common.PlayingCardView
 import org.prolibertate.games.ui.theme.FeltGreenDark
 import org.prolibertate.games.ui.theme.Parchment
-import org.prolibertate.games.ui.theme.AccentGold
+import org.prolibertate.games.ui.theme.WallaceGold
 
 private const val TITLE = "Klondike"
 
@@ -311,7 +311,7 @@ private fun Slot(
         modifier = modifier
             .width(CARD_WIDTH)
             .border(
-                border = BorderStroke(if (highlighted) 3.dp else 0.dp, AccentGold),
+                border = BorderStroke(if (highlighted) 3.dp else 0.dp, WallaceGold),
                 shape = RoundedCornerShape(4.dp),
             )
             .clickable { onClick() },

app/src/main/java/org/prolibertate/games/ui/game/PegSolitaireScreen.kt

@@ -41,8 +41,8 @@ import org.prolibertate.games.net.MatchController
 import org.prolibertate.games.ui.ScreenScaffold
 import org.prolibertate.games.ui.theme.FeltGreenDark
 import org.prolibertate.games.ui.theme.Parchment
-import org.prolibertate.games.ui.theme.AccentGold
-import org.prolibertate.games.ui.theme.AccentRed
+import org.prolibertate.games.ui.theme.WallaceGold
+import org.prolibertate.games.ui.theme.WallaceRed
 
 private const val TITLE = "Peg Solitaire"
 
@@ -214,15 +214,15 @@ private fun HoleView(
     Box(modifier = modifier.size(size), contentAlignment = Alignment.Center) {
         val diameter = size * 0.72f
         val ring = when {
-            selected -> AccentGold
-            isDestination -> AccentGold
+            selected -> WallaceGold
+            isDestination -> WallaceGold
             else -> Parchment.copy(alpha = 0.35f)
         }
         Box(
             modifier = Modifier
                 .size(diameter)
                 .background(
-                    color = if (filled) AccentRed else FeltGreenDark,
+                    color = if (filled) WallaceRed else FeltGreenDark,
                     shape = CircleShape,
                 )
                 .border(

app/src/main/java/org/prolibertate/games/ui/game/YahtzeeScreen.kt

@@ -42,8 +42,8 @@ import org.prolibertate.games.game.yahtzee.scoreOf
 import org.prolibertate.games.net.MatchController
 import org.prolibertate.games.ui.ScreenScaffold
 import org.prolibertate.games.ui.theme.Parchment
-import org.prolibertate.games.ui.theme.AccentGold
-import org.prolibertate.games.ui.theme.AccentRed
+import org.prolibertate.games.ui.theme.WallaceGold
+import org.prolibertate.games.ui.theme.WallaceRed
 
 private const val TITLE = "Yahtzee"
 
@@ -183,7 +183,7 @@ private fun Die(face: Int?, held: Boolean, enabled: Boolean, onClick: () -> Unit
             .background(if (face == null) Parchment.copy(alpha = 0.3f) else Parchment, RoundedCornerShape(8.dp))
             .border(
                 width = if (held) 3.dp else 1.dp,
-                color = if (held) AccentGold else AccentRed.copy(alpha = 0.4f),
+                color = if (held) WallaceGold else WallaceRed.copy(alpha = 0.4f),
                 shape = RoundedCornerShape(8.dp),
             )
             .clickable(enabled = enabled) { onClick() },
@@ -193,7 +193,7 @@ private fun Die(face: Int?, held: Boolean, enabled: Boolean, onClick: () -> Unit
             text = face?.toString() ?: "·",
             style = MaterialTheme.typography.titleLarge,
             fontWeight = FontWeight.Bold,
-            color = AccentRed,
+            color = WallaceRed,
         )
     }
 }
@@ -263,7 +263,7 @@ private fun CardRow(
                 },
                 modifier = Modifier.weight(1f),
                 style = MaterialTheme.typography.bodySmall,
-                color = if (written == null && open) AccentRed else MaterialTheme.colorScheme.onSurface,
+                color = if (written == null && open) WallaceRed else MaterialTheme.colorScheme.onSurface,
             )
         }
     }

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanBoardView.kt

@@ -0,0 +1,507 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.IntSize
+import org.prolibertate.games.game.catan.BuildingType
+import org.prolibertate.games.game.catan.CatanBoard
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.NO_PLAYER
+import org.prolibertate.games.game.catan.Resource
+
+/**
+ * The island, drawn and tappable.
+ *
+ * A stateless view: it is handed the state, the parts of the board that are
+ * currently tappable ([targets]) and the one setup settlement that is waiting
+ * for its road ([selectedVertex]), and it reports taps. It knows no rules; what
+ * a tap *means* is decided by [CatanInteraction]. Where things are is decided by
+ * [BoardLayout], and what they look like by [CatanStyle], so this file is only
+ * the glue between the three.
+ *
+ * To change how a piece is drawn, edit the matching `draw…` function below. To
+ * change a colour or a proportion, edit [CatanStyle] instead.
+ */
+@Composable
+fun CatanBoardView(
+    state: CatanState,
+    targets: BoardTargets,
+    selectedVertex: Int?,
+    onVertexTap: (Int) -> Unit,
+    onEdgeTap: (Int) -> Unit,
+    onHexTap: (Int) -> Unit,
+    modifier: Modifier = Modifier,
+    style: CatanStyle = LocalCatanStyle.current,
+    /** Hexes to light up as having produced on the latest roll. */
+    rolledHexes: Set<Int> = emptySet(),
+) {
+    val measurer = rememberTextMeasurer()
+    var size by remember { mutableStateOf(IntSize.Zero) }
+    val layout = remember(size) {
+        if (size.width > 0 && size.height > 0) {
+            CatanGeometry.fit(size.width.toFloat(), size.height.toFloat())
+        } else {
+            null
+        }
+    }
+
+    // Held in State so the gesture detector, which is only restarted when the
+    // layout or targets change, always calls the latest callbacks.
+    val vertexTap by rememberUpdatedState(onVertexTap)
+    val edgeTap by rememberUpdatedState(onEdgeTap)
+    val hexTap by rememberUpdatedState(onHexTap)
+
+    Canvas(
+        modifier = modifier
+            .aspectRatio(CatanGeometry.ASPECT)
+            .onSizeChanged { size = it }
+            .semantics { contentDescription = "Katan island board" }
+            .pointerInput(layout, targets, style) {
+                detectTapGestures { tap ->
+                    val board = layout ?: return@detectTapGestures
+                    val at = Pt(tap.x, tap.y)
+                    val reach = board.radius * style.tapReach
+                    when {
+                        targets.vertices.isNotEmpty() ->
+                            board.nearestVertex(at, reach, targets.vertices)?.let { vertexTap(it) }
+
+                        targets.edges.isNotEmpty() ->
+                            board.nearestEdge(at, reach, targets.edges)?.let { edgeTap(it) }
+
+                        targets.hexes.isNotEmpty() ->
+                            // A hex is big: accept a tap anywhere near its middle.
+                            board.nearestHex(at, board.radius * 0.95f, targets.hexes)?.let { hexTap(it) }
+                    }
+                }
+            },
+    ) {
+        val board = layout ?: return@Canvas
+        drawRect(color = style.sea)
+        drawPorts(state, board, style, measurer)
+        drawHexes(state, board, style, measurer)
+        drawRolled(rolledHexes, board, style)
+        drawRobber(state, board, style)
+        drawRoads(state, board, style)
+        drawEdgeTargets(targets, board, style)
+        drawBuildings(state, board, style)
+        drawVertexTargets(targets, selectedVertex, board, style)
+        drawHexTargets(targets, board, style)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Terrain and tokens
+// ---------------------------------------------------------------------------
+
+private fun DrawScope.drawHexes(
+    state: CatanState,
+    board: BoardLayout,
+    style: CatanStyle,
+    measurer: TextMeasurer,
+) {
+    for (hex in 0 until CatanBoard.HEX_COUNT) {
+        val centre = board.hexCenter(hex)
+        val corners = board.hexCorners(hex).map { insetToward(it, centre, style.hexInset) }
+        val path = polygon(corners)
+        drawPath(path, color = style.terrain.getValue(state.terrains[hex]))
+        drawPath(path, color = style.hexEdge, style = Stroke(width = board.radius * 0.03f))
+
+        val number = state.numbers[hex]
+        if (number != 0) drawToken(number, centre, board, style, measurer)
+    }
+}
+
+/** A bright wash and rim on each hex that paid out, drawn over the terrain and under the pieces. */
+private fun DrawScope.drawRolled(hexes: Set<Int>, board: BoardLayout, style: CatanStyle) {
+    for (hex in hexes) {
+        val centre = board.hexCenter(hex)
+        val path = polygon(board.hexCorners(hex).map { insetToward(it, centre, style.hexInset + 0.04f) })
+        drawPath(path, color = style.rolled.copy(alpha = 0.28f))
+        drawPath(path, color = style.pieceOutline, style = Stroke(width = board.radius * 0.13f))
+        drawPath(path, color = style.rolled, style = Stroke(width = board.radius * 0.075f))
+    }
+}
+
+private fun DrawScope.drawToken(
+    number: Int,
+    at: Pt,
+    board: BoardLayout,
+    style: CatanStyle,
+    measurer: TextMeasurer,
+) {
+    val radius = board.radius * style.tokenRadius
+    drawCircle(color = style.token, radius = radius, center = at.offset())
+    drawCircle(
+        color = style.hexEdge,
+        radius = radius,
+        center = at.offset(),
+        style = Stroke(width = board.radius * 0.02f),
+    )
+    val hot = number == 6 || number == 8
+    drawCentered(
+        measurer = measurer,
+        text = number.toString(),
+        at = Pt(at.x, at.y - radius * 0.12f),
+        fontPx = board.radius * style.tokenText,
+        color = if (hot) style.tokenHotInk else style.tokenInk,
+        weight = if (hot) FontWeight.ExtraBold else FontWeight.Bold,
+    )
+    // One pip per thirty-sixth of the odds, so the likelier numbers read at a glance.
+    val pips = CatanBoard.numberOdds(number)
+    val pipRadius = radius * 0.075f
+    val gap = pipRadius * 2.6f
+    val startX = at.x - gap * (pips - 1) / 2f
+    for (i in 0 until pips) {
+        drawCircle(
+            color = if (hot) style.tokenHotInk else style.tokenInk,
+            radius = pipRadius,
+            center = Offset(startX + i * gap, at.y + radius * 0.52f),
+        )
+    }
+}
+
+private fun DrawScope.drawRobber(state: CatanState, board: BoardLayout, style: CatanStyle) {
+    val hex = board.hexCenter(state.robber)
+    // Beside the number token rather than on it, so the number stays readable.
+    val x = hex.x + board.radius * 0.5f
+    val y = hex.y + board.radius * 0.3f
+    val s = board.radius * style.robberSize
+    val pawn = Path().apply {
+        moveTo(x - s * 0.55f, y + s * 0.9f)
+        lineTo(x - s * 0.25f, y - s * 0.15f)
+        lineTo(x + s * 0.25f, y - s * 0.15f)
+        lineTo(x + s * 0.55f, y + s * 0.9f)
+        close()
+    }
+    drawPath(pawn, color = style.robber)
+    drawCircle(color = style.robber, radius = s * 0.38f, center = Offset(x, y - s * 0.42f))
+    drawPath(pawn, color = Color.White.copy(alpha = 0.7f), style = Stroke(width = s * 0.07f))
+    drawCircle(
+        color = Color.White.copy(alpha = 0.7f),
+        radius = s * 0.38f,
+        center = Offset(x, y - s * 0.42f),
+        style = Stroke(width = s * 0.07f),
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Harbours
+// ---------------------------------------------------------------------------
+
+private fun DrawScope.drawPorts(
+    state: CatanState,
+    board: BoardLayout,
+    style: CatanStyle,
+    measurer: TextMeasurer,
+) {
+    for (port in state.ports) {
+        val anchor = board.portAnchor(port.edge)
+        val (a, b) = board.edgeEnds(port.edge)
+        val tint = port.resource?.let { style.resource.getValue(it) } ?: style.portInk
+        // Two piers from the marker to the vertices that can use the harbour.
+        for (end in listOf(a, b)) {
+            drawLine(
+                color = style.portMarker.copy(alpha = 0.9f),
+                start = anchor.offset(),
+                end = end.offset(),
+                strokeWidth = board.radius * 0.07f,
+                cap = StrokeCap.Round,
+            )
+        }
+        val radius = board.radius * style.portRadius
+        drawCircle(color = style.portMarker, radius = radius, center = anchor.offset())
+        drawCircle(
+            color = tint,
+            radius = radius,
+            center = anchor.offset(),
+            style = Stroke(width = board.radius * 0.07f),
+        )
+        // What the harbour trades: a picture of the resource, or "?" for any.
+        val iconAt = Pt(anchor.x, anchor.y - radius * 0.27f)
+        val iconSize = radius * 0.5f
+        val resource = port.resource
+        if (resource != null) {
+            drawResourceIcon(resource, iconAt, iconSize, tint, style.pieceOutline)
+        } else {
+            drawCentered(
+                measurer = measurer,
+                text = "?",
+                at = iconAt,
+                fontPx = board.radius * style.portText * 1.5f,
+                color = style.portInk,
+                weight = FontWeight.ExtraBold,
+            )
+        }
+        drawCentered(
+            measurer = measurer,
+            text = "${port.ratio}:1",
+            at = Pt(anchor.x, anchor.y + radius * 0.5f),
+            fontPx = board.radius * style.portText,
+            color = style.portInk,
+            weight = FontWeight.Bold,
+        )
+    }
+}
+
+/**
+ * A small pictogram of [resource] centred on [at], about 2·[s] across: a tree,
+ * bricks, a sheep, an ear of wheat or a rock. Drawn with paths so there are no
+ * image assets to ship or scale.
+ */
+private fun DrawScope.drawResourceIcon(resource: Resource, at: Pt, s: Float, fill: Color, line: Color) {
+    val outline = Stroke(width = s * 0.12f)
+    when (resource) {
+        Resource.LUMBER -> {
+            val crown = Path().apply {
+                moveTo(at.x, at.y - s)
+                lineTo(at.x + s * 0.8f, at.y + s * 0.3f)
+                lineTo(at.x - s * 0.8f, at.y + s * 0.3f)
+                close()
+            }
+            drawRect(color = line, topLeft = Offset(at.x - s * 0.14f, at.y + s * 0.3f), size = Size(s * 0.28f, s * 0.6f))
+            drawPath(crown, color = fill)
+            drawPath(crown, color = line, style = outline)
+        }
+
+        Resource.BRICK -> {
+            val w = s * 0.9f
+            val h = s * 0.42f
+            for ((row, shift) in listOf(0f to 0f, 1f to w * 0.5f)) {
+                val top = at.y - h + row * h
+                val left = at.x - w + shift - w * 0.25f
+                for (col in 0..1) {
+                    val x = left + col * w
+                    drawRect(color = fill, topLeft = Offset(x, top), size = Size(w, h))
+                    drawRect(color = line, topLeft = Offset(x, top), size = Size(w, h), style = outline)
+                }
+            }
+        }
+
+        Resource.WOOL -> {
+            for ((dx, dy) in listOf(-0.45f to 0f, 0.1f to -0.25f, 0.5f to 0.05f, 0f to 0.2f)) {
+                drawCircle(color = fill, radius = s * 0.42f, center = Offset(at.x + dx * s, at.y + dy * s))
+            }
+            drawCircle(color = line, radius = s * 0.24f, center = Offset(at.x - s * 0.85f, at.y + s * 0.15f))
+            drawRect(color = line, topLeft = Offset(at.x - s * 0.5f, at.y + s * 0.5f), size = Size(s * 0.14f, s * 0.45f))
+            drawRect(color = line, topLeft = Offset(at.x + s * 0.3f, at.y + s * 0.5f), size = Size(s * 0.14f, s * 0.45f))
+        }
+
+        Resource.GRAIN -> {
+            drawLine(color = line, start = Offset(at.x, at.y + s), end = Offset(at.x, at.y - s * 0.7f), strokeWidth = s * 0.14f)
+            for (i in 0..2) {
+                val y = at.y - s * 0.7f + i * s * 0.5f
+                for (side in listOf(-1f, 1f)) {
+                    val kernel = Path().apply {
+                        moveTo(at.x, y + s * 0.3f)
+                        lineTo(at.x + side * s * 0.6f, y - s * 0.05f)
+                        lineTo(at.x + side * s * 0.15f, y - s * 0.2f)
+                        close()
+                    }
+                    drawPath(kernel, color = fill)
+                    drawPath(kernel, color = line, style = Stroke(width = s * 0.08f))
+                }
+            }
+        }
+
+        Resource.ORE -> {
+            val peak = Path().apply {
+                moveTo(at.x - s, at.y + s * 0.8f)
+                lineTo(at.x - s * 0.3f, at.y - s * 0.6f)
+                lineTo(at.x + s * 0.1f, at.y + s * 0.05f)
+                lineTo(at.x + s * 0.45f, at.y - s * 0.3f)
+                lineTo(at.x + s, at.y + s * 0.8f)
+                close()
+            }
+            drawPath(peak, color = fill)
+            drawPath(peak, color = line, style = outline)
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Pieces
+// ---------------------------------------------------------------------------
+
+private fun DrawScope.drawRoads(state: CatanState, board: BoardLayout, style: CatanStyle) {
+    for (edge in 0 until CatanBoard.EDGE_COUNT) {
+        val owner = state.roads[edge]
+        if (owner == NO_PLAYER) continue
+        val (a, b) = board.edgeEnds(edge)
+        // Pulled in from the ends so adjacent roads do not fuse into a blob.
+        val from = lerp(a, b, 0.12f)
+        val to = lerp(a, b, 0.88f)
+        val width = board.radius * style.roadWidth
+        drawLine(
+            color = style.pieceOutline,
+            start = from.offset(),
+            end = to.offset(),
+            strokeWidth = width * 1.45f,
+            cap = StrokeCap.Round,
+        )
+        drawLine(
+            color = style.seats[owner % style.seats.size],
+            start = from.offset(),
+            end = to.offset(),
+            strokeWidth = width,
+            cap = StrokeCap.Round,
+        )
+    }
+}
+
+private fun DrawScope.drawBuildings(state: CatanState, board: BoardLayout, style: CatanStyle) {
+    for (vertex in 0 until CatanBoard.VERTEX_COUNT) {
+        val building = state.buildings[vertex] ?: continue
+        val at = board.vertex(vertex)
+        val fill = style.seats[building.owner % style.seats.size]
+        val path = when (building.type) {
+            BuildingType.SETTLEMENT -> housePath(at, board.radius * style.settlementSize)
+            BuildingType.CITY -> cityPath(at, board.radius * style.citySize * 0.8f)
+        }
+        drawPath(path, color = fill)
+        drawPath(path, color = style.pieceOutline, style = Stroke(width = board.radius * 0.045f))
+    }
+}
+
+/** One gable: a settlement. [s] is its half-width. */
+private fun housePath(at: Pt, s: Float): Path = Path().apply {
+    moveTo(at.x - s, at.y + s * 0.7f)
+    lineTo(at.x - s, at.y - s * 0.1f)
+    lineTo(at.x, at.y - s)
+    lineTo(at.x + s, at.y - s * 0.1f)
+    lineTo(at.x + s, at.y + s * 0.7f)
+    close()
+}
+
+/** Two gables, the taller on the left: a city. [s] is the unit its outline is scaled by. */
+private fun cityPath(at: Pt, s: Float): Path = Path().apply {
+    moveTo(at.x - s, at.y + s * 0.7f)
+    lineTo(at.x - s, at.y - s * 0.5f)
+    lineTo(at.x - s * 0.45f, at.y - s * 1.1f)
+    lineTo(at.x + s * 0.1f, at.y - s * 0.5f)
+    lineTo(at.x + s * 0.1f, at.y - s * 0.1f)
+    lineTo(at.x + s * 0.55f, at.y - s * 0.55f)
+    lineTo(at.x + s * 1.1f, at.y - s * 0.1f)
+    lineTo(at.x + s * 1.1f, at.y + s * 0.7f)
+    close()
+}
+
+// ---------------------------------------------------------------------------
+// Tap targets
+// ---------------------------------------------------------------------------
+
+private fun DrawScope.drawVertexTargets(
+    targets: BoardTargets,
+    selected: Int?,
+    board: BoardLayout,
+    style: CatanStyle,
+) {
+    val radius = board.radius * style.targetRadius
+    for (vertex in targets.vertices) {
+        val at = board.vertex(vertex).offset()
+        drawCircle(color = style.target.copy(alpha = 0.85f), radius = radius, center = at)
+        drawCircle(
+            color = style.pieceOutline,
+            radius = radius,
+            center = at,
+            style = Stroke(width = board.radius * 0.04f),
+        )
+    }
+    if (selected != null) {
+        val at = board.vertex(selected).offset()
+        drawCircle(
+            color = style.targetSelected,
+            radius = radius * 1.6f,
+            center = at,
+            style = Stroke(width = board.radius * 0.09f),
+        )
+    }
+}
+
+private fun DrawScope.drawEdgeTargets(targets: BoardTargets, board: BoardLayout, style: CatanStyle) {
+    for (edge in targets.edges) {
+        val (a, b) = board.edgeEnds(edge)
+        val from = lerp(a, b, 0.15f)
+        val to = lerp(a, b, 0.85f)
+        drawLine(
+            color = style.pieceOutline,
+            start = from.offset(),
+            end = to.offset(),
+            strokeWidth = board.radius * style.roadWidth * 1.5f,
+            cap = StrokeCap.Round,
+        )
+        drawLine(
+            color = style.target.copy(alpha = 0.9f),
+            start = from.offset(),
+            end = to.offset(),
+            strokeWidth = board.radius * style.roadWidth,
+            cap = StrokeCap.Round,
+        )
+    }
+}
+
+private fun DrawScope.drawHexTargets(targets: BoardTargets, board: BoardLayout, style: CatanStyle) {
+    for (hex in targets.hexes) {
+        val centre = board.hexCenter(hex)
+        val path = polygon(board.hexCorners(hex).map { insetToward(it, centre, style.hexInset + 0.08f) })
+        drawPath(path, color = style.target.copy(alpha = 0.38f))
+        drawPath(path, color = style.target, style = Stroke(width = board.radius * 0.07f))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Drawing helpers
+// ---------------------------------------------------------------------------
+
+private fun Pt.offset(): Offset = Offset(x, y)
+
+private fun lerp(a: Pt, b: Pt, t: Float): Pt = Pt(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t)
+
+/** [p] moved [fraction] of the way toward [centre]. */
+private fun insetToward(p: Pt, centre: Pt, fraction: Float): Pt = lerp(p, centre, fraction)
+
+private fun polygon(points: List<Pt>): Path = Path().apply {
+    points.forEachIndexed { i, p -> if (i == 0) moveTo(p.x, p.y) else lineTo(p.x, p.y) }
+    close()
+}
+
+private fun DrawScope.drawCentered(
+    measurer: TextMeasurer,
+    text: String,
+    at: Pt,
+    fontPx: Float,
+    color: Color,
+    weight: FontWeight,
+) {
+    val layout = measurer.measure(
+        text = text,
+        style = TextStyle(fontSize = fontPx.toSp(), fontWeight = weight, color = color),
+    )
+    drawText(
+        textLayoutResult = layout,
+        topLeft = Offset(at.x - layout.size.width / 2f, at.y - layout.size.height / 2f),
+    )
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanDialogs.kt

@@ -0,0 +1,620 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import org.prolibertate.games.game.catan.CatanMove
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.DevCardType
+import org.prolibertate.games.game.catan.Discard
+import org.prolibertate.games.game.catan.MaritimeTrade
+import org.prolibertate.games.game.catan.OfferTrade
+import org.prolibertate.games.game.catan.TradeCounter
+import org.prolibertate.games.game.catan.CounterTrade
+import org.prolibertate.games.game.catan.AcceptCounter
+import org.prolibertate.games.game.catan.PlayKnight
+import org.prolibertate.games.game.catan.PlayRoadBuilding
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.catan.TradeOffer
+
+/*
+ * Every Katan dialog. Each is a stateless composable apart from the selection it
+ * is helping the player make (cards picked, a partner chosen); the move it ends
+ * in is reported through a lambda and sent by the screen. What is *allowed* is
+ * always asked of [CatanInteraction], never decided here.
+ */
+
+// ---------------------------------------------------------------------------
+// Shared pieces
+// ---------------------------------------------------------------------------
+
+/** A resource tile with a minus and a plus, for choosing how many cards. */
+@Composable
+private fun ResourceCounter(
+    resource: Resource,
+    count: Int,
+    max: Int,
+    onChange: (Int) -> Unit,
+) {
+    Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        ResourceTile(resource, count, enabled = max > 0 || count > 0)
+        Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            OutlinedButton(
+                onClick = { onChange(count - 1) },
+                enabled = count > 0,
+                contentPadding = PaddingValues(0.dp),
+                modifier = Modifier.width(34.dp).height(32.dp),
+            ) { Text("−") }
+            OutlinedButton(
+                onClick = { onChange(count + 1) },
+                enabled = count < max,
+                contentPadding = PaddingValues(0.dp),
+                modifier = Modifier.width(34.dp).height(32.dp),
+            ) { Text("+") }
+        }
+    }
+}
+
+private fun Map<Resource, Int>.asCards(): List<Resource> =
+    Resource.entries.flatMap { r -> List(this[r] ?: 0) { r } }
+
+// ---------------------------------------------------------------------------
+// Discarding on a seven
+// ---------------------------------------------------------------------------
+
+/**
+ * A seven was rolled and this player holds more than seven cards: choose which
+ * half to give up. Not dismissable — the game is waiting on it.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanDiscardDialog(
+    held: Map<Resource, Int>,
+    quota: Int,
+    legal: List<CatanMove>,
+    onSubmit: (Discard) -> Unit,
+) {
+    var picked by remember { mutableStateOf(emptyMap<Resource, Int>()) }
+    val selection = picked.asCards()
+    val move = CatanInteraction.discardMove(legal, selection)
+
+    AlertDialog(
+        onDismissRequest = {},
+        title = { Text("Discard $quota cards") },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                Text(
+                    "A seven was rolled. Choose $quota cards to give up " +
+                        "(${selection.size} of $quota chosen).",
+                )
+                FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    verticalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    Resource.entries.forEach { resource ->
+                        val have = held[resource] ?: 0
+                        if (have > 0) {
+                            ResourceCounter(
+                                resource = resource,
+                                count = picked[resource] ?: 0,
+                                max = if (selection.size < quota) have else (picked[resource] ?: 0),
+                                onChange = { n -> picked = picked + (resource to n.coerceIn(0, have)) },
+                            )
+                        }
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            Button(onClick = { move?.let(onSubmit) }, enabled = move != null) { Text("Discard") }
+        },
+    )
+}
+
+// ---------------------------------------------------------------------------
+// The robber
+// ---------------------------------------------------------------------------
+
+/** More than one player can be robbed from this hex: choose whom. */
+@Composable
+fun CatanVictimDialog(
+    victims: List<Int>,
+    seats: CatanSeats,
+    onPick: (Int) -> Unit,
+    onCancel: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onCancel,
+        title = { Text("Steal from…") },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                victims.forEach { seat ->
+                    OutlinedButton(onClick = { onPick(seat) }, modifier = Modifier.fillMaxWidth()) {
+                        Text(seats.label(seat))
+                    }
+                }
+            }
+        },
+        confirmButton = {},
+        dismissButton = { TextButton(onClick = onCancel) { Text(CatanText.CANCEL) } },
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Development cards
+// ---------------------------------------------------------------------------
+
+/**
+ * The player's development cards. A Knight or Road Building plays at once; a
+ * Monopoly or Year of Plenty asks for its resource choice in a second step.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanPlayCardDialog(
+    hand: List<DevCardInHand>,
+    onPlay: (CatanMove) -> Unit,
+    onCancel: () -> Unit,
+) {
+    var chosen by remember { mutableStateOf<DevCardInHand?>(null) }
+    var picked by remember { mutableStateOf(emptyList<Resource>()) }
+    val card = chosen
+
+    AlertDialog(
+        onDismissRequest = onCancel,
+        title = { Text(card?.let { CatanText.devCard(it.card.type) } ?: "Development cards") },
+        text = {
+            Column(
+                modifier = Modifier.heightIn(max = 420.dp).verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(10.dp),
+            ) {
+                when {
+                    card == null -> {
+                        if (hand.isEmpty()) Text("You have no development cards.")
+                        hand.forEach { entry -> DevCardRow(entry, onPlay) { chosen = it } }
+                    }
+
+                    card.card.type == DevCardType.MONOPOLY -> {
+                        Text("Name a resource. Every other player hands over all of it.")
+                        val choices = CatanInteraction.monopolyChoices(card.plays)
+                        FlowRow(
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            Resource.entries.forEach { resource ->
+                                val move = choices[resource]
+                                ResourceTile(
+                                    resource = resource,
+                                    count = 0,
+                                    enabled = move != null,
+                                    onClick = { move?.let(onPlay) },
+                                )
+                            }
+                        }
+                    }
+
+                    card.card.type == DevCardType.YEAR_OF_PLENTY -> {
+                        Text("Take two resource cards from the bank (${picked.size} of 2 chosen).")
+                        val available = CatanInteraction.plentyAvailable(card.plays, picked)
+                        FlowRow(
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            Resource.entries.forEach { resource ->
+                                ResourceTile(
+                                    resource = resource,
+                                    count = picked.count { it == resource },
+                                    selected = resource in picked,
+                                    enabled = resource in available,
+                                    onClick = { picked = picked + resource },
+                                )
+                            }
+                        }
+                        if (picked.isNotEmpty()) {
+                            TextButton(onClick = { picked = emptyList() }) { Text("Clear") }
+                        }
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            if (card != null && card.card.type == DevCardType.YEAR_OF_PLENTY) {
+                val move = CatanInteraction.plentyMove(card.plays, picked)
+                Button(onClick = { move?.let(onPlay) }, enabled = move != null) { Text("Take") }
+            }
+        },
+        dismissButton = {
+            TextButton(
+                onClick = {
+                    if (card == null) {
+                        onCancel()
+                    } else {
+                        chosen = null
+                        picked = emptyList()
+                    }
+                },
+            ) { Text(if (card == null) CatanText.CANCEL else "Back") }
+        },
+    )
+}
+
+@Composable
+private fun DevCardRow(
+    entry: DevCardInHand,
+    onPlay: (CatanMove) -> Unit,
+    onChoose: (DevCardInHand) -> Unit,
+) {
+    val type = entry.card.type
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Column(modifier = Modifier.weight(1f)) {
+            Text(CatanText.devCard(type), fontWeight = FontWeight.Bold)
+            Text(CatanText.devCardHelp(type), style = MaterialTheme.typography.bodySmall)
+        }
+        when {
+            type == DevCardType.VICTORY_POINT -> Text("Hidden", style = MaterialTheme.typography.labelSmall)
+            !entry.playable -> Text("Not now", style = MaterialTheme.typography.labelSmall)
+            entry.plays.size == 1 && (entry.plays[0] is PlayKnight || entry.plays[0] is PlayRoadBuilding) ->
+                Button(onClick = { onPlay(entry.plays[0]) }) { Text("Play") }
+
+            else -> Button(onClick = { onChoose(entry) }) { Text("Play…") }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Trading
+// ---------------------------------------------------------------------------
+
+private enum class TradeTab { BANK, PLAYER }
+
+/**
+ * Trade with the bank at the best ratio the player has, or offer cards to one
+ * other player. Offers are free-form, so they are checked with the engine's
+ * structural rule ([CatanInteraction.offerAllowed]) rather than looked up in
+ * the legal list.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanTradeDialog(
+    state: CatanState,
+    seat: Int,
+    seats: CatanSeats,
+    legal: List<CatanMove>,
+    onBank: (MaritimeTrade) -> Unit,
+    onOffer: (OfferTrade) -> Unit,
+    onCancel: () -> Unit,
+) {
+    var tab by remember { mutableStateOf(TradeTab.BANK) }
+    var bankGive by remember { mutableStateOf<Resource?>(null) }
+    var everyone by remember { mutableStateOf(true) }
+    var partner by remember { mutableStateOf<Int?>(null) }
+    var give by remember { mutableStateOf(emptyMap<Resource, Int>()) }
+    var get by remember { mutableStateOf(emptyMap<Resource, Int>()) }
+
+    AlertDialog(
+        onDismissRequest = onCancel,
+        title = { Text(CatanText.TRADE) },
+        text = {
+            Column(
+                modifier = Modifier.heightIn(max = 460.dp).verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    TabButton(CatanText.TRADE_WITH_BANK, tab == TradeTab.BANK) { tab = TradeTab.BANK }
+                    TabButton(CatanText.TRADE_WITH_PLAYER, tab == TradeTab.PLAYER) { tab = TradeTab.PLAYER }
+                }
+
+                if (tab == TradeTab.BANK) {
+                    val trades = CatanInteraction.bankTrades(legal)
+                    if (trades.isEmpty()) {
+                        Text("You do not hold enough of any one resource to trade with the bank.")
+                    } else {
+                        Text("Give:", fontWeight = FontWeight.Bold)
+                        FlowRow(
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            trades.keys.forEach { resource ->
+                                val ratio = CatanInteraction.bankRatio(state, seat, resource)
+                                Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                    ResourceTile(
+                                        resource = resource,
+                                        count = ratio,
+                                        selected = bankGive == resource,
+                                        onClick = { bankGive = resource },
+                                    )
+                                    Text("$ratio : 1", style = MaterialTheme.typography.labelSmall)
+                                }
+                            }
+                        }
+                        val chosen = bankGive
+                        if (chosen != null && chosen in trades) {
+                            Text("Get one:", fontWeight = FontWeight.Bold)
+                            FlowRow(
+                                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                                verticalArrangement = Arrangement.spacedBy(8.dp),
+                            ) {
+                                trades.getValue(chosen).forEach { resource ->
+                                    ResourceTile(
+                                        resource = resource,
+                                        count = 1,
+                                        onClick = { onBank(MaritimeTrade(chosen, resource)) },
+                                    )
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    Text("Offer to:", fontWeight = FontWeight.Bold)
+                    FlowRow(
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        verticalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        TabButton(CatanText.EVERYONE, everyone) { everyone = true; partner = null }
+                        (0 until state.playerCount).filter { it != seat }.forEach { other ->
+                            TabButton(seats.label(other), !everyone && partner == other) {
+                                everyone = false
+                                partner = other
+                            }
+                        }
+                    }
+                    Text(CatanText.YOU_GIVE, fontWeight = FontWeight.Bold)
+                    CounterRow(
+                        counts = give,
+                        limit = { state.resources[seat][it] ?: 0 },
+                        onChange = { give = it },
+                    )
+                    Text(CatanText.YOU_GET, fontWeight = FontWeight.Bold)
+                    CounterRow(counts = get, limit = { 9 }, onChange = { get = it })
+                }
+            }
+        },
+        confirmButton = {
+            if (tab == TradeTab.PLAYER) {
+                val to = if (everyone) null else partner
+                val giveCards = give.asCards()
+                val getCards = get.asCards()
+                val allowed = (everyone || partner != null) &&
+                    CatanInteraction.offerAllowed(state, seat, to, giveCards, getCards)
+                Button(
+                    onClick = { onOffer(OfferTrade(to, giveCards, getCards)) },
+                    enabled = allowed,
+                ) { Text(CatanText.SEND_OFFER) }
+            }
+        },
+        dismissButton = { TextButton(onClick = onCancel) { Text(CatanText.CANCEL) } },
+    )
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun CounterRow(
+    counts: Map<Resource, Int>,
+    limit: (Resource) -> Int,
+    onChange: (Map<Resource, Int>) -> Unit,
+) {
+    FlowRow(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Resource.entries.forEach { resource ->
+            ResourceCounter(
+                resource = resource,
+                count = counts[resource] ?: 0,
+                max = limit(resource),
+                onChange = { n -> onChange(counts + (resource to n.coerceIn(0, limit(resource)))) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun TabButton(label: String, selected: Boolean, onClick: () -> Unit) {
+    if (selected) {
+        FilledTonalButton(onClick = onClick) { Text(label) }
+    } else {
+        OutlinedButton(onClick = onClick) { Text(label) }
+    }
+}
+
+/**
+ * Another player has put an offer to the local player (alone, or as one of the
+ * table). Accept, decline, or — via a second step — answer with different terms.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanTradeResponseDialog(
+    state: CatanState,
+    seat: Int,
+    offer: TradeOffer,
+    seats: CatanSeats,
+    canAccept: Boolean,
+    onAccept: () -> Unit,
+    onDecline: () -> Unit,
+    onCounter: (CounterTrade) -> Unit,
+) {
+    var countering by remember(offer) { mutableStateOf(false) }
+    // What we would give the offerer, and what we would ask of them.
+    var give by remember(offer) { mutableStateOf(offer.get.groupingBy { it }.eachCount()) }
+    var get by remember(offer) { mutableStateOf(offer.give.groupingBy { it }.eachCount()) }
+
+    AlertDialog(
+        onDismissRequest = {},
+        title = { Text(if (countering) "Counter-offer" else "Trade offer") },
+        text = {
+            Column(
+                modifier = Modifier.heightIn(max = 460.dp).verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Text(
+                    CatanText.tradeSummary(
+                        by = seats.label(offer.by),
+                        to = if (offer.to == null) "the table" else "you",
+                        give = offer.give,
+                        get = offer.get,
+                    ),
+                )
+                if (countering) {
+                    Text(CatanText.YOU_GIVE, fontWeight = FontWeight.Bold)
+                    CounterRow(
+                        counts = give,
+                        limit = { state.resources[seat][it] ?: 0 },
+                        onChange = { give = it },
+                    )
+                    Text(CatanText.YOU_GET, fontWeight = FontWeight.Bold)
+                    CounterRow(
+                        counts = get,
+                        limit = { state.resources[offer.by][it] ?: 0 },
+                        onChange = { get = it },
+                    )
+                } else if (!canAccept) {
+                    Text(
+                        "You cannot accept this: one side no longer holds the cards.",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            if (countering) {
+                val move = CounterTrade(give.asCards(), get.asCards())
+                Button(
+                    onClick = { onCounter(move) },
+                    enabled = CatanInteraction.counterAllowed(state, seat, move.give, move.get),
+                ) { Text(CatanText.SEND_COUNTER) }
+            } else {
+                Button(onClick = onAccept, enabled = canAccept) { Text(CatanText.ACCEPT) }
+            }
+        },
+        dismissButton = {
+            Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+                if (countering) {
+                    TextButton(onClick = { countering = false }) { Text(CatanText.CANCEL) }
+                } else {
+                    TextButton(onClick = { countering = true }) { Text(CatanText.COUNTER) }
+                }
+                TextButton(onClick = onDecline) { Text(CatanText.DECLINE) }
+            }
+        },
+    )
+}
+
+/** The offerer's choice once nobody accepted: take a counter-offer, or none. */
+@Composable
+fun CatanCounterChoiceDialog(
+    counters: List<TradeCounter>,
+    seats: CatanSeats,
+    onTake: (AcceptCounter) -> Unit,
+    onNoDeal: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = {},
+        title = { Text("Counter-offers") },
+        text = {
+            Column(
+                modifier = Modifier.heightIn(max = 460.dp).verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                if (counters.isEmpty()) {
+                    Text("None of the counter-offers can be met any more.")
+                }
+                counters.forEach { counter ->
+                    Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                        Text(CatanText.counterSummary(seats.label(counter.by), counter.give, counter.get))
+                        Button(onClick = { onTake(AcceptCounter(counter.by)) }) { Text(CatanText.ACCEPT) }
+                    }
+                }
+            }
+        },
+        confirmButton = { TextButton(onClick = onNoDeal) { Text(CatanText.NO_DEAL) } },
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Ending
+// ---------------------------------------------------------------------------
+
+/** The game is over: who won, and what everyone finished with. */
+@Composable
+fun CatanGameOverDialog(
+    state: CatanState,
+    seats: CatanSeats,
+    onExit: () -> Unit,
+    onLook: () -> Unit,
+) {
+    val points = (0 until state.playerCount).map { seat ->
+        // The winner's hidden victory-point cards are revealed by winning; the
+        // host's copy of the state has them, a client's has only its own.
+        seat to if (seat == seats.me) CatanRules.victoryPoints(state, seat)
+        else CatanRules.publicVictoryPoints(state)[seat]
+    }
+    AlertDialog(
+        onDismissRequest = onLook,
+        title = { Text(CatanText.winnerHeadline(state, seats)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                points.sortedByDescending { it.second }.forEach { (seat, vp) ->
+                    Text("${seats.label(seat)}: $vp points")
+                }
+            }
+        },
+        confirmButton = { TextButton(onClick = onExit) { Text(CatanText.LEAVE_GAME) } },
+        dismissButton = { TextButton(onClick = onLook) { Text(CatanText.LOOK_AT_BOARD) } },
+    )
+}
+
+@Composable
+fun CatanEndGameDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
+    AlertDialog(
+        onDismissRequest = onKeepPlaying,
+        title = { Text("End this game?") },
+        text = {
+            Text(
+                "This game ends here and the position is not saved. Anyone else " +
+                    "at the table is told you have left.",
+            )
+        },
+        confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
+        dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
+    )
+}
+
+@Composable
+fun CatanAbandonedDialog(notice: String, onExit: () -> Unit, onStay: () -> Unit) {
+    AlertDialog(
+        onDismissRequest = onStay,
+        title = { Text("The game has ended") },
+        text = { Text("$notice There are no more moves to play.") },
+        confirmButton = { TextButton(onClick = onExit) { Text(CatanText.LEAVE_GAME) } },
+        dismissButton = { TextButton(onClick = onStay) { Text(CatanText.LOOK_AT_BOARD) } },
+    )
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanGeometry.kt

@@ -0,0 +1,123 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.prolibertate.games.game.catan.CatanBoard
+import kotlin.math.sqrt
+
+/** A point in board pixels. Plain floats, so this file needs no Compose types. */
+data class Pt(val x: Float, val y: Float)
+
+/**
+ * Where the island sits on screen: the one place the engine's integer lattice
+ * (see [CatanBoard]) becomes pixels, and pixels become "which vertex / edge /
+ * hex did the player tap".
+ *
+ * Pure and Android-free, so it is unit-tested (`CatanGeometryTest`). The drawing
+ * code ([CatanBoardView]) and the tap handling both go through this, which is
+ * what keeps what is drawn and what is tappable from ever disagreeing.
+ *
+ * Lattice to pixel: a hex of circumradius `R` is pointy-top, so one lattice x-unit
+ * is `R·√3/2` and one lattice y-unit is `R/2`, and lattice +Y points up the board
+ * while pixel +y points down.
+ */
+class BoardLayout(
+    val width: Float,
+    val height: Float,
+    /** Circumradius of one hex, in pixels. */
+    val radius: Float,
+) {
+    private val centreX = width / 2f
+    private val centreY = height / 2f
+    private val unitX = radius * SQRT3 / 2f
+    private val unitY = radius / 2f
+
+    fun point(latticeX: Int, latticeY: Int): Pt =
+        Pt(centreX + latticeX * unitX, centreY - latticeY * unitY)
+
+    fun hexCenter(hex: Int): Pt {
+        val (lx, ly) = CatanBoard.hexCenter(hex)
+        return point(lx, ly)
+    }
+
+    fun vertex(vertex: Int): Pt {
+        val (lx, ly) = CatanBoard.VERTEX_POS[vertex]
+        return point(lx, ly)
+    }
+
+    fun hexCorners(hex: Int): List<Pt> = CatanBoard.HEX_CORNERS[hex].map { vertex(it) }
+
+    fun edgeEnds(edge: Int): Pair<Pt, Pt> {
+        val (a, b) = CatanBoard.EDGE_VERTICES[edge]
+        return vertex(a) to vertex(b)
+    }
+
+    fun edgeMidpoint(edge: Int): Pt {
+        val (a, b) = edgeEnds(edge)
+        return Pt((a.x + b.x) / 2f, (a.y + b.y) / 2f)
+    }
+
+    /**
+     * Where a harbour's marker is drawn: just off the coast, straight out from
+     * the middle of its edge. The marker is joined to the edge's two vertices by
+     * the board view, which is what shows which settlements can use it.
+     */
+    fun portAnchor(edge: Int): Pt {
+        val mid = edgeMidpoint(edge)
+        val dx = mid.x - centreX
+        val dy = mid.y - centreY
+        val length = sqrt(dx * dx + dy * dy).coerceAtLeast(1f)
+        return Pt(mid.x + dx / length * radius * PORT_OFFSET, mid.y + dy / length * radius * PORT_OFFSET)
+    }
+
+    /** The nearest of [among] within [reach] pixels of [at], or null. */
+    fun nearestVertex(at: Pt, reach: Float, among: Collection<Int>): Int? =
+        nearest(at, reach, among) { vertex(it) }
+
+    fun nearestEdge(at: Pt, reach: Float, among: Collection<Int>): Int? =
+        nearest(at, reach, among) { edgeMidpoint(it) }
+
+    fun nearestHex(at: Pt, reach: Float, among: Collection<Int>): Int? =
+        nearest(at, reach, among) { hexCenter(it) }
+
+    private fun nearest(at: Pt, reach: Float, among: Collection<Int>, position: (Int) -> Pt): Int? {
+        var best: Int? = null
+        var bestDistance = reach * reach
+        for (candidate in among) {
+            val p = position(candidate)
+            val dx = p.x - at.x
+            val dy = p.y - at.y
+            val d = dx * dx + dy * dy
+            if (d <= bestDistance) {
+                best = candidate
+                bestDistance = d
+            }
+        }
+        return best
+    }
+}
+
+object CatanGeometry {
+
+    /** Lattice extents of the island: x spans -5..5, y spans -8..8. */
+    private const val LATTICE_X_UNITS = 10
+    private const val LATTICE_Y_UNITS = 16
+
+    /** Empty space round the island, in hex radii, for the sea and the harbours. */
+    const val MARGIN = 1.75f
+
+    private val boardWidthInRadii = LATTICE_X_UNITS * SQRT3 / 2f + 2 * MARGIN
+    private val boardHeightInRadii = LATTICE_Y_UNITS / 2f + 2 * MARGIN
+
+    /** Width ÷ height of the board including its margin, for sizing its box. */
+    val ASPECT: Float = boardWidthInRadii / boardHeightInRadii
+
+    /** The largest layout that fits [width] × [height] pixels. */
+    fun fit(width: Float, height: Float): BoardLayout {
+        val radius = minOf(width / boardWidthInRadii, height / boardHeightInRadii)
+        return BoardLayout(width, height, radius)
+    }
+}
+
+private const val SQRT3 = 1.7320508f
+
+/** How far past the coast a harbour marker sits, in hex radii. Far enough that its piers are clearly visible. */
+internal const val PORT_OFFSET = 1.0f

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanInteraction.kt

@@ -0,0 +1,306 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.prolibertate.games.game.catan.AcceptCounter
+import org.prolibertate.games.game.catan.AcceptTrade
+import org.prolibertate.games.game.catan.BuildCity
+import org.prolibertate.games.game.catan.BuildRoad
+import org.prolibertate.games.game.catan.BuildSettlement
+import org.prolibertate.games.game.catan.BuyDevCard
+import org.prolibertate.games.game.catan.CatanBoard
+import org.prolibertate.games.game.catan.CatanMove
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.CounterTrade
+import org.prolibertate.games.game.catan.DeclineTrade
+import org.prolibertate.games.game.catan.DevCard
+import org.prolibertate.games.game.catan.DevCardType
+import org.prolibertate.games.game.catan.Discard
+import org.prolibertate.games.game.catan.EndFreeRoads
+import org.prolibertate.games.game.catan.EndTurn
+import org.prolibertate.games.game.catan.HexCoord
+import org.prolibertate.games.game.catan.MaritimeTrade
+import org.prolibertate.games.game.catan.MoveRobber
+import org.prolibertate.games.game.catan.OfferTrade
+import org.prolibertate.games.game.catan.TradeCounter
+import org.prolibertate.games.game.catan.PlayKnight
+import org.prolibertate.games.game.catan.PlayMonopoly
+import org.prolibertate.games.game.catan.PlayRoadBuilding
+import org.prolibertate.games.game.catan.PlayYearOfPlenty
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.catan.RollDice
+import org.prolibertate.games.game.catan.SetupPlace
+
+/** What a player can ask to build by tapping the board. */
+enum class BuildKind { ROAD, SETTLEMENT, CITY }
+
+/** The parts of the board the player may tap right now. Everything else is inert. */
+data class BoardTargets(
+    val vertices: Set<Int> = emptySet(),
+    val edges: Set<Int> = emptySet(),
+    val hexes: Set<Int> = emptySet(),
+) {
+    val isEmpty: Boolean get() = vertices.isEmpty() && edges.isEmpty() && hexes.isEmpty()
+}
+
+/** What a tap on the board amounts to. */
+sealed interface TapOutcome {
+    /** Nothing: the tap landed somewhere that is not a legal target. */
+    data object Ignored : TapOutcome
+
+    /** Send this move to the table. */
+    data class Submit(val move: CatanMove) : TapOutcome
+
+    /** Setup: remember this settlement; the road that goes with it is tapped next. */
+    data class PickSetupVertex(val vertex: Int) : TapOutcome
+
+    /** The robber's hex has more than one possible victim: ask which. */
+    data class PickRobberVictim(val hex: HexCoord, val victims: List<Int>) : TapOutcome
+}
+
+/**
+ * One development card in the local player's hand, and what can be done with it
+ * right now. [plays] is empty when it cannot be played this turn (bought this
+ * turn, a card has already been played, a victory-point card, or it is not the
+ * player's turn).
+ */
+data class DevCardInHand(val card: DevCard, val plays: List<CatanMove>) {
+    val playable: Boolean get() = plays.isNotEmpty()
+}
+
+/**
+ * The rules of *tapping*: given the game state, the moves the engine says are
+ * legal, and what the player has selected, what can be tapped and what a tap does.
+ *
+ * Pure functions with no Android and no Compose, so the whole interaction model is
+ * unit-tested (`CatanInteractionTest`). The screen holds the two bits of UI state
+ * ([BuildKind] and the chosen setup settlement) and passes them in; it contains no
+ * game rules of its own. **Anything that decides whether a tap is allowed belongs
+ * here, never in a composable** — the engine's [legal] list is the single source
+ * of truth, so the UI can never offer a move the rules would refuse.
+ */
+object CatanInteraction {
+
+    // --- Board ---------------------------------------------------------------
+
+    fun targets(
+        state: CatanState,
+        legal: List<CatanMove>,
+        building: BuildKind?,
+        setupVertex: Int?,
+    ): BoardTargets {
+        val setup = legal.filterIsInstance<SetupPlace>()
+        if (setup.isNotEmpty()) {
+            return if (setupVertex == null) {
+                BoardTargets(vertices = setup.map { it.vertex }.toSet())
+            } else {
+                BoardTargets(edges = setup.filter { it.vertex == setupVertex }.map { it.edge }.toSet())
+            }
+        }
+
+        val robber = legal.filterIsInstance<MoveRobber>()
+        if (robber.isNotEmpty()) {
+            return BoardTargets(hexes = robber.mapNotNull { CatanBoard.hexIndex[it.hex] }.toSet())
+        }
+
+        val roads = legal.filterIsInstance<BuildRoad>().map { it.edge }.toSet()
+        if (state.phase == CatanPhase.FREE_ROADS) return BoardTargets(edges = roads)
+
+        return when (building) {
+            BuildKind.ROAD -> BoardTargets(edges = roads)
+            BuildKind.SETTLEMENT ->
+                BoardTargets(vertices = legal.filterIsInstance<BuildSettlement>().map { it.vertex }.toSet())
+
+            BuildKind.CITY ->
+                BoardTargets(vertices = legal.filterIsInstance<BuildCity>().map { it.vertex }.toSet())
+
+            null -> BoardTargets()
+        }
+    }
+
+    fun onVertexTap(
+        vertex: Int,
+        legal: List<CatanMove>,
+        building: BuildKind?,
+        setupVertex: Int?,
+    ): TapOutcome {
+        val setup = legal.filterIsInstance<SetupPlace>()
+        if (setup.isNotEmpty()) {
+            // Re-picking is allowed until the road is chosen, so a misplaced
+            // tap does not commit the settlement.
+            return if (setup.any { it.vertex == vertex }) {
+                TapOutcome.PickSetupVertex(vertex)
+            } else {
+                TapOutcome.Ignored
+            }
+        }
+        val move: CatanMove = when (building) {
+            BuildKind.SETTLEMENT -> BuildSettlement(vertex)
+            BuildKind.CITY -> BuildCity(vertex)
+            else -> return TapOutcome.Ignored
+        }
+        return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
+    }
+
+    fun onEdgeTap(
+        edge: Int,
+        legal: List<CatanMove>,
+        building: BuildKind?,
+        setupVertex: Int?,
+    ): TapOutcome {
+        if (legal.any { it is SetupPlace }) {
+            if (setupVertex == null) return TapOutcome.Ignored
+            val move = SetupPlace(setupVertex, edge)
+            return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
+        }
+        // Free roads need no build mode; a paid road does.
+        val canBuild = building == BuildKind.ROAD || legal.any { it is EndFreeRoads }
+        if (!canBuild) return TapOutcome.Ignored
+        val move = BuildRoad(edge)
+        return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
+    }
+
+    fun onHexTap(hex: Int, legal: List<CatanMove>): TapOutcome {
+        val coord = CatanBoard.HEXES.getOrNull(hex) ?: return TapOutcome.Ignored
+        val moves = legal.filterIsInstance<MoveRobber>().filter { it.hex == coord }
+        return when {
+            moves.isEmpty() -> TapOutcome.Ignored
+            moves.size == 1 -> TapOutcome.Submit(moves.first())
+            else -> TapOutcome.PickRobberVictim(coord, moves.mapNotNull { it.victim })
+        }
+    }
+
+    // --- Action bar ------------------------------------------------------------
+
+    fun canRoll(legal: List<CatanMove>): Boolean = legal.any { it is RollDice }
+
+    /**
+     * The hexes that paid out for this turn's roll, so the board can light them.
+     * Empty until the turn's roll has happened (the dice left over from the last
+     * turn are not this turn's), on a seven, and for the hex the robber sits on.
+     */
+    fun rolledHexes(state: CatanState): Set<Int> {
+        if (state.lastDice.size != 2) return emptySet()
+        if (state.phase == CatanPhase.AWAIT_ROLL || state.phase == CatanPhase.SETUP_FIRST ||
+            state.phase == CatanPhase.SETUP_SECOND
+        ) {
+            return emptySet()
+        }
+        val total = state.lastDice.sum()
+        if (total == 7) return emptySet()
+        return (0 until CatanBoard.HEX_COUNT)
+            .filter { state.numbers[it] == total && it != state.robber }
+            .toSet()
+    }
+
+    fun canEndTurn(legal: List<CatanMove>): Boolean = legal.any { it is EndTurn }
+
+    fun canEndFreeRoads(legal: List<CatanMove>): Boolean = legal.any { it is EndFreeRoads }
+
+    fun canBuyDevCard(legal: List<CatanMove>): Boolean = legal.any { it is BuyDevCard }
+
+    fun canBuild(legal: List<CatanMove>): Set<BuildKind> = buildSet {
+        if (legal.any { it is BuildRoad }) add(BuildKind.ROAD)
+        if (legal.any { it is BuildSettlement }) add(BuildKind.SETTLEMENT)
+        if (legal.any { it is BuildCity }) add(BuildKind.CITY)
+    }
+
+    fun tradeResponses(legal: List<CatanMove>): Pair<Boolean, Boolean> =
+        legal.any { it is AcceptTrade } to legal.any { it is DeclineTrade }
+
+    // --- Development cards -----------------------------------------------------
+
+    /** [seat]'s development cards, each with the plays the engine currently allows. */
+    fun devHand(state: CatanState, seat: Int, legal: List<CatanMove>): List<DevCardInHand> =
+        state.devHands.getOrNull(seat).orEmpty().map { card ->
+            DevCardInHand(card, legal.filter { playOf(it) == card.id })
+        }.sortedWith(compareBy({ it.card.type.ordinal }, { it.card.id }))
+
+    private fun playOf(move: CatanMove): Int? = when (move) {
+        is PlayKnight -> move.card
+        is PlayRoadBuilding -> move.card
+        is PlayMonopoly -> move.card
+        is PlayYearOfPlenty -> move.card
+        else -> null
+    }
+
+    /** The Monopoly moves for one card, by the resource each would name. */
+    fun monopolyChoices(plays: List<CatanMove>): Map<Resource, PlayMonopoly> =
+        plays.filterIsInstance<PlayMonopoly>().associateBy { it.resource }
+
+    /** The Year of Plenty move that takes exactly [take], if the engine allows it. */
+    fun plentyMove(plays: List<CatanMove>, take: List<Resource>): PlayYearOfPlenty? {
+        val want = take.groupingBy { it }.eachCount()
+        return plays.filterIsInstance<PlayYearOfPlenty>().firstOrNull {
+            it.take.groupingBy { r -> r }.eachCount() == want
+        }
+    }
+
+    /**
+     * Resources a Year of Plenty can still be asked for, given what is already
+     * [picked]: those that complete some take the engine allows. Empty once the
+     * two cards are chosen.
+     */
+    fun plentyAvailable(plays: List<CatanMove>, picked: List<Resource>): Set<Resource> {
+        val chosen = picked.groupingBy { it }.eachCount()
+        val available = mutableSetOf<Resource>()
+        for (play in plays.filterIsInstance<PlayYearOfPlenty>()) {
+            if (!chosen.all { (resource, n) -> play.take.count { it == resource } >= n }) continue
+            val remaining = play.take.toMutableList()
+            picked.forEach { remaining.remove(it) }
+            available += remaining
+        }
+        return available
+    }
+
+    // --- Discarding -----------------------------------------------------------
+
+    /** How many cards a player holding [held] must discard on a seven. */
+    fun discardQuota(held: Int): Int = held / 2
+
+    /** The discard move that gives up exactly [selection], if the engine allows it. */
+    fun discardMove(legal: List<CatanMove>, selection: List<Resource>): Discard? {
+        val want = selection.groupingBy { it }.eachCount()
+        return legal.filterIsInstance<Discard>().firstOrNull {
+            it.cards.groupingBy { r -> r }.eachCount() == want
+        }
+    }
+
+    // --- Trading ---------------------------------------------------------------
+
+    /** Bank trades on offer: what can be given, and for what. */
+    fun bankTrades(legal: List<CatanMove>): Map<Resource, List<Resource>> =
+        legal.filterIsInstance<MaritimeTrade>()
+            .groupBy({ it.give }, { it.get })
+            .mapValues { (_, gets) -> gets.sortedBy { it.ordinal } }
+            .toSortedMap(compareBy<Resource> { it.ordinal })
+
+    /** What it costs [seat] to give one [resource] to the bank: 4, 3 or 2 cards. */
+    fun bankRatio(state: CatanState, seat: Int, resource: Resource): Int =
+        CatanRules.bestPortRatio(state, seat, resource)
+
+    /**
+     * Whether [seat] can offer [give] for [get] to [to] right now. Uses the
+     * engine's own structural check, since offers are not in the enumerated
+     * move list.
+     */
+    fun offerAllowed(
+        state: CatanState,
+        seat: Int,
+        to: Int?,
+        give: List<Resource>,
+        get: List<Resource>,
+    ): Boolean = give.isNotEmpty() && get.isNotEmpty() &&
+        CatanRules.isLegalMove(state, seat, OfferTrade(to, give, get))
+
+    /** Whether [seat] may answer the offer on the table with [give] for [get]. */
+    fun counterAllowed(state: CatanState, seat: Int, give: List<Resource>, get: List<Resource>): Boolean =
+        give.isNotEmpty() && get.isNotEmpty() &&
+            CatanRules.isLegalMove(state, seat, CounterTrade(give, get))
+
+    /** The counter-offers the offerer may take right now, in the order they came in. */
+    fun counterChoices(state: CatanState, legal: List<CatanMove>): List<TradeCounter> {
+        val takeable = legal.filterIsInstance<AcceptCounter>().map { it.seat }.toSet()
+        return state.pendingTrade?.counters.orEmpty().filter { it.by in takeable }
+    }
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanPanels.kt

@@ -0,0 +1,437 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.Resource
+
+/*
+ * Stateless building blocks for the Katan screen.
+ *
+ * Every composable here takes plain values and reports events through lambdas;
+ * none of them holds game state or touches the controller, so each can be
+ * restyled, re-laid-out or replaced on its own. Colours and proportions come
+ * from [CatanStyle] and wording from [CatanText].
+ */
+
+// ---------------------------------------------------------------------------
+// Resource tile
+// ---------------------------------------------------------------------------
+
+/**
+ * One resource as a coloured tile with its count. The hand, the discard picker
+ * and the trade pickers all use this, so a resource looks the same everywhere.
+ */
+@Composable
+fun ResourceTile(
+    resource: Resource,
+    count: Int,
+    modifier: Modifier = Modifier,
+    selected: Boolean = false,
+    enabled: Boolean = true,
+    style: CatanStyle = LocalCatanStyle.current,
+    onClick: (() -> Unit)? = null,
+) {
+    val shape = RoundedCornerShape(10.dp)
+    Column(
+        modifier = modifier
+            .defaultMinSize(minWidth = 56.dp)
+            .clip(shape)
+            .background(style.resource.getValue(resource).copy(alpha = if (enabled) 1f else 0.4f))
+            .border(
+                width = if (selected) 3.dp else 1.dp,
+                color = if (selected) Color.White else Color(0x33000000),
+                shape = shape,
+            )
+            .then(if (onClick != null && enabled) Modifier.clickable { onClick() } else Modifier)
+            .padding(horizontal = 6.dp, vertical = 6.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            text = count.toString(),
+            color = style.resourceInk,
+            fontWeight = FontWeight.Bold,
+            fontSize = 20.sp,
+        )
+        Text(
+            text = CatanText.resource(resource),
+            color = style.resourceInk,
+            fontSize = 11.sp,
+            maxLines = 1,
+        )
+    }
+}
+
+/** The local player's cards: one tile per resource, in a row that wraps. */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanHand(
+    state: CatanState,
+    seat: Int,
+    modifier: Modifier = Modifier,
+) {
+    FlowRow(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+        verticalArrangement = Arrangement.spacedBy(6.dp),
+    ) {
+        Resource.entries.forEach { resource ->
+            ResourceTile(resource, state.resources[seat][resource] ?: 0)
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Players
+// ---------------------------------------------------------------------------
+
+/**
+ * One player's public standing: colour, name, points, how many cards they hold
+ * (not which), and — in the roomier layout — development cards, knights and
+ * their longest road.
+ *
+ * **Fixed height.** Every line is always present (blank when there is nothing to
+ * say) and never wraps, so the card is the same height whatever the game is
+ * doing. The board is given whatever room is left, so anything that made this
+ * card taller or shorter would rescale the island under the player's thumb.
+ *
+ * [points] is passed in rather than computed here because the local player's
+ * own count includes hidden victory-point cards and everyone else's does not;
+ * the screen decides which. [compact] is the narrow portrait strip (four cards
+ * across a phone); the default has room for the detail lines.
+ */
+@Composable
+fun CatanPlayerCard(
+    state: CatanState,
+    seat: Int,
+    seats: CatanSeats,
+    points: Int,
+    modifier: Modifier = Modifier,
+    style: CatanStyle = LocalCatanStyle.current,
+    compact: Boolean = false,
+) {
+    val onTurn = state.turn == seat && state.phase != CatanPhase.GAME_OVER
+    val shape = RoundedCornerShape(12.dp)
+    Column(
+        modifier = modifier
+            .clip(shape)
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .border(
+                width = if (onTurn) 3.dp else 1.dp,
+                color = if (onTurn) MaterialTheme.colorScheme.primary else Color(0x22000000),
+                shape = shape,
+            )
+            .padding(8.dp),
+        verticalArrangement = Arrangement.spacedBy(2.dp),
+    ) {
+        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+            Box(
+                modifier = Modifier
+                    .size(14.dp)
+                    .clip(CircleShape)
+                    .background(style.seats[seat % style.seats.size])
+                    .border(1.dp, style.pieceOutline, CircleShape),
+            )
+            CardLine(seats.label(seat), MaterialTheme.typography.labelLarge, FontWeight.Bold)
+        }
+        CardLine("$points VP", MaterialTheme.typography.titleMedium, FontWeight.Bold)
+        if (compact) {
+            CardLine("${state.resourceCount(seat)} cards", MaterialTheme.typography.bodySmall)
+        } else {
+            CardLine(
+                "${state.resourceCount(seat)} cards · ${state.devHandCounts[seat]} dev",
+                MaterialTheme.typography.bodySmall,
+            )
+            CardLine(
+                "Knights ${state.knightsPlayed[seat]} · Road ${CatanRules.longestRoadFor(state, seat)}",
+                MaterialTheme.typography.bodySmall,
+            )
+        }
+        val awards = buildList {
+            if (state.longestRoadOwner == seat) add(if (compact) "Road" else "Longest road")
+            if (state.largestArmyOwner == seat) add(if (compact) "Army" else "Largest army")
+        }
+        // Always drawn, so the card does not grow when somebody takes an award.
+        CardLine(
+            text = awards.joinToString(" · ").ifEmpty { BLANK },
+            style = MaterialTheme.typography.labelSmall,
+            weight = FontWeight.Bold,
+            color = MaterialTheme.colorScheme.primary,
+        )
+    }
+}
+
+/** A non-breaking space: a line of text with nothing in it, still one line tall. */
+private const val BLANK = "\u00A0"
+
+/** One line of a player card: never wraps, so the card's height cannot change. */
+@Composable
+private fun CardLine(
+    text: String,
+    style: TextStyle,
+    weight: FontWeight? = null,
+    color: Color = Color.Unspecified,
+) {
+    Text(
+        text = text,
+        style = style,
+        fontWeight = weight,
+        color = color,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Dice
+// ---------------------------------------------------------------------------
+
+/** The two dice as last rolled, with their total. Blank until the first roll. */
+@Composable
+fun CatanDice(dice: List<Int>, modifier: Modifier = Modifier) {
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+    ) {
+        val shown = if (dice.size == 2) dice else listOf(null, null)
+        shown.forEach { value ->
+            Box(
+                modifier = Modifier
+                    .size(36.dp)
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(Color.White)
+                    .border(1.dp, Color(0x55000000), RoundedCornerShape(8.dp)),
+                contentAlignment = Alignment.Center,
+            ) {
+                Text(
+                    text = value?.toString() ?: "–",
+                    color = Color(0xFF1C1B1F),
+                    fontWeight = FontWeight.Bold,
+                    fontSize = 20.sp,
+                    textAlign = TextAlign.Center,
+                )
+            }
+        }
+        // Always drawn ("= –" before the first roll) so the row never changes width.
+        Text(
+            text = if (dice.size == 2) "= ${dice.sum()}" else "= –",
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.Bold,
+        )
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Actions
+// ---------------------------------------------------------------------------
+
+/** What the action bar offers right now. Built by the screen from [CatanInteraction]. */
+data class CatanActions(
+    val canRoll: Boolean = false,
+    val canBuild: Set<BuildKind> = emptySet(),
+    val building: BuildKind? = null,
+    val canBuyCard: Boolean = false,
+    val canPlayCard: Boolean = false,
+    val canTrade: Boolean = false,
+    val canEndTurn: Boolean = false,
+    val canEndFreeRoads: Boolean = false,
+    /** A setup settlement is chosen and a different one may still be picked. */
+    val canRepickSetup: Boolean = false,
+)
+
+/**
+ * The buttons for whatever the player can do now. Pure display: every press is a lambda.
+ *
+ * **The bar never changes size.** The top row holds the one "primary" action
+ * (roll, end turn, done with roads, cancel) and keeps its height when it is
+ * empty; the second row is always all six buttons, greyed out when they do not
+ * apply. Buttons appearing and disappearing used to resize this area and, with
+ * it, the board above — so nothing here may be conditionally *present*, only
+ * conditionally *enabled*.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun CatanActionBar(
+    actions: CatanActions,
+    onRoll: () -> Unit,
+    onBuild: (BuildKind?) -> Unit,
+    onBuyCard: () -> Unit,
+    onPlayCard: () -> Unit,
+    onTrade: () -> Unit,
+    onEndTurn: () -> Unit,
+    onEndFreeRoads: () -> Unit,
+    onRepickSetup: () -> Unit,
+    modifier: Modifier = Modifier,
+    /** Small screens: fold Road / Settlement / City into one "Build" button with a menu. */
+    compact: Boolean = false,
+) {
+    Column(modifier = modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        Row(
+            modifier = Modifier.fillMaxWidth().height(PRIMARY_ROW_HEIGHT),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            if (actions.canRoll) Button(onClick = onRoll) { Text(CatanText.ROLL) }
+            if (actions.canRepickSetup) OutlinedButton(onClick = onRepickSetup) { Text(CatanText.CANCEL) }
+            if (actions.canEndFreeRoads) Button(onClick = onEndFreeRoads) { Text(CatanText.STOP_ROADS) }
+            if (actions.canEndTurn) Button(onClick = onEndTurn) { Text(CatanText.END_TURN) }
+        }
+
+        FlowRow(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            if (compact) {
+                BuildMenuButton(actions, onBuild)
+            } else {
+                BuildButton(BuildKind.ROAD, CatanText.ROAD, CatanText.ROAD_COST, actions, onBuild)
+                BuildButton(BuildKind.SETTLEMENT, CatanText.SETTLEMENT, CatanText.SETTLEMENT_COST, actions, onBuild)
+                BuildButton(BuildKind.CITY, CatanText.CITY, CatanText.CITY_COST, actions, onBuild)
+            }
+            OutlinedButton(onClick = onBuyCard, enabled = actions.canBuyCard) {
+                LabelWithCost(CatanText.BUY_CARD, CatanText.DEV_COST)
+            }
+            OutlinedButton(onClick = onPlayCard, enabled = actions.canPlayCard) {
+                LabelWithCost(CatanText.PLAY_CARD, CatanText.NO_COST)
+            }
+            OutlinedButton(onClick = onTrade, enabled = actions.canTrade) {
+                LabelWithCost(CatanText.TRADE, CatanText.NO_COST)
+            }
+        }
+    }
+}
+
+/** Room for one button, held whether or not there is one to show. */
+private val PRIMARY_ROW_HEIGHT = 48.dp
+
+@Composable
+private fun BuildButton(
+    kind: BuildKind,
+    label: String,
+    cost: String,
+    actions: CatanActions,
+    onBuild: (BuildKind?) -> Unit,
+) {
+    val enabled = kind in actions.canBuild
+    val active = actions.building == kind
+    val onClick = { onBuild(if (active) null else kind) }
+    if (active) {
+        FilledTonalButton(onClick = onClick, enabled = enabled) { LabelWithCost(label, cost) }
+    } else {
+        OutlinedButton(onClick = onClick, enabled = enabled) { LabelWithCost(label, cost) }
+    }
+}
+
+/**
+ * The small-screen stand-in for the three build buttons: one "Build" button
+ * whose menu lists Road, Settlement and City with their costs. While a build
+ * mode is armed the button shows which, and choosing that entry again cancels it.
+ */
+@Composable
+private fun BuildMenuButton(actions: CatanActions, onBuild: (BuildKind?) -> Unit) {
+    var open by remember { mutableStateOf(false) }
+    val armed = actions.building
+    val anyEnabled = actions.canBuild.isNotEmpty() || armed != null
+    val label: @Composable () -> Unit = {
+        LabelWithCost(CatanText.BUILD, armed?.let { buildLabel(it) } ?: CatanText.NO_COST)
+    }
+    Box {
+        if (armed != null) {
+            FilledTonalButton(onClick = { open = true }, enabled = anyEnabled) { label() }
+        } else {
+            OutlinedButton(onClick = { open = true }, enabled = anyEnabled) { label() }
+        }
+        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
+            for (kind in BuildKind.entries) {
+                DropdownMenuItem(
+                    text = { LabelWithCost(buildLabel(kind), buildCost(kind)) },
+                    enabled = kind in actions.canBuild,
+                    onClick = {
+                        open = false
+                        onBuild(if (armed == kind) null else kind)
+                    },
+                )
+            }
+        }
+    }
+}
+
+private fun buildLabel(kind: BuildKind): String = when (kind) {
+    BuildKind.ROAD -> CatanText.ROAD
+    BuildKind.SETTLEMENT -> CatanText.SETTLEMENT
+    BuildKind.CITY -> CatanText.CITY
+}
+
+private fun buildCost(kind: BuildKind): String = when (kind) {
+    BuildKind.ROAD -> CatanText.ROAD_COST
+    BuildKind.SETTLEMENT -> CatanText.SETTLEMENT_COST
+    BuildKind.CITY -> CatanText.CITY_COST
+}
+
+@Composable
+private fun LabelWithCost(label: String, cost: String) {
+    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+        Text(label)
+        Text(cost, fontSize = 9.sp, maxLines = 1)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Log
+// ---------------------------------------------------------------------------
+
+/** The most recent happenings, newest last. Scrolls. */
+@Composable
+fun CatanLog(state: CatanState, modifier: Modifier = Modifier) {
+    if (state.log.isEmpty()) {
+        Text(CatanText.NO_LOG, style = MaterialTheme.typography.bodySmall, modifier = modifier)
+        return
+    }
+    Column(modifier = modifier.verticalScroll(rememberScrollState())) {
+        state.log.takeLast(40).forEach {
+            Text(text = it, style = MaterialTheme.typography.bodySmall)
+        }
+    }
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanPreviews.kt

@@ -0,0 +1,132 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.prolibertate.games.game.GameCatalog
+import org.prolibertate.games.game.catan.CatanAi
+import org.prolibertate.games.game.catan.CatanOptions
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.engine.PlayerKind
+import org.prolibertate.games.game.engine.PlayerSlot
+import org.prolibertate.games.game.engine.TableConfig
+
+/*
+ * Android Studio previews for the Katan UI. They exist so the look can be
+ * iterated on without starting a match: open this file, open the Preview pane,
+ * and edit CatanStyle / CatanText / the panels. Each preview draws a real
+ * position (the computer plays itself for a while), not a mock.
+ *
+ * Nothing here ships in a behaviour sense: previews are only compiled for tooling.
+ */
+
+private val previewJson = Json { encodeDefaults = true }
+
+/** A real game, played forward by the computer for [moves] moves, for previewing. */
+private fun sampleState(players: Int = 4, moves: Int = 90, seed: Long = 11L): CatanState {
+    val config = TableConfig(
+        gameId = GameCatalog.CATAN,
+        seats = (0 until players).map { PlayerSlot(it, "P$it", PlayerKind.AI, it) },
+        optionsJson = previewJson.encodeToString(CatanOptions(playerCount = players)),
+        seed = seed,
+    )
+    val ai = CatanAi()
+    var state = CatanRules.initialState(config)
+    repeat(moves) {
+        if (state.phase == CatanPhase.GAME_OVER) return state
+        val seat = CatanRules.currentSeat(state) ?: return state
+        val legal = CatanRules.legalMoves(state, seat)
+        if (legal.isEmpty()) return state
+        state = CatanRules.applyMove(state, seat, ai.chooseMove(state, seat, legal))
+    }
+    return state
+}
+
+@Preview(showBackground = true, widthDp = 360, heightDp = 360)
+@Composable
+private fun BoardPreview() {
+    val state = remember { sampleState() }
+    CompositionLocalProvider(LocalCatanStyle provides catanStyle(dark = false)) {
+        CatanBoardView(
+            state = state,
+            targets = BoardTargets(),
+            selectedVertex = null,
+            onVertexTap = {},
+            onEdgeTap = {},
+            onHexTap = {},
+        )
+    }
+}
+
+@Preview(showBackground = true, widthDp = 360, heightDp = 360)
+@Composable
+private fun BoardDarkPreview() {
+    val state = remember { sampleState() }
+    CompositionLocalProvider(LocalCatanStyle provides catanStyle(dark = true)) {
+        CatanBoardView(
+            state = state,
+            targets = BoardTargets(),
+            selectedVertex = null,
+            onVertexTap = {},
+            onEdgeTap = {},
+            onHexTap = {},
+        )
+    }
+}
+
+@Preview(showBackground = true, widthDp = 360, heightDp = 360)
+@Composable
+private fun BoardWithTargetsPreview() {
+    val state = remember { sampleState(moves = 6) }
+    val legal = remember(state) { CatanRules.currentSeat(state)?.let { CatanRules.legalMoves(state, it) }.orEmpty() }
+    CompositionLocalProvider(LocalCatanStyle provides catanStyle(dark = false)) {
+        CatanBoardView(
+            state = state,
+            targets = CatanInteraction.targets(state, legal, building = null, setupVertex = null),
+            selectedVertex = null,
+            onVertexTap = {},
+            onEdgeTap = {},
+            onHexTap = {},
+        )
+    }
+}
+
+@Preview(showBackground = true, widthDp = 360, heightDp = 560)
+@Composable
+private fun PanelsPreview() {
+    val state = remember { sampleState() }
+    val seats = CatanSeats(me = 0, names = listOf("You", "Ann", "Bo", "Cy"))
+    val points = remember(state) { CatanRules.publicVictoryPoints(state) }
+    Column(Modifier.padding(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+            (0 until state.playerCount).forEach { seat ->
+                CatanPlayerCard(state, seat, seats, points[seat], Modifier.weight(1f), compact = true)
+            }
+        }
+        CatanHand(state, seat = 0)
+        CatanDice(state.lastDice)
+        CatanActionBar(
+            actions = CatanActions(
+                canBuild = setOf(BuildKind.ROAD, BuildKind.CITY),
+                building = BuildKind.ROAD,
+                canBuyCard = true,
+                canTrade = true,
+                canEndTurn = true,
+            ),
+            onRoll = {}, onBuild = {}, onBuyCard = {}, onPlayCard = {}, onTrade = {},
+            onEndTurn = {}, onEndFreeRoads = {}, onRepickSetup = {},
+        )
+    }
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanScreen.kt

@@ -0,0 +1,408 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import org.prolibertate.games.game.catan.AcceptTrade
+import org.prolibertate.games.game.catan.BuyDevCard
+import org.prolibertate.games.game.catan.CatanMove
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.DeclineTrade
+import org.prolibertate.games.game.catan.DismissCounters
+import org.prolibertate.games.game.catan.EndFreeRoads
+import org.prolibertate.games.game.catan.EndTurn
+import org.prolibertate.games.game.catan.MoveRobber
+import org.prolibertate.games.game.catan.RollDice
+import org.prolibertate.games.game.catan.SetupPlace
+import org.prolibertate.games.net.MatchController
+import org.prolibertate.games.ui.ScreenScaffold
+
+/**
+ * Katan, on the island.
+ *
+ * This composable is only wiring. It reads the match from the controller, holds
+ * the handful of purely visual choices (which build mode is armed, which setup
+ * settlement is waiting for its road, which dialog is open), and hands
+ * everything else to single-purpose pieces:
+ *
+ * | Concern                        | Where it lives             |
+ * | ------------------------------ | -------------------------- |
+ * | Colours, sizes, shapes         | [CatanStyle]               |
+ * | Every word on screen           | [CatanText]                |
+ * | Island → pixels, taps → hexes  | [CatanGeometry]            |
+ * | What is tappable, what a tap does | [CatanInteraction]      |
+ * | Drawing the island             | [CatanBoardView]           |
+ * | Cards, players, dice, buttons  | `CatanPanels.kt`           |
+ * | Every dialog                   | `CatanDialogs.kt`          |
+ *
+ * There are no game rules here: the engine's legal-move list is the only source
+ * of what the player may do, so the screen cannot offer a move the rules refuse.
+ * See `docs/UI-catan.md` for how to adapt the look and feel.
+ */
+@Composable
+fun CatanScreen(
+    controller: MatchController<CatanState, CatanMove>,
+    localSeat: Int,
+    onExit: () -> Unit,
+    seatNames: List<String> = emptyList(),
+) {
+    val state by controller.state.collectAsState()
+    val legal by controller.legalMoves.collectAsState()
+    val abandoned by controller.abandoned.collectAsState()
+    val notice by controller.notice.collectAsState()
+
+    // Purely visual state. Anything that affects the game goes through submit().
+    var building by remember { mutableStateOf<BuildKind?>(null) }
+    var setupVertex by remember { mutableStateOf<Int?>(null) }
+    var victimChoice by remember { mutableStateOf<TapOutcome.PickRobberVictim?>(null) }
+    var showCards by remember { mutableStateOf(false) }
+    var showTrade by remember { mutableStateOf(false) }
+    var confirmingEnd by remember { mutableStateOf(false) }
+    var resultDismissed by remember { mutableStateOf(false) }
+
+    val dark = isSystemInDarkTheme()
+    val style = remember(dark) { catanStyle(dark) }
+    val seats = remember(localSeat, seatNames) { CatanSeats(localSeat, seatNames) }
+
+    // The engine's list changes after every move; drop any selection it no
+    // longer supports (a build mode the player can no longer afford, a setup
+    // settlement that is no longer pending).
+    LaunchedEffect(legal) {
+        if (building != null && building !in CatanInteraction.canBuild(legal)) building = null
+        if (setupVertex != null && legal.none { it is SetupPlace && it.vertex == setupVertex }) {
+            setupVertex = null
+        }
+        if (legal.isEmpty()) {
+            showCards = false
+            showTrade = false
+            victimChoice = null
+        }
+    }
+
+    val submit: (CatanMove) -> Unit = { move ->
+        controller.submit(move)
+        building = null
+        setupVertex = null
+        victimChoice = null
+        showCards = false
+        showTrade = false
+    }
+
+    val endGameAction: @Composable () -> Unit = {
+        TextButton(onClick = { confirmingEnd = true }) { Text(CatanText.END_GAME) }
+    }
+
+    val current = state
+    if (current == null) {
+        ScreenScaffold(title = CatanText.TITLE, onBack = onExit, actions = endGameAction) { modifier ->
+            Box(modifier, contentAlignment = Alignment.Center) { Text("Setting up…") }
+            abandoned?.let { CatanAbandonedDialog(it, onExit, controller::dismissAbandoned) }
+            if (confirmingEnd) CatanEndGameDialog(onExit) { confirmingEnd = false }
+        }
+        return
+    }
+
+    val targets = CatanInteraction.targets(current, legal, building, setupVertex)
+    val devHand = CatanInteraction.devHand(current, localSeat, legal)
+    val playing = current.phase == CatanPhase.PLAYING && legal.isNotEmpty()
+    val actions = CatanActions(
+        canRoll = CatanInteraction.canRoll(legal),
+        canBuild = CatanInteraction.canBuild(legal),
+        building = building,
+        canBuyCard = CatanInteraction.canBuyDevCard(legal),
+        canPlayCard = devHand.any { it.playable },
+        canTrade = playing,
+        canEndTurn = CatanInteraction.canEndTurn(legal),
+        canEndFreeRoads = CatanInteraction.canEndFreeRoads(legal),
+        canRepickSetup = setupVertex != null,
+    )
+    val rolledHexes = CatanInteraction.rolledHexes(current)
+    val prompt = CatanText.prompt(current, seats, setupVertexChosen = setupVertex != null, building = building)
+
+    val handle: (TapOutcome) -> Unit = { outcome ->
+        when (outcome) {
+            TapOutcome.Ignored -> Unit
+            is TapOutcome.Submit -> submit(outcome.move)
+            is TapOutcome.PickSetupVertex -> setupVertex = outcome.vertex
+            is TapOutcome.PickRobberVictim -> victimChoice = outcome
+        }
+    }
+
+    val publicPoints = CatanRules.publicVictoryPoints(current)
+    val pointsOf: (Int) -> Int = { seat ->
+        if (seat == localSeat) CatanRules.victoryPoints(current, seat) else publicPoints[seat]
+    }
+
+    CompositionLocalProvider(LocalCatanStyle provides style) {
+        ScreenScaffold(title = CatanText.TITLE, onBack = onExit, actions = endGameAction) { modifier ->
+            BoxWithConstraints(modifier = modifier) {
+                val wide = maxWidth > maxHeight * 1.1f
+                // Phones (either way up) get the one-button build menu.
+                val compactBuild = !wide || maxWidth < 600.dp
+
+                val board: @Composable (Modifier) -> Unit = { boardModifier ->
+                    CatanBoardView(
+                        state = current,
+                        targets = targets,
+                        selectedVertex = setupVertex,
+                        onVertexTap = { handle(CatanInteraction.onVertexTap(it, legal, building, setupVertex)) },
+                        onEdgeTap = { handle(CatanInteraction.onEdgeTap(it, legal, building, setupVertex)) },
+                        onHexTap = { handle(CatanInteraction.onHexTap(it, legal)) },
+                        modifier = boardModifier,
+                        style = style,
+                        rolledHexes = rolledHexes,
+                    )
+                }
+                val players: @Composable (Boolean) -> Unit = { grid ->
+                    PlayerCards(current, seats, pointsOf, style, twoPerRow = grid)
+                }
+                val promptRow: @Composable () -> Unit = {
+                    PromptRow(prompt, notice, current)
+                }
+                val handAndActions: @Composable () -> Unit = {
+                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        CatanHand(current, localSeat)
+                        CatanActionBar(
+                            actions = actions,
+                            onRoll = { submit(RollDice()) },
+                            onBuild = { building = it },
+                            onBuyCard = { legal.firstOrNull { m -> m is BuyDevCard }?.let(submit) },
+                            onPlayCard = { showCards = true },
+                            onTrade = { showTrade = true },
+                            onEndTurn = { legal.firstOrNull { m -> m is EndTurn }?.let(submit) },
+                            onEndFreeRoads = {
+                                legal.firstOrNull { m -> m is EndFreeRoads }?.let(submit)
+                            },
+                            onRepickSetup = { setupVertex = null },
+                            compact = compactBuild,
+                        )
+                    }
+                }
+
+                if (wide) {
+                    Row(Modifier.fillMaxSize(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+                        Box(Modifier.weight(1.5f).fillMaxSize(), contentAlignment = Alignment.Center) {
+                            board(Modifier)
+                        }
+                        Column(
+                            modifier = Modifier.weight(1f).fillMaxSize().verticalScroll(rememberScrollState()),
+                            verticalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            players(true)
+                            promptRow()
+                            handAndActions()
+                            CatanLog(current, Modifier.fillMaxWidth().height(120.dp))
+                        }
+                    }
+                } else {
+                    Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        players(false)
+                        promptRow()
+                        Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) {
+                            board(Modifier)
+                        }
+                        handAndActions()
+                    }
+                }
+            }
+
+            CatanDialogHost(
+                state = current,
+                seats = seats,
+                localSeat = localSeat,
+                legal = legal,
+                abandoned = abandoned,
+                confirmingEnd = confirmingEnd,
+                resultDismissed = resultDismissed,
+                victimChoice = victimChoice,
+                showCards = showCards,
+                showTrade = showTrade,
+                devHand = devHand,
+                onExit = onExit,
+                onSubmit = submit,
+                onStay = controller::dismissAbandoned,
+                onKeepPlaying = { confirmingEnd = false },
+                onDismissResult = { resultDismissed = true },
+                onCancelVictim = { victimChoice = null },
+                onCancelCards = { showCards = false },
+                onCancelTrade = { showTrade = false },
+            )
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Layout pieces
+// ---------------------------------------------------------------------------
+
+@Composable
+private fun PlayerCards(
+    state: CatanState,
+    seats: CatanSeats,
+    pointsOf: (Int) -> Int,
+    style: CatanStyle,
+    twoPerRow: Boolean,
+) {
+    val order = (0 until state.playerCount).toList()
+    val rows = if (twoPerRow) order.chunked(2) else listOf(order)
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        rows.forEach { row ->
+            Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                row.forEach { seat ->
+                    CatanPlayerCard(
+                        state = state,
+                        seat = seat,
+                        seats = seats,
+                        points = pointsOf(seat),
+                        modifier = Modifier.weight(1f),
+                        style = style,
+                        compact = !twoPerRow,
+                    )
+                }
+                // Keep an odd last row's card the same width as the others.
+                if (twoPerRow && row.size == 1) Box(Modifier.weight(1f))
+            }
+        }
+    }
+}
+
+/**
+ * The one line telling the player what is going on, and the dice.
+ *
+ * **Fixed height.** The text always occupies exactly two lines (padded when it is
+ * shorter, clipped when it is longer) and a refused move replaces the prompt
+ * rather than adding to it, so this row is the same height whatever is said and
+ * the board below it never moves.
+ */
+@Composable
+private fun PromptRow(prompt: String, notice: String?, state: CatanState) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(
+            text = notice ?: prompt,
+            style = MaterialTheme.typography.bodyMedium,
+            color = if (notice != null) MaterialTheme.colorScheme.error else Color.Unspecified,
+            minLines = 2,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            modifier = Modifier.weight(1f),
+        )
+        CatanDice(state.lastDice)
+    }
+}
+
+/**
+ * Chooses which dialog, if any, is showing. Pulled out of [CatanScreen] so the
+ * priority order — an ended table beats a result beats a forced discard beats
+ * an optional picker — is in one readable place.
+ */
+@Composable
+private fun CatanDialogHost(
+    state: CatanState,
+    seats: CatanSeats,
+    localSeat: Int,
+    legal: List<CatanMove>,
+    abandoned: String?,
+    confirmingEnd: Boolean,
+    resultDismissed: Boolean,
+    victimChoice: TapOutcome.PickRobberVictim?,
+    showCards: Boolean,
+    showTrade: Boolean,
+    devHand: List<DevCardInHand>,
+    onExit: () -> Unit,
+    onSubmit: (CatanMove) -> Unit,
+    onStay: () -> Unit,
+    onKeepPlaying: () -> Unit,
+    onDismissResult: () -> Unit,
+    onCancelVictim: () -> Unit,
+    onCancelCards: () -> Unit,
+    onCancelTrade: () -> Unit,
+) {
+    val offer = state.pendingTrade
+    when {
+        abandoned != null -> CatanAbandonedDialog(abandoned, onExit, onStay)
+
+        confirmingEnd -> CatanEndGameDialog(onEnd = onExit, onKeepPlaying = onKeepPlaying)
+
+        state.phase == CatanPhase.GAME_OVER ->
+            if (!resultDismissed) CatanGameOverDialog(state, seats, onExit, onDismissResult)
+
+        state.phase == CatanPhase.DISCARDING && state.discardSeat == localSeat ->
+            CatanDiscardDialog(
+                held = state.resources[localSeat],
+                quota = CatanInteraction.discardQuota(state.resourceCount(localSeat)),
+                legal = legal,
+                onSubmit = onSubmit,
+            )
+
+        state.phase == CatanPhase.TRADE_PENDING && offer != null && offer.asking == localSeat ->
+            CatanTradeResponseDialog(
+                state = state,
+                seat = localSeat,
+                offer = offer,
+                seats = seats,
+                canAccept = CatanInteraction.tradeResponses(legal).first,
+                onAccept = { onSubmit(AcceptTrade) },
+                onDecline = { onSubmit(DeclineTrade) },
+                onCounter = onSubmit,
+            )
+
+        state.phase == CatanPhase.TRADE_COUNTERS && state.turn == localSeat && legal.isNotEmpty() ->
+            CatanCounterChoiceDialog(
+                counters = CatanInteraction.counterChoices(state, legal),
+                seats = seats,
+                onTake = onSubmit,
+                onNoDeal = { onSubmit(DismissCounters) },
+            )
+
+        victimChoice != null ->
+            CatanVictimDialog(
+                victims = victimChoice.victims,
+                seats = seats,
+                onPick = { victim -> onSubmit(MoveRobber(victimChoice.hex, victim)) },
+                onCancel = onCancelVictim,
+            )
+
+        showCards -> CatanPlayCardDialog(devHand, onPlay = onSubmit, onCancel = onCancelCards)
+
+        showTrade ->
+            CatanTradeDialog(
+                state = state,
+                seat = localSeat,
+                seats = seats,
+                legal = legal,
+                onBank = onSubmit,
+                onOffer = onSubmit,
+                onCancel = onCancelTrade,
+            )
+    }
+}

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanStyle.kt

@@ -0,0 +1,133 @@
+package org.prolibertate.games.ui.game.catan
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.catan.Terrain
+
+/**
+ * Every visual decision for the Katan screen, in one place.
+ *
+ * **To restyle Katan, edit this file.** Nothing else in `ui/game/catan/` hard-
+ * codes a colour or a proportion: the board, the hand, the player strip and the
+ * dialogs all read a [CatanStyle] from [LocalCatanStyle]. A different art
+ * direction is a different [CatanStyle] value (see [catanStyle]); a new theme
+ * can be supplied at the screen's root with
+ * `CompositionLocalProvider(LocalCatanStyle provides myStyle)`.
+ *
+ * Wording is the same story in [CatanText]; geometry is in [CatanGeometry].
+ *
+ * Proportions are fractions of the *hex radius* (centre of a hex to one of its
+ * corners), so they scale with the board whatever the screen size.
+ */
+@Immutable
+data class CatanStyle(
+    // --- Board surfaces -----------------------------------------------------
+    /** The water around the island. */
+    val sea: Color,
+    /** Fill of each hex by terrain. */
+    val terrain: Map<Terrain, Color>,
+    /** Outline between hexes. */
+    val hexEdge: Color,
+    /** The number-token disc, and the ink for ordinary and hot (6 / 8) numbers. */
+    val token: Color,
+    val tokenInk: Color,
+    val tokenHotInk: Color,
+    /** The robber's pawn. */
+    val robber: Color,
+    /** Outline and wash on hexes that produced for the latest dice roll. */
+    val rolled: Color,
+    /** Harbour marker disc and its ink. */
+    val portMarker: Color,
+    val portInk: Color,
+
+    // --- Resources (hand tiles, trade pickers, harbour markers) -------------
+    val resource: Map<Resource, Color>,
+    val resourceInk: Color,
+
+    // --- Players ------------------------------------------------------------
+    /** One colour per seat, in seat order. Roads, settlements, cities, player strip. */
+    val seats: List<Color>,
+    /** Outline drawn round every piece so any seat colour reads on any terrain. */
+    val pieceOutline: Color,
+
+    // --- Interaction feedback ----------------------------------------------
+    /** Marks where the player may build or move right now. */
+    val target: Color,
+    /** The setup settlement that has been chosen and is waiting for its road. */
+    val targetSelected: Color,
+
+    // --- Metrics (fractions of the hex radius) ------------------------------
+    /** How far each tile polygon is pulled in from its corners, leaving a gap. */
+    val hexInset: Float = 0.04f,
+    val roadWidth: Float = 0.20f,
+    val settlementSize: Float = 0.30f,
+    val citySize: Float = 0.42f,
+    val tokenRadius: Float = 0.36f,
+    val robberSize: Float = 0.34f,
+    val portRadius: Float = 0.46f,
+    val targetRadius: Float = 0.20f,
+    /** How close a tap must land to a vertex / edge / hex centre to count. */
+    val tapReach: Float = 0.55f,
+    val tokenText: Float = 0.34f,
+    val portText: Float = 0.27f,
+)
+
+/** The light palette, which is also the reference for the dark one. */
+private val LightStyle = CatanStyle(
+    sea = Color(0xFF3A7CA5),
+    terrain = mapOf(
+        Terrain.FOREST to Color(0xFF2F6B3A),
+        Terrain.PASTURE to Color(0xFF9CCC65),
+        Terrain.FIELDS to Color(0xFFE8C84A),
+        Terrain.HILLS to Color(0xFFB4532F),
+        Terrain.MOUNTAINS to Color(0xFF7C8794),
+        Terrain.DESERT to Color(0xFFE6D3A0),
+    ),
+    hexEdge = Color(0x55000000),
+    token = Color(0xFFF7EFD9),
+    tokenInk = Color(0xFF2B2B2B),
+    tokenHotInk = Color(0xFFC62828),
+    robber = Color(0xFF263238),
+    rolled = Color(0xFFFFFFFF),
+    portMarker = Color(0xFFFFF8E1),
+    portInk = Color(0xFF2B2B2B),
+    resource = mapOf(
+        Resource.LUMBER to Color(0xFF2F6B3A),
+        Resource.BRICK to Color(0xFFB4532F),
+        Resource.WOOL to Color(0xFF8BC34A),
+        Resource.GRAIN to Color(0xFFE0B020),
+        Resource.ORE to Color(0xFF6B7684),
+    ),
+    resourceInk = Color(0xFFFFFFFF),
+    seats = listOf(
+        Color(0xFF1565C0), // blue
+        Color(0xFFEF6C00), // orange
+        Color(0xFFF5F5F5), // white
+        Color(0xFF8E24AA), // purple
+    ),
+    pieceOutline = Color(0xFF1B1B1B),
+    target = Color(0xFFFFEB3B),
+    targetSelected = Color(0xFF00E5FF),
+)
+
+/** Deeper sea and slightly dimmer land so the board is not a glare at night. */
+private val DarkStyle = LightStyle.copy(
+    sea = Color(0xFF14354D),
+    terrain = LightStyle.terrain.mapValues { (_, c) -> c.dim(0.82f) },
+    token = Color(0xFFE9DFC4),
+)
+
+/** The style for the current light / dark setting. */
+fun catanStyle(dark: Boolean): CatanStyle = if (dark) DarkStyle else LightStyle
+
+/**
+ * What the Katan composables read their look from. Defaults to the light style
+ * so a preview or a test with no provider still draws something sensible;
+ * [CatanScreen] provides the right one for the current theme.
+ */
+val LocalCatanStyle = staticCompositionLocalOf { LightStyle }
+
+private fun Color.dim(factor: Float): Color =
+    Color(red * factor, green * factor, blue * factor, alpha)

app/src/main/java/org/prolibertate/games/ui/game/catan/CatanText.kt

@@ -0,0 +1,239 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.DevCardType
+import org.prolibertate.games.game.catan.Port
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.catan.Terrain
+
+/**
+ * Who is who at the table, for wording. [names] may be empty or short — a
+ * client device does not always know everyone's name — and the rest fall back
+ * to "Seat N".
+ */
+class CatanSeats(val me: Int, private val names: List<String> = emptyList()) {
+    fun label(seat: Int): String = when {
+        seat == me -> "You"
+        else -> names.getOrNull(seat)?.takeIf { it.isNotBlank() } ?: "Seat ${seat + 1}"
+    }
+
+    /** For mid-sentence use: "you" rather than "You". */
+    fun lower(seat: Int): String = if (seat == me) "you" else label(seat)
+}
+
+/**
+ * Every word the Katan screen shows, in one place.
+ *
+ * **To change copy, or to localise, edit this file.** The composables never
+ * build a sentence themselves; they ask for it here. Keeping the sentences as
+ * plain functions of state also means they are unit-tested (`CatanTextTest`)
+ * without a device.
+ *
+ * "Katan" is this app's name for the game (see `docs/RULES-catan.md`); the
+ * resources are lumber, brick, wool, grain and ore.
+ */
+object CatanText {
+
+    const val TITLE = "Katan"
+
+    // --- Names ---------------------------------------------------------------
+
+    fun resource(resource: Resource): String = when (resource) {
+        Resource.LUMBER -> "Lumber"
+        Resource.BRICK -> "Brick"
+        Resource.WOOL -> "Wool"
+        Resource.GRAIN -> "Grain"
+        Resource.ORE -> "Ore"
+    }
+
+    fun terrain(terrain: Terrain): String = when (terrain) {
+        Terrain.FOREST -> "Forest"
+        Terrain.PASTURE -> "Pasture"
+        Terrain.FIELDS -> "Fields"
+        Terrain.HILLS -> "Hills"
+        Terrain.MOUNTAINS -> "Mountains"
+        Terrain.DESERT -> "Desert"
+    }
+
+    fun devCard(type: DevCardType): String = when (type) {
+        DevCardType.KNIGHT -> "Knight"
+        DevCardType.ROAD_BUILDING -> "Road building"
+        DevCardType.MONOPOLY -> "Monopoly"
+        DevCardType.YEAR_OF_PLENTY -> "Year of plenty"
+        DevCardType.VICTORY_POINT -> "Victory point"
+    }
+
+    fun devCardHelp(type: DevCardType): String = when (type) {
+        DevCardType.KNIGHT -> "Move the robber and steal a card. Three played knights take Largest Army."
+        DevCardType.ROAD_BUILDING -> "Build two roads for free."
+        DevCardType.MONOPOLY -> "Name a resource and take every card of it from the other players."
+        DevCardType.YEAR_OF_PLENTY -> "Take any two resource cards from the bank."
+        DevCardType.VICTORY_POINT -> "One victory point. Kept hidden until you win."
+    }
+
+    /** "3:1" for a generic harbour, "2:1" for a resource one. */
+    fun portRatio(port: Port): String = "${port.ratio}:1"
+
+    fun portName(port: Port): String =
+        port.resource?.let { "${portRatio(port)} ${resource(it).lowercase()}" } ?: "3:1 any"
+
+    // --- Costs ---------------------------------------------------------------
+
+    fun cost(cost: Map<Resource, Int>): String =
+        cost.entries.joinToString(" + ") { (r, n) -> "$n ${resource(r).lowercase()}" }
+
+    val ROAD_COST: String get() = cost(CatanRules.ROAD_COST)
+    val SETTLEMENT_COST: String get() = cost(CatanRules.SETTLEMENT_COST)
+    val CITY_COST: String get() = cost(CatanRules.CITY_COST)
+    val DEV_COST: String get() = cost(CatanRules.DEV_COST)
+
+    // --- Buttons and headings --------------------------------------------------
+
+    const val ROLL = "Roll dice"
+    const val END_TURN = "End turn"
+    const val ROAD = "Road"
+    const val SETTLEMENT = "Settlement"
+    const val CITY = "City"
+    const val BUY_CARD = "Buy card"
+    const val PLAY_CARD = "Play card"
+    const val TRADE = "Trade"
+    const val CANCEL = "Cancel"
+    const val CONFIRM = "Confirm"
+    const val STOP_ROADS = "Done with roads"
+    const val BUILD = "Build"
+    const val COUNTER = "Counter…"
+    const val SEND_COUNTER = "Send counter"
+    const val EVERYONE = "Everyone"
+    const val NO_DEAL = "No deal"
+
+    /**
+     * The empty second line of a button that has no cost, so every button in the
+     * action bar is the same height. A non-breaking space: blank, but a line.
+     */
+    const val NO_COST = "\u00A0"
+    const val YOUR_HAND = "Your hand"
+    const val CARDS = "cards"
+    const val ACCEPT = "Accept"
+    const val DECLINE = "Decline"
+    const val TRADE_WITH_PLAYER = "Offer to a player"
+    const val TRADE_WITH_BANK = "Trade with the bank"
+    const val YOU_GIVE = "You give"
+    const val YOU_GET = "You get"
+    const val SEND_OFFER = "Send offer"
+    const val NO_LOG = "Nothing has happened yet."
+    const val END_GAME = "End game"
+    const val LOOK_AT_BOARD = "Look at the board"
+    const val LEAVE_GAME = "Leave the game"
+
+    // --- The prompt line ------------------------------------------------------
+
+    /**
+     * The one line that tells the player what is going on and what to do.
+     *
+     * [setupVertexChosen] is the setup settlement already picked and waiting
+     * for its road; [building] is the build mode the player has entered, if any.
+     */
+    fun prompt(
+        state: CatanState,
+        seats: CatanSeats,
+        setupVertexChosen: Boolean,
+        building: BuildKind?,
+    ): String {
+        val me = seats.me
+        val onClock = CatanRules.currentSeat(state)
+        val mine = onClock == me
+        val turn = seats.label(state.turn)
+
+        return when (state.phase) {
+            CatanPhase.GAME_OVER -> {
+                val winner = state.winner
+                if (winner == null) "The game is over." else "${seats.label(winner)} won the game."
+            }
+
+            CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND -> when {
+                !mine -> "${seats.label(onClock ?: state.turn)} is placing a settlement and a road…"
+                setupVertexChosen -> "Now tap the road to place beside that settlement."
+                state.phase == CatanPhase.SETUP_SECOND ->
+                    "Place your second settlement. It earns resources from the hexes around it."
+
+                else -> "Place a settlement, then a road."
+            }
+
+            CatanPhase.AWAIT_ROLL ->
+                if (mine) "Your turn. Roll the dice." else "$turn is rolling…"
+
+            CatanPhase.DISCARDING -> {
+                val discarder = state.discardSeat
+                when {
+                    discarder == me -> "A seven! You hold ${state.resourceCount(me)} cards; " +
+                        "discard ${state.resourceCount(me) / 2}."
+
+                    discarder != null -> "A seven! ${seats.label(discarder)} must discard half."
+                    else -> "A seven! Discarding…"
+                }
+            }
+
+            CatanPhase.ROBBER ->
+                if (mine) "Move the robber. Tap a hex." else "$turn is moving the robber…"
+
+            CatanPhase.PLAYING -> when {
+                !mine -> "$turn is playing…"
+                building == BuildKind.ROAD -> "Tap an edge to build a road."
+                building == BuildKind.SETTLEMENT -> "Tap an empty crossing to build a settlement."
+                building == BuildKind.CITY -> "Tap one of your settlements to upgrade it."
+                else -> "Your turn. Build, trade, or end the turn."
+            }
+
+            CatanPhase.FREE_ROADS ->
+                if (mine) {
+                    "Road building: place ${state.pendingFreeRoads} more " +
+                        if (state.pendingFreeRoads == 1) "road." else "roads."
+                } else {
+                    "$turn is placing free roads…"
+                }
+
+            CatanPhase.TRADE_PENDING -> {
+                val offer = state.pendingTrade
+                when {
+                    offer == null -> "Waiting for a reply…"
+                    offer.asking == me -> if (offer.to == null) {
+                        "${seats.label(offer.by)} offers the table a trade. Accept, decline or counter."
+                    } else {
+                        "${seats.label(offer.by)} offers you a trade. Accept, decline or counter."
+                    }
+
+                    offer.by == me -> "Waiting for ${seats.label(offer.asking)} to answer your offer…"
+                    else -> "${seats.label(offer.by)}'s offer is with ${seats.label(offer.asking)}."
+                }
+            }
+
+            CatanPhase.TRADE_COUNTERS ->
+                if (mine) {
+                    "Nobody accepted, but there are counter-offers. Take one or turn them down."
+                } else {
+                    "$turn is weighing counter-offers…"
+                }
+        }
+    }
+
+    /** "3 Lumber + 1 Brick" for a flat list of cards. */
+    fun cards(cards: List<Resource>): String =
+        cards.groupingBy { it }.eachCount().entries
+            .sortedBy { it.key.ordinal }
+            .joinToString(" + ") { (r, n) -> "$n ${resource(r)}" }
+            .ifEmpty { "nothing" }
+
+    fun tradeSummary(by: String, to: String, give: List<Resource>, get: List<Resource>): String =
+        "$by offers ${cards(give)} to $to for ${cards(get)}"
+
+    /** One counter-offer as the offerer sees it: what that seat gives and wants. */
+    fun counterSummary(by: String, give: List<Resource>, get: List<Resource>): String =
+        "$by gives ${cards(give)} for your ${cards(get)}"
+
+    fun winnerHeadline(state: CatanState, seats: CatanSeats): String {
+        val winner = state.winner ?: return "Game over"
+        return if (winner == seats.me) "You won!" else "${seats.label(winner)} won"
+    }
+}

app/src/main/java/org/prolibertate/games/ui/theme/Tartan.kt

@@ -0,0 +1,187 @@
+package org.prolibertate.games.ui.theme
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.rotate
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import org.prolibertate.games.BuildConfig
+
+/** One band of a tartan sett, measured in threads. */
+data class TartanStripe(val color: Color, val threads: Int)
+
+val WallaceRed = Color(0xFFE01B24)
+val WallaceBlack = Color(0xFF0C0C0C)
+val WallaceGold = Color(0xFFF2C518)
+
+/**
+ * The green the hunting sett puts where the clan sett puts red.
+ *
+ * Must match `tartan_field` for a dev build in app/build.gradle.kts, which is
+ * what the launcher icon is woven from — otherwise the icon and the splash it
+ * opens on would be visibly different cloth.
+ */
+val WallaceHuntingGreen = Color(0xFF1E7A3C)
+
+/**
+ * Expands a half-sett into a full repeat by reflecting it.
+ *
+ * Tartans are specified as a half-sett between two pivots and woven out to
+ * both sides, so `A B C` becomes `A B C B` — the pivot stripes are not
+ * doubled. Writing the data this way keeps it in the same form a threadcount
+ * is published in, instead of a flat list that has to be kept symmetric by
+ * hand.
+ */
+fun List<TartanStripe>.pivoted(): List<TartanStripe> =
+    if (size < 3) this else this + drop(1).dropLast(1).reversed()
+
+/**
+ * The Wallace sett, from its published threadcount: **K/4 R32 K32 Y/4**.
+ *
+ * The slashes mark the pivots, so this is the half-sett and it reflects out to
+ * `K4 R32 K32 Y4 K32 R32` — 136 threads, roughly half black, half red, with a
+ * yellow line worth 3%. Two consequences that are easy to get backwards and
+ * that define the pattern:
+ *
+ *  - the yellow overstripe runs down the **centre of a wide black band**, not
+ *    between red and black;
+ *  - the narrow black guard sits **between two red blocks**, splitting the red
+ *    into pairs.
+ *
+ * The threadcount itself lives in [wallaceSett], because the hunting colourway
+ * below is the same cloth in a different colour and must not drift from it.
+ */
+val WallaceSett: List<TartanStripe> = wallaceSett(WallaceRed)
+
+/**
+ * Wallace Hunting: the same threadcount woven in green.
+ *
+ * Hunting setts are the clan cloth in muted, outdoor colours, and for Wallace
+ * that is the one substitution — green for the red — with the black ground and
+ * the yellow overstripe untouched. Deriving it from the same builder rather
+ * than writing the numbers out twice is what keeps that true: a change to the
+ * threadcount cannot land in one colourway and miss the other.
+ */
+val WallaceHuntingSett: List<TartanStripe> = wallaceSett(WallaceHuntingGreen)
+
+/** The Wallace threadcount woven with [field] in place of the red. */
+private fun wallaceSett(field: Color): List<TartanStripe> = listOf(
+    TartanStripe(WallaceBlack, 4),
+    TartanStripe(field, 32),
+    TartanStripe(WallaceBlack, 32),
+    TartanStripe(WallaceGold, 4),
+).pivoted()
+
+/**
+ * The cloth this build wears: the clan sett on production, the hunting sett on
+ * dev.
+ *
+ * A dev build installs as its own app beside the production one, so it has to
+ * be recognisable at a glance in the app drawer and on the splash — the green
+ * says which of the two copies just opened without anything having to be read.
+ */
+val AppSett: List<TartanStripe> =
+    if (BuildConfig.DEV_BUILD) WallaceHuntingSett else WallaceSett
+
+/** Threads in one full repeat of a sett. */
+val List<TartanStripe>.threadsPerRepeat: Int get() = sumOf { it.threads }
+
+/**
+ * The thread width that fits [repeats] repeats of [sett] across [across].
+ *
+ * Scale has to be derived from the sett rather than fixed, because changing a
+ * threadcount changes how many threads a repeat contains — a fixed width and a
+ * larger sett silently zooms in until the cloth is a couple of enormous blocks
+ * and stops reading as tartan at all.
+ */
+fun threadWidthFor(
+    sett: List<TartanStripe> = AppSett,
+    across: Dp,
+    repeats: Float = 2f,
+): Dp = across / (sett.threadsPerRepeat * repeats)
+
+/**
+ * Draws a tartan by laying the sett down vertically as warp, then across as
+ * weft at half opacity. The overlap is what produces the blended squares and
+ * the sense of a woven cloth rather than a printed grid — red warp under black
+ * weft comes out a darker red, exactly as it does on the loom.
+ *
+ * [rotationDegrees] turns the cloth on the bias. The stripes are drawn well
+ * past the edges of the canvas so the corners stay covered once it is turned.
+ */
+fun DrawScope.drawTartan(
+    sett: List<TartanStripe> = AppSett,
+    threadSize: Float,
+    rotationDegrees: Float = 0f,
+) {
+    if (sett.isEmpty() || threadSize <= 0f) return
+    val repeat = sett.sumOf { it.threads } * threadSize
+    if (repeat <= 0f) return
+
+    // Turning a square by 45 degrees needs about 0.21 of its size spare on
+    // every edge; three quarters is generous enough for any angle.
+    val pad = if (rotationDegrees == 0f) 0f else size.maxDimension * 0.75f
+    val left = -pad
+    val top = -pad
+    val right = size.width + pad
+    val bottom = size.height + pad
+
+    rotate(degrees = rotationDegrees) {
+        // Warp: full-height bands.
+        var x = left - (left.mod(repeat))
+        while (x < right) {
+            var offset = x
+            for (stripe in sett) {
+                val width = stripe.threads * threadSize
+                drawRect(
+                    color = stripe.color,
+                    topLeft = Offset(offset, top),
+                    size = Size(width, bottom - top),
+                )
+                offset += width
+            }
+            x += repeat
+        }
+
+        // Weft: full-width bands, half opacity so the warp shows through.
+        var y = top - (top.mod(repeat))
+        while (y < bottom) {
+            var offset = y
+            for (stripe in sett) {
+                val height = stripe.threads * threadSize
+                drawRect(
+                    color = stripe.color.copy(alpha = 0.5f),
+                    topLeft = Offset(left, offset),
+                    size = Size(right - left, height),
+                )
+                offset += height
+            }
+            y += repeat
+        }
+    }
+}
+
+/**
+ * A tartan fill. [threadWidth] sets the weave scale, so the same cloth can be
+ * a fine weave on a phone and a coarse one on a tablet without redrawing it.
+ */
+@Composable
+fun TartanBackground(
+    modifier: Modifier = Modifier,
+    sett: List<TartanStripe> = AppSett,
+    threadWidth: Dp = 2.dp,
+    rotationDegrees: Float = 0f,
+) {
+    Canvas(modifier = modifier) {
+        drawTartan(
+            sett = sett,
+            threadSize = threadWidth.toPx(),
+            rotationDegrees = rotationDegrees,
+        )
+    }
+}

app/src/main/java/org/prolibertate/games/ui/theme/Theme.kt

@@ -6,7 +6,6 @@ import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
-import org.prolibertate.games.BuildConfig
 
 /** Card-table green, which the board and table surfaces are drawn on. */
 val FeltGreen = Color(0xFF1B5E20)
@@ -15,31 +14,6 @@ val Parchment = Color(0xFFF4EFE4)
 val CardRed = Color(0xFFB3261E)
 val CardBlack = Color(0xFF1C1B1F)
 
-/**
- * The brand palette for Pilgrims of Katan — original and neutral, shared by
- * every game in the catalogue. Slate blue on production, deep green on dev, so
- * the two installs are told apart at a glance; both must stay in step with the
- * resValues in app/build.gradle.kts or the icon and the splash it opens on
- * would be different brands.
- *
- * The upstream shipped a clan tartan here. This project carries no clan or
- * third-party trade dress (WALA-118).
- */
-val BrandField: Color = if (BuildConfig.DEV_BUILD) Color(0xFF2A6B54) else Color(0xFF2B4A78)
-val BrandDeep: Color = if (BuildConfig.DEV_BUILD) Color(0xFF153B2F) else Color(0xFF182A44)
-
-/** The parchment accent: the emblem on the icon, the second line of the splash. */
-val BrandAccent: Color = Color(0xFFEFD9A4)
-
-/**
- * Accents used *inside* a game table — a highlight, a held die, a danger mark.
- * Deliberately channel-free: what a game shows must not change with which
- * install it is running in. Values unchanged from the upstream, so the games
- * themselves look exactly as they did.
- */
-val AccentRed = Color(0xFFE01B24)
-val AccentGold = Color(0xFFF2C518)
-
 val TeamColours: List<Color> = listOf(
     Color(0xFF1565C0), // blue
     Color(0xFFC62828), // red
@@ -65,7 +39,7 @@ private val LightColours = lightColorScheme(
 )
 
 @Composable
-fun PilgrimsTheme(
+fun ProLibertateTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
     content: @Composable () -> Unit,
 ) {

app/src/main/java/org/prolibertate/games/update/UpdatePolicy.kt

@@ -1,19 +1,17 @@
 package org.prolibertate.games.update
 
-import java.net.URI
-
 /**
  * Which line of builds an APK belongs to.
  *
  * This is a property of the build, never a preference. The two channels are
  * published by different workflows and have entirely separate version
- * sequences — a dev build's versionCode is its CI build number, a production
- * build's is its release build number, and the two are unrelated. There is no
+ * sequences — a dev build's versionCode is its CI run number, a production
+ * build's is its release run number, and the two are unrelated. There is no
  * meaning to be had from comparing across them, so nothing does.
  *
  * They also carry different applicationIds — a dev build installs as
- * `…pilgrimsofkatan.dev` — so both can sit on one device, each updating
- * itself down its own line and leaving the other alone.
+ * `…games.dev` — so both can sit on one device, each updating itself down its
+ * own line and leaving the other alone.
  */
 enum class UpdateChannel(val label: String, val blurb: String) {
     PRODUCTION("Production", "Stable builds released from main"),
@@ -23,7 +21,7 @@ enum class UpdateChannel(val label: String, val blurb: String) {
 /** Marks a tag or a version name as belonging to the dev channel. */
 const val DEV_SUFFIX = "-dev"
 
-/** One published build, as read off a repository release. */
+/** One published build, as read off a channel's `latest.json`. */
 data class Release(
     val tag: String,
     val versionCode: Int,
@@ -51,14 +49,14 @@ fun channelOfVersionName(versionName: String): UpdateChannel =
  * The channel a release belongs to.
  *
  * Two independent marks, and either is enough: the `-dev` suffix the workflow
- * puts on the tag, and the release's own prerelease flag. A release would have
- * to lose both to be mistaken for the other channel.
+ * puts on the tag, and GitHub's own prerelease flag. A release would have to
+ * lose both to be mistaken for the other channel.
  */
 fun channelOfTag(tag: String, prerelease: Boolean): UpdateChannel =
     if (tag.endsWith(DEV_SUFFIX) || prerelease) UpdateChannel.DEV else UpdateChannel.PRODUCTION
 
 /**
- * The build number out of a `v<series>.<n>` tag, which is what an APK's
+ * The run number out of a `v<series>.<n>` tag, which is what an APK's
  * versionCode is.
  *
  * Only the trailing number is read. The series is a name for people, and
@@ -67,37 +65,15 @@ fun channelOfTag(tag: String, prerelease: Boolean): UpdateChannel =
 fun versionCodeOfTag(tag: String): Int? =
     tag.substringAfterLast('.').removeSuffix(DEV_SUFFIX).toIntOrNull()
 
-/**
- * Rewrites a download URL onto [host], keeping its scheme, path and query.
- *
- * A release server can answer for more than one host name, and it hands out
- * asset URLs on whichever one it treats as canonical — which need not be the
- * one the app was told to talk to. Fetching the release list from one host and
- * the APK from another is a single DNS change away from a channel that half
- * works, so the app stays on the host it decided to trust and takes only the
- * path from what the server reported.
- *
- * Anything that cannot be parsed is returned unchanged: a broken URL fails
- * loudly at download time, while a swallowed one would fail as a silent
- * "something went wrong".
- */
-fun onReportedHost(url: String, host: String): String = try {
-    val reported = URI(url)
-    val scheme = reported.scheme ?: "https"
-    URI(scheme, null, host, -1, reported.path, reported.query, null).toString()
-} catch (e: Exception) {
-    url
-}
-
 /**
  * The build a check on launch should interrupt somebody for, or null to say
  * nothing at all.
  *
  * Only an actual update is worth a word. Opening the app is not asking a
- * question, so a check that finds nothing — or that cannot reach the release
- * server at all — stays quiet; a phone on a train would otherwise be told off
- * for it every single launch. The button in Settings *is* asking a question, and
- * reports every answer including those two.
+ * question, so a check that finds nothing — or that cannot reach the update server at all
+ * — stays quiet; a phone on a train would otherwise be told off for it every
+ * single launch. The button in Settings *is* asking a question, and reports
+ * every answer including those two.
  */
 fun launchOffer(verdict: UpdateVerdict): Release? =
     (verdict as? UpdateVerdict.Install)?.release

app/src/main/java/org/prolibertate/games/update/Updater.kt

@@ -8,36 +8,17 @@ import android.provider.Settings
 import androidx.core.content.FileProvider
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import org.json.JSONArray
 import org.json.JSONObject
-import org.prolibertate.games.BuildConfig
 import java.io.File
 import java.net.HttpURLConnection
 import java.net.URL
 
 /**
- * Over-the-air updates from the repository's releases.
+ * Over-the-air updates from plg.wallacenet.ca (Cloudflare Pages).
  *
- * The channel is the Gitea instance this app ships from
- * (`git.wallacenet.ca`), not GitHub. Gitea's release API answers with the
- * same shape the updater reads — `tag_name`, `prerelease`, `draft`, and
- * assets carrying `browser_download_url` — so this is the same code the
- * upstream ran, pointed at `/api/v1/repos/...` routes instead of
- * `api.github.com`, with `limit` where GitHub says `per_page`.
- *
- * Release tags are v<series>.<n>, where **n is the stamped build number the
- * APK's versionCode was built from** (the CI run number plus the fixed
- * `plgVersionRunOffset` — see docs/CI.md), so comparing the two is enough to
- * tell whether a newer build exists.
- *
- * The repository and its releases are public: no token is embedded in the
- * app, and every download is anonymous by design. If the repo were ever made
- * private, every check would simply start failing rather than leaking
- * anything.
- *
- * `BuildConfig.OTA_ENABLED` is a kill switch, not a channel decision — it is
- * true in this build; setting it false makes every check report that and
- * fetch nothing.
+ * Release tags are v<series>.<run-number> and the APK's versionCode is that same run
+ * number, so comparing the two is enough to tell whether a newer build exists.
+ * Everything there is public — no token is embedded in the app.
  *
  * There is nothing to choose here. The channel comes from the running APK, so
  * a dev install looks only at dev builds and a production install only at
@@ -52,11 +33,6 @@ class Updater(private val activity: Activity) {
      * this phone is on, and the phone already knows.
      */
     suspend fun check(): UpdateVerdict = withContext(Dispatchers.IO) {
-        if (!BuildConfig.OTA_ENABLED) {
-            return@withContext UpdateVerdict.Refused(
-                "In-app updates are not enabled for this build yet."
-            )
-        }
         try {
             val channel = installedChannel()
             verdictFor(
@@ -70,70 +46,37 @@ class Updater(private val activity: Activity) {
     }
 
     /**
-     * Production reads the "latest release", which by definition skips
-     * prereleases — Gitea implements it as the most recent non-prerelease,
-     * non-draft release, so the rule holds on this instance too.
-     *
-     * Dev walks the release list for the newest prerelease, which is what the
-     * CI pipeline publishes from the dev branch. The list is taken as the
-     * highest versionCode among the dev releases rather than the first one
-     * returned, so the answer does not depend on how the server chose to
-     * order the page.
+     * Each channel publishes a `latest.json` next to its APK on Cloudflare
+     * Pages: `/prod/latest.json` and `/dev/latest.json`. The two live in one
+     * site but separate paths, so a build can only ever look down its own line.
      */
-    private fun fetchLatestRelease(channel: UpdateChannel): Release? = when (channel) {
-        UpdateChannel.PRODUCTION ->
-            getJsonObject("$API/releases/latest")
-                ?.let { toRelease(it) }
-
-        UpdateChannel.DEV ->
-            getJsonArray("$API/releases?limit=30")
-                ?.let { releases ->
-                    (0 until releases.length())
-                        .mapNotNull { toRelease(releases.getJSONObject(it)) }
-                        .filter { it.channel == UpdateChannel.DEV }
-                        .maxByOrNull { it.versionCode }
-                }
+    private fun fetchLatestRelease(channel: UpdateChannel): Release? {
+        val path = if (channel == UpdateChannel.DEV) "dev" else "prod"
+        return getJsonObject("$BASE_URL/$path/latest.json")?.let { toRelease(it) }
     }
 
     private fun toRelease(json: JSONObject): Release? {
-        val tag = json.optString("tag_name").ifBlank { return null }
+        val tag = json.optString("tag").ifBlank { return null }
         val versionCode = versionCodeOfTag(tag) ?: return null
-        val channel = channelOfTag(tag, json.optBoolean("prerelease"))
-
-        val assets = json.optJSONArray("assets") ?: return null
-        val apks = (0 until assets.length())
-            .map { assets.getJSONObject(it) }
-            .filter { it.optString("name").endsWith(".apk") }
-
-        // A production release may carry the same build twice: once named for
-        // its version, and once under a fixed name so a permanent download link
-        // exists. Pick the versioned one explicitly rather than whichever was
-        // uploaded first, so what gets installed is traceable to its tag.
-        val chosen = apks.firstOrNull { it.optString("name").contains(tag) }
-            ?: apks.firstOrNull()
-            ?: return null
-
+        val apkUrl = json.optString("apkUrl").ifBlank { return null }
         return Release(
             tag = tag,
             versionCode = versionCode,
-            apkUrl = onReportedHost(chosen.getString("browser_download_url"), SERVER_HOST),
-            apkName = chosen.optString("name"),
-            channel = channel,
+            apkUrl = apkUrl,
+            apkName = json.optString("apkName"),
+            channel = channelOfTag(tag, prerelease = false),
         )
     }
 
-    private fun openConnection(url: String): HttpURLConnection =
-        (URL(url).openConnection() as HttpURLConnection).apply {
+    private fun getJsonObject(url: String): JSONObject? {
+        val connection = (URL(url).openConnection() as HttpURLConnection).apply {
             requestMethod = "GET"
-            setRequestProperty("Accept", "application/json")
-            setRequestProperty("User-Agent", "PilgrimsOfKatan-Updater")
+            setRequestProperty("User-Agent", "ProLibertateGames-Updater")
             connectTimeout = 15_000
             readTimeout = 15_000
         }
-
-    private fun getJsonObject(url: String): JSONObject? {
-        val connection = openConnection(url)
         try {
+            // 404 means the channel has nothing published yet.
             if (connection.responseCode != 200) return null
             return JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
         } finally {
@@ -141,16 +84,6 @@ class Updater(private val activity: Activity) {
         }
     }
 
-    private fun getJsonArray(url: String): JSONArray? {
-        val connection = openConnection(url)
-        try {
-            if (connection.responseCode != 200) return null
-            return JSONArray(connection.inputStream.bufferedReader().use { it.readText() })
-        } finally {
-            connection.disconnect()
-        }
-    }
-
     /** Read back from the installed APK's own version name. */
     fun installedChannel(): UpdateChannel = channelOfVersionName(installedVersionName())
 
@@ -202,13 +135,6 @@ class Updater(private val activity: Activity) {
         activity.packageManager.getPackageInfo(activity.packageName, 0).versionName ?: "unknown"
 
     private companion object {
-        /** The Gitea instance that publishes this app's releases. */
-        const val SERVER = "https://git.wallacenet.ca"
-        const val SERVER_HOST = "git.wallacenet.ca"
-        const val OWNER = "devadmin"
-        const val REPO = "PilgrimsOfKatan"
-
-        /** Release routes, Gitea's `/api/v1` spelling of GitHub's API. */
-        const val API = "$SERVER/api/v1/repos/$OWNER/$REPO"
+        const val BASE_URL = "https://plg.wallacenet.ca"
     }
 }

app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,16 +1,70 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  The flat field behind the launcher emblem: brand_field, slate blue on
-  production and deep green on dev, generated by the build (see resValue in
-  app/build.gradle.kts) so the two installs are told apart in the app drawer
-  by the icon alone.
+  A single square of the Wallace tartan, set on the bias.
+
+  Generated from the published threadcount K/4 R32 K32 Y/4 — the same numbers
+  as WallaceSett in Tartan.kt. The slashes are pivots, so the half-sett
+  reflects out to K4 R32 K32 Y4 K32 R32: the yellow overstripe runs down the
+  centre of a wide black band, and the narrow black guard splits the red into
+  pairs.
+
+  The stripes reference @color/tartan_field rather than a literal, because the
+  same threadcount is woven in two colourways: Wallace red on a production
+  build, Wallace Hunting green on a dev one, so the two installs are told apart
+  in the app drawer by the icon alone. The build generates that colour; see
+  resValue in app/build.gradle.kts.
+
+  Warp is opaque, weft laid over it at half opacity, which is what gives the
+  blended squares rather than a flat grid. Paths run well past the viewport
+  because the group is rotated 45 degrees; the overspill keeps the corners
+  covered. One full repeat fills the adaptive icon's safe zone.
 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     android:width="108dp"
     android:height="108dp"
     android:viewportWidth="108"
     android:viewportHeight="108">
-    <path
-        android:fillColor="@color/brand_field"
-        android:pathData="M0,0h108v108h-108z" />
+    <group
+        android:rotation="45"
+        android:pivotX="54.0"
+        android:pivotY="54.0">
+        <path android:fillColor="@color/tartan_ground" android:pathData="M-90.00,-90.00h288.00v288.00h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-88.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-69.88,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M-36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-16.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M2.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M55.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M74.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M108.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M127.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M146.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M180.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-105.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-88.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-69.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-52.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,-36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-33.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-16.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,0.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,2.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,19.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,38.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,55.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,74.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,91.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,108.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,110.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,127.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,144.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,146.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,163.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,180.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,182.12h288.00v16.94h-288.00z" />
+    </group>
 </vector>

app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -1,23 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  The brand emblem: a hexagonal ring around a solid hexagonal core, in
-  parchment on the brand field behind it (see ic_launcher_background).
-
-  The hexagon is a game tile, not any game's mark — deliberately generic
-  branding for Pilgrims of Katan, carrying no third-party logo or trade dress.
-  Everything sits inside the adaptive icon's safe zone (a centred 66dp circle
-  on this 108dp canvas) so no launcher mask can clip it.
+  Deliberately empty. The icon is the cloth itself, so the adaptive icon's
+  foreground layer carries nothing — anything drawn here would sit on top of the
+  tartan and break the "single square of tartan" idea.
 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     android:width="108dp"
     android:height="108dp"
     android:viewportWidth="108"
     android:viewportHeight="108">
-    <!-- Ring and core in one even-odd path: outer hexagon, inner hexagon,
-         core hexagon — odd coverage fills, so the ring and the core are drawn
-         and the gap between them stays open to the field showing through. -->
     <path
-        android:fillColor="@color/brand_accent"
-        android:fillType="evenOdd"
-        android:pathData="M84,54 L69,79.98 L39,79.98 L24,54 L39,28.02 L69,28.02 Z M72,54 L63,69.59 L45,69.59 L36,54 L45,38.41 L63,38.41 Z M63,54 L58.5,61.79 L49.5,61.79 L45,54 L49.5,46.21 L58.5,46.21 Z" />
+        android:fillColor="#00000000"
+        android:pathData="M0,0h108v108h-108z" />
 </vector>

app/src/main/res/mipmap/ic_launcher.xml

@@ -1,22 +1,70 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  The legacy (pre-API 26) launcher icon: the same brand emblem as the adaptive
-  icon's foreground, over the same brand field, in the one layer those
-  launchers get.
+  A single square of the Wallace tartan, set on the bias.
 
-  Field first, emblem second: two paths, because the emblem's ring relies on
-  even-odd parity and a filled background inside the same path would flip it.
+  Generated from the published threadcount K/4 R32 K32 Y/4 — the same numbers
+  as WallaceSett in Tartan.kt. The slashes are pivots, so the half-sett
+  reflects out to K4 R32 K32 Y4 K32 R32: the yellow overstripe runs down the
+  centre of a wide black band, and the narrow black guard splits the red into
+  pairs.
+
+  The stripes reference @color/tartan_field rather than a literal, because the
+  same threadcount is woven in two colourways: Wallace red on a production
+  build, Wallace Hunting green on a dev one, so the two installs are told apart
+  in the app drawer by the icon alone. The build generates that colour; see
+  resValue in app/build.gradle.kts.
+
+  Warp is opaque, weft laid over it at half opacity, which is what gives the
+  blended squares rather than a flat grid. Paths run well past the viewport
+  because the group is rotated 45 degrees; the overspill keeps the corners
+  covered. One full repeat fills the adaptive icon's safe zone.
 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     android:width="48dp"
     android:height="48dp"
     android:viewportWidth="108"
     android:viewportHeight="108">
-    <path
-        android:fillColor="@color/brand_field"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="@color/brand_accent"
-        android:fillType="evenOdd"
-        android:pathData="M84,54 L69,79.98 L39,79.98 L24,54 L39,28.02 L69,28.02 Z M72,54 L63,69.59 L45,69.59 L36,54 L45,38.41 L63,38.41 Z M63,54 L58.5,61.79 L49.5,61.79 L45,54 L49.5,46.21 L58.5,46.21 Z" />
+    <group
+        android:rotation="45"
+        android:pivotX="54.0"
+        android:pivotY="54.0">
+        <path android:fillColor="@color/tartan_ground" android:pathData="M-90.00,-90.00h288.00v288.00h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-88.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-69.88,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M-36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-16.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M2.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M55.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M74.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M108.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M127.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M146.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M180.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-105.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-88.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-69.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-52.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,-36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-33.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-16.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,0.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,2.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,19.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,38.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,55.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,74.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,91.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,108.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,110.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,127.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,144.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,146.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,163.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,180.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,182.12h288.00v16.94h-288.00z" />
+    </group>
 </vector>

app/src/main/res/mipmap/ic_launcher_round.xml

@@ -1,22 +1,70 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  The legacy (pre-API 26) launcher icon: the same brand emblem as the adaptive
-  icon's foreground, over the same brand field, in the one layer those
-  launchers get.
+  A single square of the Wallace tartan, set on the bias.
 
-  Field first, emblem second: two paths, because the emblem's ring relies on
-  even-odd parity and a filled background inside the same path would flip it.
+  Generated from the published threadcount K/4 R32 K32 Y/4 — the same numbers
+  as WallaceSett in Tartan.kt. The slashes are pivots, so the half-sett
+  reflects out to K4 R32 K32 Y4 K32 R32: the yellow overstripe runs down the
+  centre of a wide black band, and the narrow black guard splits the red into
+  pairs.
+
+  The stripes reference @color/tartan_field rather than a literal, because the
+  same threadcount is woven in two colourways: Wallace red on a production
+  build, Wallace Hunting green on a dev one, so the two installs are told apart
+  in the app drawer by the icon alone. The build generates that colour; see
+  resValue in app/build.gradle.kts.
+
+  Warp is opaque, weft laid over it at half opacity, which is what gives the
+  blended squares rather than a flat grid. Paths run well past the viewport
+  because the group is rotated 45 degrees; the overspill keeps the corners
+  covered. One full repeat fills the adaptive icon's safe zone.
 -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     android:width="48dp"
     android:height="48dp"
     android:viewportWidth="108"
     android:viewportHeight="108">
-    <path
-        android:fillColor="@color/brand_field"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="@color/brand_accent"
-        android:fillType="evenOdd"
-        android:pathData="M84,54 L69,79.98 L39,79.98 L24,54 L39,28.02 L69,28.02 Z M72,54 L63,69.59 L45,69.59 L36,54 L45,38.41 L63,38.41 Z M63,54 L58.5,61.79 L49.5,61.79 L45,54 L49.5,46.21 L58.5,46.21 Z" />
+    <group
+        android:rotation="45"
+        android:pivotX="54.0"
+        android:pivotY="54.0">
+        <path android:fillColor="@color/tartan_ground" android:pathData="M-90.00,-90.00h288.00v288.00h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-88.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-69.88,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M-36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M-16.94,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M2.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M36.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M55.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M74.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M108.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M127.06,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_field" android:pathData="M146.12,-90.00h16.94v288.00h-16.94z" />
+        <path android:fillColor="@color/tartan_over" android:pathData="M180.00,-90.00h2.12v288.00h-2.12z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-105.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-88.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-69.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-52.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,-36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,-33.88h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,-16.94h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,0.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,2.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,19.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,36.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,38.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,55.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,72.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,74.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,91.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,108.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,110.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,127.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,144.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_field" android:fillAlpha="0.5" android:pathData="M-90.00,146.12h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,163.06h288.00v16.94h-288.00z" />
+        <path android:fillColor="@color/tartan_over" android:fillAlpha="0.5" android:pathData="M-90.00,180.00h288.00v2.12h-288.00z" />
+        <path android:fillColor="@color/tartan_ground" android:fillAlpha="0.5" android:pathData="M-90.00,182.12h288.00v16.94h-288.00z" />
+    </group>
 </vector>

app/src/main/res/values/colors.xml

@@ -1,16 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  The colours the brand shares between channels. The two that differ —
-  brand_field (slate blue on production, deep green on dev) and its darker
-  shade splash_background — are generated by the build. See resValue in
-  app/build.gradle.kts.
+  The colours the sett shares between channels. The one that differs —
+  tartan_field, red on production and hunting green on dev — is generated by the
+  build, along with splash_background and ic_launcher_background, which are
+  shades of it. See resValue in app/build.gradle.kts.
 -->
 <resources>
     <color name="black">#FF000000</color>
     <color name="white">#FFFFFFFF</color>
 
-    <!-- The parchment accent drawn on the brand field: the emblem on the
-         launcher icon and the second line of the splash. Same number as the
-         accent in Theme.kt. -->
-    <color name="brand_accent">#EFD9A4</color>
+    <!-- The ground the sett is woven on, and the overstripe down its centre.
+         Same numbers as WallaceBlack and WallaceGold in Tartan.kt. -->
+    <color name="tartan_ground">#0C0C0C</color>
+    <color name="tartan_over">#F2C518</color>
 </resources>

app/src/main/res/values/strings.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
   app_name is generated by the build rather than declared here, because it
-  differs by channel: a dev build installs as "Pilgrims of Katan DEV"
+  differs by channel: a dev build installs as "Pro Libertate Games DEV"
   alongside the production copy. See resValue in app/build.gradle.kts.
 -->
 <resources>

app/src/main/res/values/themes.xml

@@ -2,7 +2,7 @@
 <resources>
     <!-- Compose supplies the real theme; this only needs to be a Material 3
          base with no action bar so the app draws its own top bars. -->
-    <style name="Theme.PilgrimsOfKatan" parent="android:Theme.Material.NoActionBar">
+    <style name="Theme.ProLibertateGames" parent="android:Theme.Material.NoActionBar">
         <item name="android:windowNoTitle">true</item>
         <item name="android:windowContentOverlay">@null</item>
         <item name="android:windowBackground">@color/splash_background</item>

app/src/test/java/org/prolibertate/games/game/CatalogTest.kt

@@ -106,17 +106,33 @@ class CatalogTest {
     }
 
     @Test
-    fun `every game in the catalogue can be played`() {
-        // There is nothing left marked "coming soon". The machinery that hides
-        // unfinished games from a production build is still there and still
-        // tested above — it simply has nothing to hide at the moment, and this
-        // is what will fail the day something is added to the list before its
-        // engine is written.
-        assertTrue(GameCatalog.all.all { it.available })
+    fun `every reference game in the catalogue can be played`() {
+        // Every game the app ships is playable. The one exception is Katan,
+        // listed so the slot exists and marked *Coming soon* until its engine
+        // and screen land — `available = false` is what keeps an unfinished
+        // game out of a production build while leaving it visible on a dev one.
         assertEquals(
-            GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = false),
-            GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = true),
+            listOf(GameCatalog.CATAN),
+            GameCatalog.all.filterNot { it.available }.map { it.id },
         )
+        // It is also the only difference the two channels see in a menu.
+        val hiddenFromProduction = GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = true) -
+            GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = false)
+        assertEquals(listOf(GameCatalog.byId(GameCatalog.CATAN)!!), hiddenFromProduction)
+    }
+
+    @Test
+    fun `a preview game opens on a dev build and nowhere else`() {
+        val preview = GameCatalog.all.filter { it.devPreview }
+        assertTrue("Katan is the preview game", preview.map { it.id } == listOf(GameCatalog.CATAN))
+        preview.forEach { game ->
+            assertFalse("${game.id}: preview is for games that are not yet available", game.available)
+            assertTrue("${game.id} should open on a dev build", game.playableIn(devBuild = true))
+            assertFalse("${game.id} must not open in production", game.playableIn(devBuild = false))
+        }
+        // An ordinary finished game opens everywhere.
+        val chess = GameCatalog.byId(GameCatalog.CHESS)!!
+        assertTrue(chess.playableIn(devBuild = true) && chess.playableIn(devBuild = false))
     }
 
     @Test

app/src/test/java/org/prolibertate/games/game/catan/CatanAiTest.kt

@@ -0,0 +1,191 @@
+package org.prolibertate.games.game.catan
+
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.prolibertate.games.game.GameCatalog
+import org.prolibertate.games.game.engine.PlayerKind
+import org.prolibertate.games.game.engine.PlayerSlot
+import org.prolibertate.games.game.engine.TableConfig
+
+class CatanAiTest {
+
+    private val json = Json { encodeDefaults = true }
+
+    private fun config(options: CatanOptions, seed: Long) = TableConfig(
+        gameId = GameCatalog.CATAN,
+        seats = (0 until options.playerCount).map {
+            PlayerSlot(seat = it, name = "P$it", kind = PlayerKind.AI, team = it)
+        },
+        optionsJson = json.encodeToString(options),
+        seed = seed,
+    )
+
+    /** Plays one table of engines out to a result, refusing every illegal move. */
+    private fun playOut(options: CatanOptions, seed: Long, cap: Int = 4_000): CatanState {
+        val ai = CatanAi()
+        var state = CatanRules.initialState(config(options, seed))
+        var moves = 0
+        while (!CatanRules.isFinished(state)) {
+            assertTrue("seed $seed ran past $cap moves", moves++ < cap)
+            val seat = CatanRules.currentSeat(state) ?: break
+            val move = ai.chooseMove(state, seat, CatanRules.legalMoves(state, seat))
+            assertTrue(
+                "seed $seed: seat $seat chose the illegal move $move",
+                CatanRules.isLegalMove(state, seat, move),
+            )
+            state = CatanRules.applyMove(state, seat, move)
+        }
+        return state
+    }
+
+    @Test
+    fun `three engines finish a game at ten points`() {
+        listOf(11L, 22L, 33L).forEach { seed ->
+            val state = playOut(CatanOptions(), seed)
+            assertEquals("seed $seed", CatanPhase.GAME_OVER, state.phase)
+            val winner = state.winner
+            assertTrue("seed $seed finished without a winner", winner != null)
+            assertTrue(
+                "seed $seed: the winner fell short of the target",
+                CatanRules.victoryPoints(state, winner!!) >= state.options.pointsToWin,
+            )
+        }
+    }
+
+    @Test
+    fun `four engines finish a game at ten points`() {
+        listOf(44L, 55L).forEach { seed ->
+            val state = playOut(CatanOptions(playerCount = 4), seed)
+            assertEquals("seed $seed", CatanPhase.GAME_OVER, state.phase)
+            val winner = state.winner
+            assertTrue("seed $seed finished without a winner", winner != null)
+            assertTrue(
+                "seed $seed: the winner fell short of the target",
+                CatanRules.victoryPoints(state, winner!!) >= state.options.pointsToWin,
+            )
+        }
+    }
+
+    /** A mid-game state on seat 0's turn, one card short of a settlement. */
+    private fun offeringState(): CatanState =
+        CatanRules.initialState(config(CatanOptions(), seed = 7L))
+            .copy(
+                phase = CatanPhase.PLAYING,
+                turn = 0,
+                turnNumber = 1,
+                // Lumber to spare, brick missing, and a neighbour visibly
+                // holding brick. No roads or buildings, so no build is legal
+                // and no port is open — the offer is the only move forward.
+                resources = listOf(
+                    hand(Resource.LUMBER to 4, Resource.WOOL to 1, Resource.GRAIN to 1),
+                    hand(Resource.BRICK to 2),
+                    hand(),
+                ),
+            )
+
+    private fun hand(vararg cards: Pair<Resource, Int>): Map<Resource, Int> =
+        Resource.entries.associateWith { cards.toMap()[it] ?: 0 }
+
+    @Test
+    fun `the AI offers the trade that closes its build`() {
+        val state = offeringState()
+        val move = CatanAi().chooseMove(state, 0, CatanRules.legalMoves(state, 0))
+        assertEquals(
+            OfferTrade(to = 1, give = listOf(Resource.LUMBER, Resource.LUMBER), get = listOf(Resource.BRICK)),
+            move,
+        )
+    }
+
+    @Test
+    fun `the AI offers at most one trade a turn`() {
+        // The same table, but the offer was already made and refused once.
+        val state = offeringState().copy(
+            log = listOf(
+                "Seat 0 rolls 3 + 2.",
+                "Seat 0 offers 2 lumber for a brick to seat 1.",
+                "Seat 1 declines the offer.",
+            ),
+        )
+        val move = CatanAi().chooseMove(state, 0, CatanRules.legalMoves(state, 0))
+        assertTrue("the AI re-offered within one turn: $move", move !is OfferTrade)
+        assertEquals(EndTurn, move)
+    }
+
+    @Test
+    fun `the AI answers a pending offer with accept or decline`() {
+        val state = CatanRules.initialState(config(CatanOptions(), seed = 7L))
+            .copy(
+                phase = CatanPhase.TRADE_PENDING,
+                turn = 0,
+                turnNumber = 1,
+                pendingTrade = TradeOffer(
+                    by = 0, to = 1,
+                    give = listOf(Resource.LUMBER, Resource.LUMBER),
+                    get = listOf(Resource.BRICK),
+                ),
+                resources = listOf(
+                    hand(Resource.LUMBER to 3),
+                    hand(Resource.BRICK to 2, Resource.WOOL to 1),
+                    hand(),
+                ),
+            )
+        val legal = CatanRules.legalMoves(state, 1)
+        val move = CatanAi().chooseMove(state, 1, legal)
+        assertTrue("neither accept nor decline: $move", move == AcceptTrade || move == DeclineTrade)
+        assertTrue(move in legal)
+
+        val after = CatanRules.applyMove(state, 1, move)
+        assertEquals(CatanPhase.PLAYING, after.phase)
+        assertNull(after.pendingTrade)
+    }
+
+    private fun tradeTable(offer: TradeOffer, vararg hands: Map<Resource, Int>): CatanState =
+        CatanRules.initialState(config(CatanOptions(), seed = 7L)).copy(
+            phase = CatanPhase.TRADE_PENDING,
+            turn = 0,
+            turnNumber = 1,
+            pendingTrade = offer,
+            resources = hands.toList(),
+        )
+
+    @Test
+    fun `the AI accepts an offer that gives it more than it costs, and declines the reverse`() {
+        val generous = tradeTable(
+            TradeOffer(by = 0, to = null, give = listOf(Resource.ORE, Resource.ORE), get = listOf(Resource.WOOL), asking = 1),
+            hand(Resource.ORE to 2), hand(Resource.WOOL to 2), hand(),
+        )
+        assertEquals(AcceptTrade, CatanAi().chooseMove(generous, 1, CatanRules.legalMoves(generous, 1)))
+
+        val stingy = tradeTable(
+            TradeOffer(by = 0, to = null, give = listOf(Resource.WOOL), get = listOf(Resource.ORE), asking = 1),
+            hand(Resource.WOOL to 1), hand(Resource.ORE to 2), hand(),
+        )
+        assertEquals(DeclineTrade, CatanAi().chooseMove(stingy, 1, CatanRules.legalMoves(stingy, 1)))
+    }
+
+    @Test
+    fun `an AI offerer takes the best counter and refuses a losing one`() {
+        val counters = listOf(
+            TradeCounter(by = 1, give = listOf(Resource.ORE), get = listOf(Resource.LUMBER)),
+            TradeCounter(by = 2, give = listOf(Resource.ORE, Resource.GRAIN), get = listOf(Resource.WOOL)),
+        )
+        val state = tradeTable(
+            TradeOffer(by = 0, to = null, give = listOf(Resource.WOOL), get = listOf(Resource.ORE), asking = -1, counters = counters),
+            hand(Resource.LUMBER to 1, Resource.WOOL to 1), hand(Resource.ORE to 1), hand(Resource.ORE to 1, Resource.GRAIN to 1),
+        ).copy(phase = CatanPhase.TRADE_COUNTERS)
+        val legal = CatanRules.legalMoves(state, 0)
+        assertEquals(AcceptCounter(2), CatanAi().chooseMove(state, 0, legal))
+
+        val bad = state.copy(
+            pendingTrade = state.pendingTrade!!.copy(
+                counters = listOf(TradeCounter(by = 1, give = listOf(Resource.WOOL), get = listOf(Resource.LUMBER))),
+            ),
+            resources = listOf(hand(Resource.LUMBER to 1), hand(Resource.WOOL to 1), hand()),
+        )
+        assertEquals(DismissCounters, CatanAi().chooseMove(bad, 0, CatanRules.legalMoves(bad, 0)))
+    }
+}

app/src/test/java/org/prolibertate/games/game/catan/CatanBoardTest.kt

@@ -0,0 +1,192 @@
+package org.prolibertate.games.game.catan
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class CatanBoardTest {
+
+    // -- Geometry -----------------------------------------------------------
+
+    @Test
+    fun `the island has 19 hexes, 54 vertices, 72 edges and 30 coastal edges`() {
+        assertEquals(19, CatanBoard.HEX_COUNT)
+        assertEquals(54, CatanBoard.VERTEX_COUNT)
+        assertEquals(72, CatanBoard.EDGE_COUNT)
+        assertEquals("the coast is one ring of 30 edges", 30, CatanBoard.COASTAL.size)
+        assertEquals("nine harbour positions", 9, CatanBoard.PORT_POSITIONS.size)
+    }
+
+    @Test
+    fun `every hex has six distinct corners and every edge two distinct ends`() {
+        for (h in 0 until CatanBoard.HEX_COUNT) {
+            assertEquals("hex $h", 6, CatanBoard.HEX_CORNERS[h].size)
+            assertEquals("hex $h repeats a corner", 6, CatanBoard.HEX_CORNERS[h].distinct().size)
+        }
+        CatanBoard.EDGE_VERTICES.forEach { (a, b) -> assertTrue("edge loops on itself", a != b) }
+    }
+
+    @Test
+    fun `two vertices never share a lattice position`() {
+        assertEquals(CatanBoard.VERTEX_COUNT, CatanBoard.VERTEX_POS.distinct().size)
+        assertEquals(CatanBoard.HEX_COUNT, (0 until CatanBoard.HEX_COUNT)
+            .map { CatanBoard.hexCenter(it) }
+            .distinct().size)
+    }
+
+    @Test
+    fun `adjacent hexes share exactly two vertices and one edge`() {
+        for (h in 0 until CatanBoard.HEX_COUNT) {
+            for (n in CatanBoard.HEX_NEIGHBORS[h]) {
+                val shared = CatanBoard.HEX_CORNERS[h].toSet()
+                    .intersect(CatanBoard.HEX_CORNERS[n].toSet())
+                assertEquals("hexes $h and $n", 2, shared.size)
+                val sharedEdge = CatanBoard.EDGE_HEXES.indices.count { e ->
+                    CatanBoard.EDGE_HEXES[e].containsAll(listOf(h, n))
+                }
+                assertEquals("hexes $h and $n", 1, sharedEdge)
+            }
+        }
+    }
+
+    @Test
+    fun `vertices have two or three edges, each to a distinct neighbour`() {
+        for (v in 0 until CatanBoard.VERTEX_COUNT) {
+            assertTrue("vertex $v", CatanBoard.VERTEX_EDGES[v].size in 2..3)
+            assertEquals("vertex $v", CatanBoard.VERTEX_EDGES[v].size, CatanBoard.VERTEX_NEIGHBORS[v].size)
+            CatanBoard.VERTEX_NEIGHBORS[v].forEach { n ->
+                assertTrue(
+                    "vertices $v and $n are not joined by an edge",
+                    CatanBoard.VERTEX_EDGES[v].any { CatanBoard.otherEnd(it, v) == n },
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `interior edges touch two hexes and coastal edges one`() {
+        CatanBoard.EDGE_HEXES.forEach { hexes -> assertTrue(hexes.size in 1..2) }
+        // Nineteen hexes times six edges each, counted per side: 114.
+        assertEquals(114, CatanBoard.EDGE_HEXES.sumOf { it.size })
+        val coastal = CatanBoard.EDGE_HEXES.indices.filter { CatanBoard.EDGE_HEXES[it].size == 1 }
+        assertEquals(CatanBoard.COASTAL.toSet(), coastal.toSet())
+    }
+
+    @Test
+    fun `the coast is one closed ring and the harbours are spread along it`() {
+        CatanBoard.COASTAL.forEachIndexed { i, e ->
+            val next = CatanBoard.COASTAL[(i + 1) % CatanBoard.COASTAL.size]
+            val shared = ends(e).intersect(ends(next))
+            assertTrue("coastal edges $e and $next are not consecutive", shared.isNotEmpty())
+        }
+
+        assertEquals(9, CatanBoard.PORT_POSITIONS.distinct().size)
+        assertTrue(CatanBoard.PORT_POSITIONS.all { it in CatanBoard.COASTAL })
+        val ringSpots = CatanBoard.PORT_POSITIONS.map { CatanBoard.COASTAL.indexOf(it) }.sorted()
+        val gaps = ringSpots.zipWithNext { a, b -> b - a } +
+            (CatanBoard.COASTAL.size - ringSpots.last() + ringSpots.first())
+        assertTrue("harbours sit closer than three edges apart: $gaps", gaps.all { it >= 3 })
+    }
+
+    @Test
+    fun `token odds follow the dice`() {
+        assertEquals(5, CatanBoard.numberOdds(6))
+        assertEquals(5, CatanBoard.numberOdds(8))
+        assertEquals(1, CatanBoard.numberOdds(2))
+        assertEquals(1, CatanBoard.numberOdds(12))
+        assertEquals(36, (2..12).sumOf { CatanBoard.numberOdds(it) })
+    }
+
+    // -- Island generation --------------------------------------------------
+
+    private val terrainCounts = mapOf(
+        Terrain.FOREST to 4,
+        Terrain.PASTURE to 4,
+        Terrain.FIELDS to 4,
+        Terrain.HILLS to 3,
+        Terrain.MOUNTAINS to 3,
+        Terrain.DESERT to 1,
+    )
+
+    /** The 18 number tokens dealt to the land, the seven withheld. */
+    private val tokens = listOf(6, 6, 8, 8, 2, 3, 3, 4, 4, 5, 5, 9, 9, 10, 10, 11, 11, 12)
+
+    @Test
+    fun `every seed deals the fixed terrain mix`() {
+        for (seed in 1L..500L) {
+            val island = CatanBoard.generate(seed)
+            assertEquals("seed $seed", 19, island.terrains.size)
+            terrainCounts.forEach { (terrain, n) ->
+                assertEquals("seed $seed $terrain", n, island.terrains.count { it == terrain })
+            }
+        }
+    }
+
+    @Test
+    fun `every seed deals the full token set and the desert stays bare`() {
+        for (seed in 1L..500L) {
+            val island = CatanBoard.generate(seed)
+            val dealt = island.numbers.filter { it > 0 }
+            assertEquals("seed $seed", 18, dealt.size)
+            assertEquals("seed $seed", tokens.sorted(), dealt.sorted())
+            assertEquals("seed $seed: the desert bears no token", 0, island.numbers[island.robber])
+            assertEquals(
+                "seed $seed: the robber does not start on the desert",
+                island.terrains.indexOf(Terrain.DESERT),
+                island.robber,
+            )
+        }
+    }
+
+    @Test
+    fun `no seed puts two red tokens on adjacent hexes`() {
+        for (seed in 1L..500L) {
+            val island = CatanBoard.generate(seed)
+            val red = island.numbers.withIndex()
+                .filter { it.value == 6 || it.value == 8 }
+                .map { it.index }
+            assertEquals("seed $seed", 4, red.size)
+            for (i in red.indices) {
+                for (j in i + 1 until red.size) {
+                    assertTrue(
+                        "seed $seed: red hexes ${red[i]} and ${red[j]} touch",
+                        !CatanBoard.hexesAdjacent(red[i], red[j]),
+                    )
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `every seed spreads nine harbours, five special and four generic`() {
+        for (seed in 1L..500L) {
+            val island = CatanBoard.generate(seed)
+            assertEquals("seed $seed", 9, island.ports.size)
+            assertEquals("seed $seed", 5, island.ports.count { it.resource != null })
+            assertEquals("seed $seed", 4, island.ports.count { it.resource == null })
+            assertTrue("seed $seed", island.ports.all { port ->
+                port.ratio == if (port.resource == null) 3 else 2
+            })
+            assertEquals(
+                "seed $seed: every resource has its own harbour",
+                Resource.entries,
+                island.ports.mapNotNull { it.resource }.sorted(),
+            )
+            assertEquals("seed $seed", 9, island.ports.map { it.edge }.distinct().size)
+            assertTrue("seed $seed", island.ports.all { it.edge in CatanBoard.COASTAL })
+        }
+    }
+
+    @Test
+    fun `the same seed builds the same island`() {
+        for (seed in listOf(0L, 7L, 42L, 99L, -1L)) {
+            assertEquals("seed $seed", CatanBoard.generate(seed), CatanBoard.generate(seed))
+        }
+    }
+
+    /** The two vertices of [edge], as a set. */
+    private fun ends(edge: Int): Set<Int> {
+        val (a, b) = CatanBoard.EDGE_VERTICES[edge]
+        return setOf(a, b)
+    }
+}

app/src/test/java/org/prolibertate/games/net/ScorekeeperSessionTest.kt

@@ -164,6 +164,9 @@ class ScorekeeperSessionTest {
 
         await("the guest to be let in") { guest.state.value.connected }
         assertFalse(guest.state.value.awaiting)
+        // The sheet follows the connection over the socket, so on a slow runner
+        // it can still be in flight when `connected` flips: wait for it.
+        await("the guest to receive the sheet") { guest.state.value.sheet == host.state.sheet }
         assertEquals(host.state.sheet, guest.state.value.sheet)
         assertTrue(guest.state.value.sheet.started)
         assertTrue(host.state.requests.isEmpty())

app/src/test/java/org/prolibertate/games/ui/game/catan/CatanFixtures.kt

@@ -0,0 +1,53 @@
+package org.prolibertate.games.ui.game.catan
+
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.prolibertate.games.game.GameCatalog
+import org.prolibertate.games.game.catan.BuildingType
+import org.prolibertate.games.game.catan.CatanBuilding
+import org.prolibertate.games.game.catan.CatanOptions
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.CatanState
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.engine.PlayerKind
+import org.prolibertate.games.game.engine.PlayerSlot
+import org.prolibertate.games.game.engine.TableConfig
+
+/** Shared fixtures for the Katan UI-logic tests: real islands, bent to taste. */
+internal object CatanFixtures {
+
+    private val json = Json { encodeDefaults = true }
+
+    fun config(players: Int = 3, seed: Long = 7L) = TableConfig(
+        gameId = GameCatalog.CATAN,
+        seats = (0 until players).map { PlayerSlot(seat = it, name = "P$it", kind = PlayerKind.AI, team = it) },
+        optionsJson = json.encodeToString(CatanOptions(playerCount = players)),
+        seed = seed,
+    )
+
+    /** A fresh table, on the first setup placement. */
+    fun start(players: Int = 3, seed: Long = 7L): CatanState =
+        CatanRules.initialState(config(players, seed))
+
+    /** A mid-game state on [turn]'s turn, then adjusted by [adjust]. */
+    fun playing(
+        turn: Int = 0,
+        players: Int = 3,
+        adjust: CatanState.() -> CatanState = { this },
+    ): CatanState = start(players)
+        .copy(phase = CatanPhase.PLAYING, turn = turn, turnNumber = 1)
+        .adjust()
+
+    fun hand(vararg cards: Pair<Resource, Int>): Map<Resource, Int> =
+        Resource.entries.associateWith { cards.toMap()[it] ?: 0 }
+
+    fun CatanState.withHand(seat: Int, hand: Map<Resource, Int>): CatanState =
+        copy(resources = resources.toMutableList().also { it[seat] = hand })
+
+    fun CatanState.withBuilding(vertex: Int, type: BuildingType, owner: Int): CatanState =
+        copy(buildings = buildings.toMutableList().also { it[vertex] = CatanBuilding(type, owner) })
+
+    fun CatanState.withRoad(edge: Int, owner: Int): CatanState =
+        copy(roads = roads.toMutableList().also { it[edge] = owner })
+}

app/src/test/java/org/prolibertate/games/ui/game/catan/CatanGeometryTest.kt

@@ -0,0 +1,117 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.prolibertate.games.game.catan.CatanBoard
+import kotlin.math.abs
+import kotlin.math.sqrt
+
+class CatanGeometryTest {
+
+    private val sizes = listOf(360f to 800f, 800f to 360f, 500f to 500f, 1000f to 1000f / CatanGeometry.ASPECT)
+
+    private fun dist(a: Pt, b: Pt): Float = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y))
+
+    @Test
+    fun `the whole island fits inside the box at every shape`() {
+        for ((w, h) in sizes) {
+            val layout = CatanGeometry.fit(w, h)
+            for (v in 0 until CatanBoard.VERTEX_COUNT) {
+                val p = layout.vertex(v)
+                assertTrue("vertex $v x=${p.x} outside 0..$w", p.x in 0f..w)
+                assertTrue("vertex $v y=${p.y} outside 0..$h", p.y in 0f..h)
+            }
+            for (e in CatanBoard.PORT_POSITIONS) {
+                val p = layout.portAnchor(e)
+                assertTrue("harbour marker x=${p.x} outside 0..$w at ${w}x$h", p.x in 0f..w)
+                assertTrue("harbour marker y=${p.y} outside 0..$h at ${w}x$h", p.y in 0f..h)
+            }
+        }
+    }
+
+    @Test
+    fun `the layout is as large as the box allows`() {
+        // Tall and narrow is limited by width, short and wide by height; either
+        // way the island should use most of the limiting side.
+        val tall = CatanGeometry.fit(360f, 800f)
+        val wide = CatanGeometry.fit(800f, 360f)
+        assertTrue(tall.radius > 20f)
+        assertTrue(wide.radius > 20f)
+        val xs = (0 until CatanBoard.VERTEX_COUNT).map { tall.vertex(it).x }
+        assertTrue("island should span most of the width", xs.max() - xs.min() > 360f * 0.7f)
+    }
+
+    @Test
+    fun `every edge is one hex radius long and every hex corner is one radius from its centre`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        for (e in 0 until CatanBoard.EDGE_COUNT) {
+            val (a, b) = layout.edgeEnds(e)
+            assertEquals("edge $e length", layout.radius, dist(a, b), layout.radius * 0.01f)
+        }
+        for (h in 0 until CatanBoard.HEX_COUNT) {
+            val centre = layout.hexCenter(h)
+            for (corner in layout.hexCorners(h)) {
+                assertEquals("hex $h corner", layout.radius, dist(centre, corner), layout.radius * 0.01f)
+            }
+        }
+    }
+
+    @Test
+    fun `all fifty-four vertices sit at distinct places`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        val places = (0 until CatanBoard.VERTEX_COUNT).map {
+            val p = layout.vertex(it)
+            Math.round(p.x) to Math.round(p.y)
+        }.toSet()
+        assertEquals(CatanBoard.VERTEX_COUNT, places.size)
+    }
+
+    @Test
+    fun `a tap on a vertex finds that vertex, and a tap far away finds nothing`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        val all = (0 until CatanBoard.VERTEX_COUNT).toList()
+        for (v in all) {
+            val p = layout.vertex(v)
+            assertEquals(v, layout.nearestVertex(p, layout.radius * 0.5f, all))
+            // A slightly clumsy tap still lands on it.
+            assertEquals(v, layout.nearestVertex(Pt(p.x + layout.radius * 0.2f, p.y - layout.radius * 0.15f), layout.radius * 0.55f, all))
+        }
+        assertNull(layout.nearestVertex(Pt(-100f, -100f), layout.radius * 0.5f, all))
+    }
+
+    @Test
+    fun `hit testing only considers the candidates it is given`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        val at = layout.vertex(5)
+        assertNull(layout.nearestVertex(at, layout.radius * 0.3f, listOf(6)))
+        assertEquals(6, layout.nearestVertex(layout.vertex(6), layout.radius * 0.3f, listOf(6)))
+        assertEquals(3, layout.nearestEdge(layout.edgeMidpoint(3), 5f, listOf(3, 4)))
+        assertEquals(7, layout.nearestHex(layout.hexCenter(7), 5f, listOf(7, 8)))
+    }
+
+    @Test
+    fun `the nearest candidate wins when several are in reach`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        val a = 10
+        val b = CatanBoard.VERTEX_NEIGHBORS[a].first()
+        val pa = layout.vertex(a)
+        val pb = layout.vertex(b)
+        // A point two-thirds of the way toward b is nearer b, though both are in reach.
+        val at = Pt(pa.x + (pb.x - pa.x) * 0.66f, pa.y + (pb.y - pa.y) * 0.66f)
+        assertEquals(b, layout.nearestVertex(at, layout.radius * 2f, listOf(a, b)))
+    }
+
+    @Test
+    fun `harbour markers sit outside the coast`() {
+        val layout = CatanGeometry.fit(500f, 500f)
+        val centre = Pt(500f / 2f, 500f / 2f)
+        for (e in CatanBoard.PORT_POSITIONS) {
+            val anchor = layout.portAnchor(e)
+            val mid = layout.edgeMidpoint(e)
+            assertTrue("harbour on edge $e should be past the coast", dist(anchor, centre) > dist(mid, centre))
+            assertTrue("and not floating far from it", abs(dist(anchor, mid) - layout.radius * PORT_OFFSET) < 1f)
+        }
+    }
+}

app/src/test/java/org/prolibertate/games/ui/game/catan/CatanInteractionTest.kt

@@ -0,0 +1,348 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.prolibertate.games.game.catan.BuildCity
+import org.prolibertate.games.game.catan.BuildRoad
+import org.prolibertate.games.game.catan.BuildSettlement
+import org.prolibertate.games.game.catan.BuildingType
+import org.prolibertate.games.game.catan.CatanBoard
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.CatanRules
+import org.prolibertate.games.game.catan.DevCard
+import org.prolibertate.games.game.catan.DevCardType
+import org.prolibertate.games.game.catan.Discard
+import org.prolibertate.games.game.catan.MaritimeTrade
+import org.prolibertate.games.game.catan.MoveRobber
+import org.prolibertate.games.game.catan.PlayKnight
+import org.prolibertate.games.game.catan.PlayMonopoly
+import org.prolibertate.games.game.catan.PlayYearOfPlenty
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.game.catan.SetupPlace
+import org.prolibertate.games.ui.game.catan.CatanFixtures.hand
+import org.prolibertate.games.ui.game.catan.CatanFixtures.playing
+import org.prolibertate.games.ui.game.catan.CatanFixtures.start
+import org.prolibertate.games.ui.game.catan.CatanFixtures.withBuilding
+import org.prolibertate.games.ui.game.catan.CatanFixtures.withHand
+import org.prolibertate.games.ui.game.catan.CatanFixtures.withRoad
+
+class CatanInteractionTest {
+
+    private val rich = hand(
+        Resource.LUMBER to 5, Resource.BRICK to 5, Resource.WOOL to 5,
+        Resource.GRAIN to 5, Resource.ORE to 5,
+    )
+
+    // --- Setup ---------------------------------------------------------------
+
+    @Test
+    fun `setup first offers every settlement spot, then only the roads beside the chosen one`() {
+        val state = start()
+        val legal = CatanRules.legalMoves(state, 0)
+        val setup = legal.filterIsInstance<SetupPlace>()
+
+        val first = CatanInteraction.targets(state, legal, null, null)
+        assertEquals(setup.map { it.vertex }.toSet(), first.vertices)
+        assertTrue(first.edges.isEmpty() && first.hexes.isEmpty())
+
+        val vertex = first.vertices.first()
+        val second = CatanInteraction.targets(state, legal, null, vertex)
+        assertTrue(second.vertices.isEmpty())
+        assertEquals(setup.filter { it.vertex == vertex }.map { it.edge }.toSet(), second.edges)
+    }
+
+    @Test
+    fun `a setup placement is two taps - the settlement, then its road`() {
+        val state = start()
+        val legal = CatanRules.legalMoves(state, 0)
+        val vertex = CatanInteraction.targets(state, legal, null, null).vertices.first()
+        val edge = CatanInteraction.targets(state, legal, null, vertex).edges.first()
+
+        assertEquals(TapOutcome.PickSetupVertex(vertex), CatanInteraction.onVertexTap(vertex, legal, null, null))
+        assertEquals(TapOutcome.Submit(SetupPlace(vertex, edge)), CatanInteraction.onEdgeTap(edge, legal, null, vertex))
+        // A road tapped before any settlement is chosen means nothing.
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onEdgeTap(edge, legal, null, null))
+    }
+
+    @Test
+    fun `a road that does not touch the chosen settlement is refused`() {
+        val state = start()
+        val legal = CatanRules.legalMoves(state, 0)
+        val vertex = CatanInteraction.targets(state, legal, null, null).vertices.first()
+        val beside = CatanBoard.VERTEX_EDGES[vertex].toSet()
+        val far = (0 until CatanBoard.EDGE_COUNT).first { it !in beside }
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onEdgeTap(far, legal, null, vertex))
+    }
+
+    // --- Building -------------------------------------------------------------
+
+    /** Seat 0 owns a settlement at vertex 0 and a road two edges long leading away from it. */
+    private fun established(): Triple<org.prolibertate.games.game.catan.CatanState, Int, Int> {
+        val e1 = CatanBoard.VERTEX_EDGES[0][0]
+        val w = CatanBoard.otherEnd(e1, 0)
+        val e2 = CatanBoard.VERTEX_EDGES[w].first { it != e1 }
+        val x = CatanBoard.otherEnd(e2, w)
+        val state = playing {
+            withHand(0, rich).withBuilding(0, BuildingType.SETTLEMENT, 0).withRoad(e1, 0).withRoad(e2, 0)
+        }
+        return Triple(state, x, e2)
+    }
+
+    @Test
+    fun `nothing on the board is tappable until a build mode is chosen`() {
+        val (state, _, _) = established()
+        val legal = CatanRules.legalMoves(state, 0)
+        assertTrue(CatanInteraction.targets(state, legal, null, null).isEmpty)
+    }
+
+    @Test
+    fun `build modes target exactly what the engine allows`() {
+        val (state, x, _) = established()
+        val legal = CatanRules.legalMoves(state, 0)
+
+        assertEquals(
+            legal.filterIsInstance<BuildRoad>().map { it.edge }.toSet(),
+            CatanInteraction.targets(state, legal, BuildKind.ROAD, null).edges,
+        )
+        assertTrue(x in CatanInteraction.targets(state, legal, BuildKind.SETTLEMENT, null).vertices)
+        assertEquals(setOf(0), CatanInteraction.targets(state, legal, BuildKind.CITY, null).vertices)
+        assertEquals(setOf(BuildKind.ROAD, BuildKind.SETTLEMENT, BuildKind.CITY), CatanInteraction.canBuild(legal))
+    }
+
+    @Test
+    fun `a tap builds only when the matching mode is armed and the spot is legal`() {
+        val (state, x, _) = established()
+        val legal = CatanRules.legalMoves(state, 0)
+        val road = legal.filterIsInstance<BuildRoad>().first().edge
+
+        assertEquals(TapOutcome.Submit(BuildSettlement(x)), CatanInteraction.onVertexTap(x, legal, BuildKind.SETTLEMENT, null))
+        assertEquals(TapOutcome.Submit(BuildCity(0)), CatanInteraction.onVertexTap(0, legal, BuildKind.CITY, null))
+        assertEquals(TapOutcome.Submit(BuildRoad(road)), CatanInteraction.onEdgeTap(road, legal, BuildKind.ROAD, null))
+
+        // No mode armed: nothing happens.
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onVertexTap(x, legal, null, null))
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onEdgeTap(road, legal, null, null))
+        // A settlement on an occupied crossing is not offered.
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onVertexTap(0, legal, BuildKind.SETTLEMENT, null))
+        // The wrong mode for the spot.
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onVertexTap(x, legal, BuildKind.CITY, null))
+    }
+
+    @Test
+    fun `without the cards, nothing can be built`() {
+        val (state, _, _) = established()
+        val broke = state.withHand(0, hand())
+        val legal = CatanRules.legalMoves(broke, 0)
+        assertTrue(CatanInteraction.canBuild(legal).isEmpty())
+        assertFalse(CatanInteraction.canBuyDevCard(legal))
+        assertTrue(CatanInteraction.canEndTurn(legal))
+    }
+
+    @Test
+    fun `free roads from a road building card need no build mode`() {
+        val (state, _, _) = established()
+        val free = state.copy(phase = CatanPhase.FREE_ROADS, pendingFreeRoads = 2)
+        val legal = CatanRules.legalMoves(free, 0)
+        val targets = CatanInteraction.targets(free, legal, null, null)
+        assertTrue(targets.edges.isNotEmpty())
+        val edge = targets.edges.first()
+        assertEquals(TapOutcome.Submit(BuildRoad(edge)), CatanInteraction.onEdgeTap(edge, legal, null, null))
+        assertTrue(CatanInteraction.canEndFreeRoads(legal))
+    }
+
+    // --- The robber ---------------------------------------------------------------
+
+    @Test
+    fun `the robber may go to any hex but the one it is on`() {
+        val state = playing { copy(phase = CatanPhase.ROBBER) }
+        val legal = CatanRules.legalMoves(state, 0)
+        val targets = CatanInteraction.targets(state, legal, null, null)
+        assertEquals((0 until CatanBoard.HEX_COUNT).filter { it != state.robber }.toSet(), targets.hexes)
+
+        val hex = targets.hexes.first()
+        // Nobody has built anything, so there is nobody to rob: the move goes straight through.
+        assertEquals(
+            TapOutcome.Submit(MoveRobber(CatanBoard.HEXES[hex], null)),
+            CatanInteraction.onHexTap(hex, legal),
+        )
+        assertEquals(TapOutcome.Ignored, CatanInteraction.onHexTap(state.robber, legal))
+    }
+
+    @Test
+    fun `a hex with two possible victims asks which`() {
+        val base = playing { copy(phase = CatanPhase.ROBBER) }
+        val hex = (0 until CatanBoard.HEX_COUNT).first { it != base.robber }
+        val corners = CatanBoard.HEX_CORNERS[hex]
+        val state = base
+            .withBuilding(corners[0], BuildingType.SETTLEMENT, 1)
+            .withBuilding(corners[3], BuildingType.SETTLEMENT, 2)
+            .withHand(1, hand(Resource.ORE to 1))
+            .withHand(2, hand(Resource.GRAIN to 1))
+        val legal = CatanRules.legalMoves(state, 0)
+
+        val outcome = CatanInteraction.onHexTap(hex, legal)
+        assertTrue(outcome is TapOutcome.PickRobberVictim)
+        outcome as TapOutcome.PickRobberVictim
+        assertEquals(CatanBoard.HEXES[hex], outcome.hex)
+        assertEquals(setOf(1, 2), outcome.victims.toSet())
+    }
+
+    // --- Discarding -----------------------------------------------------------------
+
+    @Test
+    fun `a seven costs half the hand, rounded down`() {
+        assertEquals(4, CatanInteraction.discardQuota(9))
+        assertEquals(4, CatanInteraction.discardQuota(8))
+        assertEquals(3, CatanInteraction.discardQuota(7))
+    }
+
+    @Test
+    fun `a discard is found only when it names exactly an allowed set of cards`() {
+        val state = playing {
+            copy(phase = CatanPhase.DISCARDING, discardSeat = 0)
+                .withHand(0, hand(Resource.LUMBER to 3, Resource.BRICK to 3, Resource.WOOL to 3))
+        }
+        val legal = CatanRules.legalMoves(state, 0)
+        assertTrue(legal.all { it is Discard })
+
+        val good = listOf(Resource.LUMBER, Resource.LUMBER, Resource.BRICK, Resource.WOOL)
+        assertNotNull(CatanInteraction.discardMove(legal, good))
+        // Order does not matter.
+        assertNotNull(CatanInteraction.discardMove(legal, good.reversed()))
+        // Too few, and more than are held.
+        assertNull(CatanInteraction.discardMove(legal, good.take(3)))
+        assertNull(CatanInteraction.discardMove(legal, List(4) { Resource.LUMBER }))
+    }
+
+    // --- Trading ---------------------------------------------------------------------
+
+    @Test
+    fun `bank trades list what can be given and what it can buy`() {
+        val state = playing { withHand(0, hand(Resource.GRAIN to 4)) }
+        val legal = CatanRules.legalMoves(state, 0)
+        assertTrue(legal.any { it is MaritimeTrade })
+
+        val trades = CatanInteraction.bankTrades(legal)
+        assertEquals(setOf(Resource.GRAIN), trades.keys)
+        assertEquals(Resource.entries.filter { it != Resource.GRAIN }, trades.getValue(Resource.GRAIN))
+        assertEquals(4, CatanInteraction.bankRatio(state, 0, Resource.GRAIN))
+    }
+
+    @Test
+    fun `an offer is allowed only to another player, for something different, from cards held`() {
+        val state = playing { withHand(0, hand(Resource.LUMBER to 2)) }
+        val lumber = listOf(Resource.LUMBER)
+        val grain = listOf(Resource.GRAIN)
+
+        assertTrue(CatanInteraction.offerAllowed(state, 0, 1, lumber, grain))
+        assertFalse("to oneself", CatanInteraction.offerAllowed(state, 0, 0, lumber, grain))
+        assertFalse("nothing offered", CatanInteraction.offerAllowed(state, 0, 1, emptyList(), grain))
+        assertFalse("nothing asked", CatanInteraction.offerAllowed(state, 0, 1, lumber, emptyList()))
+        assertFalse("like for like", CatanInteraction.offerAllowed(state, 0, 1, lumber, lumber))
+        assertFalse("more than held", CatanInteraction.offerAllowed(state, 0, 1, List(3) { Resource.LUMBER }, grain))
+        assertFalse("not their turn", CatanInteraction.offerAllowed(state, 1, 0, lumber, grain))
+    }
+
+    // --- Development cards -------------------------------------------------------------
+
+    @Test
+    fun `a development card is playable unless it was bought this turn or is a victory point`() {
+        val state = playing {
+            copy(
+                devHands = listOf(
+                    listOf(
+                        DevCard(1, DevCardType.KNIGHT, boughtTurn = 0),
+                        DevCard(2, DevCardType.VICTORY_POINT, boughtTurn = 0),
+                        DevCard(3, DevCardType.KNIGHT, boughtTurn = 1),
+                    ),
+                    emptyList(),
+                    emptyList(),
+                ),
+            )
+        }
+        val legal = CatanRules.legalMoves(state, 0)
+        val hand = CatanInteraction.devHand(state, 0, legal)
+
+        // Sorted by type then id: the two knights, then the victory point.
+        assertEquals(listOf(1, 3, 2), hand.map { it.card.id })
+        assertEquals(listOf(true, false, false), hand.map { it.playable })
+        assertEquals(listOf<Any>(PlayKnight(1)), hand.first().plays)
+    }
+
+    @Test
+    fun `monopoly offers one play per resource`() {
+        val plays = Resource.entries.map { PlayMonopoly(9, it) }
+        val choices = CatanInteraction.monopolyChoices(plays)
+        assertEquals(Resource.entries.toSet(), choices.keys)
+        assertEquals(PlayMonopoly(9, Resource.ORE), choices.getValue(Resource.ORE))
+    }
+
+    @Test
+    fun `year of plenty narrows to the cards that still complete a take`() {
+        val plays = listOf(
+            PlayYearOfPlenty(4, listOf(Resource.LUMBER, Resource.BRICK)),
+            PlayYearOfPlenty(4, listOf(Resource.LUMBER, Resource.LUMBER)),
+            PlayYearOfPlenty(4, listOf(Resource.ORE)),
+        )
+        assertEquals(
+            setOf(Resource.LUMBER, Resource.BRICK, Resource.ORE),
+            CatanInteraction.plentyAvailable(plays, emptyList()),
+        )
+        assertEquals(
+            setOf(Resource.LUMBER, Resource.BRICK),
+            CatanInteraction.plentyAvailable(plays, listOf(Resource.LUMBER)),
+        )
+        assertEquals(setOf(Resource.LUMBER), CatanInteraction.plentyAvailable(plays, listOf(Resource.BRICK)))
+        assertTrue(CatanInteraction.plentyAvailable(plays, listOf(Resource.LUMBER, Resource.LUMBER)).isEmpty())
+
+        assertEquals(plays[0], CatanInteraction.plentyMove(plays, listOf(Resource.BRICK, Resource.LUMBER)))
+        assertEquals(plays[2], CatanInteraction.plentyMove(plays, listOf(Resource.ORE)))
+        assertNull(CatanInteraction.plentyMove(plays, listOf(Resource.GRAIN)))
+    }
+
+    // --- Trade replies ------------------------------------------------------------------
+
+    @Test
+    fun `the addressee of an offer is given accept and decline`() {
+        val base = playing {
+            withHand(0, hand(Resource.LUMBER to 1)).withHand(1, hand(Resource.GRAIN to 1))
+        }
+        val offer = org.prolibertate.games.game.catan.TradeOffer(
+            by = 0, to = 1, give = listOf(Resource.LUMBER), get = listOf(Resource.GRAIN),
+        )
+        val pending = base.copy(phase = CatanPhase.TRADE_PENDING, pendingTrade = offer)
+        val legal = CatanRules.legalMoves(pending, 1)
+        assertEquals(true to true, CatanInteraction.tradeResponses(legal))
+
+        // If the addressee no longer holds what was asked, only decline remains.
+        val short = pending.withHand(1, hand())
+        assertEquals(false to true, CatanInteraction.tradeResponses(CatanRules.legalMoves(short, 1)))
+    }
+
+    // --- Rolled-hex highlight --------------------------------------------------
+
+    @Test
+    fun `rolled hexes are those carrying the number, minus the robber's`() {
+        val base = playing(turn = 0)
+        val number = base.numbers.first { it != 0 && it != 7 }
+        val state = base.copy(lastDice = if (number <= 7) listOf(number - 1, 1) else listOf(6, number - 6))
+        val all = (0 until CatanBoard.HEX_COUNT).filter { state.numbers[it] == number }
+        assertTrue(all.isNotEmpty())
+        assertEquals(all.filter { it != state.robber }.toSet(), CatanInteraction.rolledHexes(state))
+        val blocked = state.copy(robber = all.first())
+        assertFalse(all.first() in CatanInteraction.rolledHexes(blocked))
+    }
+
+    @Test
+    fun `nothing is highlighted before this turn's roll, on a seven, or in setup`() {
+        val rolled = playing(turn = 0).copy(lastDice = listOf(3, 3))
+        assertTrue(CatanInteraction.rolledHexes(rolled.copy(phase = CatanPhase.AWAIT_ROLL)).isEmpty())
+        assertTrue(CatanInteraction.rolledHexes(rolled.copy(lastDice = listOf(3, 4))).isEmpty())
+        assertTrue(CatanInteraction.rolledHexes(rolled.copy(phase = CatanPhase.SETUP_FIRST)).isEmpty())
+        assertTrue(CatanInteraction.rolledHexes(rolled.copy(lastDice = emptyList())).isEmpty())
+    }
+}

app/src/test/java/org/prolibertate/games/ui/game/catan/CatanTextTest.kt

@@ -0,0 +1,101 @@
+package org.prolibertate.games.ui.game.catan
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.prolibertate.games.game.catan.CatanPhase
+import org.prolibertate.games.game.catan.Port
+import org.prolibertate.games.game.catan.Resource
+import org.prolibertate.games.ui.game.catan.CatanFixtures.hand
+import org.prolibertate.games.ui.game.catan.CatanFixtures.playing
+import org.prolibertate.games.ui.game.catan.CatanFixtures.start
+import org.prolibertate.games.ui.game.catan.CatanFixtures.withHand
+
+class CatanTextTest {
+
+    private val names = listOf("Ann", "Bo", "Cy")
+
+    @Test
+    fun `seats are named, with You for the local player and a number when a name is unknown`() {
+        val seats = CatanSeats(me = 1, names = names)
+        assertEquals("You", seats.label(1))
+        assertEquals("Ann", seats.label(0))
+        assertEquals("you", seats.lower(1))
+        assertEquals("Seat 4", seats.label(3))
+        assertEquals("Seat 1", CatanSeats(me = 1).label(0))
+        assertEquals("Seat 1", CatanSeats(me = 1, names = listOf("  ")).label(0))
+    }
+
+    @Test
+    fun `setup prompts say what to place next`() {
+        val state = start()
+        val mine = CatanSeats(0, names)
+        assertTrue(CatanText.prompt(state, mine, setupVertexChosen = false, building = null).contains("Place a settlement"))
+        assertTrue(CatanText.prompt(state, mine, setupVertexChosen = true, building = null).contains("road"))
+        assertTrue(CatanText.prompt(state, CatanSeats(1, names), false, null).startsWith("Ann is placing"))
+        val second = state.copy(phase = CatanPhase.SETUP_SECOND, setupIndex = 3)
+        assertTrue(CatanText.prompt(second, CatanSeats(2, names), false, null).contains("second settlement"))
+    }
+
+    @Test
+    fun `the turn prompts follow the phase`() {
+        val roll = playing().copy(phase = CatanPhase.AWAIT_ROLL)
+        assertTrue(CatanText.prompt(roll, CatanSeats(0, names), false, null).contains("Roll the dice"))
+        assertEquals("Ann is rolling…", CatanText.prompt(roll, CatanSeats(1, names), false, null))
+
+        val turn = playing()
+        assertTrue(CatanText.prompt(turn, CatanSeats(0, names), false, null).contains("Your turn"))
+        assertEquals("Tap an edge to build a road.", CatanText.prompt(turn, CatanSeats(0, names), false, BuildKind.ROAD))
+        assertEquals("Bo is playing…", CatanText.prompt(playing(turn = 1), CatanSeats(0, names), false, null))
+
+        val robber = playing().copy(phase = CatanPhase.ROBBER)
+        assertTrue(CatanText.prompt(robber, CatanSeats(0, names), false, null).contains("robber"))
+    }
+
+    @Test
+    fun `the discard prompt names the quota`() {
+        val state = playing {
+            copy(phase = CatanPhase.DISCARDING, discardSeat = 0)
+                .withHand(0, hand(Resource.LUMBER to 9))
+        }
+        assertTrue(CatanText.prompt(state, CatanSeats(0, names), false, null).contains("discard 4"))
+        assertTrue(CatanText.prompt(state, CatanSeats(1, names), false, null).contains("Ann must discard half"))
+    }
+
+    @Test
+    fun `road building counts down in the singular and the plural`() {
+        val two = playing().copy(phase = CatanPhase.FREE_ROADS, pendingFreeRoads = 2)
+        val one = two.copy(pendingFreeRoads = 1)
+        assertTrue(CatanText.prompt(two, CatanSeats(0, names), false, null).endsWith("2 more roads."))
+        assertTrue(CatanText.prompt(one, CatanSeats(0, names), false, null).endsWith("1 more road."))
+    }
+
+    @Test
+    fun `the end of the game names the winner`() {
+        val over = playing().copy(phase = CatanPhase.GAME_OVER, winner = 1)
+        assertEquals("Bo won the game.", CatanText.prompt(over, CatanSeats(0, names), false, null))
+        assertEquals("You won!", CatanText.winnerHeadline(over, CatanSeats(1, names)))
+        assertEquals("Bo won", CatanText.winnerHeadline(over, CatanSeats(0, names)))
+    }
+
+    @Test
+    fun `cards read as a sorted tally`() {
+        assertEquals(
+            "2 Lumber + 1 Grain",
+            CatanText.cards(listOf(Resource.GRAIN, Resource.LUMBER, Resource.LUMBER)),
+        )
+        assertEquals("nothing", CatanText.cards(emptyList()))
+        assertEquals(
+            "Ann offers 1 Lumber to you for 2 Ore",
+            CatanText.tradeSummary("Ann", "you", listOf(Resource.LUMBER), listOf(Resource.ORE, Resource.ORE)),
+        )
+    }
+
+    @Test
+    fun `costs and harbours read as the rules state them`() {
+        assertEquals("1 lumber + 1 brick", CatanText.ROAD_COST)
+        assertEquals("2 grain + 3 ore", CatanText.CITY_COST)
+        assertEquals("2:1 ore", CatanText.portName(Port(edge = 0, resource = Resource.ORE, ratio = 2)))
+        assertEquals("3:1 any", CatanText.portName(Port(edge = 0, resource = null, ratio = 3)))
+    }
+}

app/src/test/java/org/prolibertate/games/update/UpdatePolicyTest.kt

@@ -22,7 +22,7 @@ class UpdatePolicyTest {
         tag = tag,
         versionCode = versionCode,
         apkUrl = "https://example.invalid/$tag.apk",
-        apkName = "PilgrimsOfKatan-$tag.apk",
+        apkName = "ProLibertateGames-$tag.apk",
         channel = channel,
     )
 
@@ -53,28 +53,6 @@ class UpdatePolicyTest {
         assertNull(versionCodeOfTag("nightly"))
     }
 
-    // -- Where the download happens ----------------------------------------
-
-    @Test
-    fun `a release asset is fetched from this app's host, keeping its path`() {
-        // The instance reports its canonical host; the app was told to trust
-        // another. Same bytes, one host, whatever the server names itself.
-        assertEquals(
-            "https://git.wallacenet.ca/devadmin/PilgrimsOfKatan/releases/download/" +
-                "v1.4.1001-dev/PilgrimsOfKatan-v1.4.1001-dev.apk",
-            onReportedHost(
-                "https://git.saskvalleytech.com/devadmin/PilgrimsOfKatan/releases/download/" +
-                    "v1.4.1001-dev/PilgrimsOfKatan-v1.4.1001-dev.apk",
-                "git.wallacenet.ca",
-            ),
-        )
-        // A URL that already says the right host is left exactly as it is.
-        val already = "https://git.wallacenet.ca/devadmin/PilgrimsOfKatan/releases/download/v1.4.1/a.apk"
-        assertEquals(already, onReportedHost(already, "git.wallacenet.ca"))
-        // Anything unparseable survives untouched rather than being dropped.
-        assertEquals("not a url", onReportedHost("not a url", "git.wallacenet.ca"))
-    }
-
     // -- The wall -----------------------------------------------------------
 
     @Test
@@ -151,7 +129,7 @@ class UpdatePolicyTest {
         assertNull("an up-to-date app has no business interrupting", launchOffer(UpdateVerdict.UpToDate))
         assertNull(
             "a phone with no network has nothing to apologise for",
-            launchOffer(UpdateVerdict.Refused("Unable to resolve host git.wallacenet.ca")),
+            launchOffer(UpdateVerdict.Refused("Unable to resolve host api.github.com")),
         )
         // Including the refusal that this whole change exists to produce: being
         // shown the other channel's build is not a thing to be told about.

docs/CI.md

@@ -1,136 +0,0 @@
-# CI, releases, and OTA — decisions and how to build
-
-Status as of the Pilgrims of Katan bootstrap (WALA-118).
-
-## Decisions
-
-1. **The release channel is this instance's own releases.** The app ships from
-   <https://git.wallacenet.ca/devadmin/PilgrimsOfKatan>, and the in-app updater
-   reads that repo's releases over Gitea's REST API. GitHub is not a channel for
-   this project; the only GitHub URLs left are the `upstream` remote and the
-   attribution link in the README.
-
-   The repo is **public on purpose**: the updater downloads anonymously, with no
-   token embedded in the APK. A private repo would make every check fail
-   (the API answers 404 to anonymous callers), not leak anything — but it would
-   also stop updates dead.
-
-2. **CI lives in Actions-compatible workflows in `.github/workflows/`.**
-   Gitea Actions runs workflows from `.github/workflows/` (or `.gitea/workflows/`),
-   so these files serve both a GitHub-style runner and the Gitea instance.
-   Publishing goes through `scripts/publish-release.sh` — Gitea's REST API, the
-   same routes the app's updater reads — rather than the `gh` CLI, which a runner
-   image need not carry.
-
-   | Workflow | Trigger | Publishes |
-   | --- | --- | --- |
-   | `ci.yml` | push to `dev`, PRs into `dev`/`main`, manual | dev prerelease, from `dev` only |
-   | `release.yml` | push to `main`, manual | production release, from `main` only |
-
-   Pull requests build and check but never publish. Prereleases are marked so
-   the "latest release" endpoint — which skips them — can never hand a dev build
-   to a production install.
-
-3. **A runner has to be registered before any of that executes.** As of the
-   bootstrap the instance has **no Actions runner**, so the workflows are
-   correct but idle: a Gitea runner (Docker or host) must be registered against
-   the instance and able to resolve `actions/checkout`,
-   `actions/setup-java`, `android-actions/setup-android` and
-   `actions/upload-artifact`. Until then the manual build below and the manual
-   publish script are the working paths.
-
-4. **The local build is the guaranteed path.** Workflows need a runner that may
-   not exist yet; `./gradlew assembleDebug` + `./gradlew testDebugUnitTest`
-   work on any machine with JDK 17 and the Android SDK (compileSdk 34), and CI's
-   green means exactly these two commands plus lint.
-
-## Build numbers, tags, and why updates never downgrade
-
-An APK is **`<series>.<build number>`**, the release tag is **`v<series>.<build
-number>`**, and the build number is what Android sees as `versionCode`:
-
-```
-build number = CI run number + plgVersionRunOffset      (gradle.properties)
-```
-
-- `plgVersionSeries` (currently `1.4`) is the human-facing series, set by hand
-  in `gradle.properties`.
-- `plgVersionRunOffset` (currently `1000`) is a **permanent floor**, also set by
-  hand in `gradle.properties`, set once at bootstrap and never changed.
-
-Why the offset exists: Gitea Actions restarts run numbers at 1 for each
-workflow, so without it the first release of a fresh instance would be build
-`1` — the number an unstamped local build already carries — and any reset of
-the counter would hand Android a *lower* `versionCode`, which it refuses as a
-downgrade. With the offset, every stamped build starts at 1001 and only ever
-climbs, because the run number is monotonic and the offset never moves. The
-gradle build and both workflows read the same two properties, so the tag and
-the APK inside it cannot name different versions.
-
-The series is a name for people: bumping it changes nothing about ordering,
-because `versionCode` never includes the series.
-
-Unstamped builds (local, or a PR build) are `versionCode 1`, below every
-release — the honest answer for a build nobody stamped.
-
-## Manual build (works today, no runner needed)
-
-```sh
-# JDK 17, Android SDK with platform 34 + build-tools 34
-export JAVA_HOME=...        # a JDK 17 install
-export ANDROID_HOME=...     # SDK root (or set sdk.dir in local.properties)
-
-./gradlew assembleDebug          # dev-channel app (default: ca.wallacenet.pilgrimsofkatan.dev)
-PLG_CHANNEL=production ./gradlew assembleDebug   # production app (ca.wallacenet.pilgrimsofkatan)
-./gradlew testDebugUnitTest      # JVM unit tests
-./gradlew lintDebug              # Android lint (CI runs this too)
-```
-
-The two variants install side by side: different applicationId, different
-launcher name (`Pilgrims of Katan DEV` vs `Pilgrims of Katan`), different brand
-colour.
-
-## Manual release (works today, no runner needed)
-
-```sh
-GITEA_TOKEN=… ./scripts/publish-release.sh v1.4.1001 app/build/outputs/apk/debug/app-debug.apk release "$(git rev-parse HEAD)"
-```
-
-The script takes `<tag> <apk> <prerelease|release> [target-sha]`, creates the
-release through `POST /api/v1/repos/{owner}/{repo}/releases`, and attaches the
-APK through `POST …/releases/{id}/assets` — which is the upload route Gitea's
-Swagger declares for this instance (1.27.3). If the tag already exists it
-publishes into the existing release instead of failing, so a retry is safe.
-
-## What the in-app updater reads
-
-`app/src/main/java/org/prolibertate/games/update/Updater.kt`:
-
-| Channel | Endpoint |
-| --- | --- |
-| production | `GET /api/v1/repos/devadmin/PilgrimsOfKatan/releases/latest` |
-| dev | `GET /api/v1/repos/devadmin/PilgrimsOfKatan/releases?limit=30` |
-
-- `/releases/latest` is documented by Gitea as *the most recent non-prerelease,
-  non-draft release* — the same rule GitHub implements, so the production
-  channel keeps skipping dev builds.
-- The dev path takes the highest `versionCode` among the prereleases rather
-  than whatever came first on the page, so it does not depend on server
-  ordering.
-- The JSON shape is the one the code already parsed from GitHub: `tag_name`,
-  `prerelease`, `draft`, and assets carrying `browser_download_url`. Gitea says
-  `limit` where GitHub says `per_page`.
-- Each asset must be named so it contains its tag —
-  `PilgrimsOfKatan-v1.4.1001.apk` for tag `v1.4.1001` — because the updater
-  picks the versioned APK out of the release's assets by that rule.
-
-`BuildConfig.OTA_ENABLED` is a kill switch, not a channel decision: it is
-`true`, and setting it `false` makes every check report that and fetch nothing.
-`UpdatePolicy.kt` — channel rules, tag parsing, verdicts — is pure and stays
-under test either way.
-
-## Keystore
-
-`app/debug.keystore` is committed deliberately and must never be rotated:
-every build — local, CI, release — signs with it, so an OTA update installs
-over the previous build instead of being rejected for a signature mismatch.

docs/README.md

@@ -24,6 +24,7 @@ Naming: the catalogue id, lowercase, e.g. `crazy8s` → `RULES-crazy8s.md`.
 | Golf | [RULES-golf.md](RULES-golf.md) |
 | Hearts | — (TODO) |
 | Kaiser | [RULES-kaiser.md](RULES-kaiser.md) |
+| Katan (catalogue id `catan`) | [RULES-catan.md](RULES-catan.md) |
 | Klondike | — (TODO) |
 | Mastermind | [RULES-mastermind.md](RULES-mastermind.md) |
 | Morris | [RULES-morris.md](RULES-morris.md) |
@@ -39,7 +40,10 @@ Naming: the catalogue id, lowercase, e.g. `crazy8s` → `RULES-crazy8s.md`.
 
 ## Other docs
 
-- [CI.md](CI.md) — build, CI, releases, OTA decisions.
+- Build, CI, releases and OTA are described in the CI section of the root
+  [README](../README.md).
+- [UI-catan.md](UI-catan.md) — how the Katan screen is layered, and how to restyle,
+  re-copy or re-lay-out it without touching the rules.
 - `licenses/` — third-party licences that must travel with the app
   (Uncial Antiqua under the SIL OFL; the app itself is GPL-3.0, see `/LICENSE`).
 - Repo-level agent notes live in [`CLAUDE.md`](../CLAUDE.md) at the root.

docs/RULES-catan.md

@@ -0,0 +1,326 @@
+# Katan — implemented rules
+
+This is the ruleset the engine enforces. Anything marked **toggle** is exposed
+in the game setup screen.
+
+Katan is this app's name for the island game the collection is built around.
+The catalogue id is `catan` (so this file is `RULES-catan.md` and the code lives
+in `game/catan/`), but the printed name is trademarked, so the game is listed
+and titled **Katan**. The rules themselves are the base game for three to four
+players, as published.
+
+The engine is a pure state machine (`CatanRules`) with no Android types, and its
+behaviour is pinned by `CatanBoardTest`, `CatanRulesTest` and `CatanAiTest`.
+
+## Table
+
+- **Players — *toggle*.** Three or four. `CatanOptions.playerCount`; the engine
+  refuses anything else.
+- **Points to win — *toggle*.** Defaults to 10. `CatanOptions.pointsToWin`, at
+  least 2. A lower target makes a test game short.
+
+The setup screen exposes both (players: 3 or 4; game to 5, 8, 10 or 12 points).
+
+## Board
+
+The island is the standard layout, derived once from axial hex coordinates in
+`CatanBoard` and checked at class-init:
+
+- **19 hexes**, the hexes within distance 2 of the centre.
+- **54 vertices** and **72 edges**, shared between neighbouring hexes by exact
+  integer position, not floating point. `HEX_CORNERS`, `EDGE_VERTICES`,
+  `VERTEX_EDGES`, `VERTEX_HEXES` and `EDGE_HEXES` are the shared graph.
+- **30 coastal edges**, one closed ring.
+- **9 harbours**, on fixed positions around the coast.
+
+Terrain is dealt from the physical mix and shuffled: **4 forest, 4 pasture,
+4 fields, 3 hills, 3 mountains, 1 desert**.
+
+Number tokens are the 18 the game ships, shuffled over the land hexes: four red
+tokens (**6, 6, 8, 8**) and fourteen others
+(**2, 3, 3, 4, 4, 5, 5, 9, 9, 10, 10, 11, 11, 12**). Seven never appears. The
+desert bears no token and the robber starts on it.
+
+### Keeping 6s and 8s apart
+
+The published game asks that the two red numbers not sit on adjacent hexes, and
+`generate` guarantees it rather than hoping for it:
+
+1. Shuffle the land and take four hexes; accept the draw if none of the four
+   touch each other. Retry up to 60 times.
+2. If no draw separates them, fall back to four of the six board-corner hexes,
+   which are pairwise non-adjacent by construction and at most one of which can
+   be the desert.
+
+`no seed puts two red tokens on adjacent hexes` runs the whole thing over seeds
+1..500.
+
+Harbours: the nine **positions** are fixed (the physical frame is not shuffled),
+but the nine **types** are shuffled onto them — **five 2:1 resource harbours**
+(one per resource) and **four generic 3:1 harbours**. The frame positions are
+chosen so no two harbours sit closer than three coastal edges apart.
+
+## Setup
+
+Placement runs in snake order: seats `0, 1, …, n-1` then `n-1, …, 1, 0`, each
+placing one settlement and one road. During setup the distance rule still holds
+(a settlement may not sit one edge from any other building) but the road need
+not connect to anything already placed.
+
+A player's **second** settlement earns one resource card for each adjacent
+producing hex, supply permitting — duplicates counted, so a second settlement on
+two forests earns two lumber. The first pass earns nothing.
+
+After the last placement, seat 0 leads and the first real turn begins.
+
+## Turn
+
+A turn runs through the phases in `CatanPhase`:
+
+1. **AWAIT_ROLL** — the player on the clock rolls.
+2. A seven goes to **DISCARDING** and then **ROBBER**; anything else produces and
+   goes straight to **PLAYING**.
+3. **PLAYING** — build, trade, buy and play development cards, then end the turn.
+4. **FREE_ROADS** is a detour inside PLAYING while a Road Building card is being
+   spent.
+
+### Rolling
+
+The dice are derived from the game seed and a monotonic counter (`rngStep`), not
+from a random generator stored in the state: the same seed and the same moves
+replay identically. `RollDice(forced = …)` exists so tests can stage a number;
+it is deliberately **not** a member of the enumerated move list, so a client
+cannot send one over the network — only code holding the state directly can use
+it.
+
+### Production
+
+For a non-seven total, each hex whose number matches pays its producing terrain:
+a settlement takes **1**, a city takes **2**. The robber's hex pays nothing.
+
+**When the bank cannot meet the demand for a resource, nobody receives that
+resource this roll.** This is the official ruling, implemented per-resource:
+demand is totalled first and, if it exceeds the bank's supply, every gain of
+that resource is dropped.
+
+## The robber
+
+A **seven** sends the robber: first every player holding **more than seven**
+resource cards discards half their hand (rounded down, so nine cards means four
+gone), in seat order starting from the lowest overfull seat; then the roller
+moves the robber and may steal.
+
+The robber **must move to a different hex**. Moving onto a hex lets the roller
+steal one card from one opponent who has a building on that hex and at least one
+card in hand. The card stolen is chosen at random, derived like the dice. A
+hex with no opponent holding cards offers only the move, no steal.
+
+A played Knight enters the same ROBBER phase, so the robber move after a Knight
+is the same code path.
+
+## Trading
+
+### Domestic
+
+An offer is addressed to **one** seat or, with `to = null`, to **everyone**, and
+names two card multisets: what the offerer gives, what they want.
+
+Seats are asked **one at a time**, in seat order after the offerer (seats holding
+no cards are skipped; an addressed offer asks only its addressee). The seat being
+asked may:
+
+- **accept** — the trade happens at once and the offer closes (first accept wins);
+- **decline** — the offer moves on to the next seat;
+- **counter** (`CounterTrade`) — propose different terms: what they would give and
+  what they want from the offerer. A counter must differ from the offer as made
+  (that is an accept), and both sides must hold the cards. The offer moves on.
+
+When every seat has answered and nobody accepted: with no counters the offer
+simply lapses; with counters the phase becomes `TRADE_COUNTERS` and the offerer
+either **takes one** (`AcceptCounter(seat)`, still checked for affordability) or
+**turns them all down** (`DismissCounters`).
+
+An offer is legal only when the offerer's turn is in PLAYING, the addressee is
+another seat, both legs are non-empty, the two legs are not the same multiset
+(`countOf(give) != countOf(get)` — like-for-like is not a trade), and the
+offerer actually holds the cards being offered.
+
+A seat may **accept** only if it holds what was asked and the offerer still holds
+what was promised; otherwise only decline (or counter) is offered. A refusal
+leaves every card where it was.
+
+Offers are free-form intents rather than enumerated moves (the space of card
+multisets is combinatorial), so they are validated structurally by
+`CatanRules.isLegalMove` and checked by the network driver's gate like any other
+move.
+
+### Maritime
+
+Bank trade gives `ratio` of one resource for one of another, where the ratio is
+the best the seat can get: **4:1** through the bank, **3:1** through a generic
+harbour, **2:1** through a harbour matching the resource being given. A harbour
+counts when the seat owns a settlement or city on **either** endpoint vertex of
+its edge.
+
+## Building and development cards
+
+| Build | Cost |
+| --- | --- |
+| Road | 1 lumber + 1 brick |
+| Settlement | 1 lumber + 1 brick + 1 wool + 1 grain |
+| City | 2 grain + 3 ore |
+| Development card | 1 wool + 1 grain + 1 ore |
+
+A settlement goes on an **empty vertex** at least two edges from every standing
+building and connected to the seat's own road network. A city upgrades one of
+the seat's own settlements. A road goes on an empty edge that connects to the
+seat's network: it must start from a crossing where the seat has a building, or
+where one of its roads ends.
+
+**An opponent's settlement or city on a crossing breaks the network there.** A
+road cannot be laid past it, even from a crossing where one of your own roads
+ends — only a crossing you own a building on is a way through. The same rule
+applies to the free roads of a Road Building card, and it is the same wall that
+cuts Longest Road (below).
+
+**Pieces are limited**: each player has **15 roads, 5 settlements and 4 cities**.
+A player who has laid them all cannot build another of that kind. Raising a
+settlement into a city returns the settlement to the supply, so the five
+settlements remain available to be laid again.
+
+The development deck is the published 25 cards: **14 Knights, 2 Road Building,
+2 Monopoly, 2 Year of Plenty, 5 Victory Point**. Cards are bought blind from the
+top of the deck.
+
+Timing rules the engine enforces:
+
+- **One development card per turn.** `devCardPlayedThisTurn` gates every play.
+- **A card cannot be played the turn it was bought.** Each card records
+  `boughtTurn` and is skipped while that equals the current turn.
+- **Victory Point cards are never played.** They are counted straight from the
+  hand by `victoryPoints`, and are only revealed by winning.
+- **Knight** → the robber phase, and counts toward Largest Army.
+- **Road Building** → two free road placements (FREE_ROADS); the player may
+  forfeit any that remain.
+- **Monopoly** → seizes every card of the named resource from the other seats.
+- **Year of Plenty** → takes up to two cards from the bank; taking two of a kind
+  requires the bank to hold both.
+
+## Scoring and winning
+
+Victory points are:
+
+- **Settlement 1, city 2.**
+- **Longest Road 5** — the longest single road of **five or more** segments.
+- **Largest Army 5** — first to **three** played knights.
+- **Victory Point cards**, one each.
+
+A seat wins on reaching **points to win** (default 10). The win is checked after
+every build, when a turn ends, and when a seat's turn arrives — the last covers
+points that changed on someone else's turn, such as a broken Longest Road being
+re-awarded. A seat already at the target therefore wins at the start of its own
+turn rather than having to act.
+
+### Longest Road
+
+The award goes to the longest **simple path** over a seat's own roads. The path
+never passes *through* an opponent's building (it may run up to one) and never
+revisits a vertex — so a figure of two loops sharing an intersection counts as
+one road of five, not two roads, because the intersection is a branch.
+
+Once held, the award is kept until another seat builds a **strictly longer**
+road; an equal length leaves it where it is. If the holder's road falls below
+five segments the award reopens to the longest road of five or more, lowest seat
+first on a tie. A settlement placed across an opponent's road breaks it, and the
+award is recomputed for everyone after any settlement.
+
+### Largest Army
+
+First to three knights takes it. It is stolen only by a **strictly larger** army:
+a tie leaves the incumbent ahead, exactly as Longest Road does.
+
+## The computer opponent
+
+`CatanAi` plays a legal, mildly strategic game so a solo player can host against
+computers, with the lobby filling empty seats.
+
+It reads **only public information** — terrain, numbers, buildings, roads,
+resource counts, development-card counts and knights played — plus its own hand.
+It never looks into the deck, another seat's development cards, or the seed
+beyond the roll the rules derive from it. That is a design constraint, not an
+accident: it runs on the host, where the authoritative state is fully visible.
+
+What it does:
+
+- **Setup.** Rates a settlement by the production its three hexes give (weighted
+  by the token odds and by how much it wants each resource), plus a bonus for
+  resource variety and for sitting on a harbour, plus a small term for where the
+  accompanying road points.
+- **Main phase**, in priority order: raise a city, build a settlement, play a
+  knight, play Year of Plenty or Monopoly when it closes a gap, play Road
+  Building when two segments are useful, buy a development card, build a road
+  that reaches a spot worth settling, trade at the bank only when the trade
+  completes a build this turn, make one domestic offer that closes a build, else
+  end the turn.
+- **The robber.** Moves onto the hex where it blocks the most opposing
+  production (weighted by token odds), preferring to rob whoever is holding the
+  most cards and the most points.
+- **Trades.** Accepts an offer when what arrives is worth more than what leaves
+  by its own resource valuations; a mild table, not a shark.
+- **Discards.** Throws away what it values least (wool, then brick, then lumber,
+  before grain and ore).
+
+It makes **at most one domestic offer a turn**. A declined offer changes nothing,
+so re-offering the same thing would only bounce between two seats forever; the
+engine allows more offers, the AI chooses not to.
+
+`CatanAiTest` plays three- and four-seat tables of engines out to a result from
+several seeds, refusing any illegal move the AI chooses, and checks the winner
+reached the target.
+
+## Provenance and rule choices
+
+The rules are the published base game. Where the published rules leave room, the
+engine picks one reading and records it here.
+
+**Followed from the published rules:** the board and its component mix; the
+number tokens; 6s and 8s not adjacent; snake-order setup and second-settlement
+income; production weighting; the robber on a seven; discard half over seven;
+domestic and maritime trade; build costs; the 25-card development deck and its
+timing rules; Longest Road and Largest Army worth five; victory at ten.
+
+**Choices made here, and why:**
+
+- **A bank short of a resource pays nobody that roll.** This is the official
+  ruling, and it is implemented per-resource rather than per-player.
+- **Longest Road and Largest Army are kept on a tie**, and stolen only by a
+  strictly longer road or a strictly larger army. The alternative reading lets a
+  tie steal the award; "strictly better" is the common tournament reading and
+  keeps the award from flickering.
+- **A ring road counts as a simple path.** No vertex is revisited, so six
+  segments around one hex are worth five, not six.
+- **The win is checked when a seat's turn arrives**, not only on that seat's own
+  action, so points that move on another player's turn still win.
+- **A bought Victory Point card does not win immediately.** It is counted when
+  the win is next checked (a build or the end of the turn), which is when the
+  holder would reveal it.
+- **Year of Plenty two-of-a-kind needs the bank to hold both cards**, not one.
+- **The robber must move.** Some printings allow staying put; this engine always
+  requires a different hex.
+- **Offers may be open to the whole table** and can be countered; the first accept wins (see Trading).
+
+## Known gaps
+
+- **No timer or cancel on offers.** An offer waits for each asked seat in turn; the offerer cannot withdraw it mid-round, and a player who never answers stalls the table.
+- **The AI never counters.** It accepts, declines, and picks among counters it is sent, but does not propose them.
+- **No trading away a development card.** Not part of the base game.
+- **The screen is built, not yet verified on two devices.** The Katan screen and
+  setup options exist (see [UI-catan.md](UI-catan.md)); the catalogue entry is a
+  dev-channel preview until two-device play has been verified.
+- **The AI does not look ahead.** It scores one move deep with a fixed resource
+  valuation. It plays legally and plausibly; it is not a strong opponent, and no
+  strength claim is made.
+- **The board is the standard published layout, generated.** Unlike the Sequence
+  board there is no unverified substitute here — the geometry is the real one —
+  but the *island* (terrain and token placement) is freshly generated each game,
+  so it will not match any particular physical set-up. That is the intent.

docs/UI-catan.md

@@ -0,0 +1,143 @@
+# Katan UI — how it is built, and how to change it
+
+The Katan screen (`app/src/main/java/org/prolibertate/games/ui/game/catan/`) is
+built in layers so that **look, wording, layout and interaction can each be
+changed on their own**. If you are an agent asked to restyle, retheme,
+re-copy or re-lay-out Katan, start here and touch only the layer you were asked
+about.
+
+The rules live elsewhere and are not part of the UI: `game/catan/` is a pure
+state machine (see [RULES-catan.md](RULES-catan.md)). **Nothing in `ui/game/catan/`
+decides what is legal.** The engine's legal-move list is the single source of
+truth, so the UI can only ever offer a move the rules would accept.
+
+## The layers
+
+| Layer | File | Owns | Change it to… |
+| --- | --- | --- | --- |
+| **Style** | `CatanStyle.kt` | Every colour, proportion and the light/dark palettes | Re-skin: new terrain colours, seat colours, piece sizes, token look |
+| **Copy** | `CatanText.kt` | Every sentence, button label and name shown | Reword, localise, rename resources |
+| **Geometry** | `CatanGeometry.kt` | Engine lattice → pixels, and pixel → nearest vertex/edge/hex | Change board scale, margin, harbour placement, tap reach (rarely) |
+| **Interaction** | `CatanInteraction.kt` | What is tappable, what a tap means, which buttons are live | Change *how* something is selected (never *whether* it is legal) |
+| **Board drawing** | `CatanBoardView.kt` | The `Canvas`: tiles, tokens, ports, robber, roads, pieces, highlights | Change how a piece is drawn (art, shapes, animation) |
+| **Panels** | `CatanPanels.kt` | Resource tiles, hand, player cards, dice, action bar, log | Restyle or rearrange widgets |
+| **Dialogs** | `CatanDialogs.kt` | Discard, robber victim, play card, trade, trade reply, game over | Change a dialog's flow or look |
+| **Screen** | `CatanScreen.kt` | Wiring to `MatchController`, portrait/landscape layout, which dialog shows | Change the layout or add a new element |
+| **Previews** | `CatanPreviews.kt` | Android Studio previews of real positions | Iterate on the look without a match |
+
+Everything outside this folder that mentions Katan is one-line wiring:
+`PlayScreen.kt` (builds the `MatchController`), `GameSetupScreen.kt` (players and
+points-to-win options), `Catalog.kt` (the catalogue entry).
+
+## Recipes
+
+**Change colours or sizes.** Edit `CatanStyle.kt`. `LightStyle` is the reference
+palette; `DarkStyle` is derived from it. Metrics (`roadWidth`, `settlementSize`,
+`tokenRadius`, …) are fractions of the hex radius, so they scale with the screen.
+To try a whole new theme, provide it at the root:
+`CompositionLocalProvider(LocalCatanStyle provides myStyle) { … }`.
+
+**Change wording or translate.** Edit `CatanText.kt`. Composables never build a
+sentence themselves. `prompt(...)` is the one-line "what is happening / what do I
+do" text; it is a pure function of the state, with tests in `CatanTextTest`.
+
+**Redraw a piece** (settlement, road, robber, port, token). Edit the matching
+`draw…` function in `CatanBoardView.kt`. Positions come from `BoardLayout`, so you
+only decide the shape. Keep the hit target generous (see Accessibility).
+
+**Rearrange the screen.** Edit `CatanScreen.kt`. It builds four independent
+pieces (`board`, `players`, `promptRow`, `handAndActions`) and arranges them
+differently in portrait and landscape. Moving or dropping a piece does not affect
+the others.
+
+**Add a widget.** Make it a stateless composable in `CatanPanels.kt` (values in,
+lambdas out). Do not give it the `MatchController`.
+
+**Change how a selection works** (for example a one-tap build instead of a
+build-mode toggle). Edit `CatanInteraction.kt` and its tests, then adjust the
+screen's UI state. The legal-move list stays the gate.
+
+## Rules of the road
+
+1. **Never put a rule in a composable.** If a button's enabled state or a tap's
+   result depends on game logic, it goes in `CatanInteraction` (pure, tested) and
+   is derived from the engine's `legal` list or `CatanRules`.
+2. **Never hard-code a colour or a string** outside `CatanStyle` / `CatanText`.
+3. **Stateless by default.** Panels and dialogs take values and report events. The
+   only state they may own is the transient selection they are helping the player
+   make (cards picked in a trade, for example).
+4. **Hidden information.** The local view comes from `CatanRules.viewFor`: other
+   players' development cards and the deck are empty on a client. Do not show the
+   size of the deck; it is not known to a client. Card *counts* (`resourceCount`,
+   `devHandCounts`) are public.
+5. **The state is immutable.** Never mutate it; submit a move.
+6. **The layout must not move.** Everything outside the board has a *fixed
+   height*, and the board takes whatever is left, so the island's scale is the
+   same all game. Concretely: a control is *enabled or disabled*, never
+   *present or absent* (the action bar always shows every button); text that can
+   vary in length is pinned to a fixed number of lines (`minLines = maxLines`);
+   a line that is sometimes empty is still drawn (a non-breaking space), as the
+   award line on a player card is. A change that makes any non-board element
+   taller or shorter at runtime will rescale the board under the player's thumb.
+
+## Interaction model (what the player actually does)
+
+| Phase | The player… |
+| --- | --- |
+| Setup | taps a highlighted crossing (settlement), then a highlighted edge beside it (road). *Cancel* re-picks the settlement |
+| Roll | presses **Roll dice** |
+| Seven | **Discard** dialog (forced); then taps a hex to move the robber; a victim dialog appears only if more than one player can be robbed |
+| Main turn | arms **Road / Settlement / City** and taps a highlighted spot; **Buy card**; **Play card**; **Trade**; **End turn** |
+| Road Building | taps highlighted edges, or **Done with roads** |
+| Offered a trade | **Accept / Decline / Counter…** dialog (forced); *Counter…* opens a picker pre-filled with the mirror of the offer |
+| Counter-offers received | **Counter-offers** dialog: *Accept* beside the one to take, or *No deal* |
+| Game over | result dialog |
+
+Trade offers are free-form (two card multisets), so they are validated with
+`CatanRules.isLegalMove`, not looked up in the legal list.
+
+## Testing
+
+Gradle does not run in the agent sandbox; **CI is the compile and test check**
+(dispatch `ci.yml` on your branch). What is covered:
+
+- `CatanGeometryTest` — the island fits any box, edges and corners are one radius,
+  hit-testing finds the right vertex/edge/hex.
+- `CatanInteractionTest` — targets and tap outcomes for setup, building, free
+  roads, the robber (including the victim choice), discards, bank trades, offers,
+  development cards and trade replies, all against real engine states.
+- `CatanTextTest` — the prompts and tallies.
+
+Drawing and dialogs are not unit-tested; use the previews in `CatanPreviews.kt`
+and play a game on a dev build.
+
+## Accessibility notes
+
+- Tap targets: vertices and edges accept a tap within `tapReach` (0.7) hex radii,
+  about 23 dp on a phone. If you shrink the board, keep that physical size.
+- Seat colours are blue, orange, white and purple, each outlined in near-black so
+  they read on any terrain. Colour is the only piece identity today; adding a
+  shape or letter per seat would help colour-blind players (a good first task).
+- The board has a content description but no per-hex semantics; a screen-reader
+  mode would need one.
+
+## Status and known gaps
+
+The screen is **playable and feature-complete for the engine's rules**, but is
+**unverified on two real devices**, so the catalogue entry is `devPreview`
+(openable on a dev build, hidden from production). To release it: verify
+two-device play, then in `Catalog.kt` set `available = true` and remove
+`devPreview = true`, and update `CatalogTest`.
+
+Not done yet, in rough priority order:
+
+1. Two-device verification (host + guest over the LAN) and a full game on a phone
+   and a tablet.
+2. Feedback on events: dice-roll animation, a highlight on hexes that produced,
+   resource-gain flourishes, haptics. The state carries the dice and a text log;
+   it does not say which hexes paid out, so that needs either a diff of two states
+   or an engine addition.
+3. Art: terrain textures, resource and harbour icons, a real robber pawn.
+4. A timer or cancel button on offers (the engine has neither).
+5. A board that shows the *last* move (a faint highlight of what just changed).
+6. Landscape polish on large tablets; the right-hand panel scrolls but is plain.

gradle.properties

@@ -1,5 +1,12 @@
 # Project-wide Gradle settings.
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+# C1-only JIT (-XX:TieredStopAtLevel=1): the Gitea runner's JVMs have been
+# crashing intermittently (SIGSEGV in HotSpot's compiler, bad Kotlin compiler
+# codegen) on Zulu, Corretto and Temurin alike. Dropping C2 is the test for
+# whether the optimising JIT is the trigger; it costs some build speed. The
+# Kotlin daemon needs its own copy: setting its options stops it inheriting
+# org.gradle.jvmargs.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 -XX:TieredStopAtLevel=1
+kotlin.daemon.jvm.options=-Xmx2048m,-XX:TieredStopAtLevel=1
 org.gradle.parallel=true
 org.gradle.caching=true
 
@@ -24,10 +31,10 @@ android.nonTransitiveRClass=true
 # when this changes.
 plgVersionSeries=1.4
 
-# The permanent floor under every stamped build number: versionCode (and the
-# release tag, and versionName) are `run number + this`. Gitea Actions starts
-# run numbers at 1 for each workflow, so without it the first Gitea-era release
-# would be build 1 — the same number an unstamped local build already carries —
-# and any later reset would make Android reject the next build as a downgrade.
-# Set once, at bootstrap, and never changed again: see docs/CI.md.
+# The permanent floor under every stamped build number: versionCode, versionName
+# and the release tag are all `run number + this`. Run numbers restart at 1 on a
+# new CI host (Gitea Actions), and Android refuses any versionCode lower than the
+# one installed, so without a floor the first build after a move would look like
+# a downgrade. 1000 sits above every number GitHub reached (prod 30, dev ~172).
+# Set once and never changed.
 plgVersionRunOffset=1000

scripts/publish-release.sh

@@ -1,101 +0,0 @@
-#!/bin/sh
-# Publish a built APK to this repository's Gitea releases — the channel the
-# in-app updater reads (docs/CI.md).
-#
-# The workflows call this, and so can a person: it is the whole release step,
-# runnable by hand on any machine with curl, which matters because a Gitea
-# Actions runner has to exist before the workflows can run at all.
-#
-#   scripts/publish-release.sh <tag> <apk> <prerelease|release> [target-sha]
-#
-# Environment:
-#   GITEA_TOKEN   required — a token that may create releases on the repo.
-#   GITEA_API     API base, default https://git.wallacenet.ca/api/v1
-#   GITEA_REPO    owner/name,  default devadmin/PilgrimsOfKatan
-#
-# The four arguments can also arrive as RELEASE_TAG, RELEASE_APK,
-# RELEASE_KIND and RELEASE_TARGET, which is how the workflows pass them.
-set -eu
-
-usage() {
-    sed -n '2,17p' "$0" | sed 's/^# \{0,1\}//' >&2
-}
-
-tag="${1:-${RELEASE_TAG:-}}"
-apk="${2:-${RELEASE_APK:-}}"
-kind="${3:-${RELEASE_KIND:-}}"
-target="${4:-${RELEASE_TARGET:-${GITHUB_SHA:-HEAD}}}"
-
-case "$kind" in
-    prerelease|release) ;;
-    *) usage; exit 2 ;;
-esac
-[ -n "$tag" ] || { usage; exit 2; }
-[ -f "$apk" ] || { echo "publish-release: no such APK: ${apk:-<unset>}" >&2; exit 2; }
-[ -n "${GITEA_TOKEN:-}" ] || { echo "publish-release: GITEA_TOKEN is not set" >&2; exit 2; }
-
-api="${GITEA_API:-${GITHUB_API_URL:-https://git.wallacenet.ca/api/v1}}/repos/${GITEA_REPO:-${GITHUB_REPOSITORY:-devadmin/PilgrimsOfKatan}}"
-
-tmp="$(mktemp -d)"
-trap 'rm -rf "$tmp"' EXIT INT TERM
-
-# Named for its tag, not for whatever the build happened to call it: the
-# updater picks the versioned APK out of a release's assets by finding the one
-# whose name contains the tag, so an asset called app-debug.apk would only be
-# found by the fallback rule.
-apk_name="PilgrimsOfKatan-${tag}.apk"
-
-# The tag and the file name are both derived from gradle.properties and a run
-# number, so neither can carry a quote or a backslash into this JSON.
-if [ "$kind" = "prerelease" ]; then
-    prerelease=true
-    note="Automated dev-channel build of ${target}. Newer than production and less tested — switch to the Dev update channel in Settings to be offered these. Published as a prerelease so production-channel installs never see it."
-else
-    prerelease=false
-    note="Production-channel build of ${target}. Download ${apk_name} below and install it on an Android device (you may need to allow installs from unknown apps). It is signed with the repo's fixed keystore, which is what lets the in-app updater install over it."
-fi
-
-cat > "$tmp/release.json" <<JSON
-{"tag_name":"${tag}","target_commitish":"${target}","name":"Pilgrims of Katan ${tag}","body":"${note}","prerelease":${prerelease},"draft":false}
-JSON
-
-code="$(curl -sS -o "$tmp/create.json" -w '%{http_code}' -X POST \
-    -H "Authorization: token ${GITEA_TOKEN}" \
-    -H "Content-Type: application/json" \
-    --data @"$tmp/release.json" \
-    "$api/releases")"
-
-# 422 is the usual answer when the tag already exists — a re-run of a
-# workflow, or a second attempt by hand. Publishing into the release that is
-# already there is the right thing to do, not a failure.
-if [ "$code" != "201" ] && [ "$code" != "200" ]; then
-    code="$(curl -sS -o "$tmp/create.json" -w '%{http_code}' \
-        -H "Authorization: token ${GITEA_TOKEN}" \
-        "$api/releases/tags/${tag}")"
-fi
-
-if [ "$code" != "201" ] && [ "$code" != "200" ]; then
-    echo "publish-release: creating release ${tag} failed (HTTP ${code})" >&2
-    cat "$tmp/create.json" >&2
-    echo >&2
-    exit 1
-fi
-
-# Gitea answers compact JSON, and the release's own id is the first "id" in
-# it — the author's object comes later in the document.
-id="$(grep -o '"id":[0-9]*' "$tmp/create.json" | head -n1 | tr -dc '0-9' || true)"
-[ -n "$id" ] || { echo "publish-release: no release id in response" >&2; cat "$tmp/create.json" >&2; echo >&2; exit 1; }
-
-code="$(curl -sS -o "$tmp/asset.json" -w '%{http_code}' -X POST \
-    -H "Authorization: token ${GITEA_TOKEN}" \
-    -F "attachment=@${apk};filename=${apk_name}" \
-    "$api/releases/${id}/assets")"
-
-if [ "$code" != "201" ] && [ "$code" != "200" ]; then
-    echo "publish-release: attaching ${apk_name} to release ${id} failed (HTTP ${code})" >&2
-    cat "$tmp/asset.json" >&2
-    echo >&2
-    exit 1
-fi
-
-echo "publish-release: ${tag} -> release ${id} on ${api#*/repos/}, asset ${apk_name}"

settings.gradle.kts

@@ -14,5 +14,5 @@ dependencyResolutionManagement {
     }
 }
 
-rootProject.name = "PilgrimsOfKatan"
+rootProject.name = "ProLibertateGames"
 include(":app")

site/404.html

@@ -0,0 +1,3 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Not found</title></head>
+<body><h1>404</h1><p>Not found. <a href="/">Pro Libertate Games downloads</a></p></body></html>

site/_headers

@@ -0,0 +1,7 @@
+/*/latest.json
+  Cache-Control: no-cache
+  Access-Control-Allow-Origin: *
+
+/*.apk
+  Content-Type: application/vnd.android.package-archive
+  Cache-Control: public, max-age=300

site/index.html

@@ -0,0 +1,34 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Pro Libertate Games</title>
+<style>
+  :root { color-scheme: light dark; font-family: system-ui, sans-serif; }
+  body { max-width: 32rem; margin: 3rem auto; padding: 0 1rem; line-height: 1.5; }
+  .card { border: 1px solid #8884; border-radius: .5rem; padding: 1rem; margin: 1rem 0; }
+  a.dl { display: inline-block; padding: .5rem 1rem; border-radius: .4rem; background: #2563eb; color: #fff; text-decoration: none; }
+  small { opacity: .7; }
+</style>
+</head>
+<body>
+<h1>Pro Libertate Games</h1>
+<p>Android builds. Allow <em>Install unknown apps</em> for your browser to sideload.</p>
+<div class="card" id="production"><h2>Production</h2><p>Loading…</p></div>
+<div class="card" id="dev"><h2>Dev</h2><p>Loading…</p></div>
+<script>
+for (const [channel, path] of [["production", "prod"], ["dev", "dev"]]) {
+  const box = document.getElementById(channel);
+  const title = box.querySelector("h2").outerHTML;
+  fetch(`/${path}/latest.json`, { cache: "no-cache" })
+    .then(r => r.ok ? r.json() : Promise.reject())
+    .then(j => {
+      box.innerHTML = `${title}<p><a class="dl" href="${j.apkUrl}">Download ${j.tag}</a></p>` +
+        `<small>Always newest: <a href="/${path}/ProLibertateGames.apk">/${path}/ProLibertateGames.apk</a></small>`;
+    })
+    .catch(() => { box.innerHTML = `${title}<p>No build published yet.</p>`; });
+}
+</script>
+</body>
+</html>