Compare commits
42
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4ed110e68c | ||
|
|
b818997699 | ||
|
|
aeda2924f4 | ||
|
|
2e234c7f20 | ||
|
|
f4f53a93b6 | ||
|
|
bce9b68ece | ||
|
|
68cd799f89 | ||
|
|
6c549a8b76 | ||
|
|
ebab7a8415 | ||
|
|
a0b15b3140 | ||
|
|
8990dde363 | ||
|
|
c2b21a07f5 | ||
|
|
e98afbfd8d | ||
|
|
2c90de66d1 | ||
|
|
f93eba88e5 | ||
|
|
36ab518309 | ||
|
|
77cc6c5a05 | ||
|
|
166f85734b | ||
|
|
25e38c4bf8 | ||
|
|
6bf7522042 | ||
|
|
7942adeaf7 | ||
|
|
401ebe0118 | ||
|
|
3c0469fc81 | ||
|
|
5d36b7bd62 | ||
|
|
b5b4afa731 | ||
|
|
f88099f4e2 | ||
|
|
488f600f15 | ||
|
|
9b938ffd8b | ||
|
|
ccf8d5a1ba | ||
|
|
a00df43a44 | ||
|
|
fae031d2b5 | ||
|
|
d568ff7750 | ||
|
|
2e66567643 | ||
|
|
a8ff9863a6 | ||
|
|
bd12a7a70b | ||
|
|
e370aa0ceb | ||
|
|
59a6ffc940 | ||
|
|
98506c05b7 | ||
|
|
f9b793d56e | ||
|
|
c8368416c4 | ||
|
|
e344d1d817 | ||
|
|
d88083679d |
@@ -49,8 +49,8 @@ jobs:
|
|||||||
- name: Set up Android SDK
|
- name: Set up Android SDK
|
||||||
uses: android-actions/setup-android@v4
|
uses: android-actions/setup-android@v4
|
||||||
|
|
||||||
- name: Build debug APK
|
- name: Build release APK
|
||||||
run: ./gradlew assembleDebug --no-daemon --stacktrace
|
run: ./gradlew assembleRelease --no-daemon --stacktrace
|
||||||
|
|
||||||
- name: Stage APK for release
|
- name: Stage APK for release
|
||||||
id: stage
|
id: stage
|
||||||
@@ -65,7 +65,7 @@ jobs:
|
|||||||
test -n "$offset"
|
test -n "$offset"
|
||||||
# Same arithmetic as build.gradle.kts, so the tag names the APK's own number.
|
# Same arithmetic as build.gradle.kts, so the tag names the APK's own number.
|
||||||
version="v${series}.$(( ${{ github.run_number }} + offset ))"
|
version="v${series}.$(( ${{ github.run_number }} + offset ))"
|
||||||
src="app/build/outputs/apk/debug/app-debug.apk"
|
src="app/build/outputs/apk/release/app-release.apk"
|
||||||
dest="ProLibertateGames-${version}.apk"
|
dest="ProLibertateGames-${version}.apk"
|
||||||
cp "$src" "$dest"
|
cp "$src" "$dest"
|
||||||
# The same build again under a name that never changes. GitHub's
|
# The same build again under a name that never changes. GitHub's
|
||||||
|
|||||||
@@ -1,78 +1,67 @@
|
|||||||
> **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.
|
|
||||||
|
|
||||||
# Working on this repo with Claude
|
# Working on this repo with Claude
|
||||||
|
|
||||||
## Nothing a session does triggers CI. Dispatch it explicitly.
|
CI runs on **Gitea Actions** at `git.wallacenet.ca/devadmin/ProLibertateGames`
|
||||||
|
(workflows in `.github/workflows/`), publishing to Cloudflare Pages
|
||||||
|
(`plg.wallacenet.ca`). The workflow below was measured on the dev machine
|
||||||
|
(`~/ProLibertateGames`); it replaces the earlier GitHub-sandbox notes, which no
|
||||||
|
longer apply.
|
||||||
|
|
||||||
GitHub creates **no workflow run** for anything this sandbox does — pushing a
|
## Build, test and lint locally
|
||||||
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.
|
|
||||||
|
|
||||||
This was measured, not assumed:
|
Gradle works on the dev machine. Two environment variables are required: the
|
||||||
|
default JDK is 25, which Gradle 8.14 cannot use, and the Android SDK lives in the
|
||||||
|
home directory.
|
||||||
|
|
||||||
| Action | Result |
|
```
|
||||||
| --- | --- |
|
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
|
||||||
| Human pushes a Claude-authored commit (`d165e5ef`, `469c900e`) | CI runs |
|
export ANDROID_HOME=$HOME/android-sdk # platform 34, build-tools 34.0.0
|
||||||
| Session pushes `dev` / `main` (`43394b8`, `742add4`) | no run |
|
./gradlew testDebugUnitTest lintDebug assembleDebug
|
||||||
| Session opens a PR against `dev` (#1) | no run |
|
```
|
||||||
| Session calls `workflow_dispatch` | **runs** |
|
|
||||||
|
|
||||||
`workflow_dispatch` works because it creates a run directly instead of relying
|
The Katan tests run in seconds; a clean build takes a few minutes. Run the full
|
||||||
on an event. It is the only mechanism available from a session, so every build
|
suite, lint and `assembleDebug` before pushing: they are what CI runs. There is
|
||||||
has to be asked for by hand.
|
no KVM, so no emulator; the engine and the UI logic are covered by unit tests
|
||||||
|
(see `docs/UI-catan.md`).
|
||||||
|
|
||||||
## Verify before merging, without publishing
|
## Shipping: branch, PR, CI, merge
|
||||||
|
|
||||||
`ci.yml` builds, tests and lints on any ref, but its staging and publishing
|
1. Branch from `dev`; before pushing, merge `origin/dev` in (it moves between
|
||||||
steps are gated on `github.ref == 'refs/heads/dev'`. Dispatching it on a
|
sessions).
|
||||||
**feature branch** therefore gives the full check — build, unit tests, Android
|
2. Plain `git push` has no credentials. Use the Gitea token as a one-off header:
|
||||||
lint — and publishes nothing.
|
`git -c "http.extraheader=Authorization: token $(cat ~/.config/gitea/token)" push -u origin <branch>`.
|
||||||
|
3. Open the PR with `POST /api/v1/repos/devadmin/ProLibertateGames/pulls`
|
||||||
So the working loop is:
|
(same token, `Authorization: token ...`). CI (`ci.yml`) runs on the PR: build,
|
||||||
|
unit tests and Android lint; it publishes nothing. Poll
|
||||||
1. Commit and push the feature branch.
|
`/actions/runs` until it completes (about 7 minutes).
|
||||||
2. Dispatch `ci.yml` on that branch. Wait for green. This is the real review
|
4. Merge with `POST .../pulls/N/merge {"Do":"merge"}`. The push to `dev` runs
|
||||||
gate, and it is the only verification that exists (see below).
|
`ci.yml` again and publishes the build (about 9 minutes).
|
||||||
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`.
|
|
||||||
|
|
||||||
Skipping step 4 leaves a branch whose head was never built and no release.
|
|
||||||
|
|
||||||
## Merging is a shipping action
|
## Merging is a shipping action
|
||||||
|
|
||||||
Both long-lived branches publish, so a merge is a release, not just an
|
Both long-lived branches publish, so a merge is a release, not just an
|
||||||
integration:
|
integration:
|
||||||
|
|
||||||
- **`dev`** → `ci.yml` publishes a `v<series>.N-dev` **prerelease**, offered by the
|
- **`dev`** publishes a `v<series>.N-dev` build to
|
||||||
in-app updater to anyone on the Dev channel.
|
`https://plg.wallacenet.ca/dev/latest.json`, offered by the in-app updater to
|
||||||
- **`main`** → `release.yml` publishes a **production** release, which the
|
anyone on the Dev channel.
|
||||||
updater installs for everyone on the Production channel.
|
- **`main`** runs `release.yml` and publishes a **production** release for
|
||||||
|
everyone on the Production channel. Confirm before merging to `main`.
|
||||||
|
`release.yml` runs `assembleDebug` only (no tests, no lint), so a `main`
|
||||||
|
release is only as verified as the `dev` build it replays.
|
||||||
|
|
||||||
Confirm before shipping to `main`. Note that `release.yml` runs `assembleDebug`
|
## Katan
|
||||||
only — no tests, no lint — so a `main` release is only as verified as the `dev`
|
|
||||||
build it replays.
|
|
||||||
|
|
||||||
## Gradle does not run in the sandbox
|
The island game is catalogue id `catan`, shown as **Katan**. It has two rule
|
||||||
|
sets chosen at setup: the base game (`docs/RULES-catan.md`), Cities & Knights
|
||||||
`./gradlew` cannot resolve the Android plugin here: the proxy blocks
|
(`docs/RULES-catan-ck.md`, code in `game/catan/CatanCk*.kt`, state behind
|
||||||
`dl.google.com` with a 403. No local build, no local test run, no local lint. A
|
`CatanState.ck`, which is null in the base game) and Seafarers
|
||||||
dispatched CI run is the only way to find out whether a change compiles.
|
(`docs/RULES-catan-seafarers.md`, code in `game/catan/CatanSea*.kt`, state behind
|
||||||
|
`CatanState.sea`). The base and Seafarers rules read the board from `state.topo`, not from
|
||||||
## A permanent fix, if you want one
|
`CatanBoard` directly, because a Seafarers map is not the 19-hex island
|
||||||
|
(Cities & Knights is always the standard island and still uses `CatanBoard`). The
|
||||||
The suppression is a property of the sandbox's credential, so it cannot be
|
Catan Universe reverse engineering that shaped the landscape HUD and trade board
|
||||||
fixed from inside a session. Giving the environment a personal access token to
|
is in `docs/RE-catan-universe.md`. The screen is layered; see
|
||||||
push with would make pushes and PRs behave normally for everyone. Until then,
|
`docs/UI-catan.md` before changing it.
|
||||||
the dispatch step above is the workaround.
|
|
||||||
|
|
||||||
## Bash output is filtered before it reaches the model
|
## Bash output is filtered before it reaches the model
|
||||||
|
|
||||||
|
|||||||
@@ -373,7 +373,9 @@ game:
|
|||||||
the game is out of print and the rulebook could not be obtained, so the
|
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
|
document says which parts are attested and which were derived
|
||||||
- [Katan](docs/RULES-catan.md) — the island game (catalogue id `catan`); the
|
- [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
|
rules engine, AI and screen are in place
|
||||||
|
- [Katan: Cities & Knights](docs/RULES-catan-ck.md) — the expansion rule set, chosen on
|
||||||
|
the setup screen: commodities, knights, barbarians, city improvements and progress cards
|
||||||
|
|
||||||
## Layout
|
## Layout
|
||||||
|
|
||||||
@@ -396,7 +398,7 @@ game/ rules engines and AI — pure Kotlin, no Android, unit-tested
|
|||||||
mastermind/ Mastermind codes, scoring, and a code breaker
|
mastermind/ Mastermind codes, scoring, and a code breaker
|
||||||
pirates/ Pirates and Bulgars — the cross board, the hunt, search
|
pirates/ Pirates and Bulgars — the cross board, the hunt, search
|
||||||
tayu/ Ta Yü tile geometry, river rules, scoring, AI
|
tayu/ Ta Yü tile geometry, river rules, scoring, AI
|
||||||
catan/ Katan island geometry, production, trade, dev cards, heuristic AI
|
catan/ Katan island geometry, production, trade, dev cards, Cities & Knights, heuristic AI
|
||||||
net/ wire protocol, LAN transport, lobby, match driver
|
net/ wire protocol, LAN transport, lobby, match driver
|
||||||
score/ scorekeeper sheet — pure Kotlin, unit-tested — and its store
|
score/ scorekeeper sheet — pure Kotlin, unit-tested — and its store
|
||||||
settings/ DataStore-backed preferences
|
settings/ DataStore-backed preferences
|
||||||
|
|||||||
@@ -104,6 +104,11 @@ android {
|
|||||||
|
|
||||||
buildTypes {
|
buildTypes {
|
||||||
release {
|
release {
|
||||||
|
// Signed with the same key as the debug builds, so a release installs
|
||||||
|
// over what is already on a device; a different key would make the
|
||||||
|
// updater's installs fail with a signature mismatch.
|
||||||
|
signingConfig = signingConfigs.getByName("debug")
|
||||||
|
isDebuggable = false
|
||||||
isMinifyEnabled = false
|
isMinifyEnabled = false
|
||||||
proguardFiles(
|
proguardFiles(
|
||||||
getDefaultProguardFile("proguard-android-optimize.txt"),
|
getDefaultProguardFile("proguard-android-optimize.txt"),
|
||||||
|
|||||||
@@ -10,11 +10,14 @@ import org.prolibertate.games.net.LobbyController
|
|||||||
import org.prolibertate.games.net.ScorekeeperSession
|
import org.prolibertate.games.net.ScorekeeperSession
|
||||||
import org.prolibertate.games.score.ScorekeeperRepository
|
import org.prolibertate.games.score.ScorekeeperRepository
|
||||||
import org.prolibertate.games.settings.SettingsRepository
|
import org.prolibertate.games.settings.SettingsRepository
|
||||||
|
import org.prolibertate.games.settings.YahtzeeStatsRepository
|
||||||
import org.prolibertate.games.ui.AppEnv
|
import org.prolibertate.games.ui.AppEnv
|
||||||
import org.prolibertate.games.ui.AppRoot
|
import org.prolibertate.games.ui.AppRoot
|
||||||
import org.prolibertate.games.ui.theme.ProLibertateTheme
|
import org.prolibertate.games.ui.theme.ProLibertateTheme
|
||||||
import org.prolibertate.games.update.Updater
|
import org.prolibertate.games.update.Updater
|
||||||
|
import java.io.File
|
||||||
import java.util.UUID
|
import java.util.UUID
|
||||||
|
import org.prolibertate.games.game.engine.SavedGameStore
|
||||||
|
|
||||||
class MainActivity : ComponentActivity() {
|
class MainActivity : ComponentActivity() {
|
||||||
|
|
||||||
@@ -40,6 +43,8 @@ class MainActivity : ComponentActivity() {
|
|||||||
deviceId = peerId,
|
deviceId = peerId,
|
||||||
),
|
),
|
||||||
peerId = peerId,
|
peerId = peerId,
|
||||||
|
saves = SavedGameStore(File(filesDir, "saved-games")),
|
||||||
|
yahtzeeStats = YahtzeeStatsRepository(applicationContext),
|
||||||
)
|
)
|
||||||
|
|
||||||
setContent {
|
setContent {
|
||||||
|
|||||||
@@ -106,6 +106,7 @@ object GameCatalog {
|
|||||||
const val TAYU = "tayu"
|
const val TAYU = "tayu"
|
||||||
const val MORRIS = "morris"
|
const val MORRIS = "morris"
|
||||||
const val PIRATES = "pirates"
|
const val PIRATES = "pirates"
|
||||||
|
const val MEOWDOKU = "meowdoku"
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The island game the collection is named for. Listed under Board Games
|
* The island game the collection is named for. Listed under Board Games
|
||||||
@@ -360,13 +361,19 @@ object GameCatalog {
|
|||||||
minPlayers = 3,
|
minPlayers = 3,
|
||||||
maxPlayers = 4,
|
maxPlayers = 4,
|
||||||
teamBased = false,
|
teamBased = false,
|
||||||
blurb = "Trade, build, and settle the island.",
|
blurb = "Trade, build, and settle the island, in the base game or Cities & Knights.",
|
||||||
// Engine and screen exist but have not been verified on two real
|
available = true,
|
||||||
// devices yet. Dev builds can open it as a *Preview*; a production
|
),
|
||||||
// build does not list it. Flip `available` on, and `devPreview`
|
GameDescriptor(
|
||||||
// off, once two-device play has been verified.
|
id = MEOWDOKU,
|
||||||
available = false,
|
title = "Meowdoku",
|
||||||
devPreview = true,
|
menus = setOf(GameMenu.BOARD, GameMenu.SOLITAIRE),
|
||||||
|
minPlayers = 1,
|
||||||
|
maxPlayers = 1,
|
||||||
|
teamBased = false,
|
||||||
|
blurb = "One cat in every row, column and colour, and no two touching. " +
|
||||||
|
"Wrong taps cost a heart; the board only ever accepts a cat that belongs.",
|
||||||
|
available = true,
|
||||||
),
|
),
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|||||||
@@ -20,16 +20,25 @@ import org.prolibertate.games.game.engine.GameAi
|
|||||||
*/
|
*/
|
||||||
class CatanAi : GameAi<CatanState, CatanMove> {
|
class CatanAi : GameAi<CatanState, CatanMove> {
|
||||||
|
|
||||||
|
/** Plays the Cities & Knights tables; this class keeps the base game. */
|
||||||
|
private val ck = CatanCkAi(this)
|
||||||
|
|
||||||
override fun chooseMove(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
|
override fun chooseMove(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
|
||||||
require(legal.isNotEmpty() || state.phase == CatanPhase.PLAYING) {
|
require(legal.isNotEmpty() || state.phase == CatanPhase.PLAYING) {
|
||||||
"No legal move for seat $seat"
|
"No legal move for seat $seat"
|
||||||
}
|
}
|
||||||
|
if (state.isCk) return ck.choose(state, seat, legal)
|
||||||
return when (state.phase) {
|
return when (state.phase) {
|
||||||
CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND ->
|
CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND ->
|
||||||
chooseSetup(state, seat, legal.filterIsInstance<SetupPlace>())
|
chooseSetup(state, seat, legal.filterIsInstance<SetupPlace>())
|
||||||
|
|
||||||
CatanPhase.AWAIT_ROLL -> legal.first { it is RollDice }
|
CatanPhase.AWAIT_ROLL -> legal.first { it is RollDice }
|
||||||
|
|
||||||
|
// Gold: take what the seat wants most.
|
||||||
|
CatanPhase.GOLD -> legal.filterIsInstance<PickGold>().maxByOrNull { pick ->
|
||||||
|
pick.cards.sumOf { want(it) }
|
||||||
|
} ?: legal.first()
|
||||||
|
|
||||||
CatanPhase.DISCARDING -> chooseDiscard(state, seat, legal.filterIsInstance<Discard>())
|
CatanPhase.DISCARDING -> chooseDiscard(state, seat, legal.filterIsInstance<Discard>())
|
||||||
|
|
||||||
CatanPhase.ROBBER -> chooseRobber(state, seat, legal.filterIsInstance<MoveRobber>())
|
CatanPhase.ROBBER -> chooseRobber(state, seat, legal.filterIsInstance<MoveRobber>())
|
||||||
@@ -42,8 +51,8 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
|
|
||||||
CatanPhase.PLAYING -> choosePlaying(state, seat, legal)
|
CatanPhase.PLAYING -> choosePlaying(state, seat, legal)
|
||||||
|
|
||||||
CatanPhase.GAME_OVER -> legal.firstOrNull()
|
CatanPhase.CHORE, CatanPhase.GAME_OVER -> legal.firstOrNull()
|
||||||
?: error("The game is over; nobody chooses a move")
|
?: error("Nothing to choose in phase ${state.phase}")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -51,7 +60,7 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
// Setup
|
// Setup
|
||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
private fun chooseSetup(state: CatanState, seat: Int, places: List<SetupPlace>): SetupPlace {
|
internal fun chooseSetup(state: CatanState, seat: Int, places: List<SetupPlace>): SetupPlace {
|
||||||
require(places.isNotEmpty()) { "No legal settlement placement" }
|
require(places.isNotEmpty()) { "No legal settlement placement" }
|
||||||
return places.maxByOrNull { place ->
|
return places.maxByOrNull { place ->
|
||||||
spotValue(state, place.vertex) +
|
spotValue(state, place.vertex) +
|
||||||
@@ -66,9 +75,10 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
* worth is what it reaches past it.
|
* worth is what it reaches past it.
|
||||||
*/
|
*/
|
||||||
private fun placeDirection(state: CatanState, place: SetupPlace): Double {
|
private fun placeDirection(state: CatanState, place: SetupPlace): Double {
|
||||||
val far = CatanBoard.otherEnd(place.edge, place.vertex)
|
val topo = state.topo
|
||||||
return CatanBoard.VERTEX_NEIGHBORS[far]
|
val far = topo.otherEnd(place.edge, place.vertex)
|
||||||
.filter { it != place.vertex && it !in CatanBoard.VERTEX_NEIGHBORS[place.vertex] }
|
return topo.VERTEX_NEIGHBORS[far]
|
||||||
|
.filter { it != place.vertex && it !in topo.VERTEX_NEIGHBORS[place.vertex] }
|
||||||
.maxOfOrNull { spotValue(state, it) }
|
.maxOfOrNull { spotValue(state, it) }
|
||||||
?: 0.0
|
?: 0.0
|
||||||
}
|
}
|
||||||
@@ -90,9 +100,9 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
require(moves.isNotEmpty()) { "No legal robber move" }
|
require(moves.isNotEmpty()) { "No legal robber move" }
|
||||||
val points = CatanRules.publicVictoryPoints(state)
|
val points = CatanRules.publicVictoryPoints(state)
|
||||||
return moves.maxByOrNull { move ->
|
return moves.maxByOrNull { move ->
|
||||||
val hex = CatanBoard.hexIndex.getValue(move.hex)
|
val hex = state.topo.hexIndex.getValue(move.hex)
|
||||||
var score = 0.0
|
var score = 0.0
|
||||||
for (v in CatanBoard.HEX_CORNERS[hex]) {
|
for (v in state.topo.HEX_CORNERS[hex]) {
|
||||||
val building = state.buildings[v] ?: continue
|
val building = state.buildings[v] ?: continue
|
||||||
if (building.owner == seat) continue
|
if (building.owner == seat) continue
|
||||||
val worth = if (building.type == BuildingType.CITY) 2 else 1
|
val worth = if (building.type == BuildingType.CITY) 2 else 1
|
||||||
@@ -120,6 +130,12 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
spotValue(state, it.vertex)
|
spotValue(state, it.vertex)
|
||||||
}?.let { return it }
|
}?.let { return it }
|
||||||
|
|
||||||
|
// Seafarers: a ship toward an island nobody has landed on is worth more than a card.
|
||||||
|
legal.filterIsInstance<BuildShip>()
|
||||||
|
.filter { shipValue(state, seat, it.edge) > 0.5 }
|
||||||
|
.maxByOrNull { shipValue(state, seat, it.edge) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
// A knight is worth playing whenever one is playable: it blocks an
|
// A knight is worth playing whenever one is playable: it blocks an
|
||||||
// opponent's best hex and marches toward Largest Army.
|
// opponent's best hex and marches toward Largest Army.
|
||||||
legal.filterIsInstance<PlayKnight>().firstOrNull()?.let { return it }
|
legal.filterIsInstance<PlayKnight>().firstOrNull()?.let { return it }
|
||||||
@@ -138,6 +154,12 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
|
|
||||||
legal.filterIsInstance<BuyDevCard>().firstOrNull()?.let { return it }
|
legal.filterIsInstance<BuyDevCard>().firstOrNull()?.let { return it }
|
||||||
|
|
||||||
|
// Seafarers: a ship that heads for a settlement spot worth having.
|
||||||
|
legal.filterIsInstance<BuildShip>()
|
||||||
|
.filter { shipValue(state, seat, it.edge) > 0.15 }
|
||||||
|
.maxByOrNull { shipValue(state, seat, it.edge) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
// A paid road only when it reaches toward a spot worth settling.
|
// A paid road only when it reaches toward a spot worth settling.
|
||||||
legal.filterIsInstance<BuildRoad>()
|
legal.filterIsInstance<BuildRoad>()
|
||||||
.filter { roadValue(state, it) > 0.1 }
|
.filter { roadValue(state, it) > 0.1 }
|
||||||
@@ -293,17 +315,17 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
/** What a seat would think of building on [vertex]: production and ports. */
|
/** What a seat would think of building on [vertex]: production and ports. */
|
||||||
private fun spotValue(state: CatanState, vertex: Int): Double {
|
internal fun spotValue(state: CatanState, vertex: Int): Double {
|
||||||
if (state.buildings[vertex] != null) return -1.0
|
if (state.buildings[vertex] != null) return -1.0
|
||||||
var value = 0.0
|
var value = 0.0
|
||||||
val kinds = mutableSetOf<Resource>()
|
val kinds = mutableSetOf<Resource>()
|
||||||
for (h in CatanBoard.VERTEX_HEXES[vertex]) {
|
for (h in state.topo.VERTEX_HEXES[vertex]) {
|
||||||
val resource = state.terrains[h].produces ?: continue
|
val resource = state.terrains[h].produces ?: continue
|
||||||
value += CatanBoard.numberOdds(state.numbers[h]) / 36.0 * want(resource)
|
value += CatanBoard.numberOdds(state.numbers[h]) / 36.0 * want(resource)
|
||||||
kinds += resource
|
kinds += resource
|
||||||
}
|
}
|
||||||
value += 0.12 * kinds.size // variety keeps a build plan alive
|
value += 0.12 * kinds.size // variety keeps a build plan alive
|
||||||
for (e in CatanBoard.VERTEX_EDGES[vertex]) {
|
for (e in state.topo.VERTEX_EDGES[vertex]) {
|
||||||
val port = state.ports.firstOrNull { it.edge == e } ?: continue
|
val port = state.ports.firstOrNull { it.edge == e } ?: continue
|
||||||
value += if (port.resource == null) 0.1 else 0.2
|
value += if (port.resource == null) 0.1 else 0.2
|
||||||
}
|
}
|
||||||
@@ -314,19 +336,56 @@ class CatanAi : GameAi<CatanState, CatanMove> {
|
|||||||
* What a road on this edge leads to: the best settlement spot it brings
|
* What a road on this edge leads to: the best settlement spot it brings
|
||||||
* within reach, discounted for being one step further out.
|
* within reach, discounted for being one step further out.
|
||||||
*/
|
*/
|
||||||
private fun roadValue(state: CatanState, move: BuildRoad): Double {
|
internal fun roadValue(state: CatanState, move: BuildRoad): Double {
|
||||||
var best = 0.0
|
var best = 0.0
|
||||||
val (from, to) = CatanBoard.EDGE_VERTICES[move.edge]
|
val (from, to) = state.topo.EDGE_VERTICES[move.edge]
|
||||||
for (endpoint in listOf(from, to)) {
|
for (endpoint in listOf(from, to)) {
|
||||||
for (near in CatanBoard.VERTEX_NEIGHBORS[endpoint]) {
|
for (near in state.topo.VERTEX_NEIGHBORS[endpoint]) {
|
||||||
best = maxOf(best, spotValue(state, near) * 0.8)
|
best = maxOf(best, spotValue(state, near) * 0.8)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return best
|
return best
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* What a ship on [edge] is heading for: the best open settlement spot reachable by sea from
|
||||||
|
* its far end (the end the fleet does not already hold), discounted by how far off it is,
|
||||||
|
* with a bonus for an island nobody has landed on.
|
||||||
|
*/
|
||||||
|
internal fun shipValue(state: CatanState, seat: Int, edge: Int): Double {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea ?: return 0.0
|
||||||
|
val (a, b) = topo.EDGE_VERTICES[edge]
|
||||||
|
fun held(v: Int): Boolean =
|
||||||
|
state.buildings[v]?.owner == seat || topo.VERTEX_EDGES[v].any { sea.ships[it] == seat }
|
||||||
|
val front = listOf(a, b).filter { !held(it) }.ifEmpty { return 0.0 }
|
||||||
|
var best = 0.0
|
||||||
|
val seen = mutableSetOf<Int>()
|
||||||
|
var frontier = front
|
||||||
|
var depth = 0
|
||||||
|
while (frontier.isNotEmpty() && depth <= 5) {
|
||||||
|
val next = mutableListOf<Int>()
|
||||||
|
for (v in frontier) {
|
||||||
|
if (!seen.add(v)) continue
|
||||||
|
if (CatanRules.vertexOpenForSettlement(state, v)) {
|
||||||
|
val island = topo.vertexIsland[v]
|
||||||
|
val fresh = island >= 0 && island != sea.home && sea.islandBonus[island] == NO_PLAYER
|
||||||
|
val value = (spotValue(state, v) + if (fresh) 0.5 else 0.0) * Math.pow(0.85, depth.toDouble())
|
||||||
|
best = maxOf(best, value)
|
||||||
|
}
|
||||||
|
for (e in topo.VERTEX_EDGES[v]) {
|
||||||
|
if (!topo.edgeSea[e] || sea.ships[e] != NO_PLAYER) continue
|
||||||
|
next += topo.otherEnd(e, v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
frontier = next
|
||||||
|
depth++
|
||||||
|
}
|
||||||
|
return best
|
||||||
|
}
|
||||||
|
|
||||||
/** How much the AI wants to hold one card of [resource]. */
|
/** How much the AI wants to hold one card of [resource]. */
|
||||||
private fun want(resource: Resource): Double = when (resource) {
|
internal fun want(resource: Resource): Double = when (resource) {
|
||||||
Resource.ORE -> 1.20 // the city
|
Resource.ORE -> 1.20 // the city
|
||||||
Resource.GRAIN -> 1.15 // the city and the dev cards
|
Resource.GRAIN -> 1.15 // the city and the dev cards
|
||||||
Resource.LUMBER -> 1.0 // every road and settlement
|
Resource.LUMBER -> 1.0 // every road and settlement
|
||||||
|
|||||||
@@ -5,13 +5,14 @@ import kotlin.math.atan2
|
|||||||
import kotlin.random.Random
|
import kotlin.random.Random
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The island as geometry: the 19 hexes, the 54 shared vertices, the 72
|
* The geometry of one board: its hexes, the shared vertices and edges between
|
||||||
* shared edges, the coast and the nine harbour positions.
|
* them, and which hexes are land.
|
||||||
*
|
*
|
||||||
* Everything is derived once, deterministically, from axial coordinates —
|
* Everything is derived once, deterministically, from axial coordinates —
|
||||||
* there is no randomness and no state here; the layout of a particular
|
* 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
|
* game (which terrain and number sits on which hex) is generated elsewhere
|
||||||
* live state lives in [CatanState].
|
* ([CatanBoard.generate], [SeaBoards.generate]), and the live state lives in
|
||||||
|
* [CatanState].
|
||||||
*
|
*
|
||||||
* Coordinates: hexes are addressed axially ((q, r), pointy-top). Every
|
* Coordinates: hexes are addressed axially ((q, r), pointy-top). Every
|
||||||
* position is kept on an exact integer lattice so vertices shared by
|
* position is kept on an exact integer lattice so vertices shared by
|
||||||
@@ -20,41 +21,25 @@ import kotlin.random.Random
|
|||||||
* six corners follow the offsets in [CORNER_OFFSETS]. Vertex positions are
|
* six corners follow the offsets in [CORNER_OFFSETS]. Vertex positions are
|
||||||
* in half-units of the hex grid; rendering scales and flips them (lattice
|
* in half-units of the hex grid; rendering scales and flips them (lattice
|
||||||
* +Y is toward the top of the board).
|
* +Y is toward the top of the board).
|
||||||
|
*
|
||||||
|
* The standard island ([CatanBoard.base]) is the 19-hex hexagon. A Seafarers
|
||||||
|
* map is a larger frame whose hexes are mostly sea; [land] says which.
|
||||||
*/
|
*/
|
||||||
object CatanBoard {
|
class Topology(
|
||||||
|
/** Every hex of the frame, land and sea alike. */
|
||||||
/** The 19 hexes: every (q, r) within distance 2 of the centre. */
|
val HEXES: List<HexCoord>,
|
||||||
val HEXES: List<HexCoord> = buildList {
|
/** Whether each hex is land. The base island is all land; Seafarers maps are mostly sea. */
|
||||||
for (r in -2..2) {
|
val land: List<Boolean> = List(HEXES.size) { true },
|
||||||
for (q in -2..2) {
|
/** The standard 19-hex island: checks its counts and uses the fixed nine-harbour frame. */
|
||||||
if (hexDistance(q, r, 0, 0) <= 2) add(HexCoord(q, r))
|
private val standardFrame: Boolean = false,
|
||||||
}
|
/** Harbours wanted on a non-standard map. */
|
||||||
}
|
harbours: Int = 0,
|
||||||
}
|
) {
|
||||||
|
|
||||||
val HEX_COUNT: Int = HEXES.size
|
val HEX_COUNT: Int = HEXES.size
|
||||||
|
|
||||||
val hexIndex: Map<HexCoord, Int> = HEXES.withIndex().associate { (i, hex) -> hex to i }
|
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
|
// Vertices and edges
|
||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
@@ -93,9 +78,28 @@ object CatanBoard {
|
|||||||
/** The coastal edges (those with only one hex) in ring order. */
|
/** The coastal edges (those with only one hex) in ring order. */
|
||||||
val COASTAL: List<Int>
|
val COASTAL: List<Int>
|
||||||
|
|
||||||
/** The nine fixed harbour positions, spread around the coast. */
|
/** The harbour positions: nine on the standard frame. */
|
||||||
val PORT_POSITIONS: List<Int>
|
val PORT_POSITIONS: List<Int>
|
||||||
|
|
||||||
|
// --- Land and sea (all land on the standard island) --------------------
|
||||||
|
|
||||||
|
/** A settlement may stand here: at least one of its hexes is land. */
|
||||||
|
val vertexLand: List<Boolean>
|
||||||
|
|
||||||
|
/** A road may lie here: at least one of its hexes is land. */
|
||||||
|
val edgeLand: List<Boolean>
|
||||||
|
|
||||||
|
/** A ship may sail here: at least one of its hexes is sea. */
|
||||||
|
val edgeSea: List<Boolean>
|
||||||
|
|
||||||
|
/** Which island each hex is on (a connected group of land hexes), or -1 for sea. */
|
||||||
|
val islandOf: List<Int>
|
||||||
|
|
||||||
|
val islandCount: Int
|
||||||
|
|
||||||
|
/** Which island each vertex touches, or -1 for open water. */
|
||||||
|
val vertexIsland: List<Int>
|
||||||
|
|
||||||
init {
|
init {
|
||||||
// Vertices: assign ids in first-seen order over hexes then corners.
|
// Vertices: assign ids in first-seen order over hexes then corners.
|
||||||
val vertexIds = mutableMapOf<Pair<Int, Int>, Int>()
|
val vertexIds = mutableMapOf<Pair<Int, Int>, Int>()
|
||||||
@@ -169,21 +173,55 @@ object CatanBoard {
|
|||||||
|
|
||||||
// The coast in walking order: sort the coastal edges by the angle of
|
// The coast in walking order: sort the coastal edges by the angle of
|
||||||
// their midpoint around the board centre, which is the lattice
|
// their midpoint around the board centre, which is the lattice
|
||||||
// origin. The board is a hexagon, so this yields one closed ring.
|
// origin. The standard board is a hexagon, so this yields one closed ring.
|
||||||
COASTAL = EDGE_HEXES.withIndex()
|
COASTAL = EDGE_HEXES.withIndex()
|
||||||
.filter { it.value.size == 1 }
|
.filter { it.value.size == 1 }
|
||||||
.map { (e, _) -> e }
|
.map { (e, _) -> e }
|
||||||
.sortedBy { e -> angleOf(midpoint(e)) }
|
.sortedBy { e -> angleOf(midpoint(e)) }
|
||||||
|
|
||||||
|
vertexLand = List(VERTEX_COUNT) { v -> VERTEX_HEXES[v].any { land[it] } }
|
||||||
|
edgeLand = List(EDGE_COUNT) { e -> EDGE_HEXES[e].any { land[it] } }
|
||||||
|
edgeSea = List(EDGE_COUNT) { e -> EDGE_HEXES[e].any { !land[it] } }
|
||||||
|
|
||||||
|
// Islands: connected groups of land hexes.
|
||||||
|
val island = IntArray(HEX_COUNT) { -1 }
|
||||||
|
var islands = 0
|
||||||
|
for (h in 0 until HEX_COUNT) {
|
||||||
|
if (!land[h] || island[h] != -1) continue
|
||||||
|
val stack = ArrayDeque(listOf(h))
|
||||||
|
island[h] = islands
|
||||||
|
while (stack.isNotEmpty()) {
|
||||||
|
val at = stack.removeLast()
|
||||||
|
for (n in HEX_NEIGHBORS[at]) {
|
||||||
|
if (land[n] && island[n] == -1) {
|
||||||
|
island[n] = islands
|
||||||
|
stack.addLast(n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
islands++
|
||||||
|
}
|
||||||
|
islandOf = island.toList()
|
||||||
|
islandCount = islands
|
||||||
|
vertexIsland = List(VERTEX_COUNT) { v ->
|
||||||
|
VERTEX_HEXES[v].firstOrNull { land[it] }?.let { island[it] } ?: -1
|
||||||
|
}
|
||||||
|
|
||||||
|
PORT_POSITIONS = if (standardFrame) {
|
||||||
// Harbours sit roughly every third or fourth coastal edge, like the
|
// Harbours sit roughly every third or fourth coastal edge, like the
|
||||||
// physical frame: nine positions, steps summing to the whole ring.
|
// physical frame: nine positions, steps summing to the whole ring.
|
||||||
PORT_POSITIONS = buildList {
|
buildList {
|
||||||
var at = 0
|
var at = 0
|
||||||
for (step in listOf(3, 4, 3, 3, 4, 3, 3, 4, 3)) {
|
for (step in listOf(3, 4, 3, 3, 4, 3, 3, 4, 3)) {
|
||||||
add(COASTAL[at % COASTAL.size])
|
add(COASTAL[at % COASTAL.size])
|
||||||
at += step
|
at += step
|
||||||
}
|
}
|
||||||
}.distinct()
|
}.distinct()
|
||||||
|
} else {
|
||||||
|
seaPorts(harbours)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (standardFrame) {
|
||||||
check(HEX_COUNT == 19) { "A Catan island has 19 hexes, found $HEX_COUNT" }
|
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(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(EDGE_COUNT == 72) { "A Catan island has 72 edges, found $EDGE_COUNT" }
|
||||||
@@ -191,6 +229,44 @@ object CatanBoard {
|
|||||||
check(PORT_POSITIONS.size == 9) { "Nine harbours, found ${PORT_POSITIONS.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" }
|
check(PORT_POSITIONS.all { EDGE_HEXES[it].size == 1 }) { "Harbours must be coastal" }
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Harbour sites on a map with islands: edges where land meets sea, taken
|
||||||
|
* round the map by angle about the land's centre, [count] of them as evenly
|
||||||
|
* spaced as the coast allows, never two sharing a corner.
|
||||||
|
*/
|
||||||
|
private fun seaPorts(count: Int): List<Int> {
|
||||||
|
if (count <= 0) return emptyList()
|
||||||
|
val shore = (0 until EDGE_COUNT).filter { e ->
|
||||||
|
EDGE_HEXES[e].size == 2 && EDGE_HEXES[e].any { land[it] } && EDGE_HEXES[e].any { !land[it] }
|
||||||
|
}
|
||||||
|
if (shore.isEmpty()) return emptyList()
|
||||||
|
val landCentre = HEXES.indices.filter { land[it] }.let { hs ->
|
||||||
|
val pts = hs.map { hexCenter(it) }
|
||||||
|
(pts.sumOf { it.first } / pts.size.toDouble()) to (pts.sumOf { it.second } / pts.size.toDouble())
|
||||||
|
}
|
||||||
|
val ring = shore.sortedBy { e ->
|
||||||
|
val m = midpoint(e)
|
||||||
|
atan2(m.second - landCentre.second, m.first - landCentre.first)
|
||||||
|
}
|
||||||
|
val picked = mutableListOf<Int>()
|
||||||
|
val used = mutableSetOf<Int>()
|
||||||
|
val step = ring.size.toDouble() / count
|
||||||
|
for (i in 0 until count) {
|
||||||
|
val start = (i * step).toInt()
|
||||||
|
// The first edge at or after the ideal spot whose corners are free.
|
||||||
|
val e = (0 until ring.size).map { ring[(start + it) % ring.size] }.firstOrNull { cand ->
|
||||||
|
val (a, b) = EDGE_VERTICES[cand]
|
||||||
|
a !in used && b !in used && cand !in picked
|
||||||
|
} ?: continue
|
||||||
|
picked += e
|
||||||
|
val (a, b) = EDGE_VERTICES[e]
|
||||||
|
used += a
|
||||||
|
used += b
|
||||||
|
}
|
||||||
|
return picked
|
||||||
|
}
|
||||||
|
|
||||||
/** The other endpoint of [edge], given one [vertex] on it. */
|
/** The other endpoint of [edge], given one [vertex] on it. */
|
||||||
fun otherEnd(edge: Int, vertex: Int): Int {
|
fun otherEnd(edge: Int, vertex: Int): Int {
|
||||||
@@ -207,6 +283,38 @@ object CatanBoard {
|
|||||||
/** Whether two hexes share an edge. */
|
/** Whether two hexes share an edge. */
|
||||||
fun hexesAdjacent(a: Int, b: Int): Boolean = b in HEX_NEIGHBORS[a]
|
fun hexesAdjacent(a: Int, b: Int): Boolean = b in HEX_NEIGHBORS[a]
|
||||||
|
|
||||||
|
/** Lattice extent of the whole frame: min x, max x, min y, max y. */
|
||||||
|
val lattice: IntArray by lazy {
|
||||||
|
intArrayOf(
|
||||||
|
VERTEX_POS.minOf { it.first }, VERTEX_POS.maxOf { it.first },
|
||||||
|
VERTEX_POS.minOf { it.second }, VERTEX_POS.maxOf { it.second },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
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)
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
/**
|
||||||
|
* 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,
|
||||||
|
)
|
||||||
|
|
||||||
/** Hex-grid distance between two axial positions. */
|
/** Hex-grid distance between two axial positions. */
|
||||||
fun hexDistance(q1: Int, r1: Int, q2: Int, r2: Int): Int {
|
fun hexDistance(q1: Int, r1: Int, q2: Int, r2: Int): Int {
|
||||||
val dq = q1 - q2
|
val dq = q1 - q2
|
||||||
@@ -219,16 +327,57 @@ object CatanBoard {
|
|||||||
* 8 comes up five times in thirty-six, a 2 or a 12 once.
|
* 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)
|
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)
|
* The standard island: the 19 hexes, the 54 shared vertices, the 72 shared
|
||||||
|
* edges, the coast and the nine harbour positions. Every table below is the
|
||||||
|
* standard frame's [Topology]; the rules read the topology of the *state* they
|
||||||
|
* are working on ([CatanState.topo]), which is this one in every game but Seafarers.
|
||||||
|
*/
|
||||||
|
object CatanBoard {
|
||||||
|
|
||||||
|
/** The standard island's geometry. */
|
||||||
|
val base: Topology = Topology(
|
||||||
|
HEXES = buildList {
|
||||||
|
for (r in -2..2) {
|
||||||
|
for (q in -2..2) {
|
||||||
|
if (Topology.hexDistance(q, r, 0, 0) <= 2) add(HexCoord(q, r))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
standardFrame = true,
|
||||||
|
)
|
||||||
|
|
||||||
|
val HEXES: List<HexCoord> get() = base.HEXES
|
||||||
|
val HEX_COUNT: Int get() = base.HEX_COUNT
|
||||||
|
val hexIndex: Map<HexCoord, Int> get() = base.hexIndex
|
||||||
|
val VERTEX_POS: List<Pair<Int, Int>> get() = base.VERTEX_POS
|
||||||
|
val VERTEX_COUNT: Int get() = base.VERTEX_COUNT
|
||||||
|
val HEX_CORNERS: List<List<Int>> get() = base.HEX_CORNERS
|
||||||
|
val EDGE_VERTICES: List<Pair<Int, Int>> get() = base.EDGE_VERTICES
|
||||||
|
val EDGE_COUNT: Int get() = base.EDGE_COUNT
|
||||||
|
val VERTEX_EDGES: List<List<Int>> get() = base.VERTEX_EDGES
|
||||||
|
val VERTEX_NEIGHBORS: List<List<Int>> get() = base.VERTEX_NEIGHBORS
|
||||||
|
val VERTEX_HEXES: List<List<Int>> get() = base.VERTEX_HEXES
|
||||||
|
val EDGE_HEXES: List<List<Int>> get() = base.EDGE_HEXES
|
||||||
|
val EDGE_NEIGHBORS: List<List<Int>> get() = base.EDGE_NEIGHBORS
|
||||||
|
val HEX_NEIGHBORS: List<List<Int>> get() = base.HEX_NEIGHBORS
|
||||||
|
val COASTAL: List<Int> get() = base.COASTAL
|
||||||
|
val PORT_POSITIONS: List<Int> get() = base.PORT_POSITIONS
|
||||||
|
|
||||||
|
fun otherEnd(edge: Int, vertex: Int): Int = base.otherEnd(edge, vertex)
|
||||||
|
fun hexCenter(h: Int): Pair<Int, Int> = base.hexCenter(h)
|
||||||
|
fun hexesAdjacent(a: Int, b: Int): Boolean = base.hexesAdjacent(a, b)
|
||||||
|
fun hexDistance(q1: Int, r1: Int, q2: Int, r2: Int): Int = Topology.hexDistance(q1, r1, q2, r2)
|
||||||
|
fun numberOdds(number: Int): Int = Topology.numberOdds(number)
|
||||||
|
|
||||||
|
/** 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),
|
||||||
|
)
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
// Island generation
|
// Island generation
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,345 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The computer opponent for Cities & Knights, reached through [CatanAi].
|
||||||
|
*
|
||||||
|
* It plays the same cautious game as the base AI — settle well, raise cities —
|
||||||
|
* and adds the three things this rule set asks of a player: keep enough active
|
||||||
|
* knights standing when the barbarians land, spend commodities on improvements
|
||||||
|
* as soon as it can, and answer every chore the table raises with the card it
|
||||||
|
* values least. It reads only what a player at the table could see, plus its
|
||||||
|
* own hand.
|
||||||
|
*
|
||||||
|
* It is not a strong player. It never moves knights about (they stay where
|
||||||
|
* hired, and are activated when the barbarians draw near), never plays the
|
||||||
|
* progress cards whose value depends on a plan (Inventor, Alchemist, Diplomat,
|
||||||
|
* Deserter, Intrigue), and makes no domestic offers, though it answers them.
|
||||||
|
*/
|
||||||
|
internal class CatanCkAi(private val ai: CatanAi) {
|
||||||
|
|
||||||
|
fun choose(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove = when (state.phase) {
|
||||||
|
CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND ->
|
||||||
|
ai.chooseSetup(state, seat, legal.filterIsInstance<SetupPlace>())
|
||||||
|
|
||||||
|
CatanPhase.AWAIT_ROLL -> legal.first { it is RollDice }
|
||||||
|
|
||||||
|
CatanPhase.CHORE -> chooseChore(state, seat, legal)
|
||||||
|
|
||||||
|
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.DISCARDING, CatanPhase.GOLD, CatanPhase.GAME_OVER -> legal.firstOrNull()
|
||||||
|
?: error("Nothing to choose in phase ${state.phase}")
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Chores
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
private fun chooseChore(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
|
||||||
|
val ck = state.ck!!
|
||||||
|
return when (val chore = ck.chores.first()) {
|
||||||
|
is DiscardChore -> {
|
||||||
|
val n = minOf(chore.count, CatanCk.goodsCount(state, seat))
|
||||||
|
DiscardGoods(CatanCk.goodsList(state, seat).sortedBy { worth(state, seat, it) }.take(n))
|
||||||
|
}
|
||||||
|
|
||||||
|
is GiveChore -> {
|
||||||
|
val pool = CatanCk.goodsList(state, seat)
|
||||||
|
.filter { !chore.commoditiesOnly || it.isCommodity }
|
||||||
|
.sortedBy { worth(state, seat, it) }
|
||||||
|
GiveGoods(pool.take(minOf(chore.count, pool.size)))
|
||||||
|
}
|
||||||
|
|
||||||
|
is PillageChore ->
|
||||||
|
legal.filterIsInstance<PillageCity>().minByOrNull { production(state, it.vertex) } ?: legal.first()
|
||||||
|
|
||||||
|
is PickDeckChore -> {
|
||||||
|
val picks = legal.filterIsInstance<PickDeck>()
|
||||||
|
picks.maxByOrNull { CatanCk.improvement(state, seat, it.track) } ?: legal.first()
|
||||||
|
}
|
||||||
|
|
||||||
|
is DropProgressChore ->
|
||||||
|
legal.filterIsInstance<DropProgress>().minByOrNull { drop ->
|
||||||
|
ck.progressHands[seat].first { it.id == drop.card }.kind.let(::cardWorth)
|
||||||
|
} ?: legal.first()
|
||||||
|
|
||||||
|
is MetropolisChore ->
|
||||||
|
legal.filterIsInstance<PlaceMetropolis>().maxByOrNull { production(state, it.vertex) }
|
||||||
|
?: legal.first()
|
||||||
|
|
||||||
|
is AqueductChore ->
|
||||||
|
legal.filterIsInstance<TakeAqueduct>().maxByOrNull { ai.want(it.resource) } ?: legal.first()
|
||||||
|
|
||||||
|
is RelocateChore -> legal.first()
|
||||||
|
|
||||||
|
is RemoveKnightChore ->
|
||||||
|
legal.filterIsInstance<RemoveKnight>().minByOrNull {
|
||||||
|
CatanCk.knightAt(state, it.vertex)?.level ?: 0
|
||||||
|
} ?: legal.first()
|
||||||
|
|
||||||
|
is PlaceKnightChore -> legal.first()
|
||||||
|
|
||||||
|
is SpyChore -> legal.first()
|
||||||
|
|
||||||
|
is SmithChore ->
|
||||||
|
legal.filterIsInstance<PromoteKnight>().firstOrNull() ?: legal.first { it is EndSmith }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// The robber
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
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
|
||||||
|
val worth = if (building.type == BuildingType.CITY) 2 else 1
|
||||||
|
val odds = CatanBoard.numberOdds(state.numbers[hex]) / 36.0
|
||||||
|
score += if (building.owner == seat) -worth * odds else worth * odds
|
||||||
|
}
|
||||||
|
if (move.victim != null) {
|
||||||
|
score += 0.15 * CatanCk.goodsCount(state, move.victim) + 0.3 * points[move.victim]
|
||||||
|
}
|
||||||
|
score
|
||||||
|
} ?: moves.first()
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// The main phase
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
private fun choosePlaying(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
|
||||||
|
val ck = state.ck!!
|
||||||
|
val soon = ck.barbarians <= 3
|
||||||
|
|
||||||
|
// Chase the robber off a hex it is squatting on.
|
||||||
|
if (ck.attacked) {
|
||||||
|
val onMine = legal.filterIsInstance<ChaseRobber>().firstOrNull()
|
||||||
|
val robberHurtsMe = CatanBoard.HEX_CORNERS[state.robber].any { state.buildings[it]?.owner == seat }
|
||||||
|
if (onMine != null && robberHurtsMe) return onMine
|
||||||
|
}
|
||||||
|
|
||||||
|
// The cheap upgrade first, then the full-price one.
|
||||||
|
legal.filterIsInstance<PlayProgress>()
|
||||||
|
.filter { kindOf(state, seat, it) == ProgressType.MEDICINE }
|
||||||
|
.maxByOrNull { production(state, it.vertex!!) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
legal.filterIsInstance<BuildCity>().maxByOrNull { production(state, it.vertex) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
legal.filterIsInstance<BuildSettlement>().maxByOrNull { ai.spotValue(state, it.vertex) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
// Improvements spend cards nothing else needs. Favour the track furthest along.
|
||||||
|
legal.filterIsInstance<BuyImprovement>()
|
||||||
|
.maxByOrNull { CatanCk.improvement(state, seat, it.track) * 10 + trackLean(it.track) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
// Knights: stand ready by the time the barbarians land.
|
||||||
|
defence(state, seat, legal, soon)?.let { return it }
|
||||||
|
|
||||||
|
progress(state, seat, legal)?.let { return it }
|
||||||
|
|
||||||
|
legal.filterIsInstance<BuildWall>().firstOrNull()?.let {
|
||||||
|
if (CatanCk.goodsCount(state, seat) >= 7) return it
|
||||||
|
}
|
||||||
|
|
||||||
|
legal.filterIsInstance<BuildRoad>()
|
||||||
|
.filter { ai.roadValue(state, it) > 0.1 }
|
||||||
|
.maxByOrNull { ai.roadValue(state, it) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
legal.filterIsInstance<GoodsBankTrade>()
|
||||||
|
.filter { completes(state, seat, it) }
|
||||||
|
.minByOrNull { CatanCk.bankRatio(state, seat, it.give) }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
return legal.lastOrNull { it is EndTurn } ?: legal.first()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Hire, promote and activate so the knights are standing when the barbarians land. */
|
||||||
|
private fun defence(state: CatanState, seat: Int, legal: List<CatanMove>, soon: Boolean): CatanMove? {
|
||||||
|
val mine = CatanCk.knightsOf(state, seat)
|
||||||
|
val grainLeft = state.resources[seat][Resource.GRAIN] ?: 0
|
||||||
|
|
||||||
|
if (soon) {
|
||||||
|
legal.filterIsInstance<ActivateKnight>().firstOrNull()?.let { return it }
|
||||||
|
}
|
||||||
|
val want = if (soon) 4 else 2
|
||||||
|
if (mine.size < want) {
|
||||||
|
legal.filterIsInstance<HireKnight>().maxByOrNull { ai.spotValue(state, it.vertex) }?.let { hire ->
|
||||||
|
// Keep a grain back for waking it, once the ship is close.
|
||||||
|
if (!soon || grainLeft >= 1) return hire
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (soon || mine.size >= 2) {
|
||||||
|
legal.filterIsInstance<PromoteKnight>().firstOrNull()?.let { return it }
|
||||||
|
}
|
||||||
|
if (soon) {
|
||||||
|
legal.filterIsInstance<ActivateKnight>().firstOrNull()?.let { return it }
|
||||||
|
}
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Progress cards worth playing without a plan. */
|
||||||
|
private fun progress(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove? {
|
||||||
|
val ck = state.ck!!
|
||||||
|
val soon = ck.barbarians <= 4
|
||||||
|
val plays = legal.filterIsInstance<PlayProgress>()
|
||||||
|
fun kindOf(play: PlayProgress) = ck.progressHands[seat].first { it.id == play.card }.kind
|
||||||
|
fun first(kind: ProgressType) = plays.firstOrNull { kindOf(it) == kind }
|
||||||
|
|
||||||
|
first(ProgressType.IRRIGATION)?.let { return it }
|
||||||
|
first(ProgressType.MINING)?.let { return it }
|
||||||
|
first(ProgressType.ENGINEER)?.let { return it }
|
||||||
|
first(ProgressType.SMITH)?.let { return it }
|
||||||
|
first(ProgressType.WEDDING)?.let { return it }
|
||||||
|
if (soon) first(ProgressType.WARLORD)?.let { return it }
|
||||||
|
|
||||||
|
plays.filter { kindOf(it) == ProgressType.MASTER_MERCHANT }
|
||||||
|
.maxByOrNull { play -> play.goods.orEmpty().sumOf { worth(state, seat, it) } }
|
||||||
|
?.let { return it }
|
||||||
|
|
||||||
|
first(ProgressType.SPY)?.let { return it }
|
||||||
|
first(ProgressType.BISHOP)?.let { return it }
|
||||||
|
|
||||||
|
if (legal.filterIsInstance<BuildRoad>().size >= 2) first(ProgressType.ROAD_BUILDING)?.let { return it }
|
||||||
|
|
||||||
|
// Crane: only when it makes the difference to an improvement.
|
||||||
|
first(ProgressType.CRANE)?.let { crane ->
|
||||||
|
val helps = Track.entries.any { track ->
|
||||||
|
val level = CatanCk.improvement(state, seat, track)
|
||||||
|
val have = ck.commodities[seat][track.commodity] ?: 0
|
||||||
|
level < IMPROVEMENT_MAX && have == level // one short of the next level's price
|
||||||
|
}
|
||||||
|
if (helps) return crane
|
||||||
|
}
|
||||||
|
|
||||||
|
// Saboteur: when someone level or ahead is sitting on a pile.
|
||||||
|
first(ProgressType.SABOTEUR)?.let { saboteur ->
|
||||||
|
val vp = CatanRules.publicVictoryPoints(state)
|
||||||
|
val pile = (0 until state.playerCount).filter { it != seat && vp[it] >= vp[seat] }
|
||||||
|
.sumOf { CatanCk.goodsCount(state, it) / 2 }
|
||||||
|
if (pile >= 4) return saboteur
|
||||||
|
}
|
||||||
|
|
||||||
|
// Monopolies: only when the table is holding a pile of it.
|
||||||
|
plays.filter { kindOf(it) == ProgressType.RESOURCE_MONOPOLY || kindOf(it) == ProgressType.TRADE_MONOPOLY }
|
||||||
|
.maxByOrNull { held(state, seat, it.good!!) }
|
||||||
|
?.let { best ->
|
||||||
|
val each = if (kindOf(best) == ProgressType.RESOURCE_MONOPOLY) 2 else 1
|
||||||
|
val take = (0 until state.playerCount).filter { it != seat }
|
||||||
|
.sumOf { minOf(each, CatanCk.goodsOf(state, it)[best.good!!] ?: 0) }
|
||||||
|
if (take >= 3) return best
|
||||||
|
}
|
||||||
|
|
||||||
|
// The merchant, on the best hex beside a building of ours.
|
||||||
|
plays.filter { kindOf(it) == ProgressType.MERCHANT }
|
||||||
|
.maxByOrNull { play ->
|
||||||
|
val hex = play.hexA!!
|
||||||
|
CatanBoard.numberOdds(state.numbers[hex]).toDouble()
|
||||||
|
}?.let { return it }
|
||||||
|
|
||||||
|
// A commercial harbour turns spare resources into commodities.
|
||||||
|
plays.filter { kindOf(it) == ProgressType.COMMERCIAL_HARBOR }
|
||||||
|
.maxByOrNull { held(state, seat, it.good!!) }
|
||||||
|
?.let { if (held(state, seat, it.good!!) >= 2) return it }
|
||||||
|
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun kindOf(state: CatanState, seat: Int, play: PlayProgress): ProgressType =
|
||||||
|
state.ck!!.progressHands[seat].first { it.id == play.card }.kind
|
||||||
|
|
||||||
|
/** What a building on [vertex] would draw, by the odds of its hexes and what the seat wants. */
|
||||||
|
private fun production(state: CatanState, vertex: Int): Double =
|
||||||
|
CatanBoard.VERTEX_HEXES[vertex].sumOf { h ->
|
||||||
|
val want = state.terrains[h].produces?.let { ai.want(it) } ?: 0.0
|
||||||
|
want * CatanBoard.numberOdds(state.numbers[h]) / 36.0
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun held(state: CatanState, seat: Int, good: Good): Int = CatanCk.goodsOf(state, seat)[good] ?: 0
|
||||||
|
|
||||||
|
/** Whether the trade leaves a hand that can pay for a city, a settlement or an improvement. */
|
||||||
|
private fun completes(state: CatanState, seat: Int, trade: GoodsBankTrade): Boolean {
|
||||||
|
val hand = CatanCk.goodsOf(state, seat).toMutableMap()
|
||||||
|
hand[trade.give] = (hand[trade.give] ?: 0) - CatanCk.bankRatio(state, seat, trade.give)
|
||||||
|
hand[trade.get] = (hand[trade.get] ?: 0) + 1
|
||||||
|
fun covers(cost: Map<Resource, Int>) = cost.all { (r, n) -> (hand[Good.of(r)] ?: 0) >= n }
|
||||||
|
if (covers(CatanRules.CITY_COST) || covers(CatanRules.SETTLEMENT_COST)) return true
|
||||||
|
return Track.entries.any { track ->
|
||||||
|
val level = CatanCk.improvement(state, seat, track)
|
||||||
|
level < IMPROVEMENT_MAX &&
|
||||||
|
(hand[Good.of(track.commodity)] ?: 0) >= level + 1 &&
|
||||||
|
(state.ck!!.commodities[seat][track.commodity] ?: 0) < level + 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun chooseFreeRoad(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove =
|
||||||
|
legal.filterIsInstance<BuildRoad>()
|
||||||
|
.filter { ai.roadValue(state, it) > 0.05 }
|
||||||
|
.maxByOrNull { ai.roadValue(state, it) }
|
||||||
|
?: legal.firstOrNull { it is EndFreeRoads }
|
||||||
|
?: legal.first()
|
||||||
|
|
||||||
|
private fun chooseResponse(state: CatanState, seat: Int, legal: List<CatanMove>): CatanMove {
|
||||||
|
val decline = legal.first { it is DeclineTrade }
|
||||||
|
val accept = legal.firstOrNull { it is AcceptTrade } ?: return decline
|
||||||
|
val offer = state.ck?.goodsOffer
|
||||||
|
if (offer != null) {
|
||||||
|
val incoming = offer.give.sumOf { worth(state, seat, it) }
|
||||||
|
val outgoing = offer.get.sumOf { worth(state, seat, it) }
|
||||||
|
return if (incoming > outgoing) accept else decline
|
||||||
|
}
|
||||||
|
val plain = state.pendingTrade ?: return decline
|
||||||
|
val incoming = plain.give.sumOf { ai.want(it) }
|
||||||
|
val outgoing = plain.get.sumOf { ai.want(it) }
|
||||||
|
return if (incoming > outgoing) accept else decline
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Counters to a human's... the AI never makes an offer, so this only guards the phase: take none. */
|
||||||
|
private fun chooseCounter(state: CatanState, legal: List<CatanMove>): CatanMove =
|
||||||
|
legal.firstOrNull { it is DismissCounters } ?: legal.first()
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Valuations
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** What a card is worth to this seat: resources as the base AI sees them, commodities by what they buy. */
|
||||||
|
private fun worth(state: CatanState, seat: Int, good: Good): Double =
|
||||||
|
good.resource?.let { ai.want(it) } ?: when (good) {
|
||||||
|
Good.PAPER -> 0.95
|
||||||
|
Good.COIN -> 0.9
|
||||||
|
else -> 0.85
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Which track to lean toward when two are level: politics for the knights, then science. */
|
||||||
|
private fun trackLean(track: Track): Int = when (track) {
|
||||||
|
Track.POLITICS -> 2
|
||||||
|
Track.SCIENCE -> 1
|
||||||
|
Track.TRADE -> 0
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun cardWorth(kind: ProgressType): Double = when (kind) {
|
||||||
|
ProgressType.INVENTOR, ProgressType.ALCHEMIST, ProgressType.DIPLOMAT,
|
||||||
|
ProgressType.DESERTER, ProgressType.INTRIGUE, ProgressType.MERCHANT_FLEET,
|
||||||
|
-> 0.0
|
||||||
|
|
||||||
|
ProgressType.MERCHANT, ProgressType.COMMERCIAL_HARBOR, ProgressType.CRANE -> 0.5
|
||||||
|
else -> 1.0
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,486 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.SerialName
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The data of the Cities & Knights rule set. The rules themselves live in
|
||||||
|
* [CatanCk]; docs/RULES-catan-ck.md describes them and the choices made.
|
||||||
|
*
|
||||||
|
* Everything here is reached through [CatanState.ck], which is null for the
|
||||||
|
* base game, so a base game never sees any of it.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/** Steps the barbarian ship must make before it lands. */
|
||||||
|
const val BARBARIAN_STEPS = 7
|
||||||
|
|
||||||
|
/** Commodity cards of each type the bank starts with (resources have 19). */
|
||||||
|
const val BANK_PER_COMMODITY = 12
|
||||||
|
|
||||||
|
/** Knights of each strength one player owns. */
|
||||||
|
const val KNIGHTS_PER_LEVEL = 2
|
||||||
|
|
||||||
|
/** City walls one player owns. */
|
||||||
|
const val MAX_WALLS = 3
|
||||||
|
|
||||||
|
/** Levels of city improvement in each track. */
|
||||||
|
const val IMPROVEMENT_MAX = 5
|
||||||
|
|
||||||
|
/** Progress cards a player may keep in hand. */
|
||||||
|
const val PROGRESS_HAND_MAX = 4
|
||||||
|
|
||||||
|
/** Cards a player may hold through a seven, before walls. */
|
||||||
|
const val BASE_HAND_LIMIT = 7
|
||||||
|
|
||||||
|
/** Longest Road is worth two points here; there is no Largest Army. */
|
||||||
|
const val CK_LONGEST_ROAD_VP = 2
|
||||||
|
|
||||||
|
/** Improvement level that unlocks the track's special power. */
|
||||||
|
const val IMPROVEMENT_POWER_LEVEL = 3
|
||||||
|
|
||||||
|
/** Level at which a track can claim its metropolis, and the level that can steal one. */
|
||||||
|
const val METROPOLIS_LEVEL = 4
|
||||||
|
|
||||||
|
/**
|
||||||
|
* What the three cities-of-industry give in place of a second resource:
|
||||||
|
* forest gives paper, pasture cloth and mountains coin.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
enum class Commodity { CLOTH, COIN, PAPER }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Any card a player can hold in hand and trade: a resource or a commodity.
|
||||||
|
* Progress cards are not goods.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
enum class Good {
|
||||||
|
LUMBER, BRICK, WOOL, GRAIN, ORE, CLOTH, COIN, PAPER;
|
||||||
|
|
||||||
|
val resource: Resource?
|
||||||
|
get() = when (this) {
|
||||||
|
LUMBER -> Resource.LUMBER
|
||||||
|
BRICK -> Resource.BRICK
|
||||||
|
WOOL -> Resource.WOOL
|
||||||
|
GRAIN -> Resource.GRAIN
|
||||||
|
ORE -> Resource.ORE
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
|
||||||
|
val commodity: Commodity?
|
||||||
|
get() = when (this) {
|
||||||
|
CLOTH -> Commodity.CLOTH
|
||||||
|
COIN -> Commodity.COIN
|
||||||
|
PAPER -> Commodity.PAPER
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
|
||||||
|
val isCommodity: Boolean get() = commodity != null
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
fun of(resource: Resource): Good = when (resource) {
|
||||||
|
Resource.LUMBER -> LUMBER
|
||||||
|
Resource.BRICK -> BRICK
|
||||||
|
Resource.WOOL -> WOOL
|
||||||
|
Resource.GRAIN -> GRAIN
|
||||||
|
Resource.ORE -> ORE
|
||||||
|
}
|
||||||
|
|
||||||
|
fun of(commodity: Commodity): Good = when (commodity) {
|
||||||
|
Commodity.CLOTH -> CLOTH
|
||||||
|
Commodity.COIN -> COIN
|
||||||
|
Commodity.PAPER -> PAPER
|
||||||
|
}
|
||||||
|
|
||||||
|
val RESOURCES: List<Good> = Resource.entries.map { of(it) }
|
||||||
|
val COMMODITIES: List<Good> = Commodity.entries.map { of(it) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The three tracks of city improvement. Each is bought with one commodity, has
|
||||||
|
* a colour of progress-card deck and a power that unlocks at level three.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
enum class Track(val commodity: Commodity) {
|
||||||
|
/** Yellow, bought with cloth: trade commodities two for one. */
|
||||||
|
TRADE(Commodity.CLOTH),
|
||||||
|
|
||||||
|
/** Blue, bought with coin: knights may become mighty. */
|
||||||
|
POLITICS(Commodity.COIN),
|
||||||
|
|
||||||
|
/** Green, bought with paper: the aqueduct. */
|
||||||
|
SCIENCE(Commodity.PAPER),
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* One face of the event die: a ship, or a city gate of a track's colour.
|
||||||
|
* Three faces are ships.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
enum class EventFace { SHIP, TRADE, POLITICS, SCIENCE }
|
||||||
|
|
||||||
|
/** The progress cards: [copies] of each in the deck of its [track]. */
|
||||||
|
@Serializable
|
||||||
|
enum class ProgressType(val track: Track, val copies: Int, val scoresAtOnce: Boolean = false) {
|
||||||
|
// Science (green)
|
||||||
|
ALCHEMIST(Track.SCIENCE, 2),
|
||||||
|
CRANE(Track.SCIENCE, 2),
|
||||||
|
ENGINEER(Track.SCIENCE, 1),
|
||||||
|
INVENTOR(Track.SCIENCE, 2),
|
||||||
|
IRRIGATION(Track.SCIENCE, 2),
|
||||||
|
MEDICINE(Track.SCIENCE, 2),
|
||||||
|
MINING(Track.SCIENCE, 2),
|
||||||
|
PRINTER(Track.SCIENCE, 1, scoresAtOnce = true),
|
||||||
|
ROAD_BUILDING(Track.SCIENCE, 2),
|
||||||
|
SMITH(Track.SCIENCE, 2),
|
||||||
|
|
||||||
|
// Politics (blue)
|
||||||
|
BISHOP(Track.POLITICS, 2),
|
||||||
|
CONSTITUTION(Track.POLITICS, 1, scoresAtOnce = true),
|
||||||
|
DESERTER(Track.POLITICS, 2),
|
||||||
|
DIPLOMAT(Track.POLITICS, 2),
|
||||||
|
INTRIGUE(Track.POLITICS, 2),
|
||||||
|
SABOTEUR(Track.POLITICS, 2),
|
||||||
|
SPY(Track.POLITICS, 3),
|
||||||
|
WARLORD(Track.POLITICS, 2),
|
||||||
|
WEDDING(Track.POLITICS, 2),
|
||||||
|
|
||||||
|
// Trade (yellow)
|
||||||
|
COMMERCIAL_HARBOR(Track.TRADE, 2),
|
||||||
|
MASTER_MERCHANT(Track.TRADE, 2),
|
||||||
|
MERCHANT(Track.TRADE, 6),
|
||||||
|
MERCHANT_FLEET(Track.TRADE, 2),
|
||||||
|
RESOURCE_MONOPOLY(Track.TRADE, 4),
|
||||||
|
TRADE_MONOPOLY(Track.TRADE, 2),
|
||||||
|
}
|
||||||
|
|
||||||
|
/** One progress card; [id] is stable for the life of the game. */
|
||||||
|
@Serializable
|
||||||
|
data class ProgressCard(val id: Int, val kind: ProgressType)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A knight on the board. [level] is its strength: 1 basic, 2 strong, 3 mighty.
|
||||||
|
*
|
||||||
|
* [activatedTurn] and [promotedTurn] record the turn number each happened on:
|
||||||
|
* a knight cannot act on the turn it was activated, and cannot be promoted twice
|
||||||
|
* in one turn.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class Knight(
|
||||||
|
val vertex: Int,
|
||||||
|
val owner: Int,
|
||||||
|
val level: Int,
|
||||||
|
val active: Boolean = false,
|
||||||
|
val activatedTurn: Int = 0,
|
||||||
|
val promotedTurn: Int = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** A metropolis stands on one city: [vertex] of seat [seat]. */
|
||||||
|
@Serializable
|
||||||
|
data class MetropolisAt(val seat: Int, val vertex: Int)
|
||||||
|
|
||||||
|
/** The merchant sits on a hex, controlled by [seat] (who holds its point). */
|
||||||
|
@Serializable
|
||||||
|
data class MerchantAt(val seat: Int, val hex: Int)
|
||||||
|
|
||||||
|
/** A counter-proposal to a [GoodsOffer]: seat [by] would [give] these if the offerer handed over [get]. */
|
||||||
|
@Serializable
|
||||||
|
data class GoodsCounter(val by: Int, val give: List<Good>, val get: List<Good>)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A domestic trade offer in goods, which may include commodities. It is the
|
||||||
|
* base game's [TradeOffer] in cards of any kind, and works the same way: [to] is
|
||||||
|
* the one seat it is addressed to or null for the whole table, [asking] is the
|
||||||
|
* seat that may answer now, and [counters] collect for the offerer to choose from.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class GoodsOffer(
|
||||||
|
val by: Int,
|
||||||
|
val to: Int?,
|
||||||
|
val give: List<Good>,
|
||||||
|
val get: List<Good>,
|
||||||
|
val asking: Int = to ?: -1,
|
||||||
|
val counters: List<GoodsCounter> = emptyList(),
|
||||||
|
)
|
||||||
|
|
||||||
|
/** Where play goes when the queue of [Chore]s runs out. */
|
||||||
|
@Serializable
|
||||||
|
enum class Back { PLAYING, AWAIT_ROLL, AFTER_EVENT, AFTER_DISCARDS, AFTER_PRODUCTION }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Something one seat must decide before the game can go on. A chore is queued
|
||||||
|
* when a roll, an attack or a card needs an answer from somebody (possibly not
|
||||||
|
* the player whose turn it is); the first in [CkState.chores] is the one being
|
||||||
|
* asked.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
sealed interface Chore {
|
||||||
|
val seat: Int
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Give [count] cards to the bank, of the seat's choosing (a seven, a saboteur). */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_discard")
|
||||||
|
data class DiscardChore(override val seat: Int, val count: Int) : Chore
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Hand [count] cards of the seat's choosing to seat [to] (a wedding, a
|
||||||
|
* commercial harbour). [commoditiesOnly] restricts them to commodities, and
|
||||||
|
* [reward] is the resource [to] gives back for each.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_give")
|
||||||
|
data class GiveChore(
|
||||||
|
override val seat: Int,
|
||||||
|
val count: Int,
|
||||||
|
val to: Int,
|
||||||
|
val commoditiesOnly: Boolean = false,
|
||||||
|
val reward: Good? = null,
|
||||||
|
) : Chore
|
||||||
|
|
||||||
|
/** The barbarians won and this seat lost the contest: pick a city to fall. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_pillage")
|
||||||
|
data class PillageChore(override val seat: Int) : Chore
|
||||||
|
|
||||||
|
/** Choose a colour of progress deck to draw from. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_pickDeck")
|
||||||
|
data class PickDeckChore(override val seat: Int) : Chore
|
||||||
|
|
||||||
|
/** More progress cards than the hand holds: give one back. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_dropProgress")
|
||||||
|
data class DropProgressChore(override val seat: Int) : Chore
|
||||||
|
|
||||||
|
/** Choose the city that will bear the [track] metropolis. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_metropolis")
|
||||||
|
data class MetropolisChore(override val seat: Int, val track: Track) : Chore
|
||||||
|
|
||||||
|
/** The aqueduct pays out: take any one resource. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_aqueduct")
|
||||||
|
data class AqueductChore(override val seat: Int) : Chore
|
||||||
|
|
||||||
|
/** A knight was driven from its place; move it, or lose it. [knight] stood on [Knight.vertex]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_relocate")
|
||||||
|
data class RelocateChore(override val seat: Int, val knight: Knight) : Chore
|
||||||
|
|
||||||
|
/** A deserter was played against this seat: remove one of your knights. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_removeKnight")
|
||||||
|
data class RemoveKnightChore(override val seat: Int, val by: Int) : Chore
|
||||||
|
|
||||||
|
/** Place a knight of [level] on the board for free, active or not as given. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_placeKnight")
|
||||||
|
data class PlaceKnightChore(override val seat: Int, val level: Int, val active: Boolean) : Chore
|
||||||
|
|
||||||
|
/** Choose one of [target]'s progress cards to take. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_spy")
|
||||||
|
data class SpyChore(override val seat: Int, val target: Int) : Chore
|
||||||
|
|
||||||
|
/** Promote up to [left] more knights for free. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("c_smith")
|
||||||
|
data class SmithChore(override val seat: Int, val left: Int) : Chore
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Everything Cities & Knights adds to the table.
|
||||||
|
*
|
||||||
|
* Counts that are public ([progressCounts], the knights, the improvement
|
||||||
|
* levels) are stored directly; the decks and the other seats' progress hands are
|
||||||
|
* here in full because the host owns the truth, and [CatanRules.viewFor] keeps
|
||||||
|
* them off the wire.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class CkState(
|
||||||
|
/** Commodity cards per seat. */
|
||||||
|
val commodities: List<Map<Commodity, Int>>,
|
||||||
|
/** Improvement level (0..5) per seat and track. */
|
||||||
|
val improvements: List<Map<Track, Int>>,
|
||||||
|
/** The metropolis of each track that has one. */
|
||||||
|
val metropolises: Map<Track, MetropolisAt> = emptyMap(),
|
||||||
|
val knights: List<Knight> = emptyList(),
|
||||||
|
/** Vertices whose city has a wall. */
|
||||||
|
val walls: List<Int> = emptyList(),
|
||||||
|
/** Steps left before the barbarians land, [BARBARIAN_STEPS] at the start. */
|
||||||
|
val barbarians: Int = BARBARIAN_STEPS,
|
||||||
|
/** Whether the barbarians have landed once: until then the robber sleeps. */
|
||||||
|
val attacked: Boolean = false,
|
||||||
|
val eventDie: EventFace? = null,
|
||||||
|
/** Progress decks, top first. Order is hidden. */
|
||||||
|
val decks: Map<Track, List<ProgressCard>>,
|
||||||
|
val progressHands: List<List<ProgressCard>>,
|
||||||
|
/** Public mirror of the progress-hand sizes. */
|
||||||
|
val progressCounts: List<Int>,
|
||||||
|
/** Victory points from Constitution and Printer, played face up at once. */
|
||||||
|
val progressVp: List<Int>,
|
||||||
|
/** Defender of Catan cards won, one point each. */
|
||||||
|
val defenderVp: List<Int>,
|
||||||
|
val merchant: MerchantAt? = null,
|
||||||
|
/** A crane was played this turn and its discount is unspent. */
|
||||||
|
val crane: Boolean = false,
|
||||||
|
/** A merchant fleet was played this turn for this good. */
|
||||||
|
val fleet: Good? = null,
|
||||||
|
/** Dice named by an alchemist, used by the next roll. */
|
||||||
|
val alchemist: List<Int>? = null,
|
||||||
|
/** The robber is being moved by a bishop, which robs everyone nearby. */
|
||||||
|
val bishop: Boolean = false,
|
||||||
|
val chores: List<Chore> = emptyList(),
|
||||||
|
val back: Back = Back.PLAYING,
|
||||||
|
val goodsOffer: GoodsOffer? = null,
|
||||||
|
/** Seats that have already drawn a defender or winners' card this attack, for the log only. */
|
||||||
|
val lastAttack: String? = null,
|
||||||
|
)
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Moves
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Buy the next level of improvement in [track]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("buyImprovement")
|
||||||
|
data class BuyImprovement(val track: Track) : CatanMove
|
||||||
|
|
||||||
|
/** Hire a basic knight onto [vertex], an empty crossing at the end of one of your roads. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("hireKnight")
|
||||||
|
data class HireKnight(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Pay a grain to activate the knight on [vertex]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("activateKnight")
|
||||||
|
data class ActivateKnight(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Promote the knight on [vertex] one level (paid, or free under a Smith). */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("promoteKnight")
|
||||||
|
data class PromoteKnight(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Move the active knight on [from] along your roads to [to], driving off a weaker knight there. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("moveKnight")
|
||||||
|
data class MoveKnight(val from: Int, val to: Int) : CatanMove
|
||||||
|
|
||||||
|
/** The active knight on [vertex] chases the robber; the robber move follows. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("chaseRobber")
|
||||||
|
data class ChaseRobber(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Raise a wall around the city on [vertex]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("buildWall")
|
||||||
|
data class BuildWall(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Play a progress card. Which of the optional arguments are used depends on
|
||||||
|
* the card (see [CatanCk]); the engine's legal list names every combination it
|
||||||
|
* accepts, so a client only ever chooses among them.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("progress")
|
||||||
|
data class PlayProgress(
|
||||||
|
val card: Int,
|
||||||
|
val target: Int? = null,
|
||||||
|
val vertex: Int? = null,
|
||||||
|
val edge: Int? = null,
|
||||||
|
val hexA: Int? = null,
|
||||||
|
val hexB: Int? = null,
|
||||||
|
val good: Good? = null,
|
||||||
|
val dice: List<Int>? = null,
|
||||||
|
val goods: List<Good>? = null,
|
||||||
|
) : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Trade [give] to the bank for [get], at the best ratio this seat has for the
|
||||||
|
* card it gives. Replaces [MaritimeTrade] in Cities & Knights, where
|
||||||
|
* commodities trade too.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("goodsBank")
|
||||||
|
data class GoodsBankTrade(val give: Good, val get: Good) : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Offer a trade in goods to seat [to], or to the whole table when [to] is null.
|
||||||
|
* Free-form like [OfferTrade], so it is checked structurally and is not in the
|
||||||
|
* enumerated move list.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("offerGoods")
|
||||||
|
data class OfferGoods(val to: Int?, val give: List<Good>, val get: List<Good>) : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Answer the goods offer on the table with different terms. Structural, like
|
||||||
|
* [OfferGoods]; the answers to the counters are the shared [AcceptCounter] and
|
||||||
|
* [DismissCounters].
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("counterGoods")
|
||||||
|
data class CounterGoods(val give: List<Good>, val get: List<Good>) : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Give up exactly the cards named, to a [DiscardChore]. Structural, not
|
||||||
|
* enumerated; the legal list carries one example so a seat is never without a move.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("discardGoods")
|
||||||
|
data class DiscardGoods(val cards: List<Good>) : CatanMove
|
||||||
|
|
||||||
|
/** Hand over the cards named to a [GiveChore]. Structural, like [DiscardGoods]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("giveGoods")
|
||||||
|
data class GiveGoods(val cards: List<Good>) : CatanMove
|
||||||
|
|
||||||
|
/** Let the city on [vertex] fall to the barbarians. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("pillageCity")
|
||||||
|
data class PillageCity(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Draw from the deck of this track's colour. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("pickDeck")
|
||||||
|
data class PickDeck(val track: Track) : CatanMove
|
||||||
|
|
||||||
|
/** Give up one progress card from a hand that is over the limit. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("dropProgress")
|
||||||
|
data class DropProgress(val card: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Put the metropolis on the city at [vertex]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("placeMetropolis")
|
||||||
|
data class PlaceMetropolis(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Take one [resource] from the bank for an aqueduct. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("aqueduct")
|
||||||
|
data class TakeAqueduct(val resource: Resource) : CatanMove
|
||||||
|
|
||||||
|
/** Move the knight that was driven off to [to]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("relocateKnight")
|
||||||
|
data class RelocateKnight(val to: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Take the knight on [vertex] off the board, for a deserter. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("removeKnight")
|
||||||
|
data class RemoveKnight(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Place the free knight from a deserter on [vertex]. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("placeKnight")
|
||||||
|
data class PlaceKnight(val vertex: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Take the spied progress card with this id. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("spyTake")
|
||||||
|
data class SpyTake(val card: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Stop promoting knights under a Smith. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("endSmith")
|
||||||
|
data object EndSmith : CatanMove
|
||||||
@@ -39,6 +39,12 @@ enum class Terrain(val produces: Resource?) {
|
|||||||
HILLS(Resource.BRICK),
|
HILLS(Resource.BRICK),
|
||||||
MOUNTAINS(Resource.ORE),
|
MOUNTAINS(Resource.ORE),
|
||||||
DESERT(null),
|
DESERT(null),
|
||||||
|
|
||||||
|
/** Seafarers: open water. Ships sail on it; nothing is built on it and nothing produces. */
|
||||||
|
SEA(null),
|
||||||
|
|
||||||
|
/** Seafarers: a gold field. A settlement beside it takes any resource its owner likes when its number rolls. */
|
||||||
|
GOLD(null),
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Axial coordinate of one hex on the board. See [CatanBoard]. */
|
/** Axial coordinate of one hex on the board. See [CatanBoard]. */
|
||||||
@@ -114,6 +120,9 @@ enum class CatanPhase {
|
|||||||
/** The player whose turn it is must roll the dice. */
|
/** The player whose turn it is must roll the dice. */
|
||||||
AWAIT_ROLL,
|
AWAIT_ROLL,
|
||||||
|
|
||||||
|
/** Seafarers: the first seat in [SeaState.gold] is choosing the resources its gold fields paid. */
|
||||||
|
GOLD,
|
||||||
|
|
||||||
/** Players holding more than 7 resource cards discard half. */
|
/** Players holding more than 7 resource cards discard half. */
|
||||||
DISCARDING,
|
DISCARDING,
|
||||||
|
|
||||||
@@ -133,12 +142,33 @@ enum class CatanPhase {
|
|||||||
TRADE_COUNTERS,
|
TRADE_COUNTERS,
|
||||||
|
|
||||||
GAME_OVER,
|
GAME_OVER,
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Cities & Knights only: the first seat in [CkState.chores] has something
|
||||||
|
* to decide (a discard, a city to give up, a card to draw…) and the game
|
||||||
|
* waits on it. Play resumes where [CkState.back] says.
|
||||||
|
*/
|
||||||
|
CHORE,
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Which rules a table plays. The expansion is a whole rule set, not a toggle. */
|
||||||
|
@Serializable
|
||||||
|
enum class CatanRuleSet {
|
||||||
|
/** The base game: development cards, Largest Army, a robber from the start. */
|
||||||
|
BASE,
|
||||||
|
|
||||||
|
/** Cities & Knights: commodities, knights, barbarians, city improvements. */
|
||||||
|
CITIES_AND_KNIGHTS,
|
||||||
|
|
||||||
|
/** Seafarers: ships, a pirate, gold fields and islands to settle (see `docs/RULES-catan-seafarers.md`). */
|
||||||
|
SEAFARERS,
|
||||||
}
|
}
|
||||||
|
|
||||||
@Serializable
|
@Serializable
|
||||||
data class CatanOptions(
|
data class CatanOptions(
|
||||||
val playerCount: Int = 3,
|
val playerCount: Int = 3,
|
||||||
val pointsToWin: Int = 10,
|
val pointsToWin: Int = 10,
|
||||||
|
val ruleSet: CatanRuleSet = CatanRuleSet.BASE,
|
||||||
) {
|
) {
|
||||||
init {
|
init {
|
||||||
require(playerCount in 3..4) { "The island seats three or four players" }
|
require(playerCount in 3..4) { "The island seats three or four players" }
|
||||||
@@ -210,9 +240,22 @@ data class CatanState(
|
|||||||
val rngStep: Int,
|
val rngStep: Int,
|
||||||
val winner: Int?,
|
val winner: Int?,
|
||||||
val log: List<String>,
|
val log: List<String>,
|
||||||
|
/** Everything Cities & Knights adds; null in the base game. */
|
||||||
|
val ck: CkState? = null,
|
||||||
|
/** Everything Seafarers adds (ships, the pirate, islands); null in the other rule sets. */
|
||||||
|
val sea: SeaState? = null,
|
||||||
) {
|
) {
|
||||||
val playerCount: Int get() = options.playerCount
|
val playerCount: Int get() = options.playerCount
|
||||||
|
|
||||||
|
/** The geometry this game is played on: the standard island, or a Seafarers map. */
|
||||||
|
val topo: Topology get() = sea?.let { SeaBoards.topology(it.scenario) } ?: CatanBoard.base
|
||||||
|
|
||||||
|
/** Whether this table plays Seafarers. */
|
||||||
|
val isSea: Boolean get() = sea != null
|
||||||
|
|
||||||
|
/** Whether this table plays Cities & Knights. */
|
||||||
|
val isCk: Boolean get() = ck != null
|
||||||
|
|
||||||
/** Total resource cards held by [seat]. */
|
/** Total resource cards held by [seat]. */
|
||||||
fun resourceCount(seat: Int): Int = resources[seat].values.sum()
|
fun resourceCount(seat: Int): Int = resources[seat].values.sum()
|
||||||
|
|
||||||
@@ -247,7 +290,11 @@ data class SetupPlace(val vertex: Int, val edge: Int) : CatanMove
|
|||||||
*/
|
*/
|
||||||
@Serializable
|
@Serializable
|
||||||
@SerialName("roll")
|
@SerialName("roll")
|
||||||
data class RollDice(val forced: List<Int>? = null) : CatanMove
|
data class RollDice(
|
||||||
|
val forced: List<Int>? = null,
|
||||||
|
/** Test-only, like [forced]: the event die of a Cities & Knights roll. */
|
||||||
|
val event: EventFace? = null,
|
||||||
|
) : CatanMove
|
||||||
|
|
||||||
/** Discard exactly these cards. */
|
/** Discard exactly these cards. */
|
||||||
@Serializable
|
@Serializable
|
||||||
@@ -350,3 +397,48 @@ data object EndTurn : CatanMove
|
|||||||
@Serializable
|
@Serializable
|
||||||
@SerialName("endFreeRoads")
|
@SerialName("endFreeRoads")
|
||||||
data object EndFreeRoads : CatanMove
|
data object EndFreeRoads : CatanMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Seafarers state: the ships, the pirate and the islands, alongside the base game's
|
||||||
|
* roads, robber and buildings (which keep working exactly as before).
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class SeaState(
|
||||||
|
val scenario: SeaScenario,
|
||||||
|
/** Owning seat per edge, or [NO_PLAYER]: a ship on that edge. Roads stay in [CatanState.roads]. */
|
||||||
|
val ships: List<Int>,
|
||||||
|
/** The hex the pirate occupies: always a sea hex. */
|
||||||
|
val pirate: Int,
|
||||||
|
/** Ships built this turn (they may not sail until the next) and whether a ship has sailed this turn. */
|
||||||
|
val builtThisTurn: List<Int> = emptyList(),
|
||||||
|
val shipMoved: Boolean = false,
|
||||||
|
/** Who holds the "new island" bonus for each island, or [NO_PLAYER]. The home island's is never awarded. */
|
||||||
|
val islandBonus: List<Int>,
|
||||||
|
/** The island the players start on. */
|
||||||
|
val home: Int,
|
||||||
|
/** Gold owed after a roll, front first: each seat chooses [GoldOwed.count] cards. */
|
||||||
|
val gold: List<GoldOwed> = emptyList(),
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class GoldOwed(val seat: Int, val count: Int)
|
||||||
|
|
||||||
|
/** Build a ship on [edge]: 1 lumber and 1 wool, on a sea edge joined to your fleet or a harbour town. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("ship")
|
||||||
|
data class BuildShip(val edge: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Sail the ship on [from] to [to]: once a turn, never the turn it was built, only from the open end of a route. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("moveShip")
|
||||||
|
data class MoveShip(val from: Int, val to: Int) : CatanMove
|
||||||
|
|
||||||
|
/** Move the pirate to the sea hex [hex] and rob [victim], a seat with a ship beside it, if there is one. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("pirate")
|
||||||
|
data class MovePirate(val hex: HexCoord, val victim: Int? = null) : CatanMove
|
||||||
|
|
||||||
|
/** Choose the [cards] a gold field paid. */
|
||||||
|
@Serializable
|
||||||
|
@SerialName("gold")
|
||||||
|
data class PickGold(val cards: List<Resource>) : CatanMove
|
||||||
|
|||||||
@@ -54,12 +54,24 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
"Seat count ${config.seats.size} does not match ${options.playerCount} players"
|
"Seat count ${config.seats.size} does not match ${options.playerCount} players"
|
||||||
}
|
}
|
||||||
|
|
||||||
val board = CatanBoard.generate(config.seed)
|
val sea = options.ruleSet == CatanRuleSet.SEAFARERS
|
||||||
|
val scenario = SeaScenario.NEW_SHORES
|
||||||
|
val seaBoard = if (sea) SeaBoards.generate(scenario, config.seed) else null
|
||||||
|
val topo = if (seaBoard != null) SeaBoards.topology(scenario) else CatanBoard.base
|
||||||
|
val board = seaBoard?.let { CatanBoard.Generated(it.terrains, it.numbers, it.robber, it.ports) }
|
||||||
|
?: CatanBoard.generate(config.seed)
|
||||||
// A different random stream than the island, so the same seed still
|
// A different random stream than the island, so the same seed still
|
||||||
// produces both a fixed island and a fixed deck.
|
// produces both a fixed island and a fixed deck.
|
||||||
val devDeck = DEV_DECK
|
val ck = options.ruleSet == CatanRuleSet.CITIES_AND_KNIGHTS
|
||||||
|
// Cities & Knights has no development cards: knights and progress
|
||||||
|
// cards take their place.
|
||||||
|
val devDeck = if (ck) {
|
||||||
|
emptyList()
|
||||||
|
} else {
|
||||||
|
DEV_DECK
|
||||||
.mapIndexed { id, type -> DevCard(id, type) }
|
.mapIndexed { id, type -> DevCard(id, type) }
|
||||||
.shuffled(Random(config.seed + 1))
|
.shuffled(Random(config.seed + 1))
|
||||||
|
}
|
||||||
|
|
||||||
return CatanState(
|
return CatanState(
|
||||||
options = options,
|
options = options,
|
||||||
@@ -72,8 +84,8 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
numbers = board.numbers,
|
numbers = board.numbers,
|
||||||
robber = board.robber,
|
robber = board.robber,
|
||||||
ports = board.ports,
|
ports = board.ports,
|
||||||
buildings = List(CatanBoard.VERTEX_COUNT) { null },
|
buildings = List(topo.VERTEX_COUNT) { null },
|
||||||
roads = List(CatanBoard.EDGE_COUNT) { NO_PLAYER },
|
roads = List(topo.EDGE_COUNT) { NO_PLAYER },
|
||||||
resources = List(options.playerCount) {
|
resources = List(options.playerCount) {
|
||||||
Resource.entries.associateWith { 0 }
|
Resource.entries.associateWith { 0 }
|
||||||
},
|
},
|
||||||
@@ -91,8 +103,19 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
rngStep = 0,
|
rngStep = 0,
|
||||||
winner = null,
|
winner = null,
|
||||||
log = listOf(
|
log = listOf(
|
||||||
"Catan — ${options.playerCount} players, first to ${options.pointsToWin} victory points.",
|
"Catan${if (ck) " — Cities & Knights" else if (sea) " — Seafarers: ${scenario.title}" else ""} — ${options.playerCount} players, " +
|
||||||
|
"first to ${options.pointsToWin} victory points.",
|
||||||
),
|
),
|
||||||
|
ck = if (ck) CatanCk.initial(options, config.seed) else null,
|
||||||
|
sea = seaBoard?.let {
|
||||||
|
SeaState(
|
||||||
|
scenario = scenario,
|
||||||
|
ships = List(topo.EDGE_COUNT) { NO_PLAYER },
|
||||||
|
pirate = it.pirate,
|
||||||
|
islandBonus = List(topo.islandCount) { NO_PLAYER },
|
||||||
|
home = it.home,
|
||||||
|
)
|
||||||
|
},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -102,7 +125,10 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
CatanPhase.SETUP_SECOND -> 2 * state.playerCount - 1 - state.setupIndex
|
CatanPhase.SETUP_SECOND -> 2 * state.playerCount - 1 - state.setupIndex
|
||||||
CatanPhase.DISCARDING -> state.discardSeat
|
CatanPhase.DISCARDING -> state.discardSeat
|
||||||
CatanPhase.TRADE_PENDING -> state.pendingTrade?.asking?.takeIf { it >= 0 }
|
CatanPhase.TRADE_PENDING -> state.pendingTrade?.asking?.takeIf { it >= 0 }
|
||||||
|
?: state.ck?.goodsOffer?.asking?.takeIf { it >= 0 }
|
||||||
CatanPhase.TRADE_COUNTERS -> state.turn
|
CatanPhase.TRADE_COUNTERS -> state.turn
|
||||||
|
CatanPhase.CHORE -> state.ck?.chores?.firstOrNull()?.seat
|
||||||
|
CatanPhase.GOLD -> state.sea?.gold?.firstOrNull()?.seat
|
||||||
CatanPhase.AWAIT_ROLL, CatanPhase.ROBBER,
|
CatanPhase.AWAIT_ROLL, CatanPhase.ROBBER,
|
||||||
CatanPhase.PLAYING, CatanPhase.FREE_ROADS,
|
CatanPhase.PLAYING, CatanPhase.FREE_ROADS,
|
||||||
-> state.turn
|
-> state.turn
|
||||||
@@ -133,12 +159,17 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
|
|
||||||
is CounterTrade -> counterLegal(state, seat, move)
|
is CounterTrade -> counterLegal(state, seat, move)
|
||||||
|
|
||||||
else -> move in legalMoves(state, seat)
|
else -> if (state.isCk) {
|
||||||
|
CatanCk.structurallyLegal(state, seat, move) ?: (move in legalMoves(state, seat))
|
||||||
|
} else {
|
||||||
|
move in legalMoves(state, seat)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun legalMoves(state: CatanState, seat: Int): List<CatanMove> {
|
override fun legalMoves(state: CatanState, seat: Int): List<CatanMove> {
|
||||||
if (currentSeat(state) != seat) return emptyList()
|
if (currentSeat(state) != seat) return emptyList()
|
||||||
|
if (state.isCk) return CatanCk.legalMoves(state, seat)
|
||||||
return when (state.phase) {
|
return when (state.phase) {
|
||||||
CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND -> setupMoves(state)
|
CatanPhase.SETUP_FIRST, CatanPhase.SETUP_SECOND -> setupMoves(state)
|
||||||
|
|
||||||
@@ -146,27 +177,34 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
|
|
||||||
CatanPhase.DISCARDING -> discardMoves(state, seat)
|
CatanPhase.DISCARDING -> discardMoves(state, seat)
|
||||||
|
|
||||||
CatanPhase.ROBBER -> robberMoves(state, seat)
|
CatanPhase.ROBBER -> robberMoves(state, seat) +
|
||||||
|
(if (state.isSea) SeaRules.pirateMoves(state, seat) else emptyList())
|
||||||
|
|
||||||
CatanPhase.PLAYING -> playingMoves(state, seat)
|
CatanPhase.PLAYING -> playingMoves(state, seat)
|
||||||
|
|
||||||
CatanPhase.FREE_ROADS ->
|
CatanPhase.FREE_ROADS ->
|
||||||
roadMoves(state, seat) + listOf<CatanMove>(EndFreeRoads)
|
roadMoves(state, seat) +
|
||||||
|
(if (state.isSea) SeaRules.buildShipMoves(state, seat) else emptyList()) +
|
||||||
|
listOf<CatanMove>(EndFreeRoads)
|
||||||
|
|
||||||
|
CatanPhase.GOLD -> SeaRules.goldMoves(state)
|
||||||
|
|
||||||
CatanPhase.TRADE_PENDING -> tradeResponses(state, seat)
|
CatanPhase.TRADE_PENDING -> tradeResponses(state, seat)
|
||||||
|
|
||||||
CatanPhase.TRADE_COUNTERS -> counterChoices(state)
|
CatanPhase.TRADE_COUNTERS -> counterChoices(state)
|
||||||
|
|
||||||
CatanPhase.GAME_OVER -> emptyList()
|
CatanPhase.CHORE, CatanPhase.GAME_OVER -> emptyList()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun setupMoves(state: CatanState): List<SetupPlace> {
|
internal fun setupMoves(state: CatanState): List<SetupPlace> {
|
||||||
val moves = mutableListOf<SetupPlace>()
|
val moves = mutableListOf<SetupPlace>()
|
||||||
for (v in 0 until CatanBoard.VERTEX_COUNT) {
|
for (v in 0 until state.topo.VERTEX_COUNT) {
|
||||||
if (!vertexOpenForSettlement(state, v)) continue
|
if (!vertexOpenForSettlement(state, v)) continue
|
||||||
for (e in CatanBoard.VERTEX_EDGES[v]) {
|
// Seafarers: everyone starts on the home island.
|
||||||
if (state.roads[e] != NO_PLAYER) continue
|
if (state.sea != null && state.topo.vertexIsland[v] != state.sea.home) continue
|
||||||
|
for (e in state.topo.VERTEX_EDGES[v]) {
|
||||||
|
if (state.roads[e] != NO_PLAYER || !state.topo.edgeLand[e]) continue
|
||||||
moves += SetupPlace(v, e)
|
moves += SetupPlace(v, e)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -199,18 +237,18 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
|
|
||||||
private fun robberMoves(state: CatanState, seat: Int): List<MoveRobber> {
|
private fun robberMoves(state: CatanState, seat: Int): List<MoveRobber> {
|
||||||
val moves = mutableListOf<MoveRobber>()
|
val moves = mutableListOf<MoveRobber>()
|
||||||
for (h in 0 until CatanBoard.HEX_COUNT) {
|
for (h in 0 until state.topo.HEX_COUNT) {
|
||||||
if (h == state.robber) continue
|
if (h == state.robber || !state.topo.land[h]) continue
|
||||||
val victims = CatanBoard.HEX_CORNERS[h]
|
val victims = state.topo.HEX_CORNERS[h]
|
||||||
.mapNotNull { state.buildings[it] }
|
.mapNotNull { state.buildings[it] }
|
||||||
.map { it.owner }
|
.map { it.owner }
|
||||||
.filter { it != seat }
|
.filter { it != seat }
|
||||||
.distinct()
|
.distinct()
|
||||||
.filter { state.resourceCount(it) > 0 }
|
.filter { state.resourceCount(it) > 0 }
|
||||||
if (victims.isEmpty()) {
|
if (victims.isEmpty()) {
|
||||||
moves += MoveRobber(CatanBoard.HEXES[h])
|
moves += MoveRobber(state.topo.HEXES[h])
|
||||||
} else {
|
} else {
|
||||||
victims.forEach { moves += MoveRobber(CatanBoard.HEXES[h], it) }
|
victims.forEach { moves += MoveRobber(state.topo.HEXES[h], it) }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return moves
|
return moves
|
||||||
@@ -229,6 +267,10 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
if (state.devDeck.isNotEmpty() && affordable(state, seat, DEV_COST)) {
|
if (state.devDeck.isNotEmpty() && affordable(state, seat, DEV_COST)) {
|
||||||
moves += BuyDevCard
|
moves += BuyDevCard
|
||||||
}
|
}
|
||||||
|
if (state.isSea) {
|
||||||
|
if (affordable(state, seat, SeaRules.SHIP_COST)) moves += SeaRules.buildShipMoves(state, seat)
|
||||||
|
moves += SeaRules.moveShipMoves(state, seat)
|
||||||
|
}
|
||||||
|
|
||||||
if (!state.devCardPlayedThisTurn) {
|
if (!state.devCardPlayedThisTurn) {
|
||||||
for (card in state.devHands[seat]) {
|
for (card in state.devHands[seat]) {
|
||||||
@@ -281,12 +323,16 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* Road placements that connect to [seat]'s network, cost aside. A player
|
* Road placements that connect to [seat]'s network, cost aside. A player
|
||||||
* with all fifteen roads laid has none.
|
* with all fifteen roads laid has none.
|
||||||
*/
|
*/
|
||||||
private fun roadMoves(state: CatanState, seat: Int): List<BuildRoad> =
|
internal fun roadMoves(state: CatanState, seat: Int): List<BuildRoad> =
|
||||||
if (state.roads.count { it == seat } >= MAX_ROADS) {
|
if (state.roads.count { it == seat } >= MAX_ROADS) {
|
||||||
emptyList()
|
emptyList()
|
||||||
} else {
|
} else {
|
||||||
(0 until CatanBoard.EDGE_COUNT)
|
(0 until state.topo.EDGE_COUNT)
|
||||||
.filter { state.roads[it] == NO_PLAYER && roadConnects(state, seat, it) }
|
.filter {
|
||||||
|
state.roads[it] == NO_PLAYER && state.topo.edgeLand[it] &&
|
||||||
|
state.sea?.ships?.get(it).let { ship -> ship == null || ship == NO_PLAYER } &&
|
||||||
|
roadConnects(state, seat, it)
|
||||||
|
}
|
||||||
.map { BuildRoad(it) }
|
.map { BuildRoad(it) }
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -296,30 +342,33 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* connection requirement does not apply — that is why setup uses its
|
* connection requirement does not apply — that is why setup uses its
|
||||||
* own move.)
|
* own move.)
|
||||||
*/
|
*/
|
||||||
private fun settlementVertices(state: CatanState, seat: Int): List<Int> =
|
internal fun settlementVertices(state: CatanState, seat: Int): List<Int> =
|
||||||
if (piecesOf(state, seat, BuildingType.SETTLEMENT) >= MAX_SETTLEMENTS) {
|
if (piecesOf(state, seat, BuildingType.SETTLEMENT) >= MAX_SETTLEMENTS) {
|
||||||
emptyList()
|
emptyList()
|
||||||
} else {
|
} else {
|
||||||
(0 until CatanBoard.VERTEX_COUNT).filter { v ->
|
(0 until state.topo.VERTEX_COUNT).filter { v ->
|
||||||
vertexOpenForSettlement(state, v) &&
|
vertexOpenForSettlement(state, v) &&
|
||||||
CatanBoard.VERTEX_EDGES[v].any { state.roads[it] == seat }
|
state.topo.VERTEX_EDGES[v].any { state.roads[it] == seat || state.sea?.ships?.get(it) == seat }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun cityVertices(state: CatanState, seat: Int): List<Int> =
|
internal fun cityVertices(state: CatanState, seat: Int): List<Int> =
|
||||||
if (piecesOf(state, seat, BuildingType.CITY) >= MAX_CITIES) {
|
if (piecesOf(state, seat, BuildingType.CITY) >= MAX_CITIES) {
|
||||||
emptyList()
|
emptyList()
|
||||||
} else {
|
} else {
|
||||||
(0 until CatanBoard.VERTEX_COUNT).filter { v ->
|
(0 until state.topo.VERTEX_COUNT).filter { v ->
|
||||||
state.buildings[v] == CatanBuilding(BuildingType.SETTLEMENT, seat)
|
state.buildings[v] == CatanBuilding(BuildingType.SETTLEMENT, seat)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private fun hasKnight(state: CatanState, vertex: Int): Boolean =
|
||||||
|
state.ck?.knights?.any { it.vertex == vertex } == true
|
||||||
|
|
||||||
/** How many settlements or cities [seat] currently has standing. */
|
/** How many settlements or cities [seat] currently has standing. */
|
||||||
private fun piecesOf(state: CatanState, seat: Int, type: BuildingType): Int =
|
private fun piecesOf(state: CatanState, seat: Int, type: BuildingType): Int =
|
||||||
state.buildings.count { it?.owner == seat && it.type == type }
|
state.buildings.count { it?.owner == seat && it.type == type }
|
||||||
|
|
||||||
private fun tradeResponses(state: CatanState, seat: Int): List<CatanMove> {
|
internal fun tradeResponses(state: CatanState, seat: Int): List<CatanMove> {
|
||||||
val offer = state.pendingTrade ?: return emptyList()
|
val offer = state.pendingTrade ?: return emptyList()
|
||||||
val responses = mutableListOf<CatanMove>()
|
val responses = mutableListOf<CatanMove>()
|
||||||
if (state.holdsAll(seat, offer.get) && state.holdsAll(offer.by, offer.give)) {
|
if (state.holdsAll(seat, offer.get) && state.holdsAll(offer.by, offer.give)) {
|
||||||
@@ -330,7 +379,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/** What the offerer may do with the counters: take one that is still affordable, or none. */
|
/** What the offerer may do with the counters: take one that is still affordable, or none. */
|
||||||
private fun counterChoices(state: CatanState): List<CatanMove> {
|
internal fun counterChoices(state: CatanState): List<CatanMove> {
|
||||||
val offer = state.pendingTrade ?: return emptyList()
|
val offer = state.pendingTrade ?: return emptyList()
|
||||||
val moves = mutableListOf<CatanMove>()
|
val moves = mutableListOf<CatanMove>()
|
||||||
for (counter in offer.counters) {
|
for (counter in offer.counters) {
|
||||||
@@ -353,9 +402,9 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/** An empty vertex with no building on it or one edge away. */
|
/** An empty vertex with no building on it or one edge away. */
|
||||||
private fun vertexOpenForSettlement(state: CatanState, v: Int): Boolean =
|
internal fun vertexOpenForSettlement(state: CatanState, v: Int): Boolean =
|
||||||
state.buildings[v] == null &&
|
state.buildings[v] == null && !hasKnight(state, v) && state.topo.vertexLand[v] &&
|
||||||
CatanBoard.VERTEX_NEIGHBORS[v].all { state.buildings[it] == null }
|
state.topo.VERTEX_NEIGHBORS[v].all { state.buildings[it] == null }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* A road on [edge] would join [seat]'s network of roads and buildings.
|
* A road on [edge] would join [seat]'s network of roads and buildings.
|
||||||
@@ -366,16 +415,19 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* of your own roads ending at the same crossing.
|
* of your own roads ending at the same crossing.
|
||||||
*/
|
*/
|
||||||
private fun roadConnects(state: CatanState, seat: Int, edge: Int): Boolean {
|
private fun roadConnects(state: CatanState, seat: Int, edge: Int): Boolean {
|
||||||
val (a, b) = CatanBoard.EDGE_VERTICES[edge]
|
val (a, b) = state.topo.EDGE_VERTICES[edge]
|
||||||
return networkReaches(state, seat, a) || networkReaches(state, seat, b)
|
return networkReaches(state, seat, a) || networkReaches(state, seat, b)
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Whether [seat]'s roads and buildings reach [vertex] so a road may start there. */
|
/** Whether [seat]'s roads and buildings reach [vertex] so a road may start there. */
|
||||||
private fun networkReaches(state: CatanState, seat: Int, vertex: Int): Boolean {
|
private fun networkReaches(state: CatanState, seat: Int, vertex: Int): Boolean {
|
||||||
val building = state.buildings[vertex]
|
val building = state.buildings[vertex]
|
||||||
|
// A knight is a wall to everyone but its owner, like a building.
|
||||||
|
val knight = state.ck?.knights?.firstOrNull { it.vertex == vertex }
|
||||||
|
if (knight != null && knight.owner != seat) return false
|
||||||
// Your own building is always a way in; anyone else's is a wall.
|
// Your own building is always a way in; anyone else's is a wall.
|
||||||
if (building != null) return building.owner == seat
|
if (building != null) return building.owner == seat
|
||||||
return CatanBoard.VERTEX_EDGES[vertex].any { state.roads[it] == seat }
|
return state.topo.VERTEX_EDGES[vertex].any { state.roads[it] == seat }
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun offerLegal(state: CatanState, seat: Int, move: OfferTrade): Boolean {
|
private fun offerLegal(state: CatanState, seat: Int, move: OfferTrade): Boolean {
|
||||||
@@ -401,6 +453,10 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
is RollDice -> applyRoll(state, seat, move)
|
is RollDice -> applyRoll(state, seat, move)
|
||||||
is Discard -> applyDiscard(state, seat, move)
|
is Discard -> applyDiscard(state, seat, move)
|
||||||
is MoveRobber -> applyRobber(state, seat, move)
|
is MoveRobber -> applyRobber(state, seat, move)
|
||||||
|
is BuildShip -> applyBuildShip(state, seat, move)
|
||||||
|
is MoveShip -> applyMoveShip(state, seat, move)
|
||||||
|
is MovePirate -> applyMovePirate(state, seat, move)
|
||||||
|
is PickGold -> applyPickGold(state, seat, move)
|
||||||
is BuildRoad -> applyBuildRoad(state, seat, move)
|
is BuildRoad -> applyBuildRoad(state, seat, move)
|
||||||
is BuildSettlement -> applyBuildSettlement(state, seat, move)
|
is BuildSettlement -> applyBuildSettlement(state, seat, move)
|
||||||
is BuildCity -> applyBuildCity(state, seat, move)
|
is BuildCity -> applyBuildCity(state, seat, move)
|
||||||
@@ -418,24 +474,28 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
is MaritimeTrade -> applyMaritimeTrade(state, seat, move)
|
is MaritimeTrade -> applyMaritimeTrade(state, seat, move)
|
||||||
EndTurn -> applyEndTurn(state, seat)
|
EndTurn -> applyEndTurn(state, seat)
|
||||||
EndFreeRoads -> applyEndFreeRoads(state, seat)
|
EndFreeRoads -> applyEndFreeRoads(state, seat)
|
||||||
}
|
else -> CatanCk.apply(state, seat, move)
|
||||||
|
}.let { if (it.isCk) CatanCk.settle(it) else it }
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun applySetup(state: CatanState, seat: Int, move: SetupPlace): CatanState {
|
private fun applySetup(state: CatanState, seat: Int, move: SetupPlace): CatanState {
|
||||||
val n = state.playerCount
|
val n = state.playerCount
|
||||||
val second = state.phase == CatanPhase.SETUP_SECOND
|
val second = state.phase == CatanPhase.SETUP_SECOND
|
||||||
|
// In Cities & Knights the second placement is a city.
|
||||||
|
val first = if (state.isCk && second) BuildingType.CITY else BuildingType.SETTLEMENT
|
||||||
var s = state.copy(
|
var s = state.copy(
|
||||||
buildings = state.buildings.toMutableList().also {
|
buildings = state.buildings.toMutableList().also {
|
||||||
it[move.vertex] = CatanBuilding(BuildingType.SETTLEMENT, seat)
|
it[move.vertex] = CatanBuilding(first, seat)
|
||||||
},
|
},
|
||||||
roads = state.roads.toMutableList().also { it[move.edge] = seat },
|
roads = state.roads.toMutableList().also { it[move.edge] = seat },
|
||||||
log = state.log + "Seat $seat settles at ${move.vertex} and lays a road on ${move.edge}.",
|
log = state.log + ("Seat $seat ${if (first == BuildingType.CITY) "raises a city" else "settles"} " +
|
||||||
|
"at ${move.vertex} and lays a road on ${move.edge}."),
|
||||||
)
|
)
|
||||||
|
|
||||||
if (second) {
|
if (second) {
|
||||||
// The second settlement earns one card from each adjacent
|
// The second settlement earns one card from each adjacent
|
||||||
// producing hex, supply permitting.
|
// producing hex, supply permitting.
|
||||||
val adjacent = CatanBoard.VERTEX_HEXES[move.vertex].mapNotNull { state.terrains[it].produces }
|
val adjacent = state.topo.VERTEX_HEXES[move.vertex].mapNotNull { state.terrains[it].produces }
|
||||||
val granted = adjacent.groupingBy { it }.eachCount().filter { (res, need) ->
|
val granted = adjacent.groupingBy { it }.eachCount().filter { (res, need) ->
|
||||||
need <= bankSupply(state, res)
|
need <= bankSupply(state, res)
|
||||||
}
|
}
|
||||||
@@ -463,6 +523,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun applyRoll(state: CatanState, seat: Int, move: RollDice): CatanState {
|
private fun applyRoll(state: CatanState, seat: Int, move: RollDice): CatanState {
|
||||||
|
if (state.isCk) return CatanCk.applyRoll(state, seat, move)
|
||||||
val dice = move.forced ?: derivedDice(state)
|
val dice = move.forced ?: derivedDice(state)
|
||||||
val total = dice[0] + dice[1]
|
val total = dice[0] + dice[1]
|
||||||
val s = state.copy(lastDice = dice, rngStep = state.rngStep + 1)
|
val s = state.copy(lastDice = dice, rngStep = state.rngStep + 1)
|
||||||
@@ -490,11 +551,11 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
val gains = List(state.playerCount) { mutableMapOf<Resource, Int>() }
|
val gains = List(state.playerCount) { mutableMapOf<Resource, Int>() }
|
||||||
for (resource in Resource.entries) {
|
for (resource in Resource.entries) {
|
||||||
var demand = 0
|
var demand = 0
|
||||||
for (h in 0 until CatanBoard.HEX_COUNT) {
|
for (h in 0 until state.topo.HEX_COUNT) {
|
||||||
if (state.numbers[h] != number) continue
|
if (state.numbers[h] != number) continue
|
||||||
if (h == state.robber) continue
|
if (h == state.robber) continue
|
||||||
if (state.terrains[h].produces != resource) continue
|
if (state.terrains[h].produces != resource) continue
|
||||||
for (v in CatanBoard.HEX_CORNERS[h]) {
|
for (v in state.topo.HEX_CORNERS[h]) {
|
||||||
val building = state.buildings[v] ?: continue
|
val building = state.buildings[v] ?: continue
|
||||||
val amount = if (building.type == BuildingType.CITY) 2 else 1
|
val amount = if (building.type == BuildingType.CITY) 2 else 1
|
||||||
gains[building.owner][resource] = (gains[building.owner][resource] ?: 0) + amount
|
gains[building.owner][resource] = (gains[building.owner][resource] ?: 0) + amount
|
||||||
@@ -508,6 +569,9 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Seafarers: gold fields pay a card of the owner's choice, asked for after the rest is dealt.
|
||||||
|
val goldOwed = if (state.isSea) goldOwed(state, number) else emptyList()
|
||||||
|
|
||||||
var s = state.copy(phase = CatanPhase.PLAYING)
|
var s = state.copy(phase = CatanPhase.PLAYING)
|
||||||
val whoGot = mutableListOf<String>()
|
val whoGot = mutableListOf<String>()
|
||||||
for (seat in 0 until s.playerCount) {
|
for (seat in 0 until s.playerCount) {
|
||||||
@@ -516,10 +580,31 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
s = s.copy(resources = withCounts(s.resources, seat, got, 1))
|
s = s.copy(resources = withCounts(s.resources, seat, got, 1))
|
||||||
whoGot += "seat $seat takes ${describe(got)}"
|
whoGot += "seat $seat takes ${describe(got)}"
|
||||||
}
|
}
|
||||||
val said = if (whoGot.isEmpty()) "nothing for anyone" else whoGot.joinToString(", ")
|
val goldLine = goldOwed.joinToString("") { ", seat ${it.seat} is owed ${it.count} gold" }
|
||||||
return s.copy(
|
val said = if (whoGot.isEmpty() && goldOwed.isEmpty()) "nothing for anyone" else
|
||||||
|
(whoGot.joinToString(", ") + goldLine).trimStart(',', ' ')
|
||||||
|
s = s.copy(
|
||||||
log = s.log + "Seat ${state.turn} rolls ${state.lastDice.joinToString(" + ")} — $said.",
|
log = s.log + "Seat ${state.turn} rolls ${state.lastDice.joinToString(" + ")} — $said.",
|
||||||
)
|
)
|
||||||
|
if (goldOwed.isEmpty()) return s
|
||||||
|
return SeaRules.settleGold(s.copy(sea = s.sea!!.copy(gold = goldOwed)))
|
||||||
|
}
|
||||||
|
|
||||||
|
/** What each seat is owed for gold fields showing [number], in seat order from the roller. */
|
||||||
|
private fun goldOwed(state: CatanState, number: Int): List<GoldOwed> {
|
||||||
|
val topo = state.topo
|
||||||
|
val owed = IntArray(state.playerCount)
|
||||||
|
for (h in 0 until topo.HEX_COUNT) {
|
||||||
|
if (state.terrains[h] != Terrain.GOLD || state.numbers[h] != number || h == state.robber) continue
|
||||||
|
for (v in topo.HEX_CORNERS[h]) {
|
||||||
|
val building = state.buildings[v] ?: continue
|
||||||
|
owed[building.owner] += if (building.type == BuildingType.CITY) 2 else 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return (0 until state.playerCount)
|
||||||
|
.map { (state.turn + it) % state.playerCount }
|
||||||
|
.filter { owed[it] > 0 }
|
||||||
|
.map { GoldOwed(it, owed[it]) }
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun applyDiscard(state: CatanState, seat: Int, move: Discard): CatanState {
|
private fun applyDiscard(state: CatanState, seat: Int, move: Discard): CatanState {
|
||||||
@@ -537,7 +622,8 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
((after + 1) until state.playerCount).firstOrNull { state.resourceCount(it) > 7 }
|
((after + 1) until state.playerCount).firstOrNull { state.resourceCount(it) > 7 }
|
||||||
|
|
||||||
private fun applyRobber(state: CatanState, seat: Int, move: MoveRobber): CatanState {
|
private fun applyRobber(state: CatanState, seat: Int, move: MoveRobber): CatanState {
|
||||||
val hex = CatanBoard.hexIndex[move.hex]
|
if (state.isCk) return CatanCk.applyRobber(state, seat, move)
|
||||||
|
val hex = state.topo.hexIndex[move.hex]
|
||||||
?: throw IllegalArgumentException("No hex at ${move.hex}")
|
?: throw IllegalArgumentException("No hex at ${move.hex}")
|
||||||
var s = state.copy(robber = hex, rngStep = state.rngStep + 1)
|
var s = state.copy(robber = hex, rngStep = state.rngStep + 1)
|
||||||
var stolen: String? = null
|
var stolen: String? = null
|
||||||
@@ -553,8 +639,8 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
return s.copy(
|
return s.copy(
|
||||||
phase = CatanPhase.PLAYING,
|
phase = CatanPhase.PLAYING,
|
||||||
log = s.log + "Seat $seat moves the robber to the ${terrainName(state.terrains[hex])}" +
|
log = s.log + ("Seat $seat moves the robber to the ${terrainName(state.terrains[hex])}" +
|
||||||
" (${move.hex.q},${move.hex.r})$stolen.",
|
" (${move.hex.q},${move.hex.r})$stolen."),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -566,11 +652,73 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
if (free) {
|
if (free) {
|
||||||
val left = s.pendingFreeRoads - 1
|
val left = s.pendingFreeRoads - 1
|
||||||
s = s.copy(pendingFreeRoads = left)
|
s = s.copy(pendingFreeRoads = left)
|
||||||
if (left == 0) s = s.copy(phase = CatanPhase.PLAYING)
|
if (left == 0) s = s.copy(phase = phaseAfterRoads(s))
|
||||||
}
|
}
|
||||||
return checkWin(s.copy(log = s.log + "Seat $seat builds a road on ${move.edge}."))
|
return checkWin(s.copy(log = s.log + "Seat $seat builds a road on ${move.edge}."))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private fun applyBuildShip(state: CatanState, seat: Int, move: BuildShip): CatanState {
|
||||||
|
val free = state.phase == CatanPhase.FREE_ROADS
|
||||||
|
val sea = state.sea!!
|
||||||
|
var s = state.copy(
|
||||||
|
sea = sea.copy(
|
||||||
|
ships = sea.ships.toMutableList().also { it[move.edge] = seat },
|
||||||
|
builtThisTurn = sea.builtThisTurn + move.edge,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
if (!free) s = payCost(s, seat, SeaRules.SHIP_COST)
|
||||||
|
s = refreshLongestRoad(s)
|
||||||
|
if (free) {
|
||||||
|
val left = s.pendingFreeRoads - 1
|
||||||
|
s = s.copy(pendingFreeRoads = left)
|
||||||
|
if (left == 0) s = s.copy(phase = phaseAfterRoads(s))
|
||||||
|
}
|
||||||
|
return checkWin(s.copy(log = s.log + "Seat $seat launches a ship on ${move.edge}."))
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyMoveShip(state: CatanState, seat: Int, move: MoveShip): CatanState {
|
||||||
|
val sea = state.sea!!
|
||||||
|
val ships = sea.ships.toMutableList().also {
|
||||||
|
it[move.from] = NO_PLAYER
|
||||||
|
it[move.to] = seat
|
||||||
|
}
|
||||||
|
// The ship is on a new edge, but it has sailed for the turn and may not sail again.
|
||||||
|
val s = state.copy(
|
||||||
|
sea = sea.copy(ships = ships, shipMoved = true, builtThisTurn = sea.builtThisTurn + move.to),
|
||||||
|
)
|
||||||
|
return checkWin(refreshLongestRoad(s).let {
|
||||||
|
it.copy(log = it.log + "Seat $seat sails a ship from ${move.from} to ${move.to}.")
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyMovePirate(state: CatanState, seat: Int, move: MovePirate): CatanState {
|
||||||
|
val hex = state.topo.hexIndex[move.hex] ?: throw IllegalArgumentException("No hex at ${move.hex}")
|
||||||
|
var s = state.copy(sea = state.sea!!.copy(pirate = hex), rngStep = state.rngStep + 1)
|
||||||
|
var stolen = ""
|
||||||
|
if (move.victim != null) {
|
||||||
|
val rng = Random(state.seed * 1_000_003L + state.rngStep)
|
||||||
|
val victimHand = state.handOf(move.victim)
|
||||||
|
val card = victimHand[rng.nextInt(victimHand.size)]
|
||||||
|
val less = withCards(s.resources, move.victim, listOf(card), -1)
|
||||||
|
s = s.copy(resources = withCards(less, seat, listOf(card), 1))
|
||||||
|
stolen = " and takes a ${card.name.lowercase()} from seat ${move.victim}"
|
||||||
|
}
|
||||||
|
return s.copy(
|
||||||
|
phase = CatanPhase.PLAYING,
|
||||||
|
log = s.log + "Seat $seat sends the pirate to (${move.hex.q},${move.hex.r})$stolen.",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyPickGold(state: CatanState, seat: Int, move: PickGold): CatanState {
|
||||||
|
val sea = state.sea!!
|
||||||
|
val s = state.copy(
|
||||||
|
resources = withCards(state.resources, seat, move.cards, 1),
|
||||||
|
sea = sea.copy(gold = sea.gold.drop(1)),
|
||||||
|
log = state.log + "Seat $seat takes ${describe(countOf(move.cards))} from the gold.",
|
||||||
|
)
|
||||||
|
return SeaRules.settleGold(s)
|
||||||
|
}
|
||||||
|
|
||||||
private fun applyBuildSettlement(state: CatanState, seat: Int, move: BuildSettlement): CatanState {
|
private fun applyBuildSettlement(state: CatanState, seat: Int, move: BuildSettlement): CatanState {
|
||||||
var s = state.copy(
|
var s = state.copy(
|
||||||
buildings = state.buildings.toMutableList().also {
|
buildings = state.buildings.toMutableList().also {
|
||||||
@@ -578,6 +726,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
},
|
},
|
||||||
)
|
)
|
||||||
s = payCost(s, seat, SETTLEMENT_COST)
|
s = payCost(s, seat, SETTLEMENT_COST)
|
||||||
|
s = SeaRules.claimIsland(s, seat, move.vertex)
|
||||||
// A settlement can break another player's road, so the award is
|
// A settlement can break another player's road, so the award is
|
||||||
// recomputed for everyone.
|
// recomputed for everyone.
|
||||||
s = refreshLongestRoad(s)
|
s = refreshLongestRoad(s)
|
||||||
@@ -591,7 +740,10 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
},
|
},
|
||||||
)
|
)
|
||||||
s = payCost(s, seat, CITY_COST)
|
s = payCost(s, seat, CITY_COST)
|
||||||
return checkWin(s.copy(log = s.log + "Seat $seat raises a city at ${move.vertex}."))
|
s = s.copy(log = s.log + "Seat $seat raises a city at ${move.vertex}.")
|
||||||
|
// A city can be what a waiting metropolis needed.
|
||||||
|
if (s.isCk) s = CatanCk.afterCityBuilt(s, seat)
|
||||||
|
return checkWin(s)
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun applyBuyDevCard(state: CatanState, seat: Int): CatanState {
|
private fun applyBuyDevCard(state: CatanState, seat: Int): CatanState {
|
||||||
@@ -730,6 +882,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun applyAcceptTrade(state: CatanState, seat: Int): CatanState {
|
private fun applyAcceptTrade(state: CatanState, seat: Int): CatanState {
|
||||||
|
if (state.ck?.goodsOffer != null) return CatanCk.answerOffer(state, seat, accept = true)
|
||||||
val offer = state.pendingTrade!!
|
val offer = state.pendingTrade!!
|
||||||
return state.copy(
|
return state.copy(
|
||||||
phase = CatanPhase.PLAYING,
|
phase = CatanPhase.PLAYING,
|
||||||
@@ -740,7 +893,11 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun applyDeclineTrade(state: CatanState, seat: Int): CatanState =
|
private fun applyDeclineTrade(state: CatanState, seat: Int): CatanState =
|
||||||
|
if (state.ck?.goodsOffer != null) {
|
||||||
|
CatanCk.answerOffer(state, seat, accept = false)
|
||||||
|
} else {
|
||||||
advanceTrade(state, state.pendingTrade!!, seat, "Seat $seat declines the offer.")
|
advanceTrade(state, state.pendingTrade!!, seat, "Seat $seat declines the offer.")
|
||||||
|
}
|
||||||
|
|
||||||
private fun applyCounterTrade(state: CatanState, seat: Int, move: CounterTrade): CatanState {
|
private fun applyCounterTrade(state: CatanState, seat: Int, move: CounterTrade): CatanState {
|
||||||
val offer = state.pendingTrade!!
|
val offer = state.pendingTrade!!
|
||||||
@@ -754,6 +911,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun applyAcceptCounter(state: CatanState, move: AcceptCounter): CatanState {
|
private fun applyAcceptCounter(state: CatanState, move: AcceptCounter): CatanState {
|
||||||
|
if (state.ck?.goodsOffer != null) return CatanCk.acceptCounter(state, move)
|
||||||
val offer = state.pendingTrade!!
|
val offer = state.pendingTrade!!
|
||||||
val counter = offer.counters.first { it.by == move.seat }
|
val counter = offer.counters.first { it.by == move.seat }
|
||||||
return state.copy(
|
return state.copy(
|
||||||
@@ -765,7 +923,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun applyDismissCounters(state: CatanState): CatanState =
|
private fun applyDismissCounters(state: CatanState): CatanState =
|
||||||
state.copy(
|
if (state.ck?.goodsOffer != null) CatanCk.dismissCounters(state) else state.copy(
|
||||||
phase = CatanPhase.PLAYING,
|
phase = CatanPhase.PLAYING,
|
||||||
pendingTrade = null,
|
pendingTrade = null,
|
||||||
log = state.log + "Seat ${state.turn} turns the counter-offers down.",
|
log = state.log + "Seat ${state.turn} turns the counter-offers down.",
|
||||||
@@ -777,8 +935,8 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
val s = state.copy(resources = withCards(paid, seat, listOf(move.get), 1))
|
val s = state.copy(resources = withCards(paid, seat, listOf(move.get), 1))
|
||||||
val via = if (ratio == 4) "the bank" else "a $ratio:1 harbour"
|
val via = if (ratio == 4) "the bank" else "a $ratio:1 harbour"
|
||||||
return s.copy(
|
return s.copy(
|
||||||
log = s.log + "Seat $seat trades $ratio ${move.give.name.lowercase()} for a " +
|
log = s.log + ("Seat $seat trades $ratio ${move.give.name.lowercase()} for a " +
|
||||||
"${move.get.name.lowercase()} via $via.",
|
"${move.get.name.lowercase()} via $via."),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -788,12 +946,13 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
if (settled.phase == CatanPhase.GAME_OVER) return settled
|
if (settled.phase == CatanPhase.GAME_OVER) return settled
|
||||||
|
|
||||||
val next = (state.turn + 1) % state.playerCount
|
val next = (state.turn + 1) % state.playerCount
|
||||||
val s = state.copy(
|
val s = (if (state.isCk) CatanCk.endTurn(state) else state).copy(
|
||||||
turn = next,
|
turn = next,
|
||||||
turnNumber = state.turnNumber + 1,
|
turnNumber = state.turnNumber + 1,
|
||||||
phase = CatanPhase.AWAIT_ROLL,
|
phase = CatanPhase.AWAIT_ROLL,
|
||||||
devCardPlayedThisTurn = false,
|
devCardPlayedThisTurn = false,
|
||||||
pendingTrade = null,
|
pendingTrade = null,
|
||||||
|
sea = state.sea?.copy(builtThisTurn = emptyList(), shipMoved = false),
|
||||||
)
|
)
|
||||||
// Someone can cross the target on another player's turn (a broken
|
// Someone can cross the target on another player's turn (a broken
|
||||||
// Longest Road re-awarded to a third player); they win when their
|
// Longest Road re-awarded to a third player); they win when their
|
||||||
@@ -801,9 +960,13 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
return checkWin(s)
|
return checkWin(s)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Where play goes after free roads: a card played before the roll returns to the roll. */
|
||||||
|
private fun phaseAfterRoads(state: CatanState): CatanPhase =
|
||||||
|
if (state.ck?.back == Back.AWAIT_ROLL) CatanPhase.AWAIT_ROLL else CatanPhase.PLAYING
|
||||||
|
|
||||||
private fun applyEndFreeRoads(state: CatanState, seat: Int): CatanState =
|
private fun applyEndFreeRoads(state: CatanState, seat: Int): CatanState =
|
||||||
state.copy(
|
state.copy(
|
||||||
phase = CatanPhase.PLAYING,
|
phase = phaseAfterRoads(state),
|
||||||
pendingFreeRoads = 0,
|
pendingFreeRoads = 0,
|
||||||
log = state.log + "Seat $seat forfeits the remaining free road.",
|
log = state.log + "Seat $seat forfeits the remaining free road.",
|
||||||
)
|
)
|
||||||
@@ -819,6 +982,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* view or the host's copy.
|
* view or the host's copy.
|
||||||
*/
|
*/
|
||||||
fun publicVictoryPoints(state: CatanState): List<Int> {
|
fun publicVictoryPoints(state: CatanState): List<Int> {
|
||||||
|
if (state.isCk) return CatanCk.publicVictoryPoints(state)
|
||||||
val points = IntArray(state.playerCount)
|
val points = IntArray(state.playerCount)
|
||||||
state.buildings.forEach { building ->
|
state.buildings.forEach { building ->
|
||||||
if (building != null) {
|
if (building != null) {
|
||||||
@@ -827,6 +991,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
}
|
}
|
||||||
state.longestRoadOwner?.let { points[it] += 5 }
|
state.longestRoadOwner?.let { points[it] += 5 }
|
||||||
state.largestArmyOwner?.let { points[it] += 5 }
|
state.largestArmyOwner?.let { points[it] += 5 }
|
||||||
|
if (state.isSea) for (seat in points.indices) points[seat] += SeaRules.bonusPoints(state, seat)
|
||||||
return points.toList()
|
return points.toList()
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -834,7 +999,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
publicVictoryPoints(state)[seat] +
|
publicVictoryPoints(state)[seat] +
|
||||||
state.devHands[seat].count { it.type == DevCardType.VICTORY_POINT }
|
state.devHands[seat].count { it.type == DevCardType.VICTORY_POINT }
|
||||||
|
|
||||||
private fun checkWin(state: CatanState): CatanState {
|
internal fun checkWin(state: CatanState): CatanState {
|
||||||
if (state.phase == CatanPhase.GAME_OVER) return state
|
if (state.phase == CatanPhase.GAME_OVER) return state
|
||||||
val seat = state.turn
|
val seat = state.turn
|
||||||
val points = victoryPoints(state, seat)
|
val points = victoryPoints(state, seat)
|
||||||
@@ -855,7 +1020,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* road falls below five segments the award reopens to the longest road
|
* road falls below five segments the award reopens to the longest road
|
||||||
* of five or more, lowest seat first on a tie.
|
* of five or more, lowest seat first on a tie.
|
||||||
*/
|
*/
|
||||||
private fun refreshLongestRoad(state: CatanState): CatanState {
|
internal fun refreshLongestRoad(state: CatanState): CatanState {
|
||||||
val lengths = (0 until state.playerCount).map { longestRoadFor(state, it) }
|
val lengths = (0 until state.playerCount).map { longestRoadFor(state, it) }
|
||||||
val holder = state.longestRoadOwner
|
val holder = state.longestRoadOwner
|
||||||
val best = lengths
|
val best = lengths
|
||||||
@@ -885,15 +1050,17 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
* one road, not two — the intersection is a branch).
|
* one road, not two — the intersection is a branch).
|
||||||
*/
|
*/
|
||||||
fun longestRoadFor(state: CatanState, seat: Int): Int {
|
fun longestRoadFor(state: CatanState, seat: Int): Int {
|
||||||
|
if (state.isSea) return SeaRules.longestRouteFor(state, seat)
|
||||||
var best = 0
|
var best = 0
|
||||||
val blocked = BooleanArray(CatanBoard.VERTEX_COUNT)
|
val blocked = BooleanArray(state.topo.VERTEX_COUNT)
|
||||||
for (v in 0 until CatanBoard.VERTEX_COUNT) {
|
for (v in 0 until state.topo.VERTEX_COUNT) {
|
||||||
val building = state.buildings[v]
|
val building = state.buildings[v]
|
||||||
if (building != null && building.owner != seat) blocked[v] = true
|
if (building != null && building.owner != seat) blocked[v] = true
|
||||||
}
|
}
|
||||||
for (start in 0 until CatanBoard.VERTEX_COUNT) {
|
state.ck?.knights?.forEach { if (it.owner != seat) blocked[it.vertex] = true }
|
||||||
if (CatanBoard.VERTEX_EDGES[start].none { state.roads[it] == seat }) continue
|
for (start in 0 until state.topo.VERTEX_COUNT) {
|
||||||
val visited = BooleanArray(CatanBoard.VERTEX_COUNT)
|
if (state.topo.VERTEX_EDGES[start].none { state.roads[it] == seat }) continue
|
||||||
|
val visited = BooleanArray(state.topo.VERTEX_COUNT)
|
||||||
best = maxOf(best, roadDfs(state, seat, start, blocked, visited))
|
best = maxOf(best, roadDfs(state, seat, start, blocked, visited))
|
||||||
}
|
}
|
||||||
return best
|
return best
|
||||||
@@ -908,9 +1075,9 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
): Int {
|
): Int {
|
||||||
visited[v] = true
|
visited[v] = true
|
||||||
var best = 0
|
var best = 0
|
||||||
for (e in CatanBoard.VERTEX_EDGES[v]) {
|
for (e in state.topo.VERTEX_EDGES[v]) {
|
||||||
if (state.roads[e] != seat) continue
|
if (state.roads[e] != seat) continue
|
||||||
val w = CatanBoard.otherEnd(e, v)
|
val w = state.topo.otherEnd(e, v)
|
||||||
if (visited[w]) continue
|
if (visited[w]) continue
|
||||||
if (blocked[w]) {
|
if (blocked[w]) {
|
||||||
// The segment may run up to an opponent's building, but not
|
// The segment may run up to an opponent's building, but not
|
||||||
@@ -952,7 +1119,7 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
fun bankSupply(state: CatanState, resource: Resource): Int =
|
fun bankSupply(state: CatanState, resource: Resource): Int =
|
||||||
BANK_PER_RESOURCE - state.resources.sumOf { it[resource] ?: 0 }
|
BANK_PER_RESOURCE - state.resources.sumOf { it[resource] ?: 0 }
|
||||||
|
|
||||||
private fun affordable(state: CatanState, seat: Int, cost: Map<Resource, Int>): Boolean =
|
internal fun affordable(state: CatanState, seat: Int, cost: Map<Resource, Int>): Boolean =
|
||||||
cost.all { (resource, need) -> (state.resources[seat][resource] ?: 0) >= need }
|
cost.all { (resource, need) -> (state.resources[seat][resource] ?: 0) >= need }
|
||||||
|
|
||||||
private fun payCost(state: CatanState, seat: Int, cost: Map<Resource, Int>): CatanState =
|
private fun payCost(state: CatanState, seat: Int, cost: Map<Resource, Int>): CatanState =
|
||||||
@@ -996,13 +1163,23 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
for (port in state.ports) {
|
for (port in state.ports) {
|
||||||
if (port.resource != null && port.resource != give) continue
|
if (port.resource != null && port.resource != give) continue
|
||||||
if (port.ratio >= best) continue
|
if (port.ratio >= best) continue
|
||||||
val (a, b) = CatanBoard.EDGE_VERTICES[port.edge]
|
val (a, b) = state.topo.EDGE_VERTICES[port.edge]
|
||||||
val mine = state.buildings[a]?.owner == seat || state.buildings[b]?.owner == seat
|
val mine = state.buildings[a]?.owner == seat || state.buildings[b]?.owner == seat
|
||||||
if (mine) best = port.ratio
|
if (mine) best = port.ratio
|
||||||
}
|
}
|
||||||
return best
|
return best
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** 3 if [seat] has a settlement on a generic harbour, else the bank's 4. */
|
||||||
|
fun genericPortRatio(state: CatanState, seat: Int): Int {
|
||||||
|
for (port in state.ports) {
|
||||||
|
if (port.resource != null) continue
|
||||||
|
val (a, b) = state.topo.EDGE_VERTICES[port.edge]
|
||||||
|
if (state.buildings[a]?.owner == seat || state.buildings[b]?.owner == seat) return port.ratio
|
||||||
|
}
|
||||||
|
return 4
|
||||||
|
}
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
// Results, redaction and wire format
|
// Results, redaction and wire format
|
||||||
// -----------------------------------------------------------------------
|
// -----------------------------------------------------------------------
|
||||||
@@ -1017,12 +1194,15 @@ object CatanRules : GameRules<CatanState, CatanMove> {
|
|||||||
else -> "Seat $winner wins"
|
else -> "Seat $winner wins"
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun viewFor(state: CatanState, seat: Int): CatanState = state.copy(
|
override fun viewFor(state: CatanState, seat: Int): CatanState = CatanCk.viewFor(
|
||||||
|
state.copy(
|
||||||
// Hidden information stays with the holder and the host.
|
// Hidden information stays with the holder and the host.
|
||||||
devDeck = emptyList(),
|
devDeck = emptyList(),
|
||||||
devHands = state.devHands.mapIndexed { index, hand ->
|
devHands = state.devHands.mapIndexed { index, hand ->
|
||||||
if (index == seat) hand else emptyList()
|
if (index == seat) hand else emptyList()
|
||||||
},
|
},
|
||||||
|
),
|
||||||
|
seat,
|
||||||
)
|
)
|
||||||
|
|
||||||
override fun encodeState(state: CatanState): String = json.encodeToString(state)
|
override fun encodeState(state: CatanState): String = json.encodeToString(state)
|
||||||
|
|||||||
@@ -0,0 +1,144 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
import kotlin.random.Random
|
||||||
|
|
||||||
|
/** The Seafarers maps on offer. Each is a fixed arrangement of land and sea; the tiles and numbers on it are shuffled. */
|
||||||
|
@Serializable
|
||||||
|
enum class SeaScenario(val title: String, val blurb: String) {
|
||||||
|
NEW_SHORES(
|
||||||
|
"Heading for New Shores",
|
||||||
|
"One large home island and three small ones to find by ship. Gold fields on two of the small islands.",
|
||||||
|
),
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The Seafarers maps as geometry plus a generator for one game's tiles.
|
||||||
|
*
|
||||||
|
* A map is drawn below as text: `.` is sea, `#` a land hex that gets a random resource,
|
||||||
|
* `$` a gold field, `D` the desert. Odd rows are shifted half a hex to the right (the usual
|
||||||
|
* "odd-r" offset layout). The outermost ring is always sea, so every coast is closed.
|
||||||
|
*/
|
||||||
|
object SeaBoards {
|
||||||
|
|
||||||
|
private val NEW_SHORES_MAP = listOf(
|
||||||
|
"..........",
|
||||||
|
"...##.....",
|
||||||
|
"..####.$#.",
|
||||||
|
".#####..#.",
|
||||||
|
".##D###...",
|
||||||
|
"..####..#.",
|
||||||
|
".......##.",
|
||||||
|
".$#.......",
|
||||||
|
"..........",
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun rows(scenario: SeaScenario): List<String> = when (scenario) {
|
||||||
|
SeaScenario.NEW_SHORES -> NEW_SHORES_MAP
|
||||||
|
}
|
||||||
|
|
||||||
|
private val topologies = HashMap<SeaScenario, Topology>()
|
||||||
|
|
||||||
|
/** The frame of [scenario]: every hex, with its land mask. Built once and shared. */
|
||||||
|
fun topology(scenario: SeaScenario): Topology = synchronized(topologies) {
|
||||||
|
topologies.getOrPut(scenario) { build(scenario) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Hex (row, col) of the text map as an axial coordinate (odd-r offset). */
|
||||||
|
private fun coord(row: Int, col: Int): HexCoord = HexCoord(col - (row - (row and 1)) / 2, row)
|
||||||
|
|
||||||
|
private fun build(scenario: SeaScenario): Topology {
|
||||||
|
val map = rows(scenario)
|
||||||
|
val hexes = mutableListOf<HexCoord>()
|
||||||
|
val land = mutableListOf<Boolean>()
|
||||||
|
map.forEachIndexed { row, text ->
|
||||||
|
text.forEachIndexed { col, ch ->
|
||||||
|
hexes += coord(row, col)
|
||||||
|
land += ch != '.'
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return Topology(hexes, land, standardFrame = false, harbours = 9)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Terrain kind the map asks of each hex: sea, gold, desert, or "pick a resource". */
|
||||||
|
private fun kinds(scenario: SeaScenario): List<Char> = rows(scenario).flatMap { it.toList() }
|
||||||
|
|
||||||
|
/** One game's tiles on a Seafarers map. */
|
||||||
|
@Serializable
|
||||||
|
data class Generated(
|
||||||
|
val terrains: List<Terrain>,
|
||||||
|
val numbers: List<Int>,
|
||||||
|
val robber: Int,
|
||||||
|
val pirate: Int,
|
||||||
|
val ports: List<Port>,
|
||||||
|
val home: Int,
|
||||||
|
)
|
||||||
|
|
||||||
|
private val RESOURCE_TILES = listOf(
|
||||||
|
Terrain.FOREST, Terrain.PASTURE, Terrain.FIELDS, Terrain.HILLS, Terrain.MOUNTAINS,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** Number tokens: the standard 18 plus ten more, so every land hex but the desert has one. */
|
||||||
|
private val TOKENS = listOf(2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10, 11, 11, 12) +
|
||||||
|
listOf(3, 4, 5, 6, 8, 9, 10, 11, 5, 9)
|
||||||
|
|
||||||
|
fun generate(scenario: SeaScenario, seed: Long): Generated {
|
||||||
|
val topo = topology(scenario)
|
||||||
|
val kinds = kinds(scenario)
|
||||||
|
val random = Random(seed)
|
||||||
|
|
||||||
|
// Resources fill the '#' hexes as evenly as the count allows, in shuffled order.
|
||||||
|
val plain = kinds.indices.filter { kinds[it] == '#' }
|
||||||
|
val pool = List(plain.size) { RESOURCE_TILES[it % RESOURCE_TILES.size] }.shuffled(random)
|
||||||
|
val terrains = MutableList(kinds.size) { Terrain.SEA }
|
||||||
|
kinds.forEachIndexed { h, ch ->
|
||||||
|
terrains[h] = when (ch) {
|
||||||
|
'$' -> Terrain.GOLD
|
||||||
|
'D' -> Terrain.DESERT
|
||||||
|
'#' -> pool[plain.indexOf(h)]
|
||||||
|
else -> Terrain.SEA
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val numbered = terrains.indices.filter { terrains[it] != Terrain.SEA && terrains[it] != Terrain.DESERT }
|
||||||
|
check(numbered.size <= TOKENS.size) { "Not enough number tokens for ${numbered.size} hexes" }
|
||||||
|
val tokens = TOKENS.take(numbered.size).shuffled(random)
|
||||||
|
val numbers = IntArray(terrains.size)
|
||||||
|
var placed = false
|
||||||
|
var attempt = 0
|
||||||
|
while (!placed && attempt < 200) {
|
||||||
|
val order = numbered.shuffled(random)
|
||||||
|
val assigned = IntArray(terrains.size)
|
||||||
|
order.forEachIndexed { i, h -> assigned[h] = tokens[i] }
|
||||||
|
val reds = numbered.filter { assigned[it] == 6 || assigned[it] == 8 }
|
||||||
|
val clash = reds.any { a -> reds.any { b -> a < b && topo.hexesAdjacent(a, b) } }
|
||||||
|
if (!clash || attempt == 199) {
|
||||||
|
assigned.copyInto(numbers)
|
||||||
|
placed = true
|
||||||
|
}
|
||||||
|
attempt++
|
||||||
|
}
|
||||||
|
|
||||||
|
val portTypes = (
|
||||||
|
listOf(Resource.LUMBER, Resource.BRICK, Resource.WOOL, Resource.GRAIN, Resource.ORE) + List(4) { null }
|
||||||
|
).shuffled(random)
|
||||||
|
val ports = topo.PORT_POSITIONS.mapIndexed { i, edge ->
|
||||||
|
val resource = portTypes[i % portTypes.size]
|
||||||
|
if (resource == null) Port(edge, null, 3) else Port(edge, resource, 2)
|
||||||
|
}
|
||||||
|
|
||||||
|
val desert = terrains.indexOf(Terrain.DESERT).takeIf { it >= 0 }
|
||||||
|
?: numbered.first()
|
||||||
|
val home = (0 until topo.islandCount).maxByOrNull { island -> topo.islandOf.count { it == island } } ?: 0
|
||||||
|
// The pirate starts in the open sea: the sea hex farthest from every shore.
|
||||||
|
val sea = terrains.indices.filter { terrains[it] == Terrain.SEA }
|
||||||
|
val pirate = sea.maxByOrNull { h ->
|
||||||
|
val c = topo.HEXES[h]
|
||||||
|
terrains.indices.filter { terrains[it] != Terrain.SEA }.minOfOrNull {
|
||||||
|
Topology.hexDistance(c.q, c.r, topo.HEXES[it].q, topo.HEXES[it].r)
|
||||||
|
} ?: 0
|
||||||
|
} ?: sea.first()
|
||||||
|
|
||||||
|
return Generated(terrains, numbers.toList(), desert, pirate, ports, home)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,205 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The rules Seafarers adds to the base game, kept apart from [CatanRules] so the base
|
||||||
|
* game's code reads as it always did. [CatanRules] calls in here only when a game has
|
||||||
|
* [CatanState.sea]. See `docs/RULES-catan-seafarers.md`.
|
||||||
|
*/
|
||||||
|
internal object SeaRules {
|
||||||
|
|
||||||
|
const val MAX_SHIPS = 15
|
||||||
|
|
||||||
|
/** Points for being the first to settle an island other than the home island. */
|
||||||
|
const val ISLAND_BONUS = 2
|
||||||
|
|
||||||
|
val SHIP_COST: Map<Resource, Int> = mapOf(Resource.LUMBER to 1, Resource.WOOL to 1)
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Ships
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
private fun fleetOf(state: CatanState, seat: Int): Int = state.sea!!.ships.count { it == seat }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Whether [seat]'s ships and towns reach [vertex], so a ship may start there. A town
|
||||||
|
* of anyone else is a wall; [ignoring] is a ship that is being lifted off the board.
|
||||||
|
*/
|
||||||
|
private fun shipReaches(state: CatanState, seat: Int, vertex: Int, ignoring: Int): Boolean {
|
||||||
|
val building = state.buildings[vertex]
|
||||||
|
if (building != null) return building.owner == seat
|
||||||
|
val sea = state.sea!!
|
||||||
|
return state.topo.VERTEX_EDGES[vertex].any { it != ignoring && sea.ships[it] == seat }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A sea edge a ship could sit on, joined to [seat]'s fleet or a town of theirs. */
|
||||||
|
private fun shipSites(state: CatanState, seat: Int, ignoring: Int = -1): List<Int> {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea!!
|
||||||
|
return (0 until topo.EDGE_COUNT).filter { e ->
|
||||||
|
topo.edgeSea[e] &&
|
||||||
|
state.roads[e] == NO_PLAYER &&
|
||||||
|
(sea.ships[e] == NO_PLAYER || e == ignoring) &&
|
||||||
|
sea.pirate !in topo.EDGE_HEXES[e] &&
|
||||||
|
topo.EDGE_VERTICES[e].let { (a, b) ->
|
||||||
|
shipReaches(state, seat, a, ignoring) || shipReaches(state, seat, b, ignoring)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun buildShipMoves(state: CatanState, seat: Int): List<BuildShip> =
|
||||||
|
if (fleetOf(state, seat) >= MAX_SHIPS) emptyList() else shipSites(state, seat).map { BuildShip(it) }
|
||||||
|
|
||||||
|
/** Whether the ship on [edge] sits at the open end of a route: one end touches nothing else of [seat]'s. */
|
||||||
|
private fun atOpenEnd(state: CatanState, seat: Int, edge: Int): Boolean {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea!!
|
||||||
|
return topo.EDGE_VERTICES[edge].toList().any { v ->
|
||||||
|
state.buildings[v] == null &&
|
||||||
|
topo.VERTEX_EDGES[v].none { it != edge && (state.roads[it] == seat || sea.ships[it] == seat) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A ship may sail once a turn, never the turn it was built, only from the open end of a route. */
|
||||||
|
fun moveShipMoves(state: CatanState, seat: Int): List<MoveShip> {
|
||||||
|
val sea = state.sea!!
|
||||||
|
if (sea.shipMoved) return emptyList()
|
||||||
|
val moves = mutableListOf<MoveShip>()
|
||||||
|
for (e in sea.ships.indices) {
|
||||||
|
if (sea.ships[e] != seat || e in sea.builtThisTurn || !atOpenEnd(state, seat, e)) continue
|
||||||
|
shipSites(state, seat, ignoring = e).filter { it != e }.forEach { moves += MoveShip(e, it) }
|
||||||
|
}
|
||||||
|
return moves
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Pirate
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Seats with a ship beside [hex] that hold at least one card: whom the pirate can rob there. */
|
||||||
|
private fun pirateVictims(state: CatanState, thief: Int, hex: Int): List<Int> {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea!!
|
||||||
|
return (0 until topo.EDGE_COUNT).filter { hex in topo.EDGE_HEXES[it] }
|
||||||
|
.map { sea.ships[it] }
|
||||||
|
.filter { it != NO_PLAYER && it != thief }
|
||||||
|
.distinct()
|
||||||
|
.filter { state.resourceCount(it) > 0 }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun pirateMoves(state: CatanState, seat: Int): List<MovePirate> {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea!!
|
||||||
|
val moves = mutableListOf<MovePirate>()
|
||||||
|
for (h in 0 until topo.HEX_COUNT) {
|
||||||
|
if (topo.land[h] || h == sea.pirate) continue
|
||||||
|
val victims = pirateVictims(state, seat, h)
|
||||||
|
if (victims.isEmpty()) {
|
||||||
|
moves += MovePirate(topo.HEXES[h])
|
||||||
|
} else {
|
||||||
|
victims.forEach { moves += MovePirate(topo.HEXES[h], it) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return moves
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Gold
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Every way the seat at the front of the gold queue can choose its cards, supply permitting. */
|
||||||
|
fun goldMoves(state: CatanState): List<PickGold> {
|
||||||
|
val owed = state.sea!!.gold.firstOrNull() ?: return emptyList()
|
||||||
|
val supply = Resource.entries.associateWith { CatanRules.bankSupply(state, it) }
|
||||||
|
val take = minOf(owed.count, supply.values.sum())
|
||||||
|
val picks = mutableListOf<PickGold>()
|
||||||
|
fun walk(index: Int, left: Int, acc: MutableList<Resource>) {
|
||||||
|
if (left == 0) {
|
||||||
|
picks += PickGold(acc.toList())
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if (index == Resource.entries.size) return
|
||||||
|
val resource = Resource.entries[index]
|
||||||
|
for (n in 0..minOf(left, supply.getValue(resource))) {
|
||||||
|
repeat(n) { acc += resource }
|
||||||
|
walk(index + 1, left - n, acc)
|
||||||
|
repeat(n) { acc.removeAt(acc.size - 1) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
walk(0, take, mutableListOf())
|
||||||
|
return picks
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Drops queue entries the bank can no longer pay, and leaves the gold phase once nobody is owed. */
|
||||||
|
fun settleGold(state: CatanState): CatanState {
|
||||||
|
val sea = state.sea!!
|
||||||
|
val supply = Resource.entries.sumOf { CatanRules.bankSupply(state, it) }
|
||||||
|
val queue = if (supply > 0) sea.gold else emptyList()
|
||||||
|
return if (queue.isEmpty()) {
|
||||||
|
state.copy(sea = sea.copy(gold = emptyList()), phase = CatanPhase.PLAYING)
|
||||||
|
} else {
|
||||||
|
state.copy(sea = sea.copy(gold = queue), phase = CatanPhase.GOLD)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Islands and scoring
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** The bonus points [seat] holds for first landings. */
|
||||||
|
fun bonusPoints(state: CatanState, seat: Int): Int =
|
||||||
|
(state.sea?.islandBonus?.count { it == seat } ?: 0) * ISLAND_BONUS
|
||||||
|
|
||||||
|
/** After a settlement on [vertex]: award the island bonus if it is the first on a new island. */
|
||||||
|
fun claimIsland(state: CatanState, seat: Int, vertex: Int): CatanState {
|
||||||
|
val sea = state.sea ?: return state
|
||||||
|
val island = state.topo.vertexIsland[vertex]
|
||||||
|
if (island < 0 || island == sea.home || sea.islandBonus[island] != NO_PLAYER) return state
|
||||||
|
val bonus = sea.islandBonus.toMutableList().also { it[island] = seat }
|
||||||
|
return state.copy(
|
||||||
|
sea = sea.copy(islandBonus = bonus),
|
||||||
|
log = state.log + "Seat $seat is the first to settle a new island: +$ISLAND_BONUS victory points.",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
// Longest route
|
||||||
|
// -----------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The seat's longest route over roads *and* ships. A route is a simple path of the seat's
|
||||||
|
* pieces that never runs through an opponent's town; it may change between road and ship
|
||||||
|
* only at a town of the seat's own.
|
||||||
|
*/
|
||||||
|
fun longestRouteFor(state: CatanState, seat: Int): Int {
|
||||||
|
val topo = state.topo
|
||||||
|
val sea = state.sea!!
|
||||||
|
val blocked = BooleanArray(topo.VERTEX_COUNT) { v ->
|
||||||
|
state.buildings[v]?.let { it.owner != seat } == true
|
||||||
|
}
|
||||||
|
fun owns(e: Int) = state.roads[e] == seat || sea.ships[e] == seat
|
||||||
|
fun kind(e: Int) = if (state.roads[e] == seat) 0 else 1
|
||||||
|
|
||||||
|
fun walk(v: Int, arrivedBy: Int, visited: BooleanArray): Int {
|
||||||
|
visited[v] = true
|
||||||
|
var best = 0
|
||||||
|
val ownTown = state.buildings[v]?.owner == seat
|
||||||
|
for (e in topo.VERTEX_EDGES[v]) {
|
||||||
|
if (!owns(e)) continue
|
||||||
|
val k = kind(e)
|
||||||
|
if (arrivedBy != -1 && k != arrivedBy && !ownTown) continue
|
||||||
|
val w = topo.otherEnd(e, v)
|
||||||
|
if (visited[w]) continue
|
||||||
|
best = maxOf(best, if (blocked[w]) 1 else 1 + walk(w, k, visited))
|
||||||
|
}
|
||||||
|
visited[v] = false
|
||||||
|
return best
|
||||||
|
}
|
||||||
|
|
||||||
|
var best = 0
|
||||||
|
for (start in 0 until topo.VERTEX_COUNT) {
|
||||||
|
if (topo.VERTEX_EDGES[start].none { owns(it) }) continue
|
||||||
|
best = maxOf(best, walk(start, -1, BooleanArray(topo.VERTEX_COUNT)))
|
||||||
|
}
|
||||||
|
return best
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,101 @@
|
|||||||
|
package org.prolibertate.games.game.engine
|
||||||
|
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import java.io.File
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A game in progress, kept so it can be picked up again after the app has been
|
||||||
|
* closed.
|
||||||
|
*
|
||||||
|
* The match is stored the way the host holds it: the [config] it was dealt from
|
||||||
|
* (seed, seats, options) and the whole authoritative [stateJson], hidden cards
|
||||||
|
* included, as the game's own rules encode it. Nothing here knows what game it
|
||||||
|
* is; [gameId] is only the name of the slot.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class SavedMatch(
|
||||||
|
val gameId: String,
|
||||||
|
val config: TableConfig,
|
||||||
|
/** The seat the person at this device plays. */
|
||||||
|
val localSeat: Int,
|
||||||
|
val stateJson: String,
|
||||||
|
/** Wall-clock milliseconds when the position was written. */
|
||||||
|
val savedAtMillis: Long,
|
||||||
|
/** A line saying how the game stands, from the rules' own summary. */
|
||||||
|
val summary: String = "",
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* One saved game per game, kept as a file each under [directory].
|
||||||
|
*
|
||||||
|
* One slot per game rather than a list: the player is mid-way through a game of
|
||||||
|
* Chess or they are not. Starting a new one replaces it, which is what the
|
||||||
|
* resume prompt on the setup screen says.
|
||||||
|
*
|
||||||
|
* Writes are atomic — the position goes to a temporary file that is then moved
|
||||||
|
* over the real one — so being killed half way through a save leaves the
|
||||||
|
* previous position, not half of the new one. Reads never throw: a file that
|
||||||
|
* will not parse is a game that cannot be resumed, so it is removed and reported
|
||||||
|
* as absent.
|
||||||
|
*/
|
||||||
|
class SavedGameStore(private val directory: File) {
|
||||||
|
|
||||||
|
private val json = Json {
|
||||||
|
ignoreUnknownKeys = true
|
||||||
|
encodeDefaults = true
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun fileFor(gameId: String): File {
|
||||||
|
// The ids are catalogue constants, but they become file names, so
|
||||||
|
// nothing that could climb out of the directory is let through.
|
||||||
|
require(gameId.isNotBlank() && gameId.all { it.isLetterOrDigit() || it == '_' || it == '-' }) {
|
||||||
|
"Not a game id: $gameId"
|
||||||
|
}
|
||||||
|
return File(directory, "$gameId.json")
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Writes [match] over whatever was saved for its game. */
|
||||||
|
@Synchronized
|
||||||
|
fun save(match: SavedMatch) {
|
||||||
|
directory.mkdirs()
|
||||||
|
val target = fileFor(match.gameId)
|
||||||
|
val temp = File(directory, "${match.gameId}.json.tmp")
|
||||||
|
temp.writeText(json.encodeToString(SavedMatch.serializer(), match))
|
||||||
|
if (!temp.renameTo(target)) {
|
||||||
|
// Some file systems will not rename over an existing file.
|
||||||
|
target.delete()
|
||||||
|
check(temp.renameTo(target)) { "Could not write the saved game" }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The saved game for [gameId], or null if there is none or it cannot be read. */
|
||||||
|
@Synchronized
|
||||||
|
fun load(gameId: String): SavedMatch? {
|
||||||
|
val file = fileFor(gameId)
|
||||||
|
if (!file.isFile) return null
|
||||||
|
val match = runCatching {
|
||||||
|
json.decodeFromString(SavedMatch.serializer(), file.readText())
|
||||||
|
}.getOrNull()
|
||||||
|
if (match == null || match.gameId != gameId) {
|
||||||
|
file.delete()
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
return match
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Forgets the saved game for [gameId]. A no-op if there is none. */
|
||||||
|
@Synchronized
|
||||||
|
fun clear(gameId: String) {
|
||||||
|
fileFor(gameId).delete()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Every readable saved game, the most recently played first. */
|
||||||
|
@Synchronized
|
||||||
|
fun all(): List<SavedMatch> {
|
||||||
|
val files = directory.listFiles { f -> f.isFile && f.name.endsWith(".json") } ?: return emptyList()
|
||||||
|
return files
|
||||||
|
.mapNotNull { file -> runCatching { load(file.name.removeSuffix(".json")) }.getOrNull() }
|
||||||
|
.sortedByDescending { it.savedAtMillis }
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,39 @@
|
|||||||
|
package org.prolibertate.games.game.meowdoku
|
||||||
|
|
||||||
|
import org.prolibertate.games.game.engine.GameAi
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Plays the board for the one seat.
|
||||||
|
*
|
||||||
|
* Like peg solitaire's AI, nothing normally asks it to: the single seat belongs
|
||||||
|
* to the person holding the phone. It exists because an empty seat has to be
|
||||||
|
* playable by something, and because "the computer can finish this board" is a
|
||||||
|
* property worth testing — a generated puzzle that only a human could unpack is
|
||||||
|
* a broken promise about uniqueness.
|
||||||
|
*
|
||||||
|
* It reads the answer from the state. The rules hold it, the seat is alone with
|
||||||
|
* it, and a solver that deduced its way there would be the same length as the
|
||||||
|
* hint engine in the original game without making this seat any more honest.
|
||||||
|
*/
|
||||||
|
object MeowdokuAi : GameAi<MeowdokuState, MeowdokuMove> {
|
||||||
|
|
||||||
|
override fun chooseMove(
|
||||||
|
state: MeowdokuState,
|
||||||
|
seat: Int,
|
||||||
|
legal: List<MeowdokuMove>,
|
||||||
|
): MeowdokuMove {
|
||||||
|
require(legal.isNotEmpty()) { "No move available" }
|
||||||
|
val places = legal.filterIsInstance<PlaceCat>().associateBy { it.square }
|
||||||
|
|
||||||
|
// The first cat still missing. A cross on its square is no obstacle:
|
||||||
|
// crossed squares take attempts like anything else, and a correct one
|
||||||
|
// replaces the cross.
|
||||||
|
for (row in 0 until state.side) {
|
||||||
|
if (state.cats.none { it.row == row }) {
|
||||||
|
places[Square(row, state.catCols[row])]?.let { return it }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return legal.first()
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,371 @@
|
|||||||
|
package org.prolibertate.games.game.meowdoku
|
||||||
|
|
||||||
|
import kotlin.math.abs
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Builds the puzzles.
|
||||||
|
*
|
||||||
|
* A Meowdoku puzzle is an N by N board, a colouring of it into N regions, and a
|
||||||
|
* hidden answer of N cats. The three are not chosen separately: the cats come
|
||||||
|
* first, then the regions grow out from them so every region owns exactly one
|
||||||
|
* cat, then the finished board is checked to make sure it has only that one
|
||||||
|
* answer. A puzzle with two answers is a puzzle with no answer, since the second
|
||||||
|
* one cannot be deduced from what is printed.
|
||||||
|
*
|
||||||
|
* The construction is seeded and reproducible: the same seed gives the same
|
||||||
|
* board, which is what lets a saved game come back unchanged and lets a test
|
||||||
|
* speak about "the" puzzle for a seed.
|
||||||
|
*/
|
||||||
|
object MeowdokuGenerator {
|
||||||
|
|
||||||
|
/** Smallest and largest boards worth dealing; anything bigger is a wall. */
|
||||||
|
val MIN_SIDE = 4
|
||||||
|
val MAX_SIDE = 10
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The answer, as the column of the cat in each row.
|
||||||
|
*
|
||||||
|
* One cat per row and one per column is already built in, since the rows are
|
||||||
|
* enumerated once each and no column is taken twice.
|
||||||
|
*/
|
||||||
|
fun placeCats(side: Int, rng: SeededRng): IntArray {
|
||||||
|
val cols = IntArray(side) { -1 }
|
||||||
|
val placed = placeCatsFrom(0, side, cols, rng)
|
||||||
|
// Every board from four up has a placement, and the search is complete,
|
||||||
|
// so failing here would mean the generator itself is broken.
|
||||||
|
check(placed) { "No way to settle $side cats on a $side board" }
|
||||||
|
return cols
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun placeCatsFrom(row: Int, side: Int, cols: IntArray, rng: SeededRng): Boolean {
|
||||||
|
if (row == side) return true
|
||||||
|
for (col in rng.shuffled(cols.indices.toList())) {
|
||||||
|
if (catFitsHere(row, col, cols)) {
|
||||||
|
cols[row] = col
|
||||||
|
if (placeCatsFrom(row + 1, side, cols, rng)) return true
|
||||||
|
cols[row] = -1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Whether a cat at [row],[col] is at peace with the cats in the rows above.
|
||||||
|
*
|
||||||
|
* No shared column, and no shared corner: a cat grooms the squares touching
|
||||||
|
* its own on all eight sides, so a neighbour one step away in any direction
|
||||||
|
* is too close.
|
||||||
|
*/
|
||||||
|
fun catFitsHere(row: Int, col: Int, cols: IntArray): Boolean {
|
||||||
|
for (r in 0 until row) {
|
||||||
|
val c = cols[r]
|
||||||
|
if (c == col) return false
|
||||||
|
if (abs(r - row) <= 1 && abs(c - col) <= 1) return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The colours of the board, as a region id per square.
|
||||||
|
*
|
||||||
|
* Each region starts as the cat it contains and grows outwards one square at
|
||||||
|
* a time. The first [strips] regions are grown as straight bars along their
|
||||||
|
* cat's row or column, alternating which way they run: a board of nothing but
|
||||||
|
* blobs reads as texture, and the bars are what give the regions a shape a
|
||||||
|
* player can reason about. The rest take the shortest border square, which
|
||||||
|
* keeps them clumped rather than trailing off into the far corner.
|
||||||
|
*/
|
||||||
|
fun growRegions(side: Int, catCols: IntArray, rng: SeededRng, strips: Int): Array<IntArray> {
|
||||||
|
val regions = Array(side) { IntArray(side) { -1 } }
|
||||||
|
val dirs = listOf(0 to 1, 0 to -1, 1 to 0, -1 to 0)
|
||||||
|
|
||||||
|
// Region i owns the cat in row i, which is where its colour starts.
|
||||||
|
for (r in 0 until side) regions[r][catCols[r]] = r
|
||||||
|
|
||||||
|
val sizes = IntArray(side) { 1 }
|
||||||
|
var unassigned = side * side - side
|
||||||
|
|
||||||
|
// The straight bars are laid first, and the rest is grown around them.
|
||||||
|
// The straight bars are laid first, and the rest is grown around them.
|
||||||
|
// Bar i runs along its cat's row when i is even, down its column when odd.
|
||||||
|
val stripRegions = rng.shuffled((0 until side).toList()).take(strips.coerceIn(0, side - 1)).toSet()
|
||||||
|
for ((n, region) in stripRegions.withIndex()) {
|
||||||
|
val r0 = region
|
||||||
|
val c0 = catCols[r0]
|
||||||
|
val extra = 1 + rng.nextInt(3)
|
||||||
|
var added = 0
|
||||||
|
if (n % 2 == 0) {
|
||||||
|
var left = c0 - 1
|
||||||
|
var right = c0 + 1
|
||||||
|
while (added < extra) {
|
||||||
|
val goLeft = rng.nextBoolean()
|
||||||
|
when {
|
||||||
|
goLeft && left >= 0 && regions[r0][left] == -1 ->
|
||||||
|
regions[r0][left--] = region
|
||||||
|
right < side && regions[r0][right] == -1 ->
|
||||||
|
regions[r0][right++] = region
|
||||||
|
left >= 0 && regions[r0][left] == -1 ->
|
||||||
|
regions[r0][left--] = region
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
sizes[region]++
|
||||||
|
unassigned--
|
||||||
|
added++
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
var up = r0 - 1
|
||||||
|
var down = r0 + 1
|
||||||
|
while (added < extra) {
|
||||||
|
val goUp = rng.nextBoolean()
|
||||||
|
when {
|
||||||
|
goUp && up >= 0 && regions[up][c0] == -1 ->
|
||||||
|
regions[up--][c0] = region
|
||||||
|
down < side && regions[down][c0] == -1 ->
|
||||||
|
regions[down++][c0] = region
|
||||||
|
up >= 0 && regions[up][c0] == -1 ->
|
||||||
|
regions[up--][c0] = region
|
||||||
|
else -> break
|
||||||
|
}
|
||||||
|
sizes[region]++
|
||||||
|
unassigned--
|
||||||
|
added++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// What is left goes to whichever neighbouring region is smallest, so no
|
||||||
|
// region dies young while another sprawls.
|
||||||
|
var guard = side * side * 20
|
||||||
|
while (unassigned > 0 && guard > 0) {
|
||||||
|
guard--
|
||||||
|
for (r in 0 until side) {
|
||||||
|
for (c in 0 until side) {
|
||||||
|
if (regions[r][c] != -1) continue
|
||||||
|
var best = -1
|
||||||
|
for ((dr, dc) in dirs) {
|
||||||
|
val nr = r + dr
|
||||||
|
val nc = c + dc
|
||||||
|
if (nr !in 0 until side || nc !in 0 until side) continue
|
||||||
|
val neighbour = regions[nr][nc]
|
||||||
|
if (neighbour == -1 || neighbour in stripRegions) continue
|
||||||
|
if (best == -1 || sizes[neighbour] < sizes[best]) best = neighbour
|
||||||
|
}
|
||||||
|
if (best == -1) {
|
||||||
|
for ((dr, dc) in dirs) {
|
||||||
|
val nr = r + dr
|
||||||
|
val nc = c + dc
|
||||||
|
if (nr !in 0 until side || nc !in 0 until side) continue
|
||||||
|
val neighbour = regions[nr][nc]
|
||||||
|
if (neighbour != -1 && (best == -1 || sizes[neighbour] < sizes[best])) {
|
||||||
|
best = neighbour
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (best != -1) {
|
||||||
|
regions[r][c] = best
|
||||||
|
sizes[best]++
|
||||||
|
unassigned--
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (r in 0 until side) {
|
||||||
|
for (c in 0 until side) {
|
||||||
|
if (regions[r][c] == -1) regions[r][c] = 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return regions
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* How many answers this coloured board has, up to [limit].
|
||||||
|
*
|
||||||
|
* A depth-first search with the obvious propagation: once a row is given a
|
||||||
|
* cat, the squares that cat excludes — its column, the rows beside it, and
|
||||||
|
* everything in its colour — lose their candidates. A row whose candidate
|
||||||
|
* list runs out fails immediately and the search backtracks, which is what
|
||||||
|
* makes the count finish quickly on boards of this size.
|
||||||
|
*
|
||||||
|
* Nothing about the true cats is handed to the search; it sees the colours
|
||||||
|
* and the rules and no more.
|
||||||
|
*/
|
||||||
|
fun countSolutions(side: Int, regions: Array<IntArray>, limit: Int = 2): Int {
|
||||||
|
val candidates = Array(side) { r -> (0 until side).toMutableSet() }
|
||||||
|
val colsTaken = BooleanArray(side)
|
||||||
|
val coloursTaken = BooleanArray(side)
|
||||||
|
val count = IntArray(1)
|
||||||
|
solve(0, side, regions, candidates, colsTaken, coloursTaken, count, limit)
|
||||||
|
return count[0]
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun solve(
|
||||||
|
row: Int,
|
||||||
|
side: Int,
|
||||||
|
regions: Array<IntArray>,
|
||||||
|
candidates: Array<MutableSet<Int>>,
|
||||||
|
colsTaken: BooleanArray,
|
||||||
|
coloursTaken: BooleanArray,
|
||||||
|
count: IntArray,
|
||||||
|
limit: Int,
|
||||||
|
) {
|
||||||
|
if (count[0] >= limit) return
|
||||||
|
if (row == side) {
|
||||||
|
count[0]++
|
||||||
|
return
|
||||||
|
}
|
||||||
|
for (col in candidates[row].toList()) {
|
||||||
|
val colour = regions[row][col]
|
||||||
|
if (colsTaken[col] || coloursTaken[colour]) continue
|
||||||
|
val undo = exclude(row, col, side, regions, candidates)
|
||||||
|
if (undo != null) {
|
||||||
|
colsTaken[col] = true
|
||||||
|
coloursTaken[colour] = true
|
||||||
|
solve(row + 1, side, regions, candidates, colsTaken, coloursTaken, count, limit)
|
||||||
|
colsTaken[col] = false
|
||||||
|
coloursTaken[colour] = false
|
||||||
|
undo()
|
||||||
|
}
|
||||||
|
if (count[0] >= limit) return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Crosses out what the cat at [row],[col] forbids, and returns the function
|
||||||
|
* that puts it back. Returns null if some row loses its last candidate,
|
||||||
|
* which means this placement is a dead end.
|
||||||
|
*/
|
||||||
|
private fun exclude(
|
||||||
|
row: Int,
|
||||||
|
col: Int,
|
||||||
|
side: Int,
|
||||||
|
regions: Array<IntArray>,
|
||||||
|
candidates: Array<MutableSet<Int>>,
|
||||||
|
): (() -> Unit)? {
|
||||||
|
val colour = regions[row][col]
|
||||||
|
val saved = Array(side) { r -> candidates[r].toMutableSet() }
|
||||||
|
var dead = false
|
||||||
|
for (r in 0 until side) {
|
||||||
|
if (r == row) continue
|
||||||
|
candidates[r].remove(col)
|
||||||
|
if (abs(r - row) == 1) {
|
||||||
|
candidates[r].remove(col - 1)
|
||||||
|
candidates[r].remove(col + 1)
|
||||||
|
}
|
||||||
|
candidates[r].removeAll { c -> regions[r][c] == colour }
|
||||||
|
if (candidates[r].isEmpty()) dead = true
|
||||||
|
}
|
||||||
|
if (dead) {
|
||||||
|
for (r in 0 until side) candidates[r] = saved[r]
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
for (r in 0 until side) candidates[r] = saved[r]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A complete puzzle: the colours, the answer, and a proof it is unique.
|
||||||
|
*
|
||||||
|
* Generation is rejection rather than construction — build a board, check it,
|
||||||
|
* throw it away if the check fails — and the attempts walk forward from
|
||||||
|
* [seed] so a seed that has a puzzle within a few tries gives the same one
|
||||||
|
* every time.
|
||||||
|
*/
|
||||||
|
fun generate(side: Int, seed: Long): MeowdokuPuzzle? {
|
||||||
|
val base = (seed xor (seed ushr 32)).toInt()
|
||||||
|
for (attempt in 0 until MAX_ATTEMPTS) {
|
||||||
|
val rng = SeededRng(base + attempt * 7919)
|
||||||
|
val catCols = placeCats(side, rng)
|
||||||
|
val regions = growRegions(side, catCols, SeededRng(base * 31 + attempt * 104729), strips = side / 2)
|
||||||
|
if (distinctColours(side, regions) != side) continue
|
||||||
|
if (countSolutions(side, regions, limit = 2) != 1) continue
|
||||||
|
return MeowdokuPuzzle(side, regions, catCols)
|
||||||
|
}
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
private const val MAX_ATTEMPTS = 4000
|
||||||
|
|
||||||
|
/** How many different colours a board actually shows. */
|
||||||
|
private fun distinctColours(side: Int, regions: Array<IntArray>): Int =
|
||||||
|
regions.flatMap { it.toList() }.distinct().size
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A board and its answer.
|
||||||
|
*
|
||||||
|
* The answer is stored rather than re-derived because the rules need it to
|
||||||
|
* referee: a tap either lands a cat or loses a heart, and that is judged against
|
||||||
|
* the solution, not against whether the player could have deduced it.
|
||||||
|
*/
|
||||||
|
data class MeowdokuPuzzle(
|
||||||
|
val side: Int,
|
||||||
|
/** Region id per square; ids run 0 until side. */
|
||||||
|
val regions: Array<IntArray>,
|
||||||
|
/** The column of the cat in each row. */
|
||||||
|
val catCols: IntArray,
|
||||||
|
) {
|
||||||
|
fun regionOf(row: Int, col: Int): Int = regions[row][col]
|
||||||
|
|
||||||
|
/** Every colour id, in board order, for a legend or a palette. */
|
||||||
|
val colours: List<Int> get() = (0 until side).toList()
|
||||||
|
|
||||||
|
fun solutionSquares(): List<Pair<Int, Int>> =
|
||||||
|
catCols.indices.map { it to catCols[it] }
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean = other is MeowdokuPuzzle &&
|
||||||
|
side == other.side &&
|
||||||
|
regions.contentDeepEquals(other.regions) &&
|
||||||
|
catCols.contentEquals(other.catCols)
|
||||||
|
|
||||||
|
override fun hashCode(): Int = 31 * side + regions.contentDeepHashCode()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A 32-bit linear congruential generator.
|
||||||
|
*
|
||||||
|
* Deliberately not [kotlin.random.Random]: that one is seeded per-JVM and can
|
||||||
|
* change between releases, and a puzzle generator that drifts silently corrupts
|
||||||
|
* saved games. This one is small, explicit, and the same everywhere.
|
||||||
|
*/
|
||||||
|
class SeededRng(seed: Int) {
|
||||||
|
private var state = if (seed == 0) DEFAULT_SEED else seed
|
||||||
|
|
||||||
|
/** The next 31 bits, as a non-negative int. */
|
||||||
|
fun nextInt(): Int {
|
||||||
|
state = state * MULTIPLIER + 1
|
||||||
|
return (state ushr 1) and 0x7FFF_FFFF
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A value in 0 until [bound], taken by rejection so it stays uniform. */
|
||||||
|
fun nextInt(bound: Int): Int {
|
||||||
|
require(bound > 0)
|
||||||
|
while (true) {
|
||||||
|
val n = nextInt()
|
||||||
|
// 2^31 is a multiple of no useful number of squares, so a bare
|
||||||
|
// modulus biases the low values; the slack is thrown and redrawn.
|
||||||
|
if (n < Int.MAX_VALUE - (Int.MAX_VALUE % bound)) return n % bound
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun nextBoolean(): Boolean = nextInt(2) == 0
|
||||||
|
|
||||||
|
/** The same list every time for the same seed, in a different order. */
|
||||||
|
fun <T> shuffled(items: List<T>): List<T> {
|
||||||
|
val out = items.toMutableList()
|
||||||
|
for (i in out.lastIndex downTo 1) {
|
||||||
|
val j = nextInt(i + 1)
|
||||||
|
val tmp = out[i]
|
||||||
|
out[i] = out[j]
|
||||||
|
out[j] = tmp
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
private companion object {
|
||||||
|
// The constants of the old VAX C library's `rand`, which are well tested
|
||||||
|
// and give a period of the full 31 bits.
|
||||||
|
const val MULTIPLIER = 1103515245
|
||||||
|
const val DEFAULT_SEED = 0x5DEECE66D.toInt()
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,119 @@
|
|||||||
|
package org.prolibertate.games.game.meowdoku
|
||||||
|
|
||||||
|
import kotlinx.serialization.SerialName
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
|
||||||
|
// Meowdoku hides N cats in an N by N board: exactly one cat in every row, every
|
||||||
|
// column and every colour, and no two cats sharing even a corner. A tap crosses
|
||||||
|
// a square over; a second tap on that square asks the board whether a cat
|
||||||
|
// lives there. A right answer lands the cat, a wrong one costs a heart and
|
||||||
|
// keeps the cross — so the crossing over is both the player's note and the
|
||||||
|
// first half of every guess, and the hearts are what stop it being a lottery.
|
||||||
|
|
||||||
|
/** One square of the board. */
|
||||||
|
@Serializable
|
||||||
|
data class Square(val row: Int, val col: Int)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class MeowdokuOptions(
|
||||||
|
/** The board is [side] by [side], and the answer is [side] cats. */
|
||||||
|
val side: Int = 6,
|
||||||
|
/**
|
||||||
|
* How many wrong taps the board forgives. The original game deals three,
|
||||||
|
* and the hearts on a level are part of its difficulty rather than a
|
||||||
|
* courtesy.
|
||||||
|
*/
|
||||||
|
val hearts: Int = 3,
|
||||||
|
/** How many cats the board will show on demand. */
|
||||||
|
val hints: Int = 3,
|
||||||
|
) {
|
||||||
|
init {
|
||||||
|
require(side in MeowdokuGenerator.MIN_SIDE..MeowdokuGenerator.MAX_SIDE) {
|
||||||
|
"No board of $side squares a side"
|
||||||
|
}
|
||||||
|
require(hearts in 1..9) { "A board with no hearts is lost before it is dealt" }
|
||||||
|
require(hints in 0..9) { "Hints must read on the board, not scroll" }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The dealt board plus the marks on it.
|
||||||
|
*
|
||||||
|
* [cats] and [marks] are sets rather than a state per square because a square's
|
||||||
|
* story is exactly those two memberships: nothing is a cat and crossed, and the
|
||||||
|
* empty squares carry no information worth storing.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
data class MeowdokuState(
|
||||||
|
val options: MeowdokuOptions,
|
||||||
|
/** The region id of every square, row by row. Ids run 0 until [side]. */
|
||||||
|
val regions: List<List<Int>>,
|
||||||
|
/** The column of the cat in each row — the answer, kept so taps can be judged. */
|
||||||
|
val catCols: List<Int>,
|
||||||
|
/** Cats the player has found (or a hint has shown). */
|
||||||
|
val cats: Set<Square>,
|
||||||
|
/** Squares crossed over: wrong taps and pencil marks alike. */
|
||||||
|
val marks: Set<Square>,
|
||||||
|
val heartsLeft: Int,
|
||||||
|
val hintsLeft: Int,
|
||||||
|
/** Wrong taps so far, which is how a solved board says how it was solved. */
|
||||||
|
val wrongCats: Int,
|
||||||
|
/** The last square touched, and whether touching it cost a heart. */
|
||||||
|
val lastSquare: Square? = null,
|
||||||
|
val lastWrong: Boolean = false,
|
||||||
|
val log: List<String>,
|
||||||
|
) {
|
||||||
|
val side: Int get() = options.side
|
||||||
|
|
||||||
|
/** Cats found, out of the [side] the board hides. */
|
||||||
|
val catsFound: Int get() = cats.size
|
||||||
|
|
||||||
|
val solved: Boolean get() = catsFound == side
|
||||||
|
|
||||||
|
/** Out of hearts, with cats still missing. */
|
||||||
|
val lost: Boolean get() = heartsLeft == 0 && !solved
|
||||||
|
|
||||||
|
fun regionOf(square: Square): Int = regions[square.row][square.col]
|
||||||
|
|
||||||
|
fun isCatSquare(square: Square): Boolean = catCols[square.row] == square.col
|
||||||
|
}
|
||||||
|
|
||||||
|
/** What the player may do to a board. */
|
||||||
|
@Serializable
|
||||||
|
sealed interface MeowdokuMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The second tap of a double tap: the cat attempt.
|
||||||
|
*
|
||||||
|
* One move rather than two, because that is what the player is doing: the board
|
||||||
|
* decides whether the tap found a cat or cost a heart. The square may carry the
|
||||||
|
* cross its own first tap just drew — that cross is part of the double tap,
|
||||||
|
* not a decision against it — and a correct attempt replaces it.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("cat")
|
||||||
|
data class PlaceCat(val square: Square) : MeowdokuMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Draws or erases a cross on a square with no cat on it.
|
||||||
|
*
|
||||||
|
* This is the first tap of a tap pair and every cell of a drag stroke, so it is
|
||||||
|
* the note-taking half of the scheme: free, unrewarded, and the board cannot
|
||||||
|
* lose a heart over it. A cross drawn here can still be tapped through with a
|
||||||
|
* cat attempt — the note is the player's, and only they get to change their
|
||||||
|
* mind about it.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("pencil")
|
||||||
|
data class TogglePencil(val square: Square) : MeowdokuMove
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Spends a hint to show the cat in the first row that lacks one.
|
||||||
|
*
|
||||||
|
* The original game sells hints; here they are simply counted, and the one
|
||||||
|
* choice that has to be made about them — a hint is placed by the board, not
|
||||||
|
* guessed at by the player — is the same either way.
|
||||||
|
*/
|
||||||
|
@Serializable
|
||||||
|
@SerialName("hint")
|
||||||
|
data object TakeHint : MeowdokuMove
|
||||||
@@ -0,0 +1,197 @@
|
|||||||
|
package org.prolibertate.games.game.meowdoku
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.prolibertate.games.game.GameCatalog
|
||||||
|
import org.prolibertate.games.game.engine.GameRules
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Meowdoku as a pure state machine. See RULES-meowdoku.md.
|
||||||
|
*
|
||||||
|
* The engine is a second single-seat game, alongside peg solitaire, and it
|
||||||
|
* inherits the same freedom: there is nobody to hide anything from, so
|
||||||
|
* [viewFor] hands out the whole board including the answer. The answer lives in
|
||||||
|
* the state rather than being re-derived because judging a tap against a
|
||||||
|
* deduction the player could have made is a different thing from judging it
|
||||||
|
* against what the board was dealt — and the deduction engine (crossing out
|
||||||
|
* rows, columns and colours) belongs to the player, not the referee.
|
||||||
|
*/
|
||||||
|
object MeowdokuRules : GameRules<MeowdokuState, MeowdokuMove> {
|
||||||
|
|
||||||
|
override val gameId: String = GameCatalog.MEOWDOKU
|
||||||
|
|
||||||
|
/** The one seat. */
|
||||||
|
const val SOLO_SEAT: Int = 0
|
||||||
|
|
||||||
|
private val json = Json {
|
||||||
|
ignoreUnknownKeys = true
|
||||||
|
encodeDefaults = true
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun initialState(config: TableConfig): MeowdokuState {
|
||||||
|
val options = json.decodeFromString<MeowdokuOptions>(config.optionsJson)
|
||||||
|
require(config.seats.size == 1) {
|
||||||
|
"Meowdoku seats one, not ${config.seats.size}"
|
||||||
|
}
|
||||||
|
val puzzle = deal(options.side, config.seed)
|
||||||
|
return MeowdokuState(
|
||||||
|
options = options,
|
||||||
|
regions = puzzle.regions.map { it.toList() },
|
||||||
|
catCols = puzzle.catCols.toList(),
|
||||||
|
cats = emptySet(),
|
||||||
|
marks = emptySet(),
|
||||||
|
heartsLeft = options.hearts,
|
||||||
|
hintsLeft = options.hints,
|
||||||
|
wrongCats = 0,
|
||||||
|
log = listOf("A ${options.side} by ${options.side} board, ${options.side} cats to find."),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Deals until the board is good.
|
||||||
|
*
|
||||||
|
* A seed whose first attempts all fail to produce a unique board moves the
|
||||||
|
* seed along rather than giving up: the same table asked twice gets the
|
||||||
|
* same board both times, which is what a saved game and a unit test need.
|
||||||
|
*/
|
||||||
|
private fun deal(side: Int, seed: Long): MeowdokuPuzzle {
|
||||||
|
var trySeed = seed
|
||||||
|
repeat(DEAL_TRIES) {
|
||||||
|
MeowdokuGenerator.generate(side, trySeed)?.let { return it }
|
||||||
|
trySeed = trySeed * 6364136223846793005L + 1442695040888963407L
|
||||||
|
}
|
||||||
|
error("No unique ${side} x $side board within $DEAL_TRIES deals of seed $seed")
|
||||||
|
}
|
||||||
|
|
||||||
|
private const val DEAL_TRIES = 8
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Every tap the board would take.
|
||||||
|
*
|
||||||
|
* The scheme is the original's: the first tap crosses a square over and
|
||||||
|
* opens a short window, and a second tap in that window is the cat attempt
|
||||||
|
* — so an attempt is offered on every square without a cat, crossed or
|
||||||
|
* not. The cross the attempt replaces is exactly the cross the first tap
|
||||||
|
* drew. Cats, once placed, are never tapped again: they are not a guess
|
||||||
|
* you take back.
|
||||||
|
*
|
||||||
|
* The list is written row by row, which is also the order the hint uses.
|
||||||
|
*/
|
||||||
|
override fun legalMoves(state: MeowdokuState, seat: Int): List<MeowdokuMove> {
|
||||||
|
if (seat != SOLO_SEAT || isFinished(state)) return emptyList()
|
||||||
|
val cats = ArrayList<MeowdokuMove>()
|
||||||
|
val pencils = ArrayList<MeowdokuMove>()
|
||||||
|
for (row in 0 until state.side) {
|
||||||
|
for (col in 0 until state.side) {
|
||||||
|
val square = Square(row, col)
|
||||||
|
if (square in state.cats) continue
|
||||||
|
cats += PlaceCat(square)
|
||||||
|
pencils += TogglePencil(square)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
val hint = if (state.hintsLeft > 0) listOf(TakeHint) else emptyList()
|
||||||
|
return cats + pencils + hint
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun applyMove(
|
||||||
|
state: MeowdokuState,
|
||||||
|
seat: Int,
|
||||||
|
move: MeowdokuMove,
|
||||||
|
): MeowdokuState {
|
||||||
|
require(seat == SOLO_SEAT) { "Meowdoku has one seat" }
|
||||||
|
require(move in legalMoves(state, seat)) { "$move is not a legal move" }
|
||||||
|
return when (move) {
|
||||||
|
is PlaceCat -> tap(state, move.square)
|
||||||
|
is TogglePencil -> pencil(state, move.square)
|
||||||
|
TakeHint -> hint(state)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The second tap of a double tap: found a cat, or lost a heart.
|
||||||
|
*
|
||||||
|
* A correct tap clears the cross the first tap left behind — the cat
|
||||||
|
* replaces it. A wrong one leaves the cross where it is and spends a
|
||||||
|
* heart, because a wrong square crossed twice is the same mistake twice,
|
||||||
|
* and the board remembers it either way.
|
||||||
|
*/
|
||||||
|
private fun tap(state: MeowdokuState, square: Square): MeowdokuState {
|
||||||
|
if (state.isCatSquare(square)) {
|
||||||
|
val next = state.copy(
|
||||||
|
cats = state.cats + square,
|
||||||
|
marks = state.marks - square,
|
||||||
|
lastSquare = square,
|
||||||
|
lastWrong = false,
|
||||||
|
)
|
||||||
|
val note = if (next.solved) {
|
||||||
|
"All ${next.side} cats, ${next.wrongCats} wrong taps."
|
||||||
|
} else {
|
||||||
|
"Found a cat at row ${square.row + 1}, column ${square.col + 1}."
|
||||||
|
}
|
||||||
|
return next.copy(log = next.log + note)
|
||||||
|
}
|
||||||
|
val hearts = state.heartsLeft - 1
|
||||||
|
val next = state.copy(
|
||||||
|
marks = state.marks + square,
|
||||||
|
heartsLeft = hearts,
|
||||||
|
wrongCats = state.wrongCats + 1,
|
||||||
|
lastSquare = square,
|
||||||
|
lastWrong = true,
|
||||||
|
)
|
||||||
|
return if (hearts == 0) {
|
||||||
|
next.copy(log = next.log + "Out of hearts, with ${next.side - next.catsFound} cats still hiding.")
|
||||||
|
} else {
|
||||||
|
next
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun pencil(state: MeowdokuState, square: Square): MeowdokuState {
|
||||||
|
val marks = if (square in state.marks) state.marks - square else state.marks + square
|
||||||
|
return state.copy(marks = marks, lastSquare = square, lastWrong = false)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Shows the cat in the first row without one.
|
||||||
|
*
|
||||||
|
* A revealed cat lands like a found one — and erases a pencil cross on its
|
||||||
|
* square, because the point of a hint is that the player stops having to
|
||||||
|
* work out whether the board contradicts their own notes.
|
||||||
|
*/
|
||||||
|
private fun hint(state: MeowdokuState): MeowdokuState {
|
||||||
|
val row = (0 until state.side).first { r -> state.cats.none { it.row == r } }
|
||||||
|
val square = Square(row, state.catCols[row])
|
||||||
|
return state.copy(
|
||||||
|
cats = state.cats + square,
|
||||||
|
marks = state.marks - square,
|
||||||
|
hintsLeft = state.hintsLeft - 1,
|
||||||
|
lastSquare = square,
|
||||||
|
lastWrong = false,
|
||||||
|
log = state.log + "A hint shows the cat in row ${row + 1}.",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A board is finished when it is solved or when the hearts run out. */
|
||||||
|
override fun isFinished(state: MeowdokuState): Boolean = state.solved || state.lost
|
||||||
|
|
||||||
|
override fun currentSeat(state: MeowdokuState): Int? =
|
||||||
|
if (isFinished(state)) null else SOLO_SEAT
|
||||||
|
|
||||||
|
override fun summary(state: MeowdokuState): String = when {
|
||||||
|
state.solved -> "Solved with ${state.heartsLeft} hearts to spare"
|
||||||
|
state.lost -> "Lost with ${state.catsFound} of ${state.side} cats found"
|
||||||
|
else -> "${state.catsFound} of ${state.side} cats, ${state.heartsLeft} hearts left"
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Nothing to strip. One person plays, and the answer in the state is there
|
||||||
|
* for the referee, not as a secret. Should a second seat ever race through
|
||||||
|
* the same board, this is where [MeowdokuState.catCols] gets hidden.
|
||||||
|
*/
|
||||||
|
override fun viewFor(state: MeowdokuState, seat: Int): MeowdokuState = state
|
||||||
|
|
||||||
|
override fun encodeState(state: MeowdokuState): String = json.encodeToString(state)
|
||||||
|
override fun decodeState(json: String): MeowdokuState = this.json.decodeFromString(json)
|
||||||
|
override fun encodeMove(move: MeowdokuMove): String = json.encodeToString(move)
|
||||||
|
override fun decodeMove(json: String): MeowdokuMove = this.json.decodeFromString(json)
|
||||||
|
}
|
||||||
@@ -0,0 +1,58 @@
|
|||||||
|
package org.prolibertate.games.game.yahtzee
|
||||||
|
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
|
||||||
|
/** What one finished game says about the local player's card. */
|
||||||
|
@Serializable
|
||||||
|
data class YahtzeeRecord(
|
||||||
|
val total: Int,
|
||||||
|
val gotBonus: Boolean,
|
||||||
|
/** Yahtzees scored, counting the extra ones that earned the hundred. */
|
||||||
|
val yahtzees: Int,
|
||||||
|
/** Boxes written in as nothing. */
|
||||||
|
val zeros: Int,
|
||||||
|
val players: Int,
|
||||||
|
val won: Boolean,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** Builds the record of [seat]'s card in a finished game. Ties for first count as a win. */
|
||||||
|
fun recordOf(state: YahtzeeState, seat: Int): YahtzeeRecord {
|
||||||
|
val card = state.cards[seat]
|
||||||
|
val mine = state.totalFor(seat)
|
||||||
|
val best = state.cards.indices.maxOf { state.totalFor(it) }
|
||||||
|
return YahtzeeRecord(
|
||||||
|
total = mine,
|
||||||
|
gotBonus = card.upperBonus > 0,
|
||||||
|
yahtzees = (if (card[YahtzeeCategory.YAHTZEE] == YAHTZEE_SCORE) 1 else 0) +
|
||||||
|
state.yahtzeeBonuses[seat] / YAHTZEE_BONUS,
|
||||||
|
zeros = card.boxes.count { it == 0 },
|
||||||
|
players = state.cards.size,
|
||||||
|
won = mine >= best,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A game set against the ones before it. [rank] is 1 for a new best. */
|
||||||
|
data class YahtzeeComparison(
|
||||||
|
val current: YahtzeeRecord,
|
||||||
|
val previousGames: Int,
|
||||||
|
val bestBefore: Int?,
|
||||||
|
val averageBefore: Double?,
|
||||||
|
val rank: Int,
|
||||||
|
val gamesRanked: Int,
|
||||||
|
val bonusRateBefore: Double?,
|
||||||
|
val yahtzeesBefore: Int,
|
||||||
|
val winRateBefore: Double?,
|
||||||
|
)
|
||||||
|
|
||||||
|
fun compareToHistory(previous: List<YahtzeeRecord>, current: YahtzeeRecord): YahtzeeComparison =
|
||||||
|
YahtzeeComparison(
|
||||||
|
current = current,
|
||||||
|
previousGames = previous.size,
|
||||||
|
bestBefore = previous.maxOfOrNull { it.total },
|
||||||
|
averageBefore = previous.takeIf { it.isNotEmpty() }?.map { it.total }?.average(),
|
||||||
|
rank = 1 + previous.count { it.total > current.total },
|
||||||
|
gamesRanked = previous.size + 1,
|
||||||
|
bonusRateBefore = previous.takeIf { it.isNotEmpty() }?.let { p -> p.count { it.gotBonus }.toDouble() / p.size },
|
||||||
|
yahtzeesBefore = previous.sumOf { it.yahtzees },
|
||||||
|
winRateBefore = previous.takeIf { it.isNotEmpty() }?.let { p -> p.count { it.won }.toDouble() / p.size },
|
||||||
|
)
|
||||||
@@ -96,6 +96,27 @@ class MatchController<S : Any, M : Any>(
|
|||||||
|
|
||||||
/** Host only: the true state. Clients never see this. */
|
/** Host only: the true state. Clients never see this. */
|
||||||
private var authoritative: S? = null
|
private var authoritative: S? = null
|
||||||
|
|
||||||
|
/** A position to carry on from instead of dealing, set by [restore] before [startAsHost]. */
|
||||||
|
private var restored: S? = null
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Host only: told about every position the table reaches, so it can be kept
|
||||||
|
* for later. Called under the table's lock, so it must return quickly — the
|
||||||
|
* snapshot encodes its state only when asked, and the work of writing it
|
||||||
|
* belongs to whoever is listening.
|
||||||
|
*/
|
||||||
|
var onHostState: ((HostSnapshot) -> Unit)? = null
|
||||||
|
|
||||||
|
/** One position of the table, as handed to [onHostState]. */
|
||||||
|
class HostSnapshot(
|
||||||
|
val finished: Boolean,
|
||||||
|
val summary: String,
|
||||||
|
private val encode: () -> String,
|
||||||
|
) {
|
||||||
|
/** The whole true state, encoded by the game's own rules. */
|
||||||
|
fun stateJson(): String = encode()
|
||||||
|
}
|
||||||
private val lock = Mutex()
|
private val lock = Mutex()
|
||||||
private var sequence = 0
|
private var sequence = 0
|
||||||
|
|
||||||
@@ -160,7 +181,7 @@ class MatchController<S : Any, M : Any>(
|
|||||||
check(role == Role.HOST) { "Not hosting" }
|
check(role == Role.HOST) { "Not hosting" }
|
||||||
clients.forEach { connection -> listenToPeer(connection) }
|
clients.forEach { connection -> listenToPeer(connection) }
|
||||||
scope.launch {
|
scope.launch {
|
||||||
val initial = runCatching { rules.initialState(config) }.getOrElse { error ->
|
val initial = restored ?: runCatching { rules.initialState(config) }.getOrElse { error ->
|
||||||
// A table the rules will not accept is a dead end, not a reason
|
// A table the rules will not accept is a dead end, not a reason
|
||||||
// to take the app down with it: this runs in the screen's own
|
// to take the app down with it: this runs in the screen's own
|
||||||
// scope, where nothing would catch it.
|
// scope, where nothing would catch it.
|
||||||
@@ -175,6 +196,20 @@ class MatchController<S : Any, M : Any>(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Host: carry on from a saved position instead of dealing a new game.
|
||||||
|
*
|
||||||
|
* Call before [startAsHost]. Returns false, and changes nothing, if
|
||||||
|
* [stateJson] cannot be read by this version of the game — a save made by an
|
||||||
|
* older build, say — and the caller should deal a fresh table instead.
|
||||||
|
*/
|
||||||
|
fun restore(stateJson: String): Boolean {
|
||||||
|
check(role == Role.HOST) { "Only a host can restore a game" }
|
||||||
|
val state = runCatching { rules.decodeState(stateJson) }.getOrNull() ?: return false
|
||||||
|
restored = state
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
private fun listenToPeer(connection: Connection) {
|
private fun listenToPeer(connection: Connection) {
|
||||||
peers[connection.peerId] = connection
|
peers[connection.peerId] = connection
|
||||||
peerJobs[connection.peerId] = scope.launch {
|
peerJobs[connection.peerId] = scope.launch {
|
||||||
@@ -449,6 +484,16 @@ class MatchController<S : Any, M : Any>(
|
|||||||
}
|
}
|
||||||
_finished.value = rules.isFinished(current)
|
_finished.value = rules.isFinished(current)
|
||||||
|
|
||||||
|
if (role == Role.HOST) {
|
||||||
|
onHostState?.invoke(
|
||||||
|
HostSnapshot(
|
||||||
|
finished = rules.isFinished(current),
|
||||||
|
summary = rules.summary(current),
|
||||||
|
encode = { rules.encodeState(current) },
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
for (slot in config.seats) {
|
for (slot in config.seats) {
|
||||||
val peerId = slot.peerId ?: continue
|
val peerId = slot.peerId ?: continue
|
||||||
val connection = peers[peerId] ?: continue
|
val connection = peers[peerId] ?: continue
|
||||||
|
|||||||
@@ -0,0 +1,95 @@
|
|||||||
|
package org.prolibertate.games.net
|
||||||
|
|
||||||
|
import kotlinx.coroutines.CoroutineScope
|
||||||
|
import kotlinx.coroutines.Dispatchers
|
||||||
|
import kotlinx.coroutines.Job
|
||||||
|
import kotlinx.coroutines.flow.MutableStateFlow
|
||||||
|
import kotlinx.coroutines.flow.collectLatest
|
||||||
|
import kotlinx.coroutines.flow.filterNotNull
|
||||||
|
import kotlinx.coroutines.launch
|
||||||
|
import org.prolibertate.games.game.engine.SavedGameStore
|
||||||
|
import org.prolibertate.games.game.engine.SavedMatch
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Keeps the position of one table on disk as it is played.
|
||||||
|
*
|
||||||
|
* It is fed every position the host reaches ([offer]) and writes the newest one
|
||||||
|
* off the main thread. Positions that arrive while a write is under way are
|
||||||
|
* dropped in favour of the latest — a computer's turn can be several moves in a
|
||||||
|
* second, and only where the game stands matters. A finished game is not kept:
|
||||||
|
* its slot is cleared, so a won game is not offered back as one to resume.
|
||||||
|
*
|
||||||
|
* [flush] writes whatever has not been written yet, on the caller's thread. It
|
||||||
|
* is what makes leaving the table, or the app going to the background, safe: the
|
||||||
|
* background writer may not have caught up, and the process may not be given the
|
||||||
|
* chance to let it.
|
||||||
|
*/
|
||||||
|
class MatchSaver(
|
||||||
|
private val store: SavedGameStore,
|
||||||
|
private val gameId: String,
|
||||||
|
private val config: TableConfig,
|
||||||
|
private val localSeat: Int,
|
||||||
|
private val scope: CoroutineScope,
|
||||||
|
private val clock: () -> Long = System::currentTimeMillis,
|
||||||
|
) {
|
||||||
|
private val latest = MutableStateFlow<MatchController.HostSnapshot?>(null)
|
||||||
|
private var worker: Job? = null
|
||||||
|
private var written: MatchController.HostSnapshot? = null
|
||||||
|
private var discarded = false
|
||||||
|
|
||||||
|
/** Starts the background writer. */
|
||||||
|
fun start() {
|
||||||
|
worker = scope.launch(Dispatchers.IO) {
|
||||||
|
latest.filterNotNull().collectLatest { write(it) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Hands over the newest position. Cheap: the encoding happens on the writer. */
|
||||||
|
fun offer(snapshot: MatchController.HostSnapshot) {
|
||||||
|
latest.value = snapshot
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Writes the newest position now if the writer has not already. */
|
||||||
|
fun flush() {
|
||||||
|
latest.value?.let { write(it) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The game was ended on purpose: forget the saved position and write no more. */
|
||||||
|
@Synchronized
|
||||||
|
fun discard() {
|
||||||
|
discarded = true
|
||||||
|
worker?.cancel()
|
||||||
|
worker = null
|
||||||
|
runCatching { store.clear(gameId) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun stop() {
|
||||||
|
worker?.cancel()
|
||||||
|
worker = null
|
||||||
|
}
|
||||||
|
|
||||||
|
@Synchronized
|
||||||
|
private fun write(snapshot: MatchController.HostSnapshot) {
|
||||||
|
if (discarded || snapshot === written) return
|
||||||
|
written = snapshot
|
||||||
|
// Saving is a courtesy to the player: a full disk must not take the game
|
||||||
|
// down with it.
|
||||||
|
runCatching {
|
||||||
|
if (snapshot.finished) {
|
||||||
|
store.clear(gameId)
|
||||||
|
} else {
|
||||||
|
store.save(
|
||||||
|
SavedMatch(
|
||||||
|
gameId = gameId,
|
||||||
|
config = config,
|
||||||
|
localSeat = localSeat,
|
||||||
|
stateJson = snapshot.stateJson(),
|
||||||
|
savedAtMillis = clock(),
|
||||||
|
summary = snapshot.summary,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,17 @@
|
|||||||
|
package org.prolibertate.games.score
|
||||||
|
|
||||||
|
/** The short list of names offered when a column is being named. */
|
||||||
|
object RecentNames {
|
||||||
|
const val LIMIT = 10
|
||||||
|
|
||||||
|
/**
|
||||||
|
* [name] moved to the front of [names], trimmed, with any earlier copy
|
||||||
|
* (compared ignoring case) dropped and the list cut to [LIMIT]. A blank name
|
||||||
|
* leaves the list as it was.
|
||||||
|
*/
|
||||||
|
fun with(names: List<String>, name: String): List<String> {
|
||||||
|
val typed = name.trim()
|
||||||
|
if (typed.isEmpty()) return names
|
||||||
|
return (listOf(typed) + names.filterNot { it.equals(typed, ignoreCase = true) }).take(LIMIT)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -29,6 +29,7 @@ class ScorekeeperRepository(private val context: Context) {
|
|||||||
|
|
||||||
private object Keys {
|
private object Keys {
|
||||||
val SHEET = stringPreferencesKey("sheet")
|
val SHEET = stringPreferencesKey("sheet")
|
||||||
|
val RECENT_NAMES = stringPreferencesKey("recent_names")
|
||||||
}
|
}
|
||||||
|
|
||||||
// Unknown keys are ignored so a sheet written by a newer build can still be
|
// Unknown keys are ignored so a sheet written by a newer build can still be
|
||||||
@@ -45,6 +46,24 @@ class ScorekeeperRepository(private val context: Context) {
|
|||||||
?: ScoreSheet()
|
?: ScoreSheet()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** The names last used on a sheet, most recent first, for the rename dialog. */
|
||||||
|
val recentNames: Flow<List<String>> = context.scorekeeperDataStore.data.map { prefs ->
|
||||||
|
prefs[Keys.RECENT_NAMES]
|
||||||
|
?.let { stored ->
|
||||||
|
runCatching { json.decodeFromString<List<String>>(stored) }.getOrNull()
|
||||||
|
}
|
||||||
|
?: emptyList()
|
||||||
|
}
|
||||||
|
|
||||||
|
suspend fun rememberName(name: String) {
|
||||||
|
context.scorekeeperDataStore.edit { prefs ->
|
||||||
|
val current = prefs[Keys.RECENT_NAMES]
|
||||||
|
?.let { runCatching { json.decodeFromString<List<String>>(it) }.getOrNull() }
|
||||||
|
.orEmpty()
|
||||||
|
prefs[Keys.RECENT_NAMES] = json.encodeToString(RecentNames.with(current, name))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
suspend fun save(sheet: ScoreSheet) {
|
suspend fun save(sheet: ScoreSheet) {
|
||||||
context.scorekeeperDataStore.edit { it[Keys.SHEET] = json.encodeToString(sheet) }
|
context.scorekeeperDataStore.edit { it[Keys.SHEET] = json.encodeToString(sheet) }
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -31,8 +31,18 @@ sealed interface SheetOp {
|
|||||||
/** Sets a fresh sheet up for [count] players, scored by round or by tally. */
|
/** Sets a fresh sheet up for [count] players, scored by round or by tally. */
|
||||||
@Serializable
|
@Serializable
|
||||||
@SerialName("start")
|
@SerialName("start")
|
||||||
data class StartSheet(val count: Int, val mode: ScoringMode = ScoringMode.ROUNDS) : SheetOp {
|
data class StartSheet(
|
||||||
override fun applyTo(sheet: ScoreSheet): ScoreSheet = ScoreSheet.of(count, mode)
|
val count: Int,
|
||||||
|
val mode: ScoringMode = ScoringMode.ROUNDS,
|
||||||
|
/** Names for the first seats, in order; a seat past the end stays unnamed. */
|
||||||
|
val names: List<String> = emptyList(),
|
||||||
|
) : SheetOp {
|
||||||
|
override fun applyTo(sheet: ScoreSheet): ScoreSheet {
|
||||||
|
val seated = ScoreSheet.of(count, mode)
|
||||||
|
return seated.players.foldIndexed(seated) { index, acc, player ->
|
||||||
|
names.getOrNull(index)?.let { acc.renamed(player.id, it) } ?: acc
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Rubs everything out. */
|
/** Rubs everything out. */
|
||||||
|
|||||||
@@ -24,6 +24,8 @@ data class Settings(
|
|||||||
val soundEnabled: Boolean = true,
|
val soundEnabled: Boolean = true,
|
||||||
val animationSpeed: Float = 1.0f,
|
val animationSpeed: Float = 1.0f,
|
||||||
val checkForUpdatesOnLaunch: Boolean = true,
|
val checkForUpdatesOnLaunch: Boolean = true,
|
||||||
|
/** Multiplies the system font size across the whole app. */
|
||||||
|
val textScale: Float = 1.0f,
|
||||||
/**
|
/**
|
||||||
* Exactly what the user has typed, which may be blank while they are
|
* Exactly what the user has typed, which may be blank while they are
|
||||||
* mid-edit. Nothing substitutes a default into this value: doing so meant
|
* mid-edit. Nothing substitutes a default into this value: doing so meant
|
||||||
@@ -46,6 +48,8 @@ data class Settings(
|
|||||||
companion object {
|
companion object {
|
||||||
const val MIN_SPEED = 0.5f
|
const val MIN_SPEED = 0.5f
|
||||||
const val MAX_SPEED = 2.0f
|
const val MAX_SPEED = 2.0f
|
||||||
|
const val MIN_TEXT_SCALE = 0.8f
|
||||||
|
const val MAX_TEXT_SCALE = 1.6f
|
||||||
const val DEFAULT_PLAYER_NAME = "Player"
|
const val DEFAULT_PLAYER_NAME = "Player"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -56,6 +60,7 @@ class SettingsRepository(private val context: Context) {
|
|||||||
val SOUND = booleanPreferencesKey("sound_enabled")
|
val SOUND = booleanPreferencesKey("sound_enabled")
|
||||||
val SPEED = floatPreferencesKey("animation_speed")
|
val SPEED = floatPreferencesKey("animation_speed")
|
||||||
val UPDATE_ON_LAUNCH = booleanPreferencesKey("check_updates_on_launch")
|
val UPDATE_ON_LAUNCH = booleanPreferencesKey("check_updates_on_launch")
|
||||||
|
val TEXT_SCALE = floatPreferencesKey("text_scale")
|
||||||
val NAME = stringPreferencesKey("player_name")
|
val NAME = stringPreferencesKey("player_name")
|
||||||
// There is deliberately no update-channel key. The channel is a
|
// There is deliberately no update-channel key. The channel is a
|
||||||
// property of the installed APK, not a preference — an install that
|
// property of the installed APK, not a preference — an install that
|
||||||
@@ -69,6 +74,8 @@ class SettingsRepository(private val context: Context) {
|
|||||||
soundEnabled = prefs[Keys.SOUND] ?: true,
|
soundEnabled = prefs[Keys.SOUND] ?: true,
|
||||||
animationSpeed = prefs[Keys.SPEED] ?: 1.0f,
|
animationSpeed = prefs[Keys.SPEED] ?: 1.0f,
|
||||||
checkForUpdatesOnLaunch = prefs[Keys.UPDATE_ON_LAUNCH] ?: true,
|
checkForUpdatesOnLaunch = prefs[Keys.UPDATE_ON_LAUNCH] ?: true,
|
||||||
|
textScale = (prefs[Keys.TEXT_SCALE] ?: 1.0f)
|
||||||
|
.coerceIn(Settings.MIN_TEXT_SCALE, Settings.MAX_TEXT_SCALE),
|
||||||
playerName = prefs[Keys.NAME] ?: "",
|
playerName = prefs[Keys.NAME] ?: "",
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -83,6 +90,12 @@ class SettingsRepository(private val context: Context) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
suspend fun setTextScale(scale: Float) {
|
||||||
|
context.dataStore.edit {
|
||||||
|
it[Keys.TEXT_SCALE] = scale.coerceIn(Settings.MIN_TEXT_SCALE, Settings.MAX_TEXT_SCALE)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
suspend fun setCheckForUpdatesOnLaunch(enabled: Boolean) {
|
suspend fun setCheckForUpdatesOnLaunch(enabled: Boolean) {
|
||||||
context.dataStore.edit { it[Keys.UPDATE_ON_LAUNCH] = enabled }
|
context.dataStore.edit { it[Keys.UPDATE_ON_LAUNCH] = enabled }
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,42 @@
|
|||||||
|
package org.prolibertate.games.settings
|
||||||
|
|
||||||
|
import android.content.Context
|
||||||
|
import androidx.datastore.core.DataStore
|
||||||
|
import androidx.datastore.preferences.core.Preferences
|
||||||
|
import androidx.datastore.preferences.core.edit
|
||||||
|
import androidx.datastore.preferences.core.stringPreferencesKey
|
||||||
|
import androidx.datastore.preferences.preferencesDataStore
|
||||||
|
import kotlinx.coroutines.flow.first
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeComparison
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeRecord
|
||||||
|
import org.prolibertate.games.game.yahtzee.compareToHistory
|
||||||
|
|
||||||
|
private val Context.yahtzeeStatsStore: DataStore<Preferences> by preferencesDataStore(
|
||||||
|
name = "yahtzee_stats",
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The local player's finished Yahtzee games, newest last, kept to the last [KEEP]. */
|
||||||
|
class YahtzeeStatsRepository(private val context: Context) {
|
||||||
|
|
||||||
|
private val key = stringPreferencesKey("games")
|
||||||
|
private val json = Json { ignoreUnknownKeys = true }
|
||||||
|
|
||||||
|
private fun decode(stored: String?): List<YahtzeeRecord> =
|
||||||
|
stored?.let { runCatching { json.decodeFromString<List<YahtzeeRecord>>(it) }.getOrNull() }
|
||||||
|
.orEmpty()
|
||||||
|
|
||||||
|
/** Compares [record] with every earlier game, then adds it to the history. */
|
||||||
|
suspend fun finish(record: YahtzeeRecord): YahtzeeComparison {
|
||||||
|
val previous = decode(context.yahtzeeStatsStore.data.first()[key])
|
||||||
|
context.yahtzeeStatsStore.edit {
|
||||||
|
it[key] = json.encodeToString((previous + record).takeLast(KEEP))
|
||||||
|
}
|
||||||
|
return compareToHistory(previous, record)
|
||||||
|
}
|
||||||
|
|
||||||
|
private companion object {
|
||||||
|
const val KEEP = 500
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -20,6 +20,8 @@ import androidx.compose.material3.Card
|
|||||||
import androidx.compose.material3.CardDefaults
|
import androidx.compose.material3.CardDefaults
|
||||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
import androidx.compose.ui.platform.LocalDensity
|
||||||
|
import androidx.compose.ui.unit.Density
|
||||||
import androidx.compose.material3.OutlinedButton
|
import androidx.compose.material3.OutlinedButton
|
||||||
import androidx.compose.material3.Scaffold
|
import androidx.compose.material3.Scaffold
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
@@ -29,6 +31,8 @@ import androidx.compose.runtime.Composable
|
|||||||
import androidx.compose.runtime.CompositionLocalProvider
|
import androidx.compose.runtime.CompositionLocalProvider
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
|
import androidx.compose.runtime.mutableIntStateOf
|
||||||
|
import androidx.compose.runtime.produceState
|
||||||
import androidx.compose.runtime.mutableStateOf
|
import androidx.compose.runtime.mutableStateOf
|
||||||
import androidx.compose.runtime.remember
|
import androidx.compose.runtime.remember
|
||||||
import androidx.compose.runtime.setValue
|
import androidx.compose.runtime.setValue
|
||||||
@@ -47,9 +51,14 @@ import org.prolibertate.games.net.ScorekeeperSession
|
|||||||
import org.prolibertate.games.score.ScorekeeperRepository
|
import org.prolibertate.games.score.ScorekeeperRepository
|
||||||
import org.prolibertate.games.settings.Settings
|
import org.prolibertate.games.settings.Settings
|
||||||
import org.prolibertate.games.settings.SettingsRepository
|
import org.prolibertate.games.settings.SettingsRepository
|
||||||
|
import org.prolibertate.games.settings.YahtzeeStatsRepository
|
||||||
import org.prolibertate.games.ui.game.LocalCardSpeed
|
import org.prolibertate.games.ui.game.LocalCardSpeed
|
||||||
import org.prolibertate.games.update.UpdateChannel
|
import org.prolibertate.games.update.UpdateChannel
|
||||||
import org.prolibertate.games.update.Updater
|
import org.prolibertate.games.update.Updater
|
||||||
|
import kotlinx.coroutines.Dispatchers
|
||||||
|
import kotlinx.coroutines.withContext
|
||||||
|
import org.prolibertate.games.game.engine.SavedGameStore
|
||||||
|
import org.prolibertate.games.game.engine.SavedMatch
|
||||||
|
|
||||||
/** Everything the screens need, assembled once by the activity. */
|
/** Everything the screens need, assembled once by the activity. */
|
||||||
class AppEnv(
|
class AppEnv(
|
||||||
@@ -60,6 +69,9 @@ class AppEnv(
|
|||||||
/** The shared score sheet, for the Scorekeeper to host or join. */
|
/** The shared score sheet, for the Scorekeeper to host or join. */
|
||||||
val scoreSession: ScorekeeperSession,
|
val scoreSession: ScorekeeperSession,
|
||||||
val peerId: String,
|
val peerId: String,
|
||||||
|
/** Games in progress, kept between sessions. */
|
||||||
|
val saves: SavedGameStore,
|
||||||
|
val yahtzeeStats: YahtzeeStatsRepository,
|
||||||
)
|
)
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -76,6 +88,9 @@ sealed interface Route {
|
|||||||
data class Section(val menu: GameMenu) : Route
|
data class Section(val menu: GameMenu) : Route
|
||||||
data object Settings : Route
|
data object Settings : Route
|
||||||
data object Scorekeeper : Route
|
data object Scorekeeper : Route
|
||||||
|
|
||||||
|
/** Every saved game, to carry on from or delete. */
|
||||||
|
data object Resume : Route
|
||||||
data class Setup(val gameId: String) : Route
|
data class Setup(val gameId: String) : Route
|
||||||
data class Lobby(val gameId: String, val optionsJson: String, val hosting: Boolean) : Route
|
data class Lobby(val gameId: String, val optionsJson: String, val hosting: Boolean) : Route
|
||||||
data class Play(
|
data class Play(
|
||||||
@@ -83,6 +98,8 @@ sealed interface Route {
|
|||||||
val config: TableConfig,
|
val config: TableConfig,
|
||||||
val hosting: Boolean,
|
val hosting: Boolean,
|
||||||
val localSeat: Int,
|
val localSeat: Int,
|
||||||
|
/** A saved position to carry on from, as the game's rules encoded it; null deals a new game. */
|
||||||
|
val resumeState: String? = null,
|
||||||
) : Route
|
) : Route
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -129,7 +146,14 @@ fun AppRoot(env: AppEnv) {
|
|||||||
// Card motion reads its speed from here rather than from a parameter.
|
// Card motion reads its speed from here rather than from a parameter.
|
||||||
// Every card screen animates, most of them several layers deep, and the
|
// Every card screen animates, most of them several layers deep, and the
|
||||||
// alternative was passing one unchanging number down through all of it.
|
// alternative was passing one unchanging number down through all of it.
|
||||||
CompositionLocalProvider(LocalCardSpeed provides settings.animationSpeed) {
|
val density = LocalDensity.current
|
||||||
|
val scaledDensity = remember(density, settings.textScale) {
|
||||||
|
Density(density.density, density.fontScale * settings.textScale)
|
||||||
|
}
|
||||||
|
CompositionLocalProvider(
|
||||||
|
LocalCardSpeed provides settings.animationSpeed,
|
||||||
|
LocalDensity provides scaledDensity,
|
||||||
|
) {
|
||||||
AppContent(
|
AppContent(
|
||||||
env = env,
|
env = env,
|
||||||
settings = settings,
|
settings = settings,
|
||||||
@@ -167,6 +191,8 @@ private fun AppContent(
|
|||||||
// Dev builds show the games that are not finished yet; production
|
// Dev builds show the games that are not finished yet; production
|
||||||
// releases list only what can actually be played.
|
// releases list only what can actually be played.
|
||||||
showComingSoon = showComingSoon,
|
showComingSoon = showComingSoon,
|
||||||
|
hasSaved = savedGames(env, stack).isNotEmpty(),
|
||||||
|
onResume = { push(Route.Resume) },
|
||||||
onPickSection = { push(Route.Section(it)) },
|
onPickSection = { push(Route.Section(it)) },
|
||||||
onJoinGame = { push(Route.Lobby(gameId = "", optionsJson = "{}", hosting = false)) },
|
onJoinGame = { push(Route.Lobby(gameId = "", optionsJson = "{}", hosting = false)) },
|
||||||
onScorekeeper = { push(Route.Scorekeeper) },
|
onScorekeeper = { push(Route.Scorekeeper) },
|
||||||
@@ -181,6 +207,25 @@ private fun AppContent(
|
|||||||
onBack = pop,
|
onBack = pop,
|
||||||
)
|
)
|
||||||
|
|
||||||
|
is Route.Resume -> {
|
||||||
|
// Bumped when a game is deleted, so the list is read again.
|
||||||
|
var deletions by remember(route) { mutableIntStateOf(0) }
|
||||||
|
val saved by produceState(emptyList<SavedMatch>(), route, deletions) {
|
||||||
|
value = withContext(Dispatchers.IO) { env.saves.all() }
|
||||||
|
}
|
||||||
|
ResumeScreen(
|
||||||
|
saved = saved,
|
||||||
|
onResume = { match ->
|
||||||
|
push(Route.Play(match.gameId, match.config, true, match.localSeat, match.stateJson))
|
||||||
|
},
|
||||||
|
onDelete = { match ->
|
||||||
|
env.saves.clear(match.gameId)
|
||||||
|
deletions++
|
||||||
|
},
|
||||||
|
onBack = pop,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
is Route.Settings -> SettingsScreen(
|
is Route.Settings -> SettingsScreen(
|
||||||
env = env,
|
env = env,
|
||||||
settings = settings,
|
settings = settings,
|
||||||
@@ -194,7 +239,13 @@ private fun AppContent(
|
|||||||
onBack = { pop() },
|
onBack = { pop() },
|
||||||
)
|
)
|
||||||
|
|
||||||
is Route.Setup -> GameSetupScreen(
|
is Route.Setup -> {
|
||||||
|
// Bumped when the saved game is thrown away, so the banner goes with it.
|
||||||
|
var discards by remember(route) { mutableIntStateOf(0) }
|
||||||
|
val saved by produceState<SavedMatch?>(null, route, discards) {
|
||||||
|
value = withContext(Dispatchers.IO) { env.saves.load(route.gameId) }
|
||||||
|
}
|
||||||
|
GameSetupScreen(
|
||||||
descriptor = GameCatalog.byId(route.gameId)!!,
|
descriptor = GameCatalog.byId(route.gameId)!!,
|
||||||
playerName = settings.displayName,
|
playerName = settings.displayName,
|
||||||
onBack = { pop() },
|
onBack = { pop() },
|
||||||
@@ -202,7 +253,16 @@ private fun AppContent(
|
|||||||
onHostOnline = { optionsJson ->
|
onHostOnline = { optionsJson ->
|
||||||
push(Route.Lobby(route.gameId, optionsJson, hosting = true))
|
push(Route.Lobby(route.gameId, optionsJson, hosting = true))
|
||||||
},
|
},
|
||||||
|
saved = saved,
|
||||||
|
onResume = { match ->
|
||||||
|
push(Route.Play(match.gameId, match.config, true, match.localSeat, match.stateJson))
|
||||||
|
},
|
||||||
|
onDiscardSaved = {
|
||||||
|
env.saves.clear(route.gameId)
|
||||||
|
discards++
|
||||||
|
},
|
||||||
)
|
)
|
||||||
|
}
|
||||||
|
|
||||||
is Route.Lobby -> LobbyScreen(
|
is Route.Lobby -> LobbyScreen(
|
||||||
env = env,
|
env = env,
|
||||||
@@ -231,6 +291,8 @@ private fun AppContent(
|
|||||||
@Composable
|
@Composable
|
||||||
fun MainMenuScreen(
|
fun MainMenuScreen(
|
||||||
showComingSoon: Boolean,
|
showComingSoon: Boolean,
|
||||||
|
hasSaved: Boolean,
|
||||||
|
onResume: () -> Unit,
|
||||||
onPickSection: (GameMenu) -> Unit,
|
onPickSection: (GameMenu) -> Unit,
|
||||||
onJoinGame: () -> Unit,
|
onJoinGame: () -> Unit,
|
||||||
onScorekeeper: () -> Unit,
|
onScorekeeper: () -> Unit,
|
||||||
@@ -280,6 +342,14 @@ fun MainMenuScreen(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Games left half-played, above everything else: coming back to
|
||||||
|
// the app is mostly coming back to one.
|
||||||
|
if (hasSaved) {
|
||||||
|
Button(onClick = onResume, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text("Resume game")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Below the games, and full width like them, so the column
|
// Below the games, and full width like them, so the column
|
||||||
// stays one column all the way down.
|
// stays one column all the way down.
|
||||||
OutlinedButton(
|
OutlinedButton(
|
||||||
@@ -490,3 +560,17 @@ fun PrimaryAction(text: String, enabled: Boolean = true, onClick: () -> Unit) {
|
|||||||
Text(text)
|
Text(text)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The saved games, read off the main thread each time the menu is the screen
|
||||||
|
* showing — which is when a game has just been left and its last position
|
||||||
|
* written, so the list is not read until that has happened.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
private fun savedGames(env: AppEnv, stack: List<Route>): List<SavedMatch> {
|
||||||
|
val onMenu = stack.last() is Route.Menu
|
||||||
|
val saved by produceState(emptyList<SavedMatch>(), onMenu, stack.size) {
|
||||||
|
value = if (onMenu) withContext(Dispatchers.IO) { env.saves.all() } else emptyList()
|
||||||
|
}
|
||||||
|
return saved
|
||||||
|
}
|
||||||
|
|||||||
@@ -0,0 +1,21 @@
|
|||||||
|
package org.prolibertate.games.ui
|
||||||
|
|
||||||
|
import androidx.compose.runtime.staticCompositionLocalOf
|
||||||
|
|
||||||
|
/**
|
||||||
|
* How a screen's "End game" button tells the table to forget the saved game.
|
||||||
|
*
|
||||||
|
* Leaving a table keeps its position so it can be resumed; ending one on purpose
|
||||||
|
* does not. The two arrive at the screen as the same "go back", so the
|
||||||
|
* difference is carried here instead: [PlayScreen] provides one handle, the match
|
||||||
|
* it builds says what ending means for it by setting [onEnd], and each End-game
|
||||||
|
* dialog calls [end] before it leaves.
|
||||||
|
*/
|
||||||
|
class EndGameHandle {
|
||||||
|
/** Set by the table once it knows how to forget its own saved position. */
|
||||||
|
var onEnd: () -> Unit = {}
|
||||||
|
|
||||||
|
fun end() = onEnd()
|
||||||
|
}
|
||||||
|
|
||||||
|
val LocalEndGameHandle = staticCompositionLocalOf { EndGameHandle() }
|
||||||
@@ -9,11 +9,14 @@ import androidx.compose.foundation.layout.fillMaxWidth
|
|||||||
import androidx.compose.foundation.layout.padding
|
import androidx.compose.foundation.layout.padding
|
||||||
import androidx.compose.foundation.rememberScrollState
|
import androidx.compose.foundation.rememberScrollState
|
||||||
import androidx.compose.foundation.verticalScroll
|
import androidx.compose.foundation.verticalScroll
|
||||||
|
import androidx.compose.material3.Button
|
||||||
|
import androidx.compose.material3.Card
|
||||||
import androidx.compose.material3.Divider
|
import androidx.compose.material3.Divider
|
||||||
import androidx.compose.material3.FilterChip
|
import androidx.compose.material3.FilterChip
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.Switch
|
import androidx.compose.material3.Switch
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
import androidx.compose.runtime.mutableStateOf
|
import androidx.compose.runtime.mutableStateOf
|
||||||
@@ -29,6 +32,7 @@ import org.prolibertate.games.game.GameCatalog
|
|||||||
import org.prolibertate.games.game.GameDescriptor
|
import org.prolibertate.games.game.GameDescriptor
|
||||||
import org.prolibertate.games.game.engine.PlayerKind
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
import org.prolibertate.games.game.engine.PlayerSlot
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.SavedMatch
|
||||||
import org.prolibertate.games.game.engine.TableConfig
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
import org.prolibertate.games.game.backgammon.BackgammonLevel
|
import org.prolibertate.games.game.backgammon.BackgammonLevel
|
||||||
import org.prolibertate.games.game.backgammon.BackgammonOptions
|
import org.prolibertate.games.game.backgammon.BackgammonOptions
|
||||||
@@ -46,6 +50,8 @@ import org.prolibertate.games.game.freecell.FreeCellOptions
|
|||||||
import org.prolibertate.games.game.pyramid.PyramidOptions
|
import org.prolibertate.games.game.pyramid.PyramidOptions
|
||||||
import org.prolibertate.games.game.spider.SpiderOptions
|
import org.prolibertate.games.game.spider.SpiderOptions
|
||||||
import org.prolibertate.games.game.yahtzee.YahtzeeOptions
|
import org.prolibertate.games.game.yahtzee.YahtzeeOptions
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuGenerator
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuOptions
|
||||||
import org.prolibertate.games.game.pegsolitaire.PegBoard
|
import org.prolibertate.games.game.pegsolitaire.PegBoard
|
||||||
import org.prolibertate.games.game.pegsolitaire.PegGoal
|
import org.prolibertate.games.game.pegsolitaire.PegGoal
|
||||||
import org.prolibertate.games.game.pegsolitaire.PegSolitaireOptions
|
import org.prolibertate.games.game.pegsolitaire.PegSolitaireOptions
|
||||||
@@ -58,6 +64,7 @@ import org.prolibertate.games.game.pirates.PiratesLevel
|
|||||||
import org.prolibertate.games.game.pirates.PiratesOptions
|
import org.prolibertate.games.game.pirates.PiratesOptions
|
||||||
import org.prolibertate.games.game.president.PresidentOptions
|
import org.prolibertate.games.game.president.PresidentOptions
|
||||||
import org.prolibertate.games.game.catan.CatanOptions
|
import org.prolibertate.games.game.catan.CatanOptions
|
||||||
|
import org.prolibertate.games.game.catan.CatanRuleSet
|
||||||
import org.prolibertate.games.game.sequence.SequenceOptions
|
import org.prolibertate.games.game.sequence.SequenceOptions
|
||||||
import org.prolibertate.games.game.tayu.TayuLevel
|
import org.prolibertate.games.game.tayu.TayuLevel
|
||||||
import org.prolibertate.games.game.tayu.TayuOptions
|
import org.prolibertate.games.game.tayu.TayuOptions
|
||||||
@@ -82,6 +89,10 @@ fun GameSetupScreen(
|
|||||||
onBack: () -> Unit,
|
onBack: () -> Unit,
|
||||||
onPlayOffline: (TableConfig, Int) -> Unit,
|
onPlayOffline: (TableConfig, Int) -> Unit,
|
||||||
onHostOnline: (String) -> Unit,
|
onHostOnline: (String) -> Unit,
|
||||||
|
/** A game of this kind left half-played, if there is one. */
|
||||||
|
saved: SavedMatch? = null,
|
||||||
|
onResume: (SavedMatch) -> Unit = {},
|
||||||
|
onDiscardSaved: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
var euchre by remember { mutableStateOf(EuchreOptions()) }
|
var euchre by remember { mutableStateOf(EuchreOptions()) }
|
||||||
var sequence by remember { mutableStateOf(SequenceOptions()) }
|
var sequence by remember { mutableStateOf(SequenceOptions()) }
|
||||||
@@ -100,6 +111,7 @@ fun GameSetupScreen(
|
|||||||
var pirates by remember { mutableStateOf(PiratesOptions()) }
|
var pirates by remember { mutableStateOf(PiratesOptions()) }
|
||||||
var hearts by remember { mutableStateOf(HeartsOptions()) }
|
var hearts by remember { mutableStateOf(HeartsOptions()) }
|
||||||
var pegs by remember { mutableStateOf(PegSolitaireOptions()) }
|
var pegs by remember { mutableStateOf(PegSolitaireOptions()) }
|
||||||
|
var meowdoku by remember { mutableStateOf(MeowdokuOptions()) }
|
||||||
var yahtzee by remember { mutableStateOf(YahtzeeOptions()) }
|
var yahtzee by remember { mutableStateOf(YahtzeeOptions()) }
|
||||||
var klondike by remember { mutableStateOf(KlondikeOptions()) }
|
var klondike by remember { mutableStateOf(KlondikeOptions()) }
|
||||||
var freecell by remember { mutableStateOf(FreeCellOptions()) }
|
var freecell by remember { mutableStateOf(FreeCellOptions()) }
|
||||||
@@ -131,6 +143,7 @@ fun GameSetupScreen(
|
|||||||
GameCatalog.PIRATES -> setupJson.encodeToString(pirates)
|
GameCatalog.PIRATES -> setupJson.encodeToString(pirates)
|
||||||
GameCatalog.HEARTS -> setupJson.encodeToString(hearts)
|
GameCatalog.HEARTS -> setupJson.encodeToString(hearts)
|
||||||
GameCatalog.PEG_SOLITAIRE -> setupJson.encodeToString(pegs)
|
GameCatalog.PEG_SOLITAIRE -> setupJson.encodeToString(pegs)
|
||||||
|
GameCatalog.MEOWDOKU -> setupJson.encodeToString(meowdoku)
|
||||||
GameCatalog.YAHTZEE -> setupJson.encodeToString(yahtzee)
|
GameCatalog.YAHTZEE -> setupJson.encodeToString(yahtzee)
|
||||||
GameCatalog.KLONDIKE -> setupJson.encodeToString(klondike)
|
GameCatalog.KLONDIKE -> setupJson.encodeToString(klondike)
|
||||||
GameCatalog.FREECELL -> setupJson.encodeToString(freecell)
|
GameCatalog.FREECELL -> setupJson.encodeToString(freecell)
|
||||||
@@ -148,6 +161,10 @@ fun GameSetupScreen(
|
|||||||
) {
|
) {
|
||||||
Text(descriptor.blurb, style = MaterialTheme.typography.bodyMedium)
|
Text(descriptor.blurb, style = MaterialTheme.typography.bodyMedium)
|
||||||
|
|
||||||
|
if (saved != null) {
|
||||||
|
SavedGameBanner(saved, onResume = { onResume(saved) }, onDiscard = onDiscardSaved)
|
||||||
|
}
|
||||||
|
|
||||||
Divider()
|
Divider()
|
||||||
Text("House rules", fontWeight = FontWeight.Bold)
|
Text("House rules", fontWeight = FontWeight.Bold)
|
||||||
|
|
||||||
@@ -192,6 +209,8 @@ fun GameSetupScreen(
|
|||||||
|
|
||||||
GameCatalog.PEG_SOLITAIRE -> PegSolitaireOptionsEditor(pegs) { pegs = it }
|
GameCatalog.PEG_SOLITAIRE -> PegSolitaireOptionsEditor(pegs) { pegs = it }
|
||||||
|
|
||||||
|
GameCatalog.MEOWDOKU -> MeowdokuOptionsEditor(meowdoku) { meowdoku = it }
|
||||||
|
|
||||||
GameCatalog.YAHTZEE -> YahtzeeOptionsEditor(yahtzee) { yahtzee = it }
|
GameCatalog.YAHTZEE -> YahtzeeOptionsEditor(yahtzee) { yahtzee = it }
|
||||||
|
|
||||||
GameCatalog.KLONDIKE -> KlondikeOptionsEditor(klondike) { klondike = it }
|
GameCatalog.KLONDIKE -> KlondikeOptionsEditor(klondike) { klondike = it }
|
||||||
@@ -232,6 +251,12 @@ fun GameSetupScreen(
|
|||||||
descriptor.id == GameCatalog.PIRATES && playPirates -> 1
|
descriptor.id == GameCatalog.PIRATES && playPirates -> 1
|
||||||
else -> 0
|
else -> 0
|
||||||
}
|
}
|
||||||
|
if (saved != null) {
|
||||||
|
Text(
|
||||||
|
"Starting a new game replaces the one in progress.",
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
}
|
||||||
PrimaryAction(text = if (solo) "Play" else "Play against the computer") {
|
PrimaryAction(text = if (solo) "Play" else "Play against the computer") {
|
||||||
onPlayOffline(
|
onPlayOffline(
|
||||||
offlineConfig(descriptor.id, optionsJson, seatCount, playerName, localSeat),
|
offlineConfig(descriptor.id, optionsJson, seatCount, playerName, localSeat),
|
||||||
@@ -334,9 +359,62 @@ fun teamForSeat(gameId: String, seat: Int, seatCount: Int): Int = when (gameId)
|
|||||||
else -> seat
|
else -> seat
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** The targets the setup screen offers for a Katan rule set. */
|
||||||
|
internal fun catanPointsChoices(ruleSet: CatanRuleSet): List<Int> = when (ruleSet) {
|
||||||
|
// Five is a short game for trying things out; ten is the published target.
|
||||||
|
CatanRuleSet.BASE -> listOf(5, 8, 10, 12)
|
||||||
|
// Cities & Knights is played to thirteen, which is also why it runs longer.
|
||||||
|
CatanRuleSet.CITIES_AND_KNIGHTS -> listOf(8, 10, 13, 15)
|
||||||
|
// Seafarers adds two points for each new island, so the target is higher.
|
||||||
|
CatanRuleSet.SEAFARERS -> listOf(8, 10, 12, 14)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The published target for a rule set. */
|
||||||
|
internal fun catanDefaultPoints(ruleSet: CatanRuleSet): Int = when (ruleSet) {
|
||||||
|
CatanRuleSet.BASE -> 10
|
||||||
|
CatanRuleSet.CITIES_AND_KNIGHTS -> 13
|
||||||
|
CatanRuleSet.SEAFARERS -> 12
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* [options] switched to [ruleSet]. The target moves to the new rule set's own
|
||||||
|
* default unless the one already chosen is on its menu too.
|
||||||
|
*/
|
||||||
|
internal fun catanSwitchRules(options: CatanOptions, ruleSet: CatanRuleSet): CatanOptions =
|
||||||
|
options.copy(
|
||||||
|
ruleSet = ruleSet,
|
||||||
|
pointsToWin = options.pointsToWin.takeIf { it in catanPointsChoices(ruleSet) && it != catanDefaultPoints(options.ruleSet) }
|
||||||
|
?: catanDefaultPoints(ruleSet),
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun catanRuleSetName(ruleSet: CatanRuleSet): String = when (ruleSet) {
|
||||||
|
CatanRuleSet.BASE -> "Base game"
|
||||||
|
CatanRuleSet.CITIES_AND_KNIGHTS -> "Cities & Knights"
|
||||||
|
CatanRuleSet.SEAFARERS -> "Seafarers"
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun catanRuleSetBlurb(ruleSet: CatanRuleSet): String = when (ruleSet) {
|
||||||
|
CatanRuleSet.BASE ->
|
||||||
|
"Settle the island, trade, and play development cards. Longest Road and Largest Army score."
|
||||||
|
CatanRuleSet.CITIES_AND_KNIGHTS ->
|
||||||
|
"Cities make commodities, knights hold off the barbarians, and improvements earn progress " +
|
||||||
|
"cards and metropolises. No development cards; the robber sleeps until the first attack."
|
||||||
|
CatanRuleSet.SEAFARERS ->
|
||||||
|
"Build ships to reach new islands. Gold fields pay any resource, a pirate guards the sea, " +
|
||||||
|
"and the first settlement on each new island scores two extra points."
|
||||||
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun CatanOptionsEditor(options: CatanOptions, onChange: (CatanOptions) -> Unit) {
|
private fun CatanOptionsEditor(options: CatanOptions, onChange: (CatanOptions) -> Unit) {
|
||||||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
ChipRow(
|
||||||
|
label = "Rules",
|
||||||
|
values = CatanRuleSet.entries,
|
||||||
|
selected = options.ruleSet,
|
||||||
|
display = ::catanRuleSetName,
|
||||||
|
onSelect = { onChange(catanSwitchRules(options, it)) },
|
||||||
|
)
|
||||||
|
Text(catanRuleSetBlurb(options.ruleSet), style = MaterialTheme.typography.bodySmall)
|
||||||
ChipRow(
|
ChipRow(
|
||||||
label = "Players",
|
label = "Players",
|
||||||
values = listOf(3, 4),
|
values = listOf(3, 4),
|
||||||
@@ -346,8 +424,7 @@ private fun CatanOptionsEditor(options: CatanOptions, onChange: (CatanOptions) -
|
|||||||
)
|
)
|
||||||
ChipRow(
|
ChipRow(
|
||||||
label = "Game to",
|
label = "Game to",
|
||||||
// Five is a short game for trying things out; ten is the published target.
|
values = catanPointsChoices(options.ruleSet),
|
||||||
values = listOf(5, 8, 10, 12),
|
|
||||||
selected = options.pointsToWin,
|
selected = options.pointsToWin,
|
||||||
display = { "$it points" },
|
display = { "$it points" },
|
||||||
onSelect = { onChange(options.copy(pointsToWin = it)) },
|
onSelect = { onChange(options.copy(pointsToWin = it)) },
|
||||||
@@ -1070,6 +1147,36 @@ private fun PegSolitaireOptionsEditor(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun MeowdokuOptionsEditor(
|
||||||
|
options: MeowdokuOptions,
|
||||||
|
onChange: (MeowdokuOptions) -> Unit,
|
||||||
|
) {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
ChipRow(
|
||||||
|
label = "Board",
|
||||||
|
values = (MeowdokuGenerator.MIN_SIDE..MeowdokuGenerator.MAX_SIDE).toList(),
|
||||||
|
selected = options.side,
|
||||||
|
display = { "$it × $it" },
|
||||||
|
onSelect = { onChange(options.copy(side = it)) },
|
||||||
|
)
|
||||||
|
ChipRow(
|
||||||
|
label = "Hearts",
|
||||||
|
values = (1..5).toList(),
|
||||||
|
selected = options.hearts,
|
||||||
|
display = { if (it == 1) "One" else "$it" },
|
||||||
|
onSelect = { onChange(options.copy(hearts = it)) },
|
||||||
|
)
|
||||||
|
ChipRow(
|
||||||
|
label = "Hints",
|
||||||
|
values = (0..3).toList(),
|
||||||
|
selected = options.hints,
|
||||||
|
display = { if (it == 0) "None" else "$it" },
|
||||||
|
onSelect = { onChange(options.copy(hints = it)) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun YahtzeeOptionsEditor(options: YahtzeeOptions, onChange: (YahtzeeOptions) -> Unit) {
|
private fun YahtzeeOptionsEditor(options: YahtzeeOptions, onChange: (YahtzeeOptions) -> Unit) {
|
||||||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
@@ -1170,3 +1277,30 @@ private fun PyramidOptionsEditor(options: PyramidOptions, onChange: (PyramidOpti
|
|||||||
onSelect = { onChange(options.copy(redeals = it)) },
|
onSelect = { onChange(options.copy(redeals = it)) },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The game that was left unfinished, with the two things to do about it. Shown
|
||||||
|
* above the options so it is the first thing seen on coming back to a game.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
private fun SavedGameBanner(saved: SavedMatch, onResume: () -> Unit, onDiscard: () -> Unit) {
|
||||||
|
Card(modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.padding(12.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
|
) {
|
||||||
|
Text("Game in progress", fontWeight = FontWeight.Bold)
|
||||||
|
Text(
|
||||||
|
buildString {
|
||||||
|
append("Saved ${agoText(System.currentTimeMillis(), saved.savedAtMillis)}")
|
||||||
|
if (saved.summary.isNotBlank()) append(" · ${saved.summary}")
|
||||||
|
},
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
Button(onClick = onResume) { Text("Resume") }
|
||||||
|
TextButton(onClick = onDiscard) { Text("Discard") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -2,10 +2,13 @@ package org.prolibertate.games.ui
|
|||||||
|
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
|
import androidx.compose.runtime.CompositionLocalProvider
|
||||||
import androidx.compose.runtime.DisposableEffect
|
import androidx.compose.runtime.DisposableEffect
|
||||||
import androidx.compose.runtime.LaunchedEffect
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
import androidx.compose.runtime.mutableIntStateOf
|
import androidx.compose.runtime.mutableIntStateOf
|
||||||
|
import androidx.compose.runtime.mutableLongStateOf
|
||||||
|
import androidx.compose.runtime.mutableStateOf
|
||||||
import androidx.compose.runtime.remember
|
import androidx.compose.runtime.remember
|
||||||
import androidx.compose.runtime.setValue
|
import androidx.compose.runtime.setValue
|
||||||
import androidx.compose.runtime.rememberCoroutineScope
|
import androidx.compose.runtime.rememberCoroutineScope
|
||||||
@@ -85,6 +88,10 @@ import org.prolibertate.games.game.mastermind.MastermindAi
|
|||||||
import org.prolibertate.games.game.mastermind.MastermindMove
|
import org.prolibertate.games.game.mastermind.MastermindMove
|
||||||
import org.prolibertate.games.game.mastermind.MastermindRules
|
import org.prolibertate.games.game.mastermind.MastermindRules
|
||||||
import org.prolibertate.games.game.mastermind.MastermindState
|
import org.prolibertate.games.game.mastermind.MastermindState
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuAi
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuMove
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuRules
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuState
|
||||||
import org.prolibertate.games.game.morris.MorrisAi
|
import org.prolibertate.games.game.morris.MorrisAi
|
||||||
import org.prolibertate.games.game.morris.MorrisMove
|
import org.prolibertate.games.game.morris.MorrisMove
|
||||||
import org.prolibertate.games.game.morris.MorrisRules
|
import org.prolibertate.games.game.morris.MorrisRules
|
||||||
@@ -112,6 +119,8 @@ import org.prolibertate.games.game.wizard.WizardPhase
|
|||||||
import org.prolibertate.games.game.wizard.WizardRules
|
import org.prolibertate.games.game.wizard.WizardRules
|
||||||
import org.prolibertate.games.game.wizard.WizardState
|
import org.prolibertate.games.game.wizard.WizardState
|
||||||
import org.prolibertate.games.net.MatchController
|
import org.prolibertate.games.net.MatchController
|
||||||
|
import org.prolibertate.games.net.MatchSaver
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
import org.prolibertate.games.settings.Settings
|
import org.prolibertate.games.settings.Settings
|
||||||
import org.prolibertate.games.ui.game.BackgammonScreen
|
import org.prolibertate.games.ui.game.BackgammonScreen
|
||||||
import org.prolibertate.games.ui.game.catan.CatanScreen
|
import org.prolibertate.games.ui.game.catan.CatanScreen
|
||||||
@@ -127,6 +136,7 @@ import org.prolibertate.games.ui.game.EuchreScreen
|
|||||||
import org.prolibertate.games.ui.game.GolfScreen
|
import org.prolibertate.games.ui.game.GolfScreen
|
||||||
import org.prolibertate.games.ui.game.KaiserScreen
|
import org.prolibertate.games.ui.game.KaiserScreen
|
||||||
import org.prolibertate.games.ui.game.MastermindScreen
|
import org.prolibertate.games.ui.game.MastermindScreen
|
||||||
|
import org.prolibertate.games.ui.game.MeowdokuScreen
|
||||||
import org.prolibertate.games.ui.game.MorrisScreen
|
import org.prolibertate.games.ui.game.MorrisScreen
|
||||||
import org.prolibertate.games.ui.game.PegSolitaireScreen
|
import org.prolibertate.games.ui.game.PegSolitaireScreen
|
||||||
import org.prolibertate.games.ui.game.SpiderScreen
|
import org.prolibertate.games.ui.game.SpiderScreen
|
||||||
@@ -155,6 +165,10 @@ fun PlayScreen(
|
|||||||
val scope = rememberCoroutineScope()
|
val scope = rememberCoroutineScope()
|
||||||
val role = if (route.hosting) MatchController.Role.HOST else MatchController.Role.CLIENT
|
val role = if (route.hosting) MatchController.Role.HOST else MatchController.Role.CLIENT
|
||||||
|
|
||||||
|
// The same handle for every table this screen builds, so an End-game dialog
|
||||||
|
// anywhere below can reach the table that is showing.
|
||||||
|
val endHandle = remember(route) { EndGameHandle() }
|
||||||
|
CompositionLocalProvider(LocalEndGameHandle provides endHandle) {
|
||||||
when (route.gameId) {
|
when (route.gameId) {
|
||||||
GameCatalog.EUCHRE -> {
|
GameCatalog.EUCHRE -> {
|
||||||
val controller = remember(route) {
|
val controller = remember(route) {
|
||||||
@@ -536,6 +550,34 @@ fun PlayScreen(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
GameCatalog.MEOWDOKU -> {
|
||||||
|
// Like peg solitaire the controller is rebuilt rather than
|
||||||
|
// reset — a finished board has nothing left to do — but unlike
|
||||||
|
// it a new board is dealt every time: the same cats in the same
|
||||||
|
// colours twice would only repeat the last puzzle's answer.
|
||||||
|
// Moving the seed moves the deal, and each deal is still
|
||||||
|
// reproducible from its own seed.
|
||||||
|
var attempt by remember(route) { mutableLongStateOf(0L) }
|
||||||
|
val controller = remember(route, attempt) {
|
||||||
|
MatchController<MeowdokuState, MeowdokuMove>(
|
||||||
|
rules = MeowdokuRules,
|
||||||
|
// Never consulted while a person holds the only seat.
|
||||||
|
ai = MeowdokuAi,
|
||||||
|
config = route.config.copy(seed = route.config.seed + attempt),
|
||||||
|
scope = scope,
|
||||||
|
role = role,
|
||||||
|
localSeats = setOf(route.localSeat),
|
||||||
|
primarySeat = route.localSeat,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
StartMatch(env, controller, route)
|
||||||
|
MeowdokuScreen(
|
||||||
|
controller = controller,
|
||||||
|
onNewPuzzle = { attempt++ },
|
||||||
|
onExit = onExit,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
GameCatalog.YAHTZEE -> {
|
GameCatalog.YAHTZEE -> {
|
||||||
val controller = remember(route) {
|
val controller = remember(route) {
|
||||||
MatchController<YahtzeeState, YahtzeeMove>(
|
MatchController<YahtzeeState, YahtzeeMove>(
|
||||||
@@ -552,7 +594,12 @@ fun PlayScreen(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
StartMatch(env, controller, route)
|
StartMatch(env, controller, route)
|
||||||
YahtzeeScreen(controller = controller, localSeat = route.localSeat, onExit = onExit)
|
YahtzeeScreen(
|
||||||
|
controller = controller,
|
||||||
|
localSeat = route.localSeat,
|
||||||
|
stats = env.yahtzeeStats,
|
||||||
|
onExit = onExit,
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
GameCatalog.KLONDIKE -> {
|
GameCatalog.KLONDIKE -> {
|
||||||
@@ -700,6 +747,7 @@ fun PlayScreen(
|
|||||||
else -> Text("That game isn't playable yet.")
|
else -> Text("That game isn't playable yet.")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun <S : Any, M : Any> StartMatch(
|
private fun <S : Any, M : Any> StartMatch(
|
||||||
@@ -707,8 +755,38 @@ private fun <S : Any, M : Any> StartMatch(
|
|||||||
controller: MatchController<S, M>,
|
controller: MatchController<S, M>,
|
||||||
route: Route.Play,
|
route: Route.Play,
|
||||||
) {
|
) {
|
||||||
|
val scope = rememberCoroutineScope()
|
||||||
|
val endHandle = LocalEndGameHandle.current
|
||||||
|
|
||||||
|
// A game against the computer (or on one device) is kept as it is played, so
|
||||||
|
// it can be picked up after the app has been closed. A table with another
|
||||||
|
// device at it is not: the other player's seat cannot be held for them.
|
||||||
|
val saveable = route.hosting && route.config.seats.none { it.kind == PlayerKind.HUMAN_REMOTE }
|
||||||
|
val saver = remember(controller) {
|
||||||
|
if (saveable) {
|
||||||
|
MatchSaver(env.saves, route.gameId, route.config, route.localSeat, scope)
|
||||||
|
} else {
|
||||||
|
null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// The position to carry on from belongs to the first table only. Dealing
|
||||||
|
// again (solitaire's "new deal") builds a fresh controller under the same
|
||||||
|
// route, and that one must not be put back to where the last one stood.
|
||||||
|
val resume = remember(route) { mutableStateOf(route.resumeState) }
|
||||||
|
|
||||||
LaunchedEffect(controller) {
|
LaunchedEffect(controller) {
|
||||||
if (route.hosting) {
|
if (route.hosting) {
|
||||||
|
resume.value?.let { saved ->
|
||||||
|
resume.value = null
|
||||||
|
// A save this version cannot read — one from an older build — is
|
||||||
|
// not worth keeping; the table is dealt afresh instead.
|
||||||
|
if (!controller.restore(saved)) env.saves.clear(route.gameId)
|
||||||
|
}
|
||||||
|
if (saver != null) {
|
||||||
|
saver.start()
|
||||||
|
controller.onHostState = saver::offer
|
||||||
|
endHandle.onEnd = saver::discard
|
||||||
|
}
|
||||||
controller.startAsHost(env.lobby.hostConnections)
|
controller.startAsHost(env.lobby.hostConnections)
|
||||||
} else {
|
} else {
|
||||||
env.lobby.clientConnection?.let { controller.startAsClient(it) }
|
env.lobby.clientConnection?.let { controller.startAsClient(it) }
|
||||||
@@ -721,6 +799,10 @@ private fun <S : Any, M : Any> StartMatch(
|
|||||||
env.lobby.rebinder = controller
|
env.lobby.rebinder = controller
|
||||||
onDispose {
|
onDispose {
|
||||||
env.lobby.rebinder = null
|
env.lobby.rebinder = null
|
||||||
|
// Whatever the writer has not caught up with is written before the
|
||||||
|
// table goes, so leaving mid-move does not lose the last move.
|
||||||
|
saver?.flush()
|
||||||
|
saver?.stop()
|
||||||
controller.close()
|
controller.close()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -734,11 +816,14 @@ private fun <S : Any, M : Any> StartMatch(
|
|||||||
// sent. So the table is asked for again on the way back in, over a fresh
|
// sent. So the table is asked for again on the way back in, over a fresh
|
||||||
// link if the old one did not survive.
|
// link if the old one did not survive.
|
||||||
val lifecycleOwner = LocalLifecycleOwner.current
|
val lifecycleOwner = LocalLifecycleOwner.current
|
||||||
DisposableEffect(lifecycleOwner, route.hosting) {
|
DisposableEffect(lifecycleOwner, route.hosting, saver) {
|
||||||
val observer = LifecycleEventObserver { _, event ->
|
val observer = LifecycleEventObserver { _, event ->
|
||||||
if (event == Lifecycle.Event.ON_START && !route.hosting) {
|
if (event == Lifecycle.Event.ON_START && !route.hosting) {
|
||||||
env.lobby.restoreLink()
|
env.lobby.restoreLink()
|
||||||
}
|
}
|
||||||
|
// The app going to the background may be the last the process hears:
|
||||||
|
// Android can end it without a word, so the position is written now.
|
||||||
|
if (event == Lifecycle.Event.ON_STOP) saver?.flush()
|
||||||
}
|
}
|
||||||
lifecycleOwner.lifecycle.addObserver(observer)
|
lifecycleOwner.lifecycle.addObserver(observer)
|
||||||
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
|
onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
|
||||||
|
|||||||
@@ -0,0 +1,87 @@
|
|||||||
|
package org.prolibertate.games.ui
|
||||||
|
|
||||||
|
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.foundation.lazy.LazyColumn
|
||||||
|
import androidx.compose.foundation.lazy.items
|
||||||
|
import androidx.compose.material3.AlertDialog
|
||||||
|
import androidx.compose.material3.Button
|
||||||
|
import androidx.compose.material3.Card
|
||||||
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
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.Modifier
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import org.prolibertate.games.game.GameCatalog
|
||||||
|
import org.prolibertate.games.game.engine.SavedMatch
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Every game that can be carried on from, most recently played first, each with
|
||||||
|
* a way to pick it up and a way to throw it away.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun ResumeScreen(
|
||||||
|
saved: List<SavedMatch>,
|
||||||
|
onResume: (SavedMatch) -> Unit,
|
||||||
|
onDelete: (SavedMatch) -> Unit,
|
||||||
|
onBack: () -> Unit,
|
||||||
|
) {
|
||||||
|
var deleting by remember { mutableStateOf<SavedMatch?>(null) }
|
||||||
|
|
||||||
|
ScreenScaffold(title = "Resume game", onBack = onBack) { modifier ->
|
||||||
|
if (saved.isEmpty()) {
|
||||||
|
Text("No games to resume.", modifier = modifier)
|
||||||
|
} else {
|
||||||
|
val now = System.currentTimeMillis()
|
||||||
|
LazyColumn(
|
||||||
|
modifier = modifier,
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
items(saved, key = { it.gameId }) { match ->
|
||||||
|
val title = GameCatalog.byId(match.gameId)?.title ?: match.gameId
|
||||||
|
Card(modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.padding(12.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
|
) {
|
||||||
|
Text(title, fontWeight = FontWeight.Bold)
|
||||||
|
Text(
|
||||||
|
buildString {
|
||||||
|
append("Saved ${agoText(now, match.savedAtMillis)}")
|
||||||
|
if (match.summary.isNotBlank()) append(" · ${match.summary}")
|
||||||
|
},
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
Button(onClick = { onResume(match) }) { Text("Resume") }
|
||||||
|
TextButton(onClick = { deleting = match }) { Text("Delete") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
deleting?.let { match ->
|
||||||
|
val title = GameCatalog.byId(match.gameId)?.title ?: match.gameId
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = { deleting = null },
|
||||||
|
title = { Text("Delete this game?") },
|
||||||
|
text = { Text("Your saved game of $title will be removed and cannot be resumed.") },
|
||||||
|
confirmButton = {
|
||||||
|
TextButton(onClick = { deleting = null; onDelete(match) }) { Text("Delete") }
|
||||||
|
},
|
||||||
|
dismissButton = { TextButton(onClick = { deleting = null }) { Text("Keep it") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,24 @@
|
|||||||
|
package org.prolibertate.games.ui
|
||||||
|
|
||||||
|
import org.prolibertate.games.game.engine.SavedMatch
|
||||||
|
|
||||||
|
/** How long ago something happened, in the words a person would use. */
|
||||||
|
fun agoText(nowMillis: Long, thenMillis: Long): String {
|
||||||
|
val seconds = ((nowMillis - thenMillis) / 1000).coerceAtLeast(0)
|
||||||
|
val minutes = seconds / 60
|
||||||
|
val hours = minutes / 60
|
||||||
|
val days = hours / 24
|
||||||
|
return when {
|
||||||
|
seconds < 45 -> "just now"
|
||||||
|
minutes < 2 -> "a minute ago"
|
||||||
|
minutes < 60 -> "$minutes minutes ago"
|
||||||
|
hours < 2 -> "an hour ago"
|
||||||
|
hours < 24 -> "$hours hours ago"
|
||||||
|
days < 2 -> "yesterday"
|
||||||
|
else -> "$days days ago"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** "Chess · saved 5 minutes ago" for a menu line. */
|
||||||
|
fun savedLine(title: String, match: SavedMatch, nowMillis: Long): String =
|
||||||
|
"$title · saved ${agoText(nowMillis, match.savedAtMillis)}"
|
||||||
@@ -36,6 +36,7 @@ import androidx.compose.runtime.DisposableEffect
|
|||||||
import androidx.compose.runtime.LaunchedEffect
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
|
import androidx.compose.runtime.mutableStateListOf
|
||||||
import androidx.compose.runtime.mutableStateMapOf
|
import androidx.compose.runtime.mutableStateMapOf
|
||||||
import androidx.compose.runtime.mutableStateOf
|
import androidx.compose.runtime.mutableStateOf
|
||||||
import androidx.compose.runtime.remember
|
import androidx.compose.runtime.remember
|
||||||
@@ -114,6 +115,8 @@ fun ScorekeeperScreen(
|
|||||||
local = repository.sheet.first()
|
local = repository.sheet.first()
|
||||||
loaded = true
|
loaded = true
|
||||||
}
|
}
|
||||||
|
val recentNames by repository.recentNames.collectAsState(initial = emptyList())
|
||||||
|
val nameUsed: (String) -> Unit = { name -> scope.launch { repository.rememberName(name) } }
|
||||||
|
|
||||||
val shared by session.state.collectAsState()
|
val shared by session.state.collectAsState()
|
||||||
val role = shared.role
|
val role = shared.role
|
||||||
@@ -220,7 +223,7 @@ fun ScorekeeperScreen(
|
|||||||
|
|
||||||
role == Role.GUEST -> Column(modifier = modifier) {
|
role == Role.GUEST -> Column(modifier = modifier) {
|
||||||
ConnectionBanner(shared = shared, onSync = { session.sync() })
|
ConnectionBanner(shared = shared, onSync = { session.sync() })
|
||||||
Scoring(modifier = Modifier.weight(1f), sheet = sheet, onOp = change)
|
Scoring(Modifier.weight(1f), sheet, change, recentNames, nameUsed)
|
||||||
}
|
}
|
||||||
|
|
||||||
joining && role == Role.NONE ->
|
joining && role == Role.NONE ->
|
||||||
@@ -228,11 +231,16 @@ fun ScorekeeperScreen(
|
|||||||
|
|
||||||
!sheet.started -> SetupPane(
|
!sheet.started -> SetupPane(
|
||||||
modifier = modifier,
|
modifier = modifier,
|
||||||
onStart = { count, mode -> change(StartSheet(count, mode)) },
|
recentNames = recentNames,
|
||||||
|
onStart = { count, mode, names ->
|
||||||
|
change(StartSheet(count, mode, names))
|
||||||
|
// Last first, so the list reads in seating order.
|
||||||
|
names.reversed().forEach(nameUsed)
|
||||||
|
},
|
||||||
onJoin = { joining = true },
|
onJoin = { joining = true },
|
||||||
)
|
)
|
||||||
|
|
||||||
else -> Scoring(modifier = modifier, sheet = sheet, onOp = change)
|
else -> Scoring(modifier, sheet, change, recentNames, nameUsed)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -289,9 +297,46 @@ fun ScorekeeperScreen(
|
|||||||
|
|
||||||
@OptIn(ExperimentalLayoutApi::class)
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
@Composable
|
@Composable
|
||||||
private fun SetupPane(modifier: Modifier, onStart: (Int, ScoringMode) -> Unit, onJoin: () -> Unit) {
|
private fun SetupPane(
|
||||||
|
modifier: Modifier,
|
||||||
|
recentNames: List<String>,
|
||||||
|
onStart: (Int, ScoringMode, List<String>) -> Unit,
|
||||||
|
onJoin: () -> Unit,
|
||||||
|
) {
|
||||||
var count by remember { mutableStateOf(ScoreSheet.DEFAULT_PLAYERS) }
|
var count by remember { mutableStateOf(ScoreSheet.DEFAULT_PLAYERS) }
|
||||||
var mode by remember { mutableStateOf(ScoringMode.ROUNDS) }
|
var mode by remember { mutableStateOf(ScoringMode.ROUNDS) }
|
||||||
|
// -1 while the options are showing; otherwise the seat being named.
|
||||||
|
var naming by remember { mutableStateOf(-1) }
|
||||||
|
val names = remember { mutableStateListOf<String>() }
|
||||||
|
|
||||||
|
if (naming >= 0) {
|
||||||
|
NamePane(
|
||||||
|
modifier = modifier,
|
||||||
|
seat = naming,
|
||||||
|
count = count,
|
||||||
|
name = names.getOrElse(naming) { "" },
|
||||||
|
// Offered once only: two players on one sheet with the same name
|
||||||
|
// are indistinguishable.
|
||||||
|
suggestions = recentNames.filter { recent ->
|
||||||
|
names.withIndex().none { (seat, taken) ->
|
||||||
|
seat != naming && taken.trim().equals(recent.trim(), ignoreCase = true)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
onName = { typed ->
|
||||||
|
while (names.size <= naming) names.add("")
|
||||||
|
names[naming] = typed
|
||||||
|
},
|
||||||
|
onBack = { naming -= 1 },
|
||||||
|
onNext = {
|
||||||
|
if (naming + 1 < count) {
|
||||||
|
naming += 1
|
||||||
|
} else {
|
||||||
|
onStart(count, mode, List(count) { names.getOrElse(it) { "" }.trim() })
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
Column(
|
Column(
|
||||||
modifier = modifier.verticalScroll(rememberScrollState()),
|
modifier = modifier.verticalScroll(rememberScrollState()),
|
||||||
@@ -339,33 +384,98 @@ private fun SetupPane(modifier: Modifier, onStart: (Int, ScoringMode) -> Unit, o
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
Text(
|
Text(
|
||||||
text = "Names come next: tap a column head to name it. Players can be " +
|
text = "You will be asked for each name next, or skip them and tap a " +
|
||||||
"added, removed or dragged into a different order at any point " +
|
"column head later. Players can be added, removed or dragged into " +
|
||||||
"without losing anybody's score.",
|
"a different order at any point without losing anybody's score.",
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodySmall,
|
||||||
)
|
)
|
||||||
PrimaryAction(text = "Start scoring") { onStart(count, mode) }
|
PrimaryAction(text = "Next: name the players") { naming = 0 }
|
||||||
OutlinedButton(onClick = onJoin, modifier = Modifier.fillMaxWidth()) {
|
OutlinedButton(onClick = onJoin, modifier = Modifier.fillMaxWidth()) {
|
||||||
Text("Join a shared sheet nearby")
|
Text("Join a shared sheet nearby")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** One seat's name, asked for on its own; a blank leaves the seat as "Player N". */
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
private fun NamePane(
|
||||||
|
modifier: Modifier,
|
||||||
|
seat: Int,
|
||||||
|
count: Int,
|
||||||
|
name: String,
|
||||||
|
suggestions: List<String>,
|
||||||
|
onName: (String) -> Unit,
|
||||||
|
onBack: () -> Unit,
|
||||||
|
onNext: () -> Unit,
|
||||||
|
) {
|
||||||
|
val focus = remember { FocusRequester() }
|
||||||
|
LaunchedEffect(seat) { focus.requestFocus() }
|
||||||
|
val last = seat + 1 >= count
|
||||||
|
Column(
|
||||||
|
modifier = modifier.verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(12.dp),
|
||||||
|
) {
|
||||||
|
Text("Player ${seat + 1} of $count", style = MaterialTheme.typography.titleMedium)
|
||||||
|
OutlinedTextField(
|
||||||
|
value = name,
|
||||||
|
onValueChange = onName,
|
||||||
|
placeholder = { Text("Player ${seat + 1}") },
|
||||||
|
singleLine = true,
|
||||||
|
keyboardOptions = KeyboardOptions(imeAction = if (last) ImeAction.Done else ImeAction.Next),
|
||||||
|
keyboardActions = KeyboardActions(onNext = { onNext() }, onDone = { onNext() }),
|
||||||
|
modifier = Modifier.fillMaxWidth().focusRequester(focus),
|
||||||
|
)
|
||||||
|
if (suggestions.isNotEmpty()) {
|
||||||
|
Text("Recent names", style = MaterialTheme.typography.labelMedium)
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||||
|
) {
|
||||||
|
suggestions.forEach { recent ->
|
||||||
|
FilterChip(
|
||||||
|
selected = recent.equals(name.trim(), ignoreCase = true),
|
||||||
|
onClick = { onName(recent) },
|
||||||
|
label = { Text(recent) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
PrimaryAction(text = if (last) "Start scoring" else "Next") { onNext() }
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
TextButton(onClick = onBack) { Text("Back") }
|
||||||
|
TextButton(onClick = { onName(""); onNext() }) { Text(if (last) "Skip and start" else "Skip") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// The sheet: a column per player, a row per round, totals ruled off at the foot
|
// The sheet: a column per player, a row per round, totals ruled off at the foot
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun Scoring(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) {
|
private fun Scoring(
|
||||||
|
modifier: Modifier,
|
||||||
|
sheet: ScoreSheet,
|
||||||
|
onOp: (SheetOp) -> Unit,
|
||||||
|
recentNames: List<String>,
|
||||||
|
onNameUsed: (String) -> Unit,
|
||||||
|
) {
|
||||||
if (sheet.mode == ScoringMode.TALLY) {
|
if (sheet.mode == ScoringMode.TALLY) {
|
||||||
TallySheet(modifier = modifier, sheet = sheet, onOp = onOp)
|
TallySheet(modifier, sheet, onOp, recentNames, onNameUsed)
|
||||||
} else {
|
} else {
|
||||||
Sheet(modifier = modifier, sheet = sheet, onOp = onOp)
|
Sheet(modifier, sheet, onOp, recentNames, onNameUsed)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) {
|
private fun Sheet(
|
||||||
|
modifier: Modifier,
|
||||||
|
sheet: ScoreSheet,
|
||||||
|
onOp: (SheetOp) -> Unit,
|
||||||
|
recentNames: List<String>,
|
||||||
|
onNameUsed: (String) -> Unit,
|
||||||
|
) {
|
||||||
// One scroll state shared by the head, the rows and the totals, so all three
|
// One scroll state shared by the head, the rows and the totals, so all three
|
||||||
// move together: a column and the name over it must never come apart. Every
|
// move together: a column and the name over it must never come apart. Every
|
||||||
// row is built the same way and is therefore exactly the same width, which
|
// row is built the same way and is therefore exactly the same width, which
|
||||||
@@ -384,6 +494,9 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
var lastTyped by remember { mutableStateOf(-1) }
|
var lastTyped by remember { mutableStateOf(-1) }
|
||||||
// The cell to put the cursor in when a round is opened by tapping it.
|
// The cell to put the cursor in when a round is opened by tapping it.
|
||||||
var focusPlayer by remember { mutableStateOf(-1) }
|
var focusPlayer by remember { mutableStateOf(-1) }
|
||||||
|
// Bumped when a round is finished, to put the cursor back in the first cell
|
||||||
|
// of the row that is now being filled in.
|
||||||
|
var nextRoundFocus by remember { mutableStateOf(0) }
|
||||||
|
|
||||||
val editing = if (correcting >= 0) correction else pending
|
val editing = if (correcting >= 0) correction else pending
|
||||||
|
|
||||||
@@ -513,7 +626,7 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
)
|
)
|
||||||
},
|
},
|
||||||
trailing = { EmptyCell(width = ADD_COLUMN, height = ROW_HEIGHT) },
|
trailing = { EmptyCell(width = ADD_COLUMN, height = ROW_HEIGHT) },
|
||||||
) { _, player ->
|
) { index, player ->
|
||||||
if (correcting >= 0) {
|
if (correcting >= 0) {
|
||||||
// A round is being corrected above; what is typed here
|
// A round is being corrected above; what is typed here
|
||||||
// is kept, but only one row is edited at a time.
|
// is kept, but only one row is edited at a time.
|
||||||
@@ -521,6 +634,8 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
} else {
|
} else {
|
||||||
PointsField(
|
PointsField(
|
||||||
text = pending[player.id].orEmpty(),
|
text = pending[player.id].orEmpty(),
|
||||||
|
autoFocus = index == 0 && nextRoundFocus > 0,
|
||||||
|
focusRequest = nextRoundFocus,
|
||||||
onText = {
|
onText = {
|
||||||
pending[player.id] = it
|
pending[player.id] = it
|
||||||
lastTyped = player.id
|
lastTyped = player.id
|
||||||
@@ -563,6 +678,7 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
onOp(AddRound(amountsAsPoints(pending)))
|
onOp(AddRound(amountsAsPoints(pending)))
|
||||||
pending.clear()
|
pending.clear()
|
||||||
}
|
}
|
||||||
|
nextRoundFocus += 1
|
||||||
lastTyped = -1
|
lastTyped = -1
|
||||||
focusPlayer = -1
|
focusPlayer = -1
|
||||||
},
|
},
|
||||||
@@ -587,6 +703,8 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
RenameDialog(
|
RenameDialog(
|
||||||
sheet = sheet,
|
sheet = sheet,
|
||||||
player = renamed,
|
player = renamed,
|
||||||
|
recentNames = recentNames,
|
||||||
|
onNameUsed = onNameUsed,
|
||||||
onName = { onOp(RenamePlayer(renamed.id, it)) },
|
onName = { onOp(RenamePlayer(renamed.id, it)) },
|
||||||
onRemove = {
|
onRemove = {
|
||||||
onOp(RemovePlayer(renamed.id))
|
onOp(RemovePlayer(renamed.id))
|
||||||
@@ -607,7 +725,13 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit
|
|||||||
* sheet, so tapping one in the list takes it back off.
|
* sheet, so tapping one in the list takes it back off.
|
||||||
*/
|
*/
|
||||||
@Composable
|
@Composable
|
||||||
private fun TallySheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) {
|
private fun TallySheet(
|
||||||
|
modifier: Modifier,
|
||||||
|
sheet: ScoreSheet,
|
||||||
|
onOp: (SheetOp) -> Unit,
|
||||||
|
recentNames: List<String>,
|
||||||
|
onNameUsed: (String) -> Unit,
|
||||||
|
) {
|
||||||
var renaming by remember { mutableStateOf(-1) }
|
var renaming by remember { mutableStateOf(-1) }
|
||||||
|
|
||||||
Column(modifier = modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(modifier = modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
@@ -676,6 +800,8 @@ private fun TallySheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) ->
|
|||||||
RenameDialog(
|
RenameDialog(
|
||||||
sheet = sheet,
|
sheet = sheet,
|
||||||
player = renamed,
|
player = renamed,
|
||||||
|
recentNames = recentNames,
|
||||||
|
onNameUsed = onNameUsed,
|
||||||
onName = { onOp(RenamePlayer(renamed.id, it)) },
|
onName = { onOp(RenamePlayer(renamed.id, it)) },
|
||||||
onRemove = {
|
onRemove = {
|
||||||
onOp(RemovePlayer(renamed.id))
|
onOp(RemovePlayer(renamed.id))
|
||||||
@@ -961,9 +1087,14 @@ private fun PointsCell(text: String, muted: Boolean = false, onClick: (() -> Uni
|
|||||||
|
|
||||||
/** A cell being typed into. Blank means nothing entered; a typed 0 is kept and shown. */
|
/** A cell being typed into. Blank means nothing entered; a typed 0 is kept and shown. */
|
||||||
@Composable
|
@Composable
|
||||||
private fun PointsField(text: String, onText: (String) -> Unit, autoFocus: Boolean = false) {
|
private fun PointsField(
|
||||||
|
text: String,
|
||||||
|
onText: (String) -> Unit,
|
||||||
|
autoFocus: Boolean = false,
|
||||||
|
focusRequest: Int = 0,
|
||||||
|
) {
|
||||||
val focus = remember { FocusRequester() }
|
val focus = remember { FocusRequester() }
|
||||||
LaunchedEffect(autoFocus) { if (autoFocus) focus.requestFocus() }
|
LaunchedEffect(autoFocus, focusRequest) { if (autoFocus) focus.requestFocus() }
|
||||||
BasicTextField(
|
BasicTextField(
|
||||||
value = text,
|
value = text,
|
||||||
onValueChange = { onText(sanitiseAmount(it)) },
|
onValueChange = { onText(sanitiseAmount(it)) },
|
||||||
@@ -1064,16 +1195,27 @@ private fun ActionBar(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
@Composable
|
@Composable
|
||||||
private fun RenameDialog(
|
private fun RenameDialog(
|
||||||
sheet: ScoreSheet,
|
sheet: ScoreSheet,
|
||||||
player: ScorePlayer,
|
player: ScorePlayer,
|
||||||
|
recentNames: List<String>,
|
||||||
|
onNameUsed: (String) -> Unit,
|
||||||
onName: (String) -> Unit,
|
onName: (String) -> Unit,
|
||||||
onRemove: () -> Unit,
|
onRemove: () -> Unit,
|
||||||
onDismiss: () -> Unit,
|
onDismiss: () -> Unit,
|
||||||
) {
|
) {
|
||||||
|
// Closing the dialog is what files the name away, so a name is remembered
|
||||||
|
// once rather than once per keystroke.
|
||||||
|
val finish = {
|
||||||
|
onNameUsed(player.name)
|
||||||
|
onDismiss()
|
||||||
|
}
|
||||||
|
val taken = sheet.players.filter { it.id != player.id }.map { it.name.trim().lowercase() }
|
||||||
|
val suggestions = recentNames.filter { it.trim().lowercase() !in taken }
|
||||||
AlertDialog(
|
AlertDialog(
|
||||||
onDismissRequest = onDismiss,
|
onDismissRequest = finish,
|
||||||
title = { Text("Name this column") },
|
title = { Text("Name this column") },
|
||||||
text = {
|
text = {
|
||||||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
@@ -1084,6 +1226,21 @@ private fun RenameDialog(
|
|||||||
singleLine = true,
|
singleLine = true,
|
||||||
modifier = Modifier.fillMaxWidth(),
|
modifier = Modifier.fillMaxWidth(),
|
||||||
)
|
)
|
||||||
|
if (suggestions.isNotEmpty()) {
|
||||||
|
Text("Recent names", style = MaterialTheme.typography.labelMedium)
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||||
|
) {
|
||||||
|
suggestions.forEach { name ->
|
||||||
|
FilterChip(
|
||||||
|
selected = name.equals(player.name.trim(), ignoreCase = true),
|
||||||
|
onClick = { onName(name) },
|
||||||
|
label = { Text(name) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
TextButton(
|
TextButton(
|
||||||
onClick = onRemove,
|
onClick = onRemove,
|
||||||
// The last two columns stay: a sheet needs somebody on it.
|
// The last two columns stay: a sheet needs somebody on it.
|
||||||
@@ -1091,7 +1248,7 @@ private fun RenameDialog(
|
|||||||
) { Text("Remove this player and their score") }
|
) { Text("Remove this player and their score") }
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onDismiss) { Text("Done") } },
|
confirmButton = { TextButton(onClick = finish) { Text("Done") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -24,6 +24,7 @@ import androidx.compose.ui.Modifier
|
|||||||
import androidx.compose.ui.text.font.FontWeight
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
import androidx.compose.ui.unit.dp
|
import androidx.compose.ui.unit.dp
|
||||||
import kotlinx.coroutines.launch
|
import kotlinx.coroutines.launch
|
||||||
|
import kotlin.math.roundToInt
|
||||||
import org.prolibertate.games.settings.Settings
|
import org.prolibertate.games.settings.Settings
|
||||||
import org.prolibertate.games.update.Release
|
import org.prolibertate.games.update.Release
|
||||||
import org.prolibertate.games.update.UpdateChannel
|
import org.prolibertate.games.update.UpdateChannel
|
||||||
@@ -83,6 +84,26 @@ fun SettingsScreen(
|
|||||||
|
|
||||||
Divider()
|
Divider()
|
||||||
|
|
||||||
|
Column {
|
||||||
|
Text("Text size", fontWeight = FontWeight.Bold)
|
||||||
|
Text(
|
||||||
|
text = "${(settings.textScale * 100).roundToInt()}% — " +
|
||||||
|
"scales text throughout the app, on top of your phone's setting",
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
Slider(
|
||||||
|
value = settings.textScale,
|
||||||
|
onValueChange = { scale ->
|
||||||
|
scope.launch { env.settingsRepository.setTextScale(scale) }
|
||||||
|
},
|
||||||
|
valueRange = Settings.MIN_TEXT_SCALE..Settings.MAX_TEXT_SCALE,
|
||||||
|
// 10% increments across 80%-160%.
|
||||||
|
steps = 7,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
Divider()
|
||||||
|
|
||||||
Column {
|
Column {
|
||||||
Text("Your name", fontWeight = FontWeight.Bold)
|
Text("Your name", fontWeight = FontWeight.Bold)
|
||||||
Text(
|
Text(
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
import androidx.compose.foundation.clickable
|
import androidx.compose.foundation.clickable
|
||||||
@@ -378,7 +379,12 @@ private fun LeaveDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left."
|
"at the table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.BorderStroke
|
import androidx.compose.foundation.BorderStroke
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
@@ -79,7 +80,12 @@ fun PatienceEndDialog(what: String, onEnd: () -> Unit, onKeepPlaying: () -> Unit
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text(what) },
|
text = { Text(what) },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
import androidx.compose.foundation.clickable
|
import androidx.compose.foundation.clickable
|
||||||
@@ -314,7 +315,12 @@ private fun EndGameDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left."
|
"at the table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
import androidx.compose.foundation.clickable
|
import androidx.compose.foundation.clickable
|
||||||
@@ -215,7 +216,12 @@ private fun ConfirmEndDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left."
|
"at the table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -60,6 +60,22 @@ fun CrazyEightsScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
|
|
||||||
// Playing an eight is two decisions: the card, then the suit it turns the
|
// Playing an eight is two decisions: the card, then the suit it turns the
|
||||||
@@ -68,13 +84,15 @@ fun CrazyEightsScreen(
|
|||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Crazy 8s", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Crazy 8s", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "Crazy 8s", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Crazy 8s", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * 0.16f).coerceIn(44.dp, 92.dp)
|
val cardWidth = (minOf(maxWidth, maxHeight) * 0.16f).coerceIn(44.dp, 92.dp)
|
||||||
|
|
||||||
|
|||||||
@@ -65,11 +65,28 @@ fun CribbageScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Cribbage", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Cribbage", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
@@ -79,7 +96,8 @@ fun CribbageScreen(
|
|||||||
// together. Forgotten whenever a new hand is dealt.
|
// together. Forgotten whenever a new hand is dealt.
|
||||||
var chosen by remember(current.handNumber) { mutableStateOf(emptySet<Card>()) }
|
var chosen by remember(current.handNumber) { mutableStateOf(emptySet<Card>()) }
|
||||||
|
|
||||||
ScreenScaffold(title = "Cribbage", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Cribbage", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * 0.16f).coerceIn(44.dp, 92.dp)
|
val cardWidth = (minOf(maxWidth, maxHeight) * 0.16f).coerceIn(44.dp, 92.dp)
|
||||||
|
|
||||||
|
|||||||
@@ -22,6 +22,7 @@ import androidx.compose.material3.Button
|
|||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.OutlinedButton
|
import androidx.compose.material3.OutlinedButton
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
import androidx.compose.runtime.LaunchedEffect
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
@@ -72,18 +73,36 @@ fun EuchreScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
val notice by controller.notice.collectAsState()
|
val notice by controller.notice.collectAsState()
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Euchre", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Euchre", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "Euchre", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Euchre", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val compact = maxWidth < 600.dp
|
val compact = maxWidth < 600.dp
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * if (compact) 0.17f else 0.12f)
|
val cardWidth = (minOf(maxWidth, maxHeight) * if (compact) 0.17f else 0.12f)
|
||||||
|
|||||||
@@ -69,18 +69,36 @@ fun GolfScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
var mode by remember { mutableStateOf(PlaceMode.SWAP) }
|
var mode by remember { mutableStateOf(PlaceMode.SWAP) }
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Golf", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Golf", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "Golf", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Golf", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val shortest = minOf(maxWidth, maxHeight)
|
val shortest = minOf(maxWidth, maxHeight)
|
||||||
val ownCard = (shortest * 0.16f).coerceIn(40.dp, 84.dp)
|
val ownCard = (shortest * 0.16f).coerceIn(40.dp, 84.dp)
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.layout.Arrangement
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
import androidx.compose.foundation.layout.Box
|
import androidx.compose.foundation.layout.Box
|
||||||
import androidx.compose.foundation.layout.Column
|
import androidx.compose.foundation.layout.Column
|
||||||
@@ -268,7 +269,12 @@ private fun EndHeartsDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -22,6 +22,7 @@ import androidx.compose.material3.Button
|
|||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.OutlinedButton
|
import androidx.compose.material3.OutlinedButton
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.LaunchedEffect
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
@@ -74,18 +75,36 @@ fun KaiserScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
val notice by controller.notice.collectAsState()
|
val notice by controller.notice.collectAsState()
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Kaiser", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Kaiser", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "Kaiser", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Kaiser", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val compact = maxWidth < 600.dp
|
val compact = maxWidth < 600.dp
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * if (compact) 0.15f else 0.11f)
|
val cardWidth = (minOf(maxWidth, maxHeight) * if (compact) 0.15f else 0.11f)
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.BorderStroke
|
import androidx.compose.foundation.BorderStroke
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
@@ -342,7 +343,12 @@ private fun EndTableDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text("The deal is left as it stands.") },
|
text = { Text("The deal is left as it stands.") },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
import androidx.compose.foundation.clickable
|
import androidx.compose.foundation.clickable
|
||||||
@@ -356,7 +357,12 @@ private fun EndDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,379 @@
|
|||||||
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import androidx.compose.foundation.background
|
||||||
|
import androidx.compose.foundation.border
|
||||||
|
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.aspectRatio
|
||||||
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
|
import androidx.compose.foundation.rememberScrollState
|
||||||
|
import androidx.compose.foundation.verticalScroll
|
||||||
|
import androidx.compose.foundation.gestures.awaitEachGesture
|
||||||
|
import androidx.compose.foundation.gestures.awaitFirstDown
|
||||||
|
import androidx.compose.material3.AlertDialog
|
||||||
|
import androidx.compose.material3.Button
|
||||||
|
import androidx.compose.material3.FilterChip
|
||||||
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
|
import androidx.compose.runtime.Composable
|
||||||
|
import androidx.compose.runtime.collectAsState
|
||||||
|
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.Alignment
|
||||||
|
import androidx.compose.ui.Modifier
|
||||||
|
import androidx.compose.ui.geometry.Offset
|
||||||
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import androidx.compose.ui.input.pointer.pointerInput
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import androidx.compose.ui.unit.sp
|
||||||
|
import androidx.compose.ui.unit.TextUnit
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuMove
|
||||||
|
import org.prolibertate.games.game.meowdoku.MeowdokuState
|
||||||
|
import org.prolibertate.games.game.meowdoku.PlaceCat
|
||||||
|
import org.prolibertate.games.game.meowdoku.Square
|
||||||
|
import org.prolibertate.games.game.meowdoku.TakeHint
|
||||||
|
import org.prolibertate.games.game.meowdoku.TogglePencil
|
||||||
|
import org.prolibertate.games.net.MatchController
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
|
import org.prolibertate.games.ui.ScreenScaffold
|
||||||
|
import org.prolibertate.games.ui.theme.CardRed
|
||||||
|
import kotlin.math.abs
|
||||||
|
import kotlin.math.roundToInt
|
||||||
|
|
||||||
|
private const val TITLE = "Meowdoku"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* How long the second tap of a double tap may take to arrive.
|
||||||
|
*
|
||||||
|
* 350 ms, the number the original game ships: long enough that a deliberate
|
||||||
|
* one-two still reads as one question, short enough that nobody pairs two
|
||||||
|
* taps they meant for two separate squares.
|
||||||
|
*/
|
||||||
|
private const val DOUBLE_TAP_WINDOW_MILLIS = 350L
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The region colours, one per cat the board can hold.
|
||||||
|
*
|
||||||
|
* The board never needs two regions of one colour — a side-ten board has ten
|
||||||
|
* regions and the palette has ten — so a region's colour is just its id, and
|
||||||
|
* nothing has to be computed to keep neighbours apart. The palette reads as
|
||||||
|
* watercolour on purpose: cats are dark ink on top of it, and a square the
|
||||||
|
* player has crossed over is too.
|
||||||
|
*/
|
||||||
|
private val RegionColours = listOf(
|
||||||
|
Color(0xFFF2C6C2), // rose
|
||||||
|
Color(0xFFF7E0A6), // butter
|
||||||
|
Color(0xFFCDE8C5), // mint
|
||||||
|
Color(0xFFC5E3F0), // sky
|
||||||
|
Color(0xFFD8CDEB), // lilac
|
||||||
|
Color(0xFFEBC9A0), // apricot
|
||||||
|
Color(0xFFBFE3D0), // spruce
|
||||||
|
Color(0xFFF0D7E3), // blossom
|
||||||
|
Color(0xFFCFCFE8), // periwinkle
|
||||||
|
Color(0xFFE3E7C1), // lime
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The puzzle board, tapped the way the original's is.
|
||||||
|
*
|
||||||
|
* One tap crosses a square over; a second tap on the same square within
|
||||||
|
* [DOUBLE_TAP_WINDOW_MILLIS] asks the board whether a cat lives there. Drag
|
||||||
|
* strokes paint or erase crosses along the line the finger takes, which is
|
||||||
|
* how a row gets crossed out in one gesture rather than eight taps. Cats are
|
||||||
|
* permanent: tapping one does nothing, and a stroke skips over it.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun MeowdokuScreen(
|
||||||
|
controller: MatchController<MeowdokuState, MeowdokuMove>,
|
||||||
|
onNewPuzzle: () -> Unit,
|
||||||
|
onExit: () -> Unit,
|
||||||
|
) {
|
||||||
|
val state by controller.state.collectAsState()
|
||||||
|
val legal by controller.legalMoves.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
|
||||||
|
val current = state
|
||||||
|
if (current == null) {
|
||||||
|
ScreenScaffold(title = TITLE, onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Setting up…") }
|
||||||
|
abandoned?.let { LeftBoardDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) EndBoardDialog(onExit) { confirmingEnd = false }
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
val places = legal.filterIsInstance<PlaceCat>().map { it.square }.toSet()
|
||||||
|
val pencils = legal.filterIsInstance<TogglePencil>().map { it.square }.toSet()
|
||||||
|
val finished by controller.finished.collectAsState()
|
||||||
|
|
||||||
|
ScreenScaffold(title = TITLE, onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
Column(
|
||||||
|
modifier = modifier.verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(10.dp),
|
||||||
|
) {
|
||||||
|
Text(
|
||||||
|
text = when {
|
||||||
|
current.solved -> "Found every cat" +
|
||||||
|
if (current.wrongCats == 0) ", not one tap wasted." else ", with ${current.wrongCats} wrong taps."
|
||||||
|
current.lost -> "Out of hearts, with ${current.side - current.catsFound} cats still hiding."
|
||||||
|
else -> "${current.catsFound} of ${current.side} cats found. " +
|
||||||
|
"Tap to cross a square, tap it again for a cat."
|
||||||
|
},
|
||||||
|
fontWeight = FontWeight.Bold,
|
||||||
|
)
|
||||||
|
Text(
|
||||||
|
text = "Hearts " + "♥".repeat(current.heartsLeft) +
|
||||||
|
" · Hints " + current.hintsLeft,
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
|
||||||
|
Board(
|
||||||
|
state = current,
|
||||||
|
// Moves are refused rather than hidden: an attempt or a note
|
||||||
|
// the board would reject (a tap on a cat, mostly) has to die
|
||||||
|
// here, in the gesture, where the player can be doing nothing
|
||||||
|
// else the same instant.
|
||||||
|
onNote = { square -> if (square in pencils) controller.submit(TogglePencil(square)) },
|
||||||
|
onAttempt = { square -> if (square in places) controller.submit(PlaceCat(square)) },
|
||||||
|
)
|
||||||
|
|
||||||
|
if (TakeHint in legal) {
|
||||||
|
FilterChip(
|
||||||
|
selected = false,
|
||||||
|
onClick = { controller.submit(TakeHint) },
|
||||||
|
label = { Text("Hint") },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (finished) {
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
Button(onClick = onNewPuzzle) { Text("New puzzle") }
|
||||||
|
TextButton(onClick = onExit) { Text("Leave") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
current.log.takeLast(2).forEach {
|
||||||
|
Text(it, style = MaterialTheme.typography.bodySmall)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
abandoned?.let { LeftBoardDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) EndBoardDialog(onExit) { confirmingEnd = false }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The board as one gesture surface.
|
||||||
|
*
|
||||||
|
* Cells are drawn by weight inside a square frame, but input is not per-cell:
|
||||||
|
* a stroke is one continuous gesture, so the pointer works in board
|
||||||
|
* coordinates and maps positions to squares itself. The cell list renders
|
||||||
|
* underneath, and the live state is read through [rememberUpdatedState]
|
||||||
|
* because a gesture outlives the recompositions it lands in.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
private fun Board(
|
||||||
|
state: MeowdokuState,
|
||||||
|
onNote: (Square) -> Unit,
|
||||||
|
onAttempt: (Square) -> Unit,
|
||||||
|
) {
|
||||||
|
val side = state.side
|
||||||
|
val current by rememberUpdatedState(state)
|
||||||
|
val note by rememberUpdatedState(onNote)
|
||||||
|
val attempt by rememberUpdatedState(onAttempt)
|
||||||
|
|
||||||
|
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
|
||||||
|
// One cell's edge, so a cat is always about half a square whatever
|
||||||
|
// board was dealt.
|
||||||
|
val cell = maxWidth / side
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.aspectRatio(1f)
|
||||||
|
.pointerInput(side) {
|
||||||
|
val cellPx = size.width.toFloat() / side
|
||||||
|
var lastTap: Square? = null
|
||||||
|
var lastTapAt = 0L
|
||||||
|
awaitEachGesture {
|
||||||
|
val down = awaitFirstDown(requireUnconsumed = false)
|
||||||
|
val board = current
|
||||||
|
val start = squareAt(down.position, cellPx, side)
|
||||||
|
?: return@awaitEachGesture
|
||||||
|
if (start in board.cats) return@awaitEachGesture
|
||||||
|
|
||||||
|
val now = System.currentTimeMillis()
|
||||||
|
if (start == lastTap && now - lastTapAt < DOUBLE_TAP_WINDOW_MILLIS) {
|
||||||
|
// The second tap of a pair: the cat attempt, and
|
||||||
|
// no note — the cross it lands on was drawn by
|
||||||
|
// this pair's first tap, and the board replaces it.
|
||||||
|
lastTap = null
|
||||||
|
attempt(start)
|
||||||
|
do {
|
||||||
|
val event = awaitPointerEvent()
|
||||||
|
val change = event.changes.firstOrNull { it.id == down.id }
|
||||||
|
change?.consume()
|
||||||
|
} while (change != null && change.pressed)
|
||||||
|
return@awaitEachGesture
|
||||||
|
}
|
||||||
|
|
||||||
|
// The first tap: a note, and the stroke that may follow
|
||||||
|
// paints the same note everywhere it goes.
|
||||||
|
lastTap = start
|
||||||
|
lastTapAt = now
|
||||||
|
val erasing = start in board.marks
|
||||||
|
note(start)
|
||||||
|
val marks = board.marks.toMutableSet()
|
||||||
|
marks.flip(start)
|
||||||
|
var previous = start
|
||||||
|
|
||||||
|
while (true) {
|
||||||
|
val event = awaitPointerEvent()
|
||||||
|
val change = event.changes.firstOrNull { it.id == down.id }
|
||||||
|
if (change == null || !change.pressed) break
|
||||||
|
change.consume()
|
||||||
|
val here = squareAt(change.position, cellPx, side) ?: continue
|
||||||
|
if (here == previous) continue
|
||||||
|
for (square in path(previous, here)) {
|
||||||
|
if (square in board.cats) continue
|
||||||
|
// `marks` is the stroke's own mirror: the base
|
||||||
|
// board plus every note this stroke has
|
||||||
|
// already submitted. The state flow lags a
|
||||||
|
// frame behind submissions, and a stroke that
|
||||||
|
// crosses a square twice must leave it at the
|
||||||
|
// stroke's target, not flip it back.
|
||||||
|
//
|
||||||
|
// Erasing means "flip everything still
|
||||||
|
// crossed"; painting means "flip everything
|
||||||
|
// still blank" — which is the same test read
|
||||||
|
// two ways: flip while marked == erasing.
|
||||||
|
if ((square in marks) == erasing) {
|
||||||
|
note(square)
|
||||||
|
marks.flip(square)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
previous = here
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
) {
|
||||||
|
Column(modifier = Modifier.aspectRatio(1f)) {
|
||||||
|
for (row in 0 until side) {
|
||||||
|
Row(modifier = Modifier.weight(1f)) {
|
||||||
|
for (col in 0 until side) {
|
||||||
|
CellView(
|
||||||
|
square = Square(row, col),
|
||||||
|
state = current,
|
||||||
|
glyphSize = (cell.value * 0.55f).sp,
|
||||||
|
modifier = Modifier.weight(1f),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Which square a pointer position is over, or null if it has left the board. */
|
||||||
|
private fun squareAt(position: Offset, cellPx: Float, side: Int): Square? {
|
||||||
|
val col = (position.x / cellPx).toInt()
|
||||||
|
val row = (position.y / cellPx).toInt()
|
||||||
|
if (row !in 0 until side || col !in 0 until side) return null
|
||||||
|
return Square(row, col)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Add the square, or drop it if it was already there — the stroke's own toggle. */
|
||||||
|
private fun MutableSet<Square>.flip(square: Square) {
|
||||||
|
if (!add(square)) remove(square)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The squares between two consecutive pointer reads, endpoints not repeated.
|
||||||
|
*
|
||||||
|
* A fast stroke publishes fewer positions than it crosses cells, so the line
|
||||||
|
* between two reads is walked in whole-cell steps. [path] returns at most one
|
||||||
|
* square per cell crossed, in order, which is what lets a stroke cross a row
|
||||||
|
* in one drag without missing the squares between two events.
|
||||||
|
*/
|
||||||
|
private fun path(from: Square, to: Square): List<Square> {
|
||||||
|
val dr = to.row - from.row
|
||||||
|
val dc = to.col - from.col
|
||||||
|
val steps = maxOf(abs(dr), abs(dc))
|
||||||
|
if (steps <= 1) return listOf(to)
|
||||||
|
return (1..steps).map { i ->
|
||||||
|
Square(
|
||||||
|
from.row + (dr * i.toFloat() / steps).roundToInt(),
|
||||||
|
from.col + (dc * i.toFloat() / steps).roundToInt(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun CellView(
|
||||||
|
square: Square,
|
||||||
|
state: MeowdokuState,
|
||||||
|
glyphSize: TextUnit,
|
||||||
|
modifier: Modifier,
|
||||||
|
) {
|
||||||
|
val isCat = square in state.cats
|
||||||
|
val isMark = square in state.marks
|
||||||
|
val justWrong = state.lastWrong && state.lastSquare == square
|
||||||
|
Box(
|
||||||
|
modifier = modifier
|
||||||
|
.aspectRatio(1f)
|
||||||
|
.border(1.dp, Color(0x33000000))
|
||||||
|
.background(RegionColours[state.regionOf(square) % RegionColours.size])
|
||||||
|
.then(
|
||||||
|
if (justWrong) Modifier.border(3.dp, CardRed) else Modifier
|
||||||
|
),
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) {
|
||||||
|
when {
|
||||||
|
isCat -> Text("🐱", fontSize = glyphSize)
|
||||||
|
isMark -> Text(
|
||||||
|
"✕",
|
||||||
|
color = Color(0xAA1C1B1F),
|
||||||
|
fontWeight = FontWeight.Bold,
|
||||||
|
fontSize = glyphSize,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun EndBoardDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onKeepPlaying,
|
||||||
|
title = { Text("End this game?") },
|
||||||
|
text = { Text("The board is left as it stands.") },
|
||||||
|
confirmButton = {
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun LeftBoardDialog(notice: String, onExit: () -> Unit, onStay: () -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onStay,
|
||||||
|
title = { Text("The game has ended") },
|
||||||
|
text = { Text(notice) },
|
||||||
|
confirmButton = { TextButton(onClick = onExit) { Text("Leave the game") } },
|
||||||
|
dismissButton = { TextButton(onClick = onStay) { Text("Look at the board") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.Canvas
|
import androidx.compose.foundation.Canvas
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
@@ -483,7 +484,12 @@ private fun LeaveBoardDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left."
|
"at the table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.BorderStroke
|
import androidx.compose.foundation.BorderStroke
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
@@ -242,7 +243,12 @@ private fun EndBoardDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text("The board is left as it stands.") },
|
text = { Text("The board is left as it stands.") },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.Canvas
|
import androidx.compose.foundation.Canvas
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
@@ -371,7 +372,12 @@ private fun LeaveFieldDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left."
|
"at the table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -20,11 +20,15 @@ import androidx.compose.foundation.rememberScrollState
|
|||||||
import androidx.compose.material3.Button
|
import androidx.compose.material3.Button
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.OutlinedButton
|
import androidx.compose.material3.OutlinedButton
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
import androidx.compose.runtime.key
|
import androidx.compose.runtime.key
|
||||||
|
import androidx.compose.runtime.mutableStateOf
|
||||||
|
import androidx.compose.runtime.remember
|
||||||
|
import androidx.compose.runtime.setValue
|
||||||
import androidx.compose.ui.Alignment
|
import androidx.compose.ui.Alignment
|
||||||
import androidx.compose.ui.Modifier
|
import androidx.compose.ui.Modifier
|
||||||
import androidx.compose.ui.draw.rotate
|
import androidx.compose.ui.draw.rotate
|
||||||
@@ -66,16 +70,34 @@ fun PresidentScreen(
|
|||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "President", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "President", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
|
dialogs()
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "President", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "President", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * 0.15f).coerceIn(44.dp, 88.dp)
|
val cardWidth = (minOf(maxWidth, maxHeight) * 0.15f).coerceIn(44.dp, 88.dp)
|
||||||
|
|
||||||
|
|||||||
@@ -18,6 +18,7 @@ import androidx.compose.foundation.shape.CircleShape
|
|||||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.Text
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.collectAsState
|
import androidx.compose.runtime.collectAsState
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
@@ -81,12 +82,29 @@ fun SequenceScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
var selected by remember { mutableStateOf<Card?>(null) }
|
var selected by remember { mutableStateOf<Card?>(null) }
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Sequence", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Sequence", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
@@ -97,7 +115,8 @@ fun SequenceScreen(
|
|||||||
val removals = legal.filterIsInstance<RemoveChip>().filter { it.card == selected }
|
val removals = legal.filterIsInstance<RemoveChip>().filter { it.card == selected }
|
||||||
val highlighted = (placements.map { it.cell } + removals.map { it.cell }).toSet()
|
val highlighted = (placements.map { it.cell } + removals.map { it.cell }).toSet()
|
||||||
|
|
||||||
ScreenScaffold(title = "Sequence", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Sequence", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val wide = maxWidth > maxHeight
|
val wide = maxWidth > maxHeight
|
||||||
val boardSide = if (wide) {
|
val boardSide = if (wide) {
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.Canvas
|
import androidx.compose.foundation.Canvas
|
||||||
import androidx.compose.foundation.gestures.detectTapGestures
|
import androidx.compose.foundation.gestures.detectTapGestures
|
||||||
import androidx.compose.foundation.layout.Arrangement
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
@@ -668,7 +669,12 @@ private fun TayuConfirmEndDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"table is told you have left."
|
"table is told you have left."
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -75,18 +75,36 @@ fun WizardScreen(
|
|||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
|
val abandoned by controller.abandoned.collectAsState()
|
||||||
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
|
val endGameAction: @Composable () -> Unit = {
|
||||||
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
|
}
|
||||||
|
val dialogs: @Composable () -> Unit = {
|
||||||
|
abandoned?.let { PatienceLeftDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
|
if (confirmingEnd) {
|
||||||
|
PatienceEndDialog(
|
||||||
|
what = "The game ends here. Anyone else at the table is told you have left.",
|
||||||
|
onEnd = onExit,
|
||||||
|
onKeepPlaying = { confirmingEnd = false },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
val legal by controller.legalMoves.collectAsState()
|
val legal by controller.legalMoves.collectAsState()
|
||||||
val notice by controller.notice.collectAsState()
|
val notice by controller.notice.collectAsState()
|
||||||
|
|
||||||
val current = state
|
val current = state
|
||||||
if (current == null) {
|
if (current == null) {
|
||||||
ScreenScaffold(title = "Wizard", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Wizard", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
Box(modifier, contentAlignment = Alignment.Center) { Text("Dealing…") }
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
ScreenScaffold(title = "Wizard", onBack = onExit) { modifier ->
|
ScreenScaffold(title = "Wizard", onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
|
dialogs()
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val cardWidth = (minOf(maxWidth, maxHeight) * 0.14f).coerceIn(40.dp, 88.dp)
|
val cardWidth = (minOf(maxWidth, maxHeight) * 0.14f).coerceIn(40.dp, 88.dp)
|
||||||
|
|
||||||
|
|||||||
@@ -1,11 +1,16 @@
|
|||||||
package org.prolibertate.games.ui.game
|
package org.prolibertate.games.ui.game
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.background
|
import androidx.compose.foundation.background
|
||||||
import androidx.compose.foundation.border
|
import androidx.compose.foundation.border
|
||||||
import androidx.compose.foundation.clickable
|
import androidx.compose.foundation.clickable
|
||||||
import androidx.compose.foundation.layout.Arrangement
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
import androidx.compose.foundation.layout.Box
|
import androidx.compose.foundation.layout.Box
|
||||||
|
import androidx.compose.foundation.layout.BoxWithConstraints
|
||||||
|
import androidx.compose.foundation.horizontalScroll
|
||||||
|
import androidx.compose.foundation.layout.width
|
||||||
import androidx.compose.foundation.layout.Column
|
import androidx.compose.foundation.layout.Column
|
||||||
|
import androidx.compose.foundation.Canvas
|
||||||
import androidx.compose.foundation.layout.Row
|
import androidx.compose.foundation.layout.Row
|
||||||
import androidx.compose.foundation.layout.fillMaxWidth
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
import androidx.compose.foundation.layout.padding
|
import androidx.compose.foundation.layout.padding
|
||||||
@@ -29,12 +34,17 @@ import androidx.compose.runtime.remember
|
|||||||
import androidx.compose.runtime.setValue
|
import androidx.compose.runtime.setValue
|
||||||
import androidx.compose.ui.Alignment
|
import androidx.compose.ui.Alignment
|
||||||
import androidx.compose.ui.Modifier
|
import androidx.compose.ui.Modifier
|
||||||
|
import androidx.compose.ui.geometry.Offset
|
||||||
import androidx.compose.ui.text.font.FontWeight
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
import androidx.compose.ui.unit.dp
|
import androidx.compose.ui.unit.dp
|
||||||
import org.prolibertate.games.game.yahtzee.DICE_COUNT
|
import org.prolibertate.games.game.yahtzee.DICE_COUNT
|
||||||
import org.prolibertate.games.game.yahtzee.RollDice
|
import org.prolibertate.games.game.yahtzee.RollDice
|
||||||
import org.prolibertate.games.game.yahtzee.ScoreIn
|
import org.prolibertate.games.game.yahtzee.ScoreIn
|
||||||
import org.prolibertate.games.game.yahtzee.YahtzeeCategory
|
import org.prolibertate.games.game.yahtzee.YahtzeeCategory
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeComparison
|
||||||
|
import org.prolibertate.games.game.yahtzee.recordOf
|
||||||
|
import org.prolibertate.games.settings.YahtzeeStatsRepository
|
||||||
|
import kotlin.math.roundToInt
|
||||||
import org.prolibertate.games.game.yahtzee.YahtzeeMove
|
import org.prolibertate.games.game.yahtzee.YahtzeeMove
|
||||||
import org.prolibertate.games.game.yahtzee.YahtzeeSection
|
import org.prolibertate.games.game.yahtzee.YahtzeeSection
|
||||||
import org.prolibertate.games.game.yahtzee.YahtzeeState
|
import org.prolibertate.games.game.yahtzee.YahtzeeState
|
||||||
@@ -60,6 +70,7 @@ private const val TITLE = "Yahtzee"
|
|||||||
fun YahtzeeScreen(
|
fun YahtzeeScreen(
|
||||||
controller: MatchController<YahtzeeState, YahtzeeMove>,
|
controller: MatchController<YahtzeeState, YahtzeeMove>,
|
||||||
localSeat: Int,
|
localSeat: Int,
|
||||||
|
stats: YahtzeeStatsRepository,
|
||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val state by controller.state.collectAsState()
|
val state by controller.state.collectAsState()
|
||||||
@@ -68,6 +79,11 @@ fun YahtzeeScreen(
|
|||||||
|
|
||||||
val kept = remember { mutableStateListOf<Int>() }
|
val kept = remember { mutableStateListOf<Int>() }
|
||||||
var confirmingEnd by remember { mutableStateOf(false) }
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
|
var confirmingZero by remember { mutableStateOf<YahtzeeCategory?>(null) }
|
||||||
|
var comparison by remember { mutableStateOf<YahtzeeComparison?>(null) }
|
||||||
|
// Only a game seen to finish is recorded: reopening a saved game that was
|
||||||
|
// already over must not count it a second time.
|
||||||
|
var sawInProgress by remember { mutableStateOf(false) }
|
||||||
|
|
||||||
val endGameAction: @Composable () -> Unit = {
|
val endGameAction: @Composable () -> Unit = {
|
||||||
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
|
||||||
@@ -88,6 +104,15 @@ fun YahtzeeScreen(
|
|||||||
// refused, and the Throw button would look broken again.
|
// refused, and the Throw button would look broken again.
|
||||||
LaunchedEffect(current.turn, current.round) { kept.clear() }
|
LaunchedEffect(current.turn, current.round) { kept.clear() }
|
||||||
|
|
||||||
|
LaunchedEffect(current.isOver) {
|
||||||
|
if (!current.isOver) {
|
||||||
|
sawInProgress = true
|
||||||
|
} else if (sawInProgress) {
|
||||||
|
sawInProgress = false
|
||||||
|
comparison = stats.finish(recordOf(current, localSeat))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
val yours = current.turn == localSeat && !current.isOver
|
val yours = current.turn == localSeat && !current.isOver
|
||||||
val canRoll = legal.any { it is RollDice }
|
val canRoll = legal.any { it is RollDice }
|
||||||
val writable = legal.filterIsInstance<ScoreIn>().map { it.category }.toSet()
|
val writable = legal.filterIsInstance<ScoreIn>().map { it.category }.toSet()
|
||||||
@@ -137,8 +162,14 @@ fun YahtzeeScreen(
|
|||||||
localSeat = localSeat,
|
localSeat = localSeat,
|
||||||
writable = if (yours) writable else emptySet(),
|
writable = if (yours) writable else emptySet(),
|
||||||
onWrite = {
|
onWrite = {
|
||||||
|
// A zero is a box spent for nothing, and one mis-tap on a
|
||||||
|
// dense card is all it takes, so ask first.
|
||||||
|
if (scoreOf(it, current.dice) == 0) {
|
||||||
|
confirmingZero = it
|
||||||
|
} else {
|
||||||
controller.submit(ScoreIn(it))
|
controller.submit(ScoreIn(it))
|
||||||
kept.clear()
|
kept.clear()
|
||||||
|
}
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -149,8 +180,78 @@ fun YahtzeeScreen(
|
|||||||
|
|
||||||
abandoned?.let { LeftCardDialog(it, onExit, controller::dismissAbandoned) }
|
abandoned?.let { LeftCardDialog(it, onExit, controller::dismissAbandoned) }
|
||||||
if (confirmingEnd) EndCardDialog(onExit) { confirmingEnd = false }
|
if (confirmingEnd) EndCardDialog(onExit) { confirmingEnd = false }
|
||||||
|
comparison?.let { StatsDialog(it, onExit) { comparison = null } }
|
||||||
|
confirmingZero?.let { category ->
|
||||||
|
ZeroScoreDialog(
|
||||||
|
category = category,
|
||||||
|
onConfirm = {
|
||||||
|
confirmingZero = null
|
||||||
|
controller.submit(ScoreIn(category))
|
||||||
|
kept.clear()
|
||||||
|
},
|
||||||
|
onCancel = { confirmingZero = null },
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun StatsDialog(c: YahtzeeComparison, onLeave: () -> Unit, onClose: () -> Unit) {
|
||||||
|
fun pct(v: Double?) = v?.let { "${(it * 100).roundToInt()}%" } ?: "—"
|
||||||
|
val headline = when {
|
||||||
|
c.previousGames == 0 -> "Your first recorded game."
|
||||||
|
c.rank == 1 -> "A new personal best!"
|
||||||
|
else -> "${ordinal(c.rank)} best of ${c.gamesRanked} games."
|
||||||
|
}
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onClose,
|
||||||
|
title = { Text("Game over: ${c.current.total} points") },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
Text(headline, fontWeight = FontWeight.Bold)
|
||||||
|
StatLine("", "This game", "Before")
|
||||||
|
StatLine("Score", "${c.current.total}", c.averageBefore?.let { "avg ${it.roundToInt()}, best ${c.bestBefore}" } ?: "—")
|
||||||
|
StatLine("Upper bonus", if (c.current.gotBonus) "Yes" else "No", pct(c.bonusRateBefore))
|
||||||
|
StatLine("Yahtzees", "${c.current.yahtzees}", "${c.yahtzeesBefore} total")
|
||||||
|
StatLine("Zeroed boxes", "${c.current.zeros}", "")
|
||||||
|
if (c.current.players > 1) {
|
||||||
|
StatLine("Result", if (c.current.won) "Won" else "Lost", "won ${pct(c.winRateBefore)}")
|
||||||
|
}
|
||||||
|
Text(
|
||||||
|
"Games before this one: ${c.previousGames}",
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = { TextButton(onClick = onLeave) { Text("Leave the game") } },
|
||||||
|
dismissButton = { TextButton(onClick = onClose) { Text("Look at the card") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun StatLine(label: String, now: String, before: String) {
|
||||||
|
Row(modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text(label, modifier = Modifier.weight(1.2f), fontWeight = FontWeight.Bold)
|
||||||
|
Text(now, modifier = Modifier.weight(1f))
|
||||||
|
Text(before, modifier = Modifier.weight(1.6f))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun ordinal(n: Int): String {
|
||||||
|
val suffix = if (n % 100 in 11..13) "th" else when (n % 10) { 1 -> "st"; 2 -> "nd"; 3 -> "rd"; else -> "th" }
|
||||||
|
return "$n$suffix"
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun ZeroScoreDialog(category: YahtzeeCategory, onConfirm: () -> Unit, onCancel: () -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onCancel,
|
||||||
|
title = { Text("Score zero?") },
|
||||||
|
text = { Text("These dice are worth 0 in ${category.label}. Write the zero there?") },
|
||||||
|
confirmButton = { TextButton(onClick = onConfirm) { Text("Score 0") } },
|
||||||
|
dismissButton = { TextButton(onClick = onCancel) { Text("Choose another") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun DiceRow(
|
private fun DiceRow(
|
||||||
@@ -189,12 +290,29 @@ private fun Die(face: Int?, held: Boolean, enabled: Boolean, onClick: () -> Unit
|
|||||||
.clickable(enabled = enabled) { onClick() },
|
.clickable(enabled = enabled) { onClick() },
|
||||||
contentAlignment = Alignment.Center,
|
contentAlignment = Alignment.Center,
|
||||||
) {
|
) {
|
||||||
Text(
|
if (face != null) {
|
||||||
text = face?.toString() ?: "·",
|
Canvas(modifier = Modifier.size(48.dp)) {
|
||||||
style = MaterialTheme.typography.titleLarge,
|
val radius = size.minDimension * 0.08f
|
||||||
fontWeight = FontWeight.Bold,
|
pipPositions(face).forEach { (x, y) ->
|
||||||
color = WallaceRed,
|
drawCircle(WallaceRed, radius, Offset(size.width * x, size.height * y))
|
||||||
)
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Pip centres as fractions of the die face, in the usual casino layout. */
|
||||||
|
private fun pipPositions(face: Int): List<Pair<Float, Float>> {
|
||||||
|
val lo = 0.28f
|
||||||
|
val mid = 0.5f
|
||||||
|
val hi = 0.72f
|
||||||
|
return when (face) {
|
||||||
|
1 -> listOf(mid to mid)
|
||||||
|
2 -> listOf(lo to lo, hi to hi)
|
||||||
|
3 -> listOf(lo to lo, mid to mid, hi to hi)
|
||||||
|
4 -> listOf(lo to lo, hi to lo, lo to hi, hi to hi)
|
||||||
|
5 -> listOf(lo to lo, hi to lo, mid to mid, lo to hi, hi to hi)
|
||||||
|
else -> listOf(lo to lo, hi to lo, lo to mid, hi to mid, lo to hi, hi to hi)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -205,29 +323,62 @@ private fun ScoreCard(
|
|||||||
writable: Set<YahtzeeCategory>,
|
writable: Set<YahtzeeCategory>,
|
||||||
onWrite: (YahtzeeCategory) -> Unit,
|
onWrite: (YahtzeeCategory) -> Unit,
|
||||||
) {
|
) {
|
||||||
Column(modifier = Modifier.fillMaxWidth()) {
|
// Upper boxes and bonus on the left, lower boxes and total on the right, so
|
||||||
|
// each half is wide enough for text that can actually be read. Each half
|
||||||
|
// has a floor on its width; if two of them do not fit (many players, large
|
||||||
|
// text) the pair scrolls sideways instead of squeezing.
|
||||||
|
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
|
||||||
|
val needed = (CARD_LABEL_WIDTH + CARD_SEAT_WIDTH * state.cards.size).dp
|
||||||
|
val half = maxOf((maxWidth - CARD_GAP.dp) / 2, needed)
|
||||||
|
Row(
|
||||||
|
modifier = Modifier.horizontalScroll(rememberScrollState()),
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(CARD_GAP.dp),
|
||||||
|
) {
|
||||||
|
Column(modifier = Modifier.width(half)) {
|
||||||
|
CardHeader(state, localSeat)
|
||||||
|
CardSection(YahtzeeSection.UPPER, state, localSeat, writable, onWrite)
|
||||||
|
TotalRow("Bonus at 63", state.cards.map { it.upperBonus })
|
||||||
|
}
|
||||||
|
Column(modifier = Modifier.width(half)) {
|
||||||
|
CardHeader(state, localSeat)
|
||||||
|
CardSection(YahtzeeSection.LOWER, state, localSeat, writable, onWrite)
|
||||||
|
Divider()
|
||||||
|
TotalRow("Total", state.cards.indices.map { state.totalFor(it) }, bold = true)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private const val CARD_LABEL_WIDTH = 120
|
||||||
|
private const val CARD_SEAT_WIDTH = 56
|
||||||
|
private const val CARD_GAP = 12
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun CardHeader(state: YahtzeeState, localSeat: Int) {
|
||||||
Row(modifier = Modifier.fillMaxWidth()) {
|
Row(modifier = Modifier.fillMaxWidth()) {
|
||||||
Text("", modifier = Modifier.weight(2f), style = MaterialTheme.typography.labelSmall)
|
Text("", modifier = Modifier.weight(2f))
|
||||||
state.cards.indices.forEach { seat ->
|
state.cards.indices.forEach { seat ->
|
||||||
Text(
|
Text(
|
||||||
text = if (seat == localSeat) "You" else "S$seat",
|
text = if (seat == localSeat) "You" else "S$seat",
|
||||||
modifier = Modifier.weight(1f),
|
modifier = Modifier.weight(1f),
|
||||||
style = MaterialTheme.typography.labelSmall,
|
style = MaterialTheme.typography.labelLarge,
|
||||||
fontWeight = FontWeight.Bold,
|
fontWeight = FontWeight.Bold,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
YahtzeeSection.entries.forEach { section ->
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun CardSection(
|
||||||
|
section: YahtzeeSection,
|
||||||
|
state: YahtzeeState,
|
||||||
|
localSeat: Int,
|
||||||
|
writable: Set<YahtzeeCategory>,
|
||||||
|
onWrite: (YahtzeeCategory) -> Unit,
|
||||||
|
) {
|
||||||
YahtzeeCategory.entries.filter { it.section == section }.forEach { category ->
|
YahtzeeCategory.entries.filter { it.section == section }.forEach { category ->
|
||||||
CardRow(state, localSeat, category, writable, onWrite)
|
CardRow(state, localSeat, category, writable, onWrite)
|
||||||
}
|
}
|
||||||
if (section == YahtzeeSection.UPPER) {
|
|
||||||
TotalRow("Bonus at 63", state.cards.map { it.upperBonus })
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Divider()
|
|
||||||
TotalRow("Total", state.cards.indices.map { state.totalFor(it) }, bold = true)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
@@ -243,12 +394,12 @@ private fun CardRow(
|
|||||||
modifier = Modifier
|
modifier = Modifier
|
||||||
.fillMaxWidth()
|
.fillMaxWidth()
|
||||||
.clickable(enabled = open) { onWrite(category) }
|
.clickable(enabled = open) { onWrite(category) }
|
||||||
.padding(vertical = 2.dp),
|
.padding(vertical = 5.dp),
|
||||||
) {
|
) {
|
||||||
Text(
|
Text(
|
||||||
text = category.label,
|
text = category.label,
|
||||||
modifier = Modifier.weight(2f),
|
modifier = Modifier.weight(2f),
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodyMedium,
|
||||||
fontWeight = if (open) FontWeight.Bold else FontWeight.Normal,
|
fontWeight = if (open) FontWeight.Bold else FontWeight.Normal,
|
||||||
)
|
)
|
||||||
state.cards.forEachIndexed { seat, card ->
|
state.cards.forEachIndexed { seat, card ->
|
||||||
@@ -262,7 +413,7 @@ private fun CardRow(
|
|||||||
else -> "—"
|
else -> "—"
|
||||||
},
|
},
|
||||||
modifier = Modifier.weight(1f),
|
modifier = Modifier.weight(1f),
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodyMedium,
|
||||||
color = if (written == null && open) WallaceRed else MaterialTheme.colorScheme.onSurface,
|
color = if (written == null && open) WallaceRed else MaterialTheme.colorScheme.onSurface,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -271,18 +422,18 @@ private fun CardRow(
|
|||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun TotalRow(label: String, values: List<Int>, bold: Boolean = false) {
|
private fun TotalRow(label: String, values: List<Int>, bold: Boolean = false) {
|
||||||
Row(modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp)) {
|
Row(modifier = Modifier.fillMaxWidth().padding(vertical = 5.dp)) {
|
||||||
Text(
|
Text(
|
||||||
text = label,
|
text = label,
|
||||||
modifier = Modifier.weight(2f),
|
modifier = Modifier.weight(2f),
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodyMedium,
|
||||||
fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal,
|
fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal,
|
||||||
)
|
)
|
||||||
values.forEach {
|
values.forEach {
|
||||||
Text(
|
Text(
|
||||||
text = "$it",
|
text = "$it",
|
||||||
modifier = Modifier.weight(1f),
|
modifier = Modifier.weight(1f),
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodyMedium,
|
||||||
fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal,
|
fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -295,7 +446,12 @@ private fun EndCardDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
onDismissRequest = onKeepPlaying,
|
onDismissRequest = onKeepPlaying,
|
||||||
title = { Text("End this game?") },
|
title = { Text("End this game?") },
|
||||||
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
text = { Text("The game ends here. Anyone else at the table is told you have left.") },
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -14,6 +14,7 @@ import androidx.compose.ui.geometry.Offset
|
|||||||
import androidx.compose.ui.geometry.Size
|
import androidx.compose.ui.geometry.Size
|
||||||
import androidx.compose.ui.graphics.Color
|
import androidx.compose.ui.graphics.Color
|
||||||
import androidx.compose.ui.graphics.Path
|
import androidx.compose.ui.graphics.Path
|
||||||
|
import androidx.compose.ui.graphics.PathEffect
|
||||||
import androidx.compose.ui.graphics.StrokeCap
|
import androidx.compose.ui.graphics.StrokeCap
|
||||||
import androidx.compose.ui.graphics.drawscope.DrawScope
|
import androidx.compose.ui.graphics.drawscope.DrawScope
|
||||||
import androidx.compose.ui.graphics.drawscope.Stroke
|
import androidx.compose.ui.graphics.drawscope.Stroke
|
||||||
@@ -32,6 +33,7 @@ import org.prolibertate.games.game.catan.CatanBoard
|
|||||||
import org.prolibertate.games.game.catan.CatanState
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
import org.prolibertate.games.game.catan.NO_PLAYER
|
import org.prolibertate.games.game.catan.NO_PLAYER
|
||||||
import org.prolibertate.games.game.catan.Resource
|
import org.prolibertate.games.game.catan.Resource
|
||||||
|
import org.prolibertate.games.game.catan.Terrain
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The island, drawn and tappable.
|
* The island, drawn and tappable.
|
||||||
@@ -58,12 +60,20 @@ fun CatanBoardView(
|
|||||||
style: CatanStyle = LocalCatanStyle.current,
|
style: CatanStyle = LocalCatanStyle.current,
|
||||||
/** Hexes to light up as having produced on the latest roll. */
|
/** Hexes to light up as having produced on the latest roll. */
|
||||||
rolledHexes: Set<Int> = emptySet(),
|
rolledHexes: Set<Int> = emptySet(),
|
||||||
|
/** Cities & Knights: the knight whose menu is open or that is about to move. */
|
||||||
|
selectedKnight: Int? = null,
|
||||||
|
/** A placement lined up but not yet confirmed (or being dragged over): drawn as a solid ghost. */
|
||||||
|
stagedVertex: Int? = null,
|
||||||
|
stagedEdge: Int? = null,
|
||||||
|
/** The seat that will own the staged piece, for its colour. */
|
||||||
|
stagedSeat: Int? = null,
|
||||||
) {
|
) {
|
||||||
val measurer = rememberTextMeasurer()
|
val measurer = rememberTextMeasurer()
|
||||||
var size by remember { mutableStateOf(IntSize.Zero) }
|
var size by remember { mutableStateOf(IntSize.Zero) }
|
||||||
val layout = remember(size) {
|
val topo = state.topo
|
||||||
|
val layout = remember(size, topo) {
|
||||||
if (size.width > 0 && size.height > 0) {
|
if (size.width > 0 && size.height > 0) {
|
||||||
CatanGeometry.fit(size.width.toFloat(), size.height.toFloat())
|
CatanGeometry.fit(size.width.toFloat(), size.height.toFloat(), topo)
|
||||||
} else {
|
} else {
|
||||||
null
|
null
|
||||||
}
|
}
|
||||||
@@ -77,7 +87,7 @@ fun CatanBoardView(
|
|||||||
|
|
||||||
Canvas(
|
Canvas(
|
||||||
modifier = modifier
|
modifier = modifier
|
||||||
.aspectRatio(CatanGeometry.ASPECT)
|
.aspectRatio(CatanGeometry.aspect(topo))
|
||||||
.onSizeChanged { size = it }
|
.onSizeChanged { size = it }
|
||||||
.semantics { contentDescription = "Katan island board" }
|
.semantics { contentDescription = "Katan island board" }
|
||||||
.pointerInput(layout, targets, style) {
|
.pointerInput(layout, targets, style) {
|
||||||
@@ -86,11 +96,11 @@ fun CatanBoardView(
|
|||||||
val at = Pt(tap.x, tap.y)
|
val at = Pt(tap.x, tap.y)
|
||||||
val reach = board.radius * style.tapReach
|
val reach = board.radius * style.tapReach
|
||||||
when {
|
when {
|
||||||
targets.vertices.isNotEmpty() ->
|
targets.tappableVertices.isNotEmpty() ->
|
||||||
board.nearestVertex(at, reach, targets.vertices)?.let { vertexTap(it) }
|
board.nearestVertex(at, reach, targets.tappableVertices)?.let { vertexTap(it) }
|
||||||
|
|
||||||
targets.edges.isNotEmpty() ->
|
targets.edges.isNotEmpty() || targets.ships.isNotEmpty() ->
|
||||||
board.nearestEdge(at, reach, targets.edges)?.let { edgeTap(it) }
|
board.nearestEdge(at, reach, targets.edges + targets.ships)?.let { edgeTap(it) }
|
||||||
|
|
||||||
targets.hexes.isNotEmpty() ->
|
targets.hexes.isNotEmpty() ->
|
||||||
// A hex is big: accept a tap anywhere near its middle.
|
// A hex is big: accept a tap anywhere near its middle.
|
||||||
@@ -105,11 +115,20 @@ fun CatanBoardView(
|
|||||||
drawHexes(state, board, style, measurer)
|
drawHexes(state, board, style, measurer)
|
||||||
drawRolled(rolledHexes, board, style)
|
drawRolled(rolledHexes, board, style)
|
||||||
drawRobber(state, board, style)
|
drawRobber(state, board, style)
|
||||||
|
drawPirate(state, board, style)
|
||||||
|
drawMerchant(state, board, style, measurer)
|
||||||
drawRoads(state, board, style)
|
drawRoads(state, board, style)
|
||||||
|
drawShips(state, board, style)
|
||||||
drawEdgeTargets(targets, board, style)
|
drawEdgeTargets(targets, board, style)
|
||||||
|
drawShipTargets(targets, board, style)
|
||||||
drawBuildings(state, board, style)
|
drawBuildings(state, board, style)
|
||||||
drawVertexTargets(targets, selectedVertex, board, style)
|
drawWalls(state, board, style)
|
||||||
|
drawMetropolises(state, board, style)
|
||||||
|
drawKnights(state, board, style)
|
||||||
|
drawKnightTargets(targets, board, style)
|
||||||
|
drawVertexTargets(targets, selectedVertex ?: selectedKnight, board, style)
|
||||||
drawHexTargets(targets, board, style)
|
drawHexTargets(targets, board, style)
|
||||||
|
drawStaged(stagedVertex, stagedEdge, stagedSeat, board, style)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -123,10 +142,15 @@ private fun DrawScope.drawHexes(
|
|||||||
style: CatanStyle,
|
style: CatanStyle,
|
||||||
measurer: TextMeasurer,
|
measurer: TextMeasurer,
|
||||||
) {
|
) {
|
||||||
for (hex in 0 until CatanBoard.HEX_COUNT) {
|
for (hex in 0 until state.topo.HEX_COUNT) {
|
||||||
val centre = board.hexCenter(hex)
|
val centre = board.hexCenter(hex)
|
||||||
val corners = board.hexCorners(hex).map { insetToward(it, centre, style.hexInset) }
|
val corners = board.hexCorners(hex).map { insetToward(it, centre, style.hexInset) }
|
||||||
val path = polygon(corners)
|
val path = polygon(corners)
|
||||||
|
if (state.terrains[hex] == Terrain.SEA) {
|
||||||
|
// Open water: only a faint outline, so ships have a grid to sail on.
|
||||||
|
drawPath(path, color = style.hexEdge.copy(alpha = 0.12f), style = Stroke(width = board.radius * 0.02f))
|
||||||
|
continue
|
||||||
|
}
|
||||||
drawPath(path, color = style.terrain.getValue(state.terrains[hex]))
|
drawPath(path, color = style.terrain.getValue(state.terrains[hex]))
|
||||||
drawPath(path, color = style.hexEdge, style = Stroke(width = board.radius * 0.03f))
|
drawPath(path, color = style.hexEdge, style = Stroke(width = board.radius * 0.03f))
|
||||||
|
|
||||||
@@ -185,6 +209,10 @@ private fun DrawScope.drawToken(
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun DrawScope.drawRobber(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
private fun DrawScope.drawRobber(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
// In Cities & Knights the robber sleeps, drawn faintly, until the barbarians first land.
|
||||||
|
val asleep = state.ck?.attacked == false
|
||||||
|
val tint = if (asleep) style.robber.copy(alpha = 0.3f) else style.robber
|
||||||
|
val rim = Color.White.copy(alpha = if (asleep) 0.25f else 0.7f)
|
||||||
val hex = board.hexCenter(state.robber)
|
val hex = board.hexCenter(state.robber)
|
||||||
// Beside the number token rather than on it, so the number stays readable.
|
// Beside the number token rather than on it, so the number stays readable.
|
||||||
val x = hex.x + board.radius * 0.5f
|
val x = hex.x + board.radius * 0.5f
|
||||||
@@ -197,11 +225,11 @@ private fun DrawScope.drawRobber(state: CatanState, board: BoardLayout, style: C
|
|||||||
lineTo(x + s * 0.55f, y + s * 0.9f)
|
lineTo(x + s * 0.55f, y + s * 0.9f)
|
||||||
close()
|
close()
|
||||||
}
|
}
|
||||||
drawPath(pawn, color = style.robber)
|
drawPath(pawn, color = tint)
|
||||||
drawCircle(color = style.robber, radius = s * 0.38f, center = Offset(x, y - s * 0.42f))
|
drawCircle(color = tint, 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))
|
drawPath(pawn, color = rim, style = Stroke(width = s * 0.07f))
|
||||||
drawCircle(
|
drawCircle(
|
||||||
color = Color.White.copy(alpha = 0.7f),
|
color = rim,
|
||||||
radius = s * 0.38f,
|
radius = s * 0.38f,
|
||||||
center = Offset(x, y - s * 0.42f),
|
center = Offset(x, y - s * 0.42f),
|
||||||
style = Stroke(width = s * 0.07f),
|
style = Stroke(width = s * 0.07f),
|
||||||
@@ -347,7 +375,7 @@ private fun DrawScope.drawResourceIcon(resource: Resource, at: Pt, s: Float, fil
|
|||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
private fun DrawScope.drawRoads(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
private fun DrawScope.drawRoads(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
for (edge in 0 until CatanBoard.EDGE_COUNT) {
|
for (edge in 0 until state.topo.EDGE_COUNT) {
|
||||||
val owner = state.roads[edge]
|
val owner = state.roads[edge]
|
||||||
if (owner == NO_PLAYER) continue
|
if (owner == NO_PLAYER) continue
|
||||||
val (a, b) = board.edgeEnds(edge)
|
val (a, b) = board.edgeEnds(edge)
|
||||||
@@ -373,7 +401,7 @@ private fun DrawScope.drawRoads(state: CatanState, board: BoardLayout, style: Ca
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun DrawScope.drawBuildings(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
private fun DrawScope.drawBuildings(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
for (vertex in 0 until CatanBoard.VERTEX_COUNT) {
|
for (vertex in 0 until state.topo.VERTEX_COUNT) {
|
||||||
val building = state.buildings[vertex] ?: continue
|
val building = state.buildings[vertex] ?: continue
|
||||||
val at = board.vertex(vertex)
|
val at = board.vertex(vertex)
|
||||||
val fill = style.seats[building.owner % style.seats.size]
|
val fill = style.seats[building.owner % style.seats.size]
|
||||||
@@ -409,6 +437,131 @@ private fun cityPath(at: Pt, s: Float): Path = Path().apply {
|
|||||||
close()
|
close()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Cities & Knights pieces
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** A dashed wall round each walled city, crenellated by the dashes. */
|
||||||
|
private fun DrawScope.drawWalls(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val walls = state.ck?.walls ?: return
|
||||||
|
for (vertex in walls) {
|
||||||
|
val at = board.vertex(vertex).offset()
|
||||||
|
val radius = board.radius * style.citySize * 1.25f
|
||||||
|
val dash = PathEffect.dashPathEffect(floatArrayOf(radius * 0.38f, radius * 0.22f))
|
||||||
|
drawCircle(
|
||||||
|
color = style.pieceOutline,
|
||||||
|
radius = radius,
|
||||||
|
center = at,
|
||||||
|
style = Stroke(width = board.radius * 0.13f, pathEffect = dash),
|
||||||
|
)
|
||||||
|
drawCircle(
|
||||||
|
color = style.wall,
|
||||||
|
radius = radius,
|
||||||
|
center = at,
|
||||||
|
style = Stroke(width = board.radius * 0.09f, pathEffect = dash),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A pennant in the track's colour flying over a city that carries its metropolis. */
|
||||||
|
private fun DrawScope.drawMetropolises(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val metropolises = state.ck?.metropolises ?: return
|
||||||
|
for ((track, at) in metropolises) {
|
||||||
|
val base = board.vertex(at.vertex)
|
||||||
|
val unit = board.radius * style.citySize
|
||||||
|
val poleTop = Pt(base.x + unit * 0.9f, base.y - unit * 2.0f)
|
||||||
|
val poleBottom = Pt(base.x + unit * 0.9f, base.y - unit * 0.4f)
|
||||||
|
drawLine(
|
||||||
|
color = style.pieceOutline,
|
||||||
|
start = poleBottom.offset(),
|
||||||
|
end = poleTop.offset(),
|
||||||
|
strokeWidth = board.radius * 0.05f,
|
||||||
|
)
|
||||||
|
val flag = Path().apply {
|
||||||
|
moveTo(poleTop.x, poleTop.y)
|
||||||
|
lineTo(poleTop.x + unit * 1.1f, poleTop.y + unit * 0.35f)
|
||||||
|
lineTo(poleTop.x, poleTop.y + unit * 0.7f)
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
drawPath(flag, color = style.track.getValue(track))
|
||||||
|
drawPath(flag, color = style.pieceOutline, style = Stroke(width = board.radius * 0.035f))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Each knight is a shield in its owner's colour, marked with one, two or three
|
||||||
|
* dots for its strength. A sleeping knight is drawn faded; an awake one has a
|
||||||
|
* bright rim.
|
||||||
|
*/
|
||||||
|
private fun DrawScope.drawKnights(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val knights = state.ck?.knights ?: return
|
||||||
|
for (knight in knights) {
|
||||||
|
val at = board.vertex(knight.vertex)
|
||||||
|
val s = board.radius * style.knightSize
|
||||||
|
val seat = style.seats[knight.owner % style.seats.size]
|
||||||
|
val path = shieldPath(at, s)
|
||||||
|
if (knight.active) {
|
||||||
|
drawPath(path, color = style.knightReady, style = Stroke(width = s * 0.55f))
|
||||||
|
}
|
||||||
|
drawPath(path, color = if (knight.active) seat else seat.copy(alpha = 0.55f))
|
||||||
|
drawPath(path, color = style.pieceOutline, style = Stroke(width = s * 0.16f))
|
||||||
|
val pip = s * 0.14f
|
||||||
|
val gap = pip * 2.8f
|
||||||
|
val startX = at.x - gap * (knight.level - 1) / 2f
|
||||||
|
for (i in 0 until knight.level) {
|
||||||
|
drawCircle(
|
||||||
|
color = style.pieceOutline,
|
||||||
|
radius = pip,
|
||||||
|
center = Offset(startX + i * gap, at.y - s * 0.05f),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun shieldPath(at: Pt, s: Float): Path = Path().apply {
|
||||||
|
moveTo(at.x - s * 0.8f, at.y - s)
|
||||||
|
lineTo(at.x + s * 0.8f, at.y - s)
|
||||||
|
lineTo(at.x + s * 0.8f, at.y + s * 0.1f)
|
||||||
|
quadraticBezierTo(at.x + s * 0.8f, at.y + s * 0.9f, at.x, at.y + s * 1.25f)
|
||||||
|
quadraticBezierTo(at.x - s * 0.8f, at.y + s * 0.9f, at.x - s * 0.8f, at.y + s * 0.1f)
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A ring round each of the player's knights that can do something now. */
|
||||||
|
private fun DrawScope.drawKnightTargets(targets: BoardTargets, board: BoardLayout, style: CatanStyle) {
|
||||||
|
for (vertex in targets.knights) {
|
||||||
|
drawCircle(
|
||||||
|
color = style.target,
|
||||||
|
radius = board.radius * style.knightSize * 1.9f,
|
||||||
|
center = board.vertex(vertex).offset(),
|
||||||
|
style = Stroke(width = board.radius * 0.07f),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The merchant: a coin in its controller's colour, beside the hex it sits on. */
|
||||||
|
private fun DrawScope.drawMerchant(
|
||||||
|
state: CatanState,
|
||||||
|
board: BoardLayout,
|
||||||
|
style: CatanStyle,
|
||||||
|
measurer: TextMeasurer,
|
||||||
|
) {
|
||||||
|
val merchant = state.ck?.merchant ?: return
|
||||||
|
val hex = board.hexCenter(merchant.hex)
|
||||||
|
val at = Pt(hex.x - board.radius * 0.5f, hex.y + board.radius * 0.3f)
|
||||||
|
val r = board.radius * 0.2f
|
||||||
|
drawCircle(color = style.seats[merchant.seat % style.seats.size], radius = r, center = at.offset())
|
||||||
|
drawCircle(color = style.pieceOutline, radius = r, center = at.offset(), style = Stroke(width = r * 0.3f))
|
||||||
|
drawCentered(
|
||||||
|
measurer = measurer,
|
||||||
|
text = "M",
|
||||||
|
at = at,
|
||||||
|
fontPx = r * 1.3f,
|
||||||
|
color = style.pieceOutline,
|
||||||
|
weight = FontWeight.ExtraBold,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// Tap targets
|
// Tap targets
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -505,3 +658,86 @@ private fun DrawScope.drawCentered(
|
|||||||
topLeft = Offset(at.x - layout.size.width / 2f, at.y - layout.size.height / 2f),
|
topLeft = Offset(at.x - layout.size.width / 2f, at.y - layout.size.height / 2f),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** The ghost of a placement waiting for ✓: a solid piece in the player's colour with a bright ring. */
|
||||||
|
private fun DrawScope.drawStaged(vertex: Int?, edge: Int?, seat: Int?, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val colour = seat?.let { style.seats.getOrNull(it) } ?: style.target
|
||||||
|
if (edge != null) {
|
||||||
|
val (a, b) = board.edgeEnds(edge)
|
||||||
|
val from = lerp(a, b, 0.1f)
|
||||||
|
val to = lerp(a, b, 0.9f)
|
||||||
|
drawLine(style.targetSelected, from.offset(), to.offset(), board.radius * style.roadWidth * 2.1f, StrokeCap.Round)
|
||||||
|
drawLine(colour, from.offset(), to.offset(), board.radius * style.roadWidth * 1.3f, StrokeCap.Round)
|
||||||
|
}
|
||||||
|
if (vertex != null) {
|
||||||
|
val at = board.vertex(vertex).offset()
|
||||||
|
val radius = board.radius * style.targetRadius
|
||||||
|
drawCircle(colour, radius * 1.3f, at)
|
||||||
|
drawCircle(style.targetSelected, radius * 1.9f, at, style = Stroke(width = board.radius * 0.1f))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Seafarers: ships, the pirate
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** A ship on each sea edge that has one: a hull along the edge with a sail amidships, in the owner's colour. */
|
||||||
|
private fun DrawScope.drawShips(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val sea = state.sea ?: return
|
||||||
|
for (edge in sea.ships.indices) {
|
||||||
|
val owner = sea.ships[edge]
|
||||||
|
if (owner == NO_PLAYER) continue
|
||||||
|
val (a, b) = board.edgeEnds(edge)
|
||||||
|
val from = lerp(a, b, 0.2f)
|
||||||
|
val to = lerp(a, b, 0.8f)
|
||||||
|
val width = board.radius * style.roadWidth * 1.15f
|
||||||
|
val colour = style.seats[owner % style.seats.size]
|
||||||
|
drawLine(style.pieceOutline, from.offset(), to.offset(), width * 1.5f, StrokeCap.Round)
|
||||||
|
drawLine(colour, from.offset(), to.offset(), width, StrokeCap.Round)
|
||||||
|
// The sail: a small triangle standing off the hull, on the screen's upper side.
|
||||||
|
val mid = lerp(a, b, 0.5f)
|
||||||
|
val s = board.radius * 0.17f
|
||||||
|
val sail = Path().apply {
|
||||||
|
moveTo(mid.x - s * 0.1f, mid.y - s * 1.9f)
|
||||||
|
lineTo(mid.x + s * 1.1f, mid.y - s * 0.2f)
|
||||||
|
lineTo(mid.x - s * 0.1f, mid.y - s * 0.2f)
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
drawPath(sail, style.shipSail)
|
||||||
|
drawPath(sail, style.pieceOutline, style = Stroke(width = board.radius * 0.03f))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A ring round each of the player's ships that can sail, so they read as tappable. */
|
||||||
|
private fun DrawScope.drawShipTargets(targets: BoardTargets, board: BoardLayout, style: CatanStyle) {
|
||||||
|
for (edge in targets.ships) {
|
||||||
|
val mid = board.edgeMidpoint(edge).offset()
|
||||||
|
drawCircle(style.target, board.radius * 0.38f, mid, style = Stroke(width = board.radius * 0.07f))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The pirate: a black pawn with a flag, drawn beside the middle of its sea hex like the robber. */
|
||||||
|
private fun DrawScope.drawPirate(state: CatanState, board: BoardLayout, style: CatanStyle) {
|
||||||
|
val sea = state.sea ?: return
|
||||||
|
val hex = board.hexCenter(sea.pirate)
|
||||||
|
val x = hex.x
|
||||||
|
val y = hex.y + board.radius * 0.1f
|
||||||
|
val s = board.radius * style.robberSize
|
||||||
|
val hull = Path().apply {
|
||||||
|
moveTo(x - s * 1.0f, y)
|
||||||
|
lineTo(x + s * 1.0f, y)
|
||||||
|
lineTo(x + s * 0.6f, y + s * 0.7f)
|
||||||
|
lineTo(x - s * 0.6f, y + s * 0.7f)
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
drawPath(hull, style.pirate)
|
||||||
|
drawLine(style.pirate, Offset(x, y), Offset(x, y - s * 1.5f), strokeWidth = s * 0.12f)
|
||||||
|
val flag = Path().apply {
|
||||||
|
moveTo(x, y - s * 1.5f)
|
||||||
|
lineTo(x + s * 0.9f, y - s * 1.15f)
|
||||||
|
lineTo(x, y - s * 0.8f)
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
drawPath(flag, style.pirate)
|
||||||
|
drawPath(hull, Color.White.copy(alpha = 0.7f), style = Stroke(width = s * 0.07f))
|
||||||
|
}
|
||||||
|
|||||||
@@ -0,0 +1,813 @@
|
|||||||
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import androidx.compose.foundation.background
|
||||||
|
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.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.size
|
||||||
|
import androidx.compose.foundation.layout.width
|
||||||
|
import androidx.compose.foundation.rememberScrollState
|
||||||
|
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||||
|
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.draw.clip
|
||||||
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import org.prolibertate.games.game.catan.AcceptCounter
|
||||||
|
import org.prolibertate.games.game.catan.ActivateKnight
|
||||||
|
import org.prolibertate.games.game.catan.BuyImprovement
|
||||||
|
import org.prolibertate.games.game.catan.CatanCk
|
||||||
|
import org.prolibertate.games.game.catan.CatanMove
|
||||||
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.ChaseRobber
|
||||||
|
import org.prolibertate.games.game.catan.CounterGoods
|
||||||
|
import org.prolibertate.games.game.catan.DropProgress
|
||||||
|
import org.prolibertate.games.game.catan.GoodsBankTrade
|
||||||
|
import org.prolibertate.games.game.catan.Good
|
||||||
|
import org.prolibertate.games.game.catan.GoodsCounter
|
||||||
|
import org.prolibertate.games.game.catan.GoodsOffer
|
||||||
|
import org.prolibertate.games.game.catan.IMPROVEMENT_MAX
|
||||||
|
import org.prolibertate.games.game.catan.MoveKnight
|
||||||
|
import org.prolibertate.games.game.catan.OfferGoods
|
||||||
|
import org.prolibertate.games.game.catan.PickDeck
|
||||||
|
import org.prolibertate.games.game.catan.PlayProgress
|
||||||
|
import org.prolibertate.games.game.catan.ProgressCard
|
||||||
|
import org.prolibertate.games.game.catan.ProgressType
|
||||||
|
import org.prolibertate.games.game.catan.PromoteKnight
|
||||||
|
import org.prolibertate.games.game.catan.SpyTake
|
||||||
|
import org.prolibertate.games.game.catan.TakeAqueduct
|
||||||
|
import org.prolibertate.games.game.catan.Track
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The Cities & Knights dialogs. Like the base game's, each is a stateless
|
||||||
|
* composable apart from the choice it is helping the player make, and what is
|
||||||
|
* allowed is always asked of the engine's legal list through CatanInteraction.
|
||||||
|
*/
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Shared pieces
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** A card tile with a minus and a plus, for choosing how many of a good. */
|
||||||
|
@Composable
|
||||||
|
private fun GoodCounter(good: Good, count: Int, max: Int, onChange: (Int) -> Unit) {
|
||||||
|
Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(4.dp)) {
|
||||||
|
GoodTile(good, 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<Good, Int>.asGoods(): List<Good> = Good.entries.flatMap { g -> List(this[g] ?: 0) { g } }
|
||||||
|
|
||||||
|
/** A row of the three track colours, used for decks and improvements. */
|
||||||
|
@Composable
|
||||||
|
private fun TrackChip(track: Track, style: CatanStyle = LocalCatanStyle.current) {
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.size(14.dp)
|
||||||
|
.clip(RoundedCornerShape(3.dp))
|
||||||
|
.background(style.track.getValue(track)),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Choosing cards to give up
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pick exactly [quota] cards out of [held] — to discard on a seven or a saboteur,
|
||||||
|
* or to hand over for a wedding or a commercial harbour. Not dismissable: the
|
||||||
|
* game is waiting on it. [allowed] is the engine's structural check, so the
|
||||||
|
* confirm button only lights when the move would be accepted.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanGoodsPickDialog(
|
||||||
|
title: String,
|
||||||
|
intro: String,
|
||||||
|
held: Map<Good, Int>,
|
||||||
|
quota: Int,
|
||||||
|
confirmLabel: String,
|
||||||
|
selectable: (Good) -> Boolean,
|
||||||
|
allowed: (List<Good>) -> Boolean,
|
||||||
|
onConfirm: (List<Good>) -> Unit,
|
||||||
|
) {
|
||||||
|
var picked by remember { mutableStateOf(emptyMap<Good, Int>()) }
|
||||||
|
val selection = picked.asGoods()
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text(title) },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||||
|
Text("$intro (${selection.size} of $quota chosen).")
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Good.entries.forEach { good ->
|
||||||
|
val have = held[good] ?: 0
|
||||||
|
if (have > 0 && selectable(good)) {
|
||||||
|
GoodCounter(
|
||||||
|
good = good,
|
||||||
|
count = picked[good] ?: 0,
|
||||||
|
max = if (selection.size < quota) have else (picked[good] ?: 0),
|
||||||
|
onChange = { n -> picked = picked + (good to n.coerceIn(0, have)) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {
|
||||||
|
Button(onClick = { onConfirm(selection) }, enabled = allowed(selection)) { Text(confirmLabel) }
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// City improvements
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** The three improvement tracks: where the player stands, what the next level costs, and what it earns. */
|
||||||
|
@Composable
|
||||||
|
fun CatanImproveDialog(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
onBuy: (BuyImprovement) -> Unit,
|
||||||
|
onCancel: () -> Unit,
|
||||||
|
) {
|
||||||
|
val ck = state.ck ?: return
|
||||||
|
val buyable = CatanInteraction.improvable(legal)
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onCancel,
|
||||||
|
title = { Text(CatanText.IMPROVE) },
|
||||||
|
text = {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.heightIn(max = 460.dp).verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(14.dp),
|
||||||
|
) {
|
||||||
|
Track.entries.forEach { track ->
|
||||||
|
val level = CatanCk.improvement(state, seat, track)
|
||||||
|
val have = ck.commodities[seat][track.commodity] ?: 0
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
|
||||||
|
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
TrackChip(track)
|
||||||
|
Text(CatanText.track(track), fontWeight = FontWeight.Bold)
|
||||||
|
Text("level $level of $IMPROVEMENT_MAX", style = MaterialTheme.typography.labelMedium)
|
||||||
|
}
|
||||||
|
Text(CatanText.trackPower(track), style = MaterialTheme.typography.bodySmall)
|
||||||
|
if (level >= IMPROVEMENT_MAX) {
|
||||||
|
Text("Fully built.", style = MaterialTheme.typography.bodySmall)
|
||||||
|
} else {
|
||||||
|
val cost = CatanCk.improvementCost(state, seat, track)
|
||||||
|
Button(onClick = { onBuy(BuyImprovement(track)) }, enabled = track in buyable) {
|
||||||
|
Text(
|
||||||
|
"${CatanCk.improvementName(track, level + 1)}: $cost " +
|
||||||
|
"${CatanText.good(Good.of(track.commodity))} (you hold $have)",
|
||||||
|
)
|
||||||
|
}
|
||||||
|
if (level + 1 == org.prolibertate.games.game.catan.METROPOLIS_LEVEL ||
|
||||||
|
level + 1 == IMPROVEMENT_MAX
|
||||||
|
) {
|
||||||
|
Text(
|
||||||
|
if (level + 1 == IMPROVEMENT_MAX) {
|
||||||
|
"Level five takes a metropolis from a seat still on four."
|
||||||
|
} else {
|
||||||
|
"Level four earns the first metropolis in this track: two more points."
|
||||||
|
},
|
||||||
|
style = MaterialTheme.typography.labelSmall,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
dismissButton = { TextButton(onClick = onCancel) { Text("Close") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Progress cards
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The player's progress cards. A card with nothing to decide plays at once; one
|
||||||
|
* that names a seat, a card or dice asks for it in a second step; one that
|
||||||
|
* needs a tap on the board closes the dialog and arms the board (see [ArmedCard]).
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanProgressDialog(
|
||||||
|
hand: List<ProgressInHand>,
|
||||||
|
seats: CatanSeats,
|
||||||
|
onPlay: (CatanMove) -> Unit,
|
||||||
|
onArm: (ArmedCard) -> Unit,
|
||||||
|
onCancel: () -> Unit,
|
||||||
|
) {
|
||||||
|
var chosen by remember { mutableStateOf<ProgressInHand?>(null) }
|
||||||
|
var target by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var yellow by remember { mutableStateOf(1) }
|
||||||
|
var red by remember { mutableStateOf(1) }
|
||||||
|
val entry = chosen
|
||||||
|
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onCancel,
|
||||||
|
title = { Text(entry?.let { CatanText.progress(it.card.kind) } ?: "Progress cards") },
|
||||||
|
text = {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.heightIn(max = 440.dp).verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(10.dp),
|
||||||
|
) {
|
||||||
|
if (entry == null) {
|
||||||
|
if (hand.isEmpty()) Text("You hold no progress cards.")
|
||||||
|
hand.forEach { card ->
|
||||||
|
ProgressRow(card) { picked ->
|
||||||
|
val kind = picked.card.kind
|
||||||
|
when {
|
||||||
|
kind in CatanInteraction.BOARD_CARDS -> onArm(ArmedCard(kind, picked.plays))
|
||||||
|
picked.plays.size == 1 && picked.plays[0].isBare() -> onPlay(picked.plays[0])
|
||||||
|
else -> {
|
||||||
|
chosen = picked
|
||||||
|
target = null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Text(CatanText.progressHelp(entry.card.kind), style = MaterialTheme.typography.bodySmall)
|
||||||
|
val kind = entry.card.kind
|
||||||
|
val plays = entry.plays
|
||||||
|
when {
|
||||||
|
kind == ProgressType.ALCHEMIST -> {
|
||||||
|
Text("Production die (yellow)", fontWeight = FontWeight.Bold)
|
||||||
|
DiePicker(yellow) { yellow = it }
|
||||||
|
Text("Progress die (red)", fontWeight = FontWeight.Bold)
|
||||||
|
DiePicker(red) { red = it }
|
||||||
|
}
|
||||||
|
|
||||||
|
kind == ProgressType.DESERTER || kind == ProgressType.SPY -> {
|
||||||
|
Text("Choose a player:", fontWeight = FontWeight.Bold)
|
||||||
|
plays.mapNotNull { it.target }.distinct().forEach { seat ->
|
||||||
|
OutlinedButton(
|
||||||
|
onClick = { plays.firstOrNull { it.target == seat }?.let(onPlay) },
|
||||||
|
modifier = Modifier.fillMaxWidth(),
|
||||||
|
) { Text(seats.label(seat)) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
kind == ProgressType.MASTER_MERCHANT -> {
|
||||||
|
Text("Choose a player with more points:", fontWeight = FontWeight.Bold)
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
plays.mapNotNull { it.target }.distinct().forEach { seat ->
|
||||||
|
if (target == seat) {
|
||||||
|
FilledTonalButton(onClick = { target = seat }) { Text(seats.label(seat)) }
|
||||||
|
} else {
|
||||||
|
OutlinedButton(onClick = { target = seat }) { Text(seats.label(seat)) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
val seat = target
|
||||||
|
if (seat != null) {
|
||||||
|
Text("Take:", fontWeight = FontWeight.Bold)
|
||||||
|
plays.filter { it.target == seat }.forEach { play ->
|
||||||
|
OutlinedButton(
|
||||||
|
onClick = { onPlay(play) },
|
||||||
|
modifier = Modifier.fillMaxWidth(),
|
||||||
|
) { Text(CatanText.goods(play.goods.orEmpty())) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
val label = when (kind) {
|
||||||
|
ProgressType.COMMERCIAL_HARBOR -> "Offer which resource?"
|
||||||
|
ProgressType.MERCHANT_FLEET -> "Trade which card two for one?"
|
||||||
|
ProgressType.RESOURCE_MONOPOLY -> "Name a resource:"
|
||||||
|
else -> "Name a commodity:"
|
||||||
|
}
|
||||||
|
Text(label, fontWeight = FontWeight.Bold)
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
plays.mapNotNull { it.good }.distinct().forEach { good ->
|
||||||
|
GoodTile(
|
||||||
|
good = good,
|
||||||
|
count = 0,
|
||||||
|
onClick = { plays.firstOrNull { it.good == good }?.let(onPlay) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {
|
||||||
|
if (entry != null && entry.card.kind == ProgressType.ALCHEMIST) {
|
||||||
|
val play = entry.plays.firstOrNull { it.dice == listOf(yellow, red) }
|
||||||
|
Button(onClick = { play?.let(onPlay) }, enabled = play != null) { Text("Play") }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
dismissButton = {
|
||||||
|
TextButton(
|
||||||
|
onClick = {
|
||||||
|
if (entry == null) {
|
||||||
|
onCancel()
|
||||||
|
} else {
|
||||||
|
chosen = null
|
||||||
|
target = null
|
||||||
|
}
|
||||||
|
},
|
||||||
|
) { Text(if (entry == null) CatanText.CANCEL else "Back") }
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun PlayProgress.isBare(): Boolean =
|
||||||
|
target == null && vertex == null && edge == null && hexA == null && hexB == null &&
|
||||||
|
good == null && dice == null && goods == null
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun DiePicker(selected: Int, onPick: (Int) -> Unit) {
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
(1..6).forEach { n ->
|
||||||
|
if (n == selected) {
|
||||||
|
FilledTonalButton(
|
||||||
|
onClick = { onPick(n) },
|
||||||
|
contentPadding = PaddingValues(0.dp),
|
||||||
|
modifier = Modifier.size(40.dp),
|
||||||
|
) { Text("$n") }
|
||||||
|
} else {
|
||||||
|
OutlinedButton(
|
||||||
|
onClick = { onPick(n) },
|
||||||
|
contentPadding = PaddingValues(0.dp),
|
||||||
|
modifier = Modifier.size(40.dp),
|
||||||
|
) { Text("$n") }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun ProgressRow(entry: ProgressInHand, onChoose: (ProgressInHand) -> Unit) {
|
||||||
|
val kind = entry.card.kind
|
||||||
|
Row(
|
||||||
|
modifier = Modifier.fillMaxWidth(),
|
||||||
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
TrackChip(kind.track)
|
||||||
|
Column(modifier = Modifier.weight(1f)) {
|
||||||
|
Text(CatanText.progress(kind), fontWeight = FontWeight.Bold)
|
||||||
|
Text(CatanText.progressHelp(kind), style = MaterialTheme.typography.bodySmall)
|
||||||
|
}
|
||||||
|
if (entry.playable) {
|
||||||
|
Button(onClick = { onChoose(entry) }) { Text("Play") }
|
||||||
|
} else {
|
||||||
|
Text("Not now", style = MaterialTheme.typography.labelSmall)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Knights
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** What the knight on one crossing can do: wake, promote, move, chase the robber. */
|
||||||
|
@Composable
|
||||||
|
fun CatanKnightDialog(
|
||||||
|
state: CatanState,
|
||||||
|
vertex: Int,
|
||||||
|
actions: List<CatanMove>,
|
||||||
|
onDo: (CatanMove) -> Unit,
|
||||||
|
onMove: (Int) -> Unit,
|
||||||
|
onCancel: () -> Unit,
|
||||||
|
) {
|
||||||
|
val knight = state.ck?.knights?.firstOrNull { it.vertex == vertex }
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = onCancel,
|
||||||
|
title = { Text(knight?.let { CatanText.knightName(it.level) } ?: "Knight") },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
if (knight != null) {
|
||||||
|
val mood = when {
|
||||||
|
!knight.active -> "Asleep. Waking it costs ${CatanText.ACTIVATE_COST}."
|
||||||
|
knight.activatedTurn == state.turnNumber -> "Awake, but it woke this turn and cannot act yet."
|
||||||
|
else -> "Awake and ready. It counts against the barbarians."
|
||||||
|
}
|
||||||
|
Text(mood, style = MaterialTheme.typography.bodySmall)
|
||||||
|
}
|
||||||
|
actions.forEach { move ->
|
||||||
|
when (move) {
|
||||||
|
is ActivateKnight ->
|
||||||
|
Button(onClick = { onDo(move) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text("Wake (${CatanText.ACTIVATE_COST})")
|
||||||
|
}
|
||||||
|
|
||||||
|
is PromoteKnight ->
|
||||||
|
Button(onClick = { onDo(move) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text("Promote (${CatanText.KNIGHT_COST})")
|
||||||
|
}
|
||||||
|
|
||||||
|
is MoveKnight ->
|
||||||
|
OutlinedButton(onClick = { onMove(move.from) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text("Move along your roads")
|
||||||
|
}
|
||||||
|
|
||||||
|
is ChaseRobber ->
|
||||||
|
OutlinedButton(onClick = { onDo(move) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
Text("Chase away the robber")
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> Unit
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (actions.isEmpty()) Text("Nothing to do with it right now.")
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
dismissButton = { TextButton(onClick = onCancel) { Text("Close") } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Chores that are answered in a dialog
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Choose a colour of progress deck to draw from. */
|
||||||
|
@Composable
|
||||||
|
fun CatanPickDeckDialog(legal: List<CatanMove>, onPick: (PickDeck) -> Unit) {
|
||||||
|
val open = legal.filterIsInstance<PickDeck>()
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text("Draw a progress card") },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
Text("Catan held. You tied for the strongest defence, so choose any deck.")
|
||||||
|
open.forEach { pick ->
|
||||||
|
Button(onClick = { onPick(pick) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
TrackChip(pick.track)
|
||||||
|
Text(" ${CatanText.track(pick.track)}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The hand is over its limit: give one progress card back. */
|
||||||
|
@Composable
|
||||||
|
fun CatanDropProgressDialog(hand: List<ProgressCard>, onDrop: (DropProgress) -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text("Too many progress cards") },
|
||||||
|
text = {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.heightIn(max = 380.dp).verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Text("You may keep four. Choose one to give back.")
|
||||||
|
hand.forEach { card ->
|
||||||
|
OutlinedButton(onClick = { onDrop(DropProgress(card.id)) }, modifier = Modifier.fillMaxWidth()) {
|
||||||
|
TrackChip(card.kind.track)
|
||||||
|
Text(" ${CatanText.progress(card.kind)}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The aqueduct pays: take any one resource. */
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanAqueductDialog(legal: List<CatanMove>, onTake: (TakeAqueduct) -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text("Aqueduct") },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||||
|
Text("The dice paid you nothing. Take any resource.")
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
legal.filterIsInstance<TakeAqueduct>().forEach { take ->
|
||||||
|
ResourceTile(resource = take.resource, count = 1, onClick = { onTake(take) })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A spy: these are the progress cards the other player holds; take one. */
|
||||||
|
@Composable
|
||||||
|
fun CatanSpyDialog(cards: List<ProgressCard>, legal: List<CatanMove>, onTake: (SpyTake) -> Unit) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text("Spy") },
|
||||||
|
text = {
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.heightIn(max = 380.dp).verticalScroll(rememberScrollState()),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Text("Choose a card to take.")
|
||||||
|
cards.forEach { card ->
|
||||||
|
val take = SpyTake(card.id)
|
||||||
|
OutlinedButton(
|
||||||
|
onClick = { onTake(take) },
|
||||||
|
enabled = take in legal,
|
||||||
|
modifier = Modifier.fillMaxWidth(),
|
||||||
|
) {
|
||||||
|
TrackChip(card.kind.track)
|
||||||
|
Text(" ${CatanText.progress(card.kind)}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Trading in goods
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
private enum class GoodsTab { BANK, PLAYER }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Trade with the bank at the best ratio each card has, or offer cards —
|
||||||
|
* commodities included — to one other player.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanGoodsTradeDialog(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
seats: CatanSeats,
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
onBank: (GoodsBankTrade) -> Unit,
|
||||||
|
onOffer: (OfferGoods) -> Unit,
|
||||||
|
onCancel: () -> Unit,
|
||||||
|
) {
|
||||||
|
var tab by remember { mutableStateOf(GoodsTab.BANK) }
|
||||||
|
var bankGive by remember { mutableStateOf<Good?>(null) }
|
||||||
|
var everyone by remember { mutableStateOf(true) }
|
||||||
|
var partner by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var give by remember { mutableStateOf(emptyMap<Good, Int>()) }
|
||||||
|
var get by remember { mutableStateOf(emptyMap<Good, Int>()) }
|
||||||
|
val held = CatanCk.goodsOf(state, seat)
|
||||||
|
|
||||||
|
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)) {
|
||||||
|
GoodsTabButton(CatanText.TRADE_WITH_BANK, tab == GoodsTab.BANK) { tab = GoodsTab.BANK }
|
||||||
|
GoodsTabButton(CatanText.TRADE_WITH_PLAYER, tab == GoodsTab.PLAYER) { tab = GoodsTab.PLAYER }
|
||||||
|
}
|
||||||
|
if (tab == GoodsTab.BANK) {
|
||||||
|
val trades = CatanInteraction.goodsBankTrades(legal)
|
||||||
|
if (trades.isEmpty()) {
|
||||||
|
Text("You do not hold enough of any one card 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 { good ->
|
||||||
|
val ratio = CatanCk.bankRatio(state, seat, good)
|
||||||
|
Column(horizontalAlignment = Alignment.CenterHorizontally) {
|
||||||
|
GoodTile(good, ratio, selected = bankGive == good, onClick = { bankGive = good })
|
||||||
|
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 { good ->
|
||||||
|
GoodTile(good, 1, onClick = { onBank(GoodsBankTrade(chosen, good)) })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Text("Offer to:", fontWeight = FontWeight.Bold)
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
GoodsTabButton(CatanText.EVERYONE, everyone) {
|
||||||
|
everyone = true
|
||||||
|
partner = null
|
||||||
|
}
|
||||||
|
(0 until state.playerCount).filter { it != seat }.forEach { other ->
|
||||||
|
GoodsTabButton(seats.label(other), !everyone && partner == other) {
|
||||||
|
everyone = false
|
||||||
|
partner = other
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Text(CatanText.YOU_GIVE, fontWeight = FontWeight.Bold)
|
||||||
|
GoodCounters(give, { held[it] ?: 0 }) { give = it }
|
||||||
|
Text(CatanText.YOU_GET, fontWeight = FontWeight.Bold)
|
||||||
|
GoodCounters(get, { 9 }) { get = it }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {
|
||||||
|
if (tab == GoodsTab.PLAYER) {
|
||||||
|
val to = if (everyone) null else partner
|
||||||
|
val giveCards = give.asGoods()
|
||||||
|
val getCards = get.asGoods()
|
||||||
|
val allowed = (everyone || partner != null) &&
|
||||||
|
CatanInteraction.goodsOfferAllowed(state, seat, to, giveCards, getCards)
|
||||||
|
Button(
|
||||||
|
onClick = { onOffer(OfferGoods(to, giveCards, getCards)) },
|
||||||
|
enabled = allowed,
|
||||||
|
) { Text(CatanText.SEND_OFFER) }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
dismissButton = { TextButton(onClick = onCancel) { Text(CatanText.CANCEL) } },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
private fun GoodCounters(counts: Map<Good, Int>, limit: (Good) -> Int, onChange: (Map<Good, Int>) -> Unit) {
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Good.entries.forEach { good ->
|
||||||
|
GoodCounter(
|
||||||
|
good = good,
|
||||||
|
count = counts[good] ?: 0,
|
||||||
|
max = limit(good),
|
||||||
|
onChange = { n -> onChange(counts + (good to n.coerceIn(0, limit(good)))) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun GoodsTabButton(label: String, selected: Boolean, onClick: () -> Unit) {
|
||||||
|
if (selected) {
|
||||||
|
FilledTonalButton(onClick = onClick) { Text(label) }
|
||||||
|
} else {
|
||||||
|
OutlinedButton(onClick = onClick) { Text(label) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A goods offer has reached the local player: accept it, decline it, or answer
|
||||||
|
* with different terms. The counter's two sides start as the offer turned around.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanGoodsTradeResponseDialog(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
offer: GoodsOffer,
|
||||||
|
seats: CatanSeats,
|
||||||
|
canAccept: Boolean,
|
||||||
|
onAccept: () -> Unit,
|
||||||
|
onDecline: () -> Unit,
|
||||||
|
onCounter: (CounterGoods) -> Unit,
|
||||||
|
) {
|
||||||
|
var countering by remember(offer) { mutableStateOf(false) }
|
||||||
|
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(
|
||||||
|
"${seats.label(offer.by)} offers ${CatanText.goods(offer.give)} to " +
|
||||||
|
"${if (offer.to == null) "the table" else "you"} for ${CatanText.goods(offer.get)}",
|
||||||
|
)
|
||||||
|
if (countering) {
|
||||||
|
Text(CatanText.YOU_GIVE, fontWeight = FontWeight.Bold)
|
||||||
|
GoodCounters(give, { CatanCk.goodsOf(state, seat)[it] ?: 0 }) { give = it }
|
||||||
|
Text(CatanText.YOU_GET, fontWeight = FontWeight.Bold)
|
||||||
|
GoodCounters(get, { CatanCk.goodsOf(state, offer.by)[it] ?: 0 }) { 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 = CounterGoods(give.asGoods(), get.asGoods())
|
||||||
|
Button(
|
||||||
|
onClick = { onCounter(move) },
|
||||||
|
enabled = CatanInteraction.goodsCounterAllowed(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 a goods offer: take a counter-offer, or none. */
|
||||||
|
@Composable
|
||||||
|
fun CatanGoodsCounterChoiceDialog(
|
||||||
|
counters: List<GoodsCounter>,
|
||||||
|
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(
|
||||||
|
"${seats.label(counter.by)} would give ${CatanText.goods(counter.give)} " +
|
||||||
|
"for ${CatanText.goods(counter.get)}",
|
||||||
|
)
|
||||||
|
Button(onClick = { onTake(AcceptCounter(counter.by)) }) { Text(CatanText.ACCEPT) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = { TextButton(onClick = onNoDeal) { Text(CatanText.NO_DEAL) } },
|
||||||
|
)
|
||||||
|
}
|
||||||
@@ -1,5 +1,6 @@
|
|||||||
package org.prolibertate.games.ui.game.catan
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import org.prolibertate.games.ui.LocalEndGameHandle
|
||||||
import androidx.compose.foundation.layout.Arrangement
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
import androidx.compose.foundation.layout.Column
|
import androidx.compose.foundation.layout.Column
|
||||||
import androidx.compose.foundation.layout.ExperimentalLayoutApi
|
import androidx.compose.foundation.layout.ExperimentalLayoutApi
|
||||||
@@ -137,6 +138,55 @@ fun CatanDiscardDialog(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Gold (Seafarers)
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A gold field paid out: choose the resource cards it gives. Not dismissable: the game
|
||||||
|
* is waiting. The engine's list says which resources the bank can still pay.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
|
@Composable
|
||||||
|
fun CatanGoldDialog(
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
onSubmit: (org.prolibertate.games.game.catan.PickGold) -> Unit,
|
||||||
|
) {
|
||||||
|
val count = CatanInteraction.goldCount(legal)
|
||||||
|
var picked by remember { mutableStateOf(emptyMap<Resource, Int>()) }
|
||||||
|
val selection = picked.asCards()
|
||||||
|
val move = CatanInteraction.goldMove(legal, selection)
|
||||||
|
// A resource is on offer if some legal pick names it.
|
||||||
|
val offered = legal.filterIsInstance<org.prolibertate.games.game.catan.PickGold>()
|
||||||
|
.flatMap { it.cards }.toSet()
|
||||||
|
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = {},
|
||||||
|
title = { Text(CatanText.GOLD_TITLE) },
|
||||||
|
text = {
|
||||||
|
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||||
|
Text("Gold! Choose $count resource cards (${selection.size} of $count chosen).")
|
||||||
|
FlowRow(
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Resource.entries.filter { it in offered }.forEach { resource ->
|
||||||
|
ResourceCounter(
|
||||||
|
resource = resource,
|
||||||
|
count = picked[resource] ?: 0,
|
||||||
|
max = if (selection.size < count) count else (picked[resource] ?: 0),
|
||||||
|
onChange = { n -> picked = picked + (resource to n.coerceIn(0, count)) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
confirmButton = {
|
||||||
|
Button(onClick = { move?.let(onSubmit) }, enabled = move != null) { Text(CatanText.GOLD_TAKE) }
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// The robber
|
// The robber
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -603,7 +653,12 @@ fun CatanEndGameDialog(onEnd: () -> Unit, onKeepPlaying: () -> Unit) {
|
|||||||
"at the table is told you have left.",
|
"at the table is told you have left.",
|
||||||
)
|
)
|
||||||
},
|
},
|
||||||
confirmButton = { TextButton(onClick = onEnd) { Text("End the game") } },
|
confirmButton = {
|
||||||
|
// Ending a game on purpose also forgets the saved position: only
|
||||||
|
// leaving the table keeps it to be picked up again.
|
||||||
|
val handle = LocalEndGameHandle.current
|
||||||
|
TextButton(onClick = { handle.end(); onEnd() }) { Text("End the game") }
|
||||||
|
},
|
||||||
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
dismissButton = { TextButton(onClick = onKeepPlaying) { Text("Keep playing") } },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,6 +1,7 @@
|
|||||||
package org.prolibertate.games.ui.game.catan
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
import org.prolibertate.games.game.catan.CatanBoard
|
import org.prolibertate.games.game.catan.CatanBoard
|
||||||
|
import org.prolibertate.games.game.catan.Topology
|
||||||
import kotlin.math.sqrt
|
import kotlin.math.sqrt
|
||||||
|
|
||||||
/** A point in board pixels. Plain floats, so this file needs no Compose types. */
|
/** A point in board pixels. Plain floats, so this file needs no Compose types. */
|
||||||
@@ -24,29 +25,35 @@ class BoardLayout(
|
|||||||
val height: Float,
|
val height: Float,
|
||||||
/** Circumradius of one hex, in pixels. */
|
/** Circumradius of one hex, in pixels. */
|
||||||
val radius: Float,
|
val radius: Float,
|
||||||
|
/** The board this layout draws: the standard island unless the game is Seafarers. */
|
||||||
|
val topo: Topology = CatanBoard.base,
|
||||||
) {
|
) {
|
||||||
private val centreX = width / 2f
|
private val centreX = width / 2f
|
||||||
private val centreY = height / 2f
|
private val centreY = height / 2f
|
||||||
private val unitX = radius * SQRT3 / 2f
|
private val unitX = radius * SQRT3 / 2f
|
||||||
private val unitY = radius / 2f
|
private val unitY = radius / 2f
|
||||||
|
|
||||||
|
/** The lattice point drawn at the middle of the box: the middle of the frame. */
|
||||||
|
private val midX = (topo.lattice[0] + topo.lattice[1]) / 2f
|
||||||
|
private val midY = (topo.lattice[2] + topo.lattice[3]) / 2f
|
||||||
|
|
||||||
fun point(latticeX: Int, latticeY: Int): Pt =
|
fun point(latticeX: Int, latticeY: Int): Pt =
|
||||||
Pt(centreX + latticeX * unitX, centreY - latticeY * unitY)
|
Pt(centreX + (latticeX - midX) * unitX, centreY - (latticeY - midY) * unitY)
|
||||||
|
|
||||||
fun hexCenter(hex: Int): Pt {
|
fun hexCenter(hex: Int): Pt {
|
||||||
val (lx, ly) = CatanBoard.hexCenter(hex)
|
val (lx, ly) = topo.hexCenter(hex)
|
||||||
return point(lx, ly)
|
return point(lx, ly)
|
||||||
}
|
}
|
||||||
|
|
||||||
fun vertex(vertex: Int): Pt {
|
fun vertex(vertex: Int): Pt {
|
||||||
val (lx, ly) = CatanBoard.VERTEX_POS[vertex]
|
val (lx, ly) = topo.VERTEX_POS[vertex]
|
||||||
return point(lx, ly)
|
return point(lx, ly)
|
||||||
}
|
}
|
||||||
|
|
||||||
fun hexCorners(hex: Int): List<Pt> = CatanBoard.HEX_CORNERS[hex].map { vertex(it) }
|
fun hexCorners(hex: Int): List<Pt> = topo.HEX_CORNERS[hex].map { vertex(it) }
|
||||||
|
|
||||||
fun edgeEnds(edge: Int): Pair<Pt, Pt> {
|
fun edgeEnds(edge: Int): Pair<Pt, Pt> {
|
||||||
val (a, b) = CatanBoard.EDGE_VERTICES[edge]
|
val (a, b) = topo.EDGE_VERTICES[edge]
|
||||||
return vertex(a) to vertex(b)
|
return vertex(a) to vertex(b)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -62,8 +69,15 @@ class BoardLayout(
|
|||||||
*/
|
*/
|
||||||
fun portAnchor(edge: Int): Pt {
|
fun portAnchor(edge: Int): Pt {
|
||||||
val mid = edgeMidpoint(edge)
|
val mid = edgeMidpoint(edge)
|
||||||
val dx = mid.x - centreX
|
// Straight out from the middle of the island on the standard board; on a map of
|
||||||
val dy = mid.y - centreY
|
// islands, straight out from the land hex the harbour sits on.
|
||||||
|
val from = if (topo.EDGE_HEXES[edge].size == 1) {
|
||||||
|
Pt(centreX, centreY)
|
||||||
|
} else {
|
||||||
|
topo.EDGE_HEXES[edge].firstOrNull { topo.land[it] }?.let { hexCenter(it) } ?: Pt(centreX, centreY)
|
||||||
|
}
|
||||||
|
val dx = mid.x - from.x
|
||||||
|
val dy = mid.y - from.y
|
||||||
val length = sqrt(dx * dx + dy * dy).coerceAtLeast(1f)
|
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)
|
return Pt(mid.x + dx / length * radius * PORT_OFFSET, mid.y + dy / length * radius * PORT_OFFSET)
|
||||||
}
|
}
|
||||||
@@ -97,23 +111,29 @@ class BoardLayout(
|
|||||||
|
|
||||||
object CatanGeometry {
|
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. */
|
/** Empty space round the island, in hex radii, for the sea and the harbours. */
|
||||||
const val MARGIN = 1.75f
|
const val MARGIN = 1.75f
|
||||||
|
|
||||||
private val boardWidthInRadii = LATTICE_X_UNITS * SQRT3 / 2f + 2 * MARGIN
|
/** A Seafarers frame already ends in a ring of sea, so it needs almost none. */
|
||||||
private val boardHeightInRadii = LATTICE_Y_UNITS / 2f + 2 * MARGIN
|
private const val FRAME_MARGIN = 0.3f
|
||||||
|
|
||||||
|
private fun margin(topo: Topology) = if (topo.land.all { it }) MARGIN else FRAME_MARGIN
|
||||||
|
|
||||||
|
private fun widthInRadii(topo: Topology) =
|
||||||
|
(topo.lattice[1] - topo.lattice[0]) * SQRT3 / 2f + 2 * margin(topo)
|
||||||
|
|
||||||
|
private fun heightInRadii(topo: Topology) =
|
||||||
|
(topo.lattice[3] - topo.lattice[2]) / 2f + 2 * margin(topo)
|
||||||
|
|
||||||
/** Width ÷ height of the board including its margin, for sizing its box. */
|
/** Width ÷ height of the board including its margin, for sizing its box. */
|
||||||
val ASPECT: Float = boardWidthInRadii / boardHeightInRadii
|
val ASPECT: Float = widthInRadii(CatanBoard.base) / heightInRadii(CatanBoard.base)
|
||||||
|
|
||||||
|
fun aspect(topo: Topology): Float = widthInRadii(topo) / heightInRadii(topo)
|
||||||
|
|
||||||
/** The largest layout that fits [width] × [height] pixels. */
|
/** The largest layout that fits [width] × [height] pixels. */
|
||||||
fun fit(width: Float, height: Float): BoardLayout {
|
fun fit(width: Float, height: Float, topo: Topology = CatanBoard.base): BoardLayout {
|
||||||
val radius = minOf(width / boardWidthInRadii, height / boardHeightInRadii)
|
val radius = minOf(width / widthInRadii(topo), height / heightInRadii(topo))
|
||||||
return BoardLayout(width, height, radius)
|
return BoardLayout(width, height, radius, topo)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,474 @@
|
|||||||
|
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.gestures.detectDragGestures
|
||||||
|
import androidx.compose.foundation.gestures.detectTransformGestures
|
||||||
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
|
import androidx.compose.foundation.layout.Box
|
||||||
|
import androidx.compose.foundation.horizontalScroll
|
||||||
|
import androidx.compose.foundation.layout.Column
|
||||||
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
|
import androidx.compose.foundation.layout.height
|
||||||
|
import androidx.compose.foundation.layout.width
|
||||||
|
import androidx.compose.foundation.rememberScrollState
|
||||||
|
import androidx.compose.material3.Surface
|
||||||
|
import androidx.compose.foundation.layout.fillMaxSize
|
||||||
|
import androidx.compose.foundation.layout.Row
|
||||||
|
import androidx.compose.foundation.layout.padding
|
||||||
|
import androidx.compose.foundation.layout.size
|
||||||
|
import androidx.compose.foundation.shape.CircleShape
|
||||||
|
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||||
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.runtime.Composable
|
||||||
|
import androidx.compose.runtime.getValue
|
||||||
|
import androidx.compose.runtime.mutableFloatStateOf
|
||||||
|
import androidx.compose.runtime.mutableStateOf
|
||||||
|
import androidx.compose.runtime.remember
|
||||||
|
import androidx.compose.runtime.rememberUpdatedState
|
||||||
|
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.geometry.Offset
|
||||||
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import androidx.compose.ui.graphics.graphicsLayer
|
||||||
|
import androidx.compose.ui.input.pointer.pointerInput
|
||||||
|
import androidx.compose.ui.layout.LayoutCoordinates
|
||||||
|
import androidx.compose.ui.layout.onGloballyPositioned
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.unit.Dp
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import androidx.compose.ui.unit.sp
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The heads-up display pieces of the landscape Katan screen: the controls the
|
||||||
|
* Catan Universe match screen uses (see docs/RE-catan-universe.md), redrawn in
|
||||||
|
* 2D. Stateless, like everything in CatanPanels.kt: values in, lambdas out.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/** A round HUD button: a glyph or short word, optionally with a one-word caption. */
|
||||||
|
@Composable
|
||||||
|
fun HudRoundButton(
|
||||||
|
glyph: String,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
caption: String? = null,
|
||||||
|
enabled: Boolean = true,
|
||||||
|
primary: Boolean = false,
|
||||||
|
tint: Color = Color.Unspecified,
|
||||||
|
diameter: Dp = 56.dp,
|
||||||
|
onClick: () -> Unit,
|
||||||
|
) {
|
||||||
|
val container = when {
|
||||||
|
tint != Color.Unspecified -> tint
|
||||||
|
primary -> MaterialTheme.colorScheme.primary
|
||||||
|
else -> MaterialTheme.colorScheme.secondaryContainer
|
||||||
|
}
|
||||||
|
val ink = if (primary || tint != Color.Unspecified) Color.White else MaterialTheme.colorScheme.onSecondaryContainer
|
||||||
|
Column(modifier, horizontalAlignment = Alignment.CenterHorizontally) {
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.size(diameter)
|
||||||
|
.clip(CircleShape)
|
||||||
|
.background(container.copy(alpha = if (enabled) 1f else 0.35f))
|
||||||
|
.border(2.dp, Color(0x55000000), CircleShape)
|
||||||
|
.then(if (enabled) Modifier.clickable(onClick = onClick) else Modifier),
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) {
|
||||||
|
Text(glyph, color = ink.copy(alpha = if (enabled) 1f else 0.6f), fontSize = 18.sp, fontWeight = FontWeight.Bold)
|
||||||
|
}
|
||||||
|
// Always laid out, so the button column never changes height.
|
||||||
|
Text(caption ?: " ", fontSize = 10.sp, maxLines = 1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The left-hand build column: one icon per piece. **Drag one onto the board** and
|
||||||
|
* release over a lit spot to stage it; or tap to arm the board and tap a spot. The
|
||||||
|
* column reports pointer positions in window coordinates so the screen can find the
|
||||||
|
* spot under the finger whatever the board's zoom and pan.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun HudBuildColumn(
|
||||||
|
kinds: List<BuildKind>,
|
||||||
|
canBuild: Set<BuildKind>,
|
||||||
|
armed: BuildKind?,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
onTap: (BuildKind) -> Unit,
|
||||||
|
onDragStart: (BuildKind, Offset) -> Unit,
|
||||||
|
onDrag: (Offset) -> Unit,
|
||||||
|
onDragEnd: () -> Unit,
|
||||||
|
) {
|
||||||
|
Column(modifier, verticalArrangement = Arrangement.spacedBy(3.dp), horizontalAlignment = Alignment.CenterHorizontally) {
|
||||||
|
kinds.forEach { kind ->
|
||||||
|
BuildChip(kind, enabled = kind in canBuild, armed = armed == kind, onTap, onDragStart, onDrag, onDragEnd)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun BuildChip(
|
||||||
|
kind: BuildKind,
|
||||||
|
enabled: Boolean,
|
||||||
|
armed: Boolean,
|
||||||
|
onTap: (BuildKind) -> Unit,
|
||||||
|
onDragStart: (BuildKind, Offset) -> Unit,
|
||||||
|
onDrag: (Offset) -> Unit,
|
||||||
|
onDragEnd: () -> Unit,
|
||||||
|
) {
|
||||||
|
var coords by remember { mutableStateOf<LayoutCoordinates?>(null) }
|
||||||
|
val start by rememberUpdatedState(onDragStart)
|
||||||
|
val move by rememberUpdatedState(onDrag)
|
||||||
|
val end by rememberUpdatedState(onDragEnd)
|
||||||
|
val tap by rememberUpdatedState(onTap)
|
||||||
|
val shape = RoundedCornerShape(12.dp)
|
||||||
|
Column(horizontalAlignment = Alignment.CenterHorizontally) {
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.size(46.dp)
|
||||||
|
.clip(shape)
|
||||||
|
.background(
|
||||||
|
when {
|
||||||
|
armed -> MaterialTheme.colorScheme.primary
|
||||||
|
else -> MaterialTheme.colorScheme.secondaryContainer.copy(alpha = if (enabled) 1f else 0.35f)
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.border(2.dp, Color(0x55000000), shape)
|
||||||
|
.onGloballyPositioned { coords = it }
|
||||||
|
.pointerInput(enabled, kind) {
|
||||||
|
if (!enabled) return@pointerInput
|
||||||
|
detectDragGestures(
|
||||||
|
onDragStart = { local ->
|
||||||
|
coords?.localToWindow(local)?.let { start(kind, it) }
|
||||||
|
},
|
||||||
|
onDrag = { change, _ ->
|
||||||
|
change.consume()
|
||||||
|
coords?.localToWindow(change.position)?.let { move(it) }
|
||||||
|
},
|
||||||
|
onDragEnd = { end() },
|
||||||
|
onDragCancel = { end() },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
.then(if (enabled) Modifier.clickable { tap(kind) } else Modifier),
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) {
|
||||||
|
Text(
|
||||||
|
CatanHudGlyphs.of(kind),
|
||||||
|
fontSize = 22.sp,
|
||||||
|
color = if (armed) Color.White else MaterialTheme.colorScheme.onSecondaryContainer,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
Text(CatanHudGlyphs.label(kind), fontSize = 10.sp, maxLines = 1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Glyphs and captions of the build column. Kept apart so the art can be swapped for drawables. */
|
||||||
|
object CatanHudGlyphs {
|
||||||
|
fun of(kind: BuildKind): String = when (kind) {
|
||||||
|
BuildKind.ROAD -> "━"
|
||||||
|
BuildKind.SETTLEMENT -> "⌂"
|
||||||
|
BuildKind.CITY -> "▲"
|
||||||
|
BuildKind.WALL -> "▦"
|
||||||
|
BuildKind.KNIGHT -> "♞"
|
||||||
|
BuildKind.SHIP -> "⛵"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun label(kind: BuildKind): String = when (kind) {
|
||||||
|
BuildKind.ROAD -> CatanText.ROAD
|
||||||
|
BuildKind.SETTLEMENT -> CatanText.SETTLEMENT
|
||||||
|
BuildKind.CITY -> CatanText.CITY
|
||||||
|
BuildKind.WALL -> CatanText.WALL
|
||||||
|
BuildKind.KNIGHT -> CatanText.KNIGHT
|
||||||
|
BuildKind.SHIP -> CatanText.SHIP
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ✓ beside ✗: confirm or cancel a staged placement. Always laid out; enabled only while something is staged. */
|
||||||
|
@Composable
|
||||||
|
fun HudConfirmButtons(
|
||||||
|
staged: Boolean,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
onConfirm: () -> Unit,
|
||||||
|
onCancel: () -> Unit,
|
||||||
|
) {
|
||||||
|
Row(modifier, horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.Bottom) {
|
||||||
|
HudRoundButton("✓", caption = CatanText.CONFIRM_BUILD, enabled = staged, tint = Color(0xFF2E7D32), diameter = 48.dp, onClick = onConfirm)
|
||||||
|
HudRoundButton("✕", caption = CatanText.CANCEL_BUILD, enabled = staged, tint = Color(0xFFC62828), diameter = 48.dp, onClick = onCancel)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pan with one finger, pinch to zoom, like the Universe board camera. The content
|
||||||
|
* is drawn through a graphics layer, so taps inside it arrive already in the
|
||||||
|
* content's own coordinates and the board's hit-testing needs no changes.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun ZoomPanBox(
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
minScale: Float = 1f,
|
||||||
|
maxScale: Float = 3f,
|
||||||
|
content: @Composable () -> Unit,
|
||||||
|
) {
|
||||||
|
var scale by remember { mutableFloatStateOf(1f) }
|
||||||
|
var offset by remember { mutableStateOf(Offset.Zero) }
|
||||||
|
Box(
|
||||||
|
modifier = modifier
|
||||||
|
.clip(RoundedCornerShape(0.dp))
|
||||||
|
.pointerInput(Unit) {
|
||||||
|
detectTransformGestures { centroid, pan, zoom, _ ->
|
||||||
|
val newScale = (scale * zoom).coerceIn(minScale, maxScale)
|
||||||
|
val centre = Offset(size.width / 2f, size.height / 2f)
|
||||||
|
// The content point under the fingers stays under them while zooming; then pan.
|
||||||
|
val world = (centroid - centre - offset) / scale
|
||||||
|
val next = centroid - centre - world * newScale + pan
|
||||||
|
val maxX = size.width * (newScale - 1f) / 2f
|
||||||
|
val maxY = size.height * (newScale - 1f) / 2f
|
||||||
|
offset = Offset(next.x.coerceIn(-maxX, maxX), next.y.coerceIn(-maxY, maxY))
|
||||||
|
scale = newScale
|
||||||
|
}
|
||||||
|
},
|
||||||
|
) {
|
||||||
|
Box(
|
||||||
|
Modifier
|
||||||
|
.fillMaxSize()
|
||||||
|
.graphicsLayer {
|
||||||
|
scaleX = scale
|
||||||
|
scaleY = scale
|
||||||
|
translationX = offset.x
|
||||||
|
translationY = offset.y
|
||||||
|
},
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) { content() }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A small caption pill, for the drag hint and the staged-move text. */
|
||||||
|
@Composable
|
||||||
|
fun HudPill(text: String, modifier: Modifier = Modifier) {
|
||||||
|
Text(
|
||||||
|
text,
|
||||||
|
color = Color.White,
|
||||||
|
fontSize = 12.sp,
|
||||||
|
maxLines = 1,
|
||||||
|
modifier = modifier
|
||||||
|
.clip(RoundedCornerShape(50))
|
||||||
|
.background(Color(0xCC000000))
|
||||||
|
.padding(horizontal = 12.dp, vertical = 4.dp),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The landscape screen, laid out like the Catan Universe match view:
|
||||||
|
*
|
||||||
|
* ```
|
||||||
|
* ┌ player strip ───────────────────────────────────────────────┐
|
||||||
|
* │ prompt + dice │
|
||||||
|
* │ [build] the island (pinch / pan) [✓] [✕] │
|
||||||
|
* │ [column] │
|
||||||
|
* │ [log] ┌ your cards ┐ [buy][play] [⇄][●]│
|
||||||
|
* └─────────────┴────────────┴───────────────────────────────────┘
|
||||||
|
* ```
|
||||||
|
*
|
||||||
|
* Everything here is wiring around the existing panels; the island is handed in as [board].
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun CatanHud(
|
||||||
|
state: org.prolibertate.games.game.catan.CatanState,
|
||||||
|
seats: CatanSeats,
|
||||||
|
style: CatanStyle,
|
||||||
|
actions: CatanActions,
|
||||||
|
prompt: String,
|
||||||
|
notice: String?,
|
||||||
|
legal: List<org.prolibertate.games.game.catan.CatanMove>,
|
||||||
|
localSeat: Int,
|
||||||
|
targets: BoardTargets,
|
||||||
|
pointsOf: (Int) -> Int,
|
||||||
|
staged: org.prolibertate.games.game.catan.CatanMove?,
|
||||||
|
dragKind: BuildKind?,
|
||||||
|
dragAt: Offset?,
|
||||||
|
showLog: Boolean,
|
||||||
|
boardCoords: LayoutCoordinates?,
|
||||||
|
building: BuildKind?,
|
||||||
|
onBoardCoords: (LayoutCoordinates) -> Unit,
|
||||||
|
onToggleLog: () -> Unit,
|
||||||
|
onArm: (BuildKind) -> Unit,
|
||||||
|
onDragStart: (BuildKind, Offset) -> Unit,
|
||||||
|
onDrag: (Offset) -> Unit,
|
||||||
|
onDragEnd: () -> Unit,
|
||||||
|
onConfirm: () -> Unit,
|
||||||
|
onCancelStaged: () -> Unit,
|
||||||
|
onRoll: () -> Unit,
|
||||||
|
onEndTurn: () -> Unit,
|
||||||
|
onEndFreeRoads: () -> Unit,
|
||||||
|
onEndSmith: () -> Unit,
|
||||||
|
onRepickSetup: () -> Unit,
|
||||||
|
onBuyCard: () -> Unit,
|
||||||
|
onPlayCard: () -> Unit,
|
||||||
|
onTrade: () -> Unit,
|
||||||
|
onImprove: () -> Unit,
|
||||||
|
onProgress: () -> Unit,
|
||||||
|
board: @Composable (Modifier) -> Unit,
|
||||||
|
) {
|
||||||
|
Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||||
|
HudPlayerStrip(state, seats, pointsOf, style)
|
||||||
|
// Cities & Knights: the ship and the improvement levels are as much part
|
||||||
|
// of the game as the scores, so they sit with them rather than in a panel
|
||||||
|
// this layout does not have room for.
|
||||||
|
if (state.isCk) CatanBarbarians(state, Modifier.padding(horizontal = 8.dp), style)
|
||||||
|
Box(Modifier.weight(1f).fillMaxWidth()) {
|
||||||
|
// The island fills the whole area; controls float over its sea margin.
|
||||||
|
ZoomPanBox(Modifier.fillMaxSize().padding(start = 64.dp, end = 64.dp, top = 30.dp, bottom = 44.dp)) {
|
||||||
|
board(Modifier.onGloballyPositioned(onBoardCoords))
|
||||||
|
}
|
||||||
|
|
||||||
|
// What is going on, and the dice. Two lines, always.
|
||||||
|
Row(
|
||||||
|
Modifier.align(Alignment.TopCenter).padding(horizontal = 64.dp)
|
||||||
|
.clip(RoundedCornerShape(10.dp))
|
||||||
|
.background(MaterialTheme.colorScheme.surface.copy(alpha = 0.8f))
|
||||||
|
.padding(horizontal = 8.dp, vertical = 1.dp),
|
||||||
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
|
) {
|
||||||
|
Text(
|
||||||
|
text = notice ?: prompt,
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
color = if (notice != null) MaterialTheme.colorScheme.error else Color.Unspecified,
|
||||||
|
minLines = 2,
|
||||||
|
maxLines = 2,
|
||||||
|
modifier = Modifier.weight(1f),
|
||||||
|
)
|
||||||
|
CatanDice(state.lastDice, ck = state.isCk, event = state.ck?.eventDie)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Left: pieces to drag onto the island.
|
||||||
|
HudBuildColumn(
|
||||||
|
kinds = actions.buildKinds,
|
||||||
|
canBuild = actions.canBuild,
|
||||||
|
armed = building,
|
||||||
|
modifier = Modifier.align(Alignment.CenterStart).padding(start = 6.dp),
|
||||||
|
onTap = onArm,
|
||||||
|
onDragStart = onDragStart,
|
||||||
|
onDrag = onDrag,
|
||||||
|
onDragEnd = onDragEnd,
|
||||||
|
)
|
||||||
|
|
||||||
|
// Right, middle: the card actions.
|
||||||
|
Column(
|
||||||
|
Modifier.align(Alignment.CenterEnd).padding(end = 6.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||||
|
horizontalAlignment = Alignment.CenterHorizontally,
|
||||||
|
) {
|
||||||
|
if (actions.ck) {
|
||||||
|
HudRoundButton("⬆", caption = CatanText.IMPROVE, enabled = actions.canImprove, diameter = 44.dp, onClick = onImprove)
|
||||||
|
HudRoundButton("🂠", caption = CatanText.CARDS_SHORT, enabled = actions.canPlayProgress, diameter = 44.dp, onClick = onProgress)
|
||||||
|
} else {
|
||||||
|
HudRoundButton("+", caption = CatanText.BUY_SHORT, enabled = actions.canBuyCard, diameter = 44.dp, onClick = onBuyCard)
|
||||||
|
HudRoundButton("🂠", caption = CatanText.CARDS_SHORT, enabled = actions.canPlayCard, diameter = 44.dp, onClick = onPlayCard)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bottom centre: your cards.
|
||||||
|
Box(
|
||||||
|
Modifier.align(Alignment.BottomCenter).padding(bottom = 4.dp, start = 80.dp, end = 270.dp)
|
||||||
|
.clip(RoundedCornerShape(12.dp))
|
||||||
|
.background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f))
|
||||||
|
.horizontalScroll(rememberScrollState())
|
||||||
|
.padding(6.dp),
|
||||||
|
) { CatanHand(state, localSeat) }
|
||||||
|
|
||||||
|
// Bottom left: the log.
|
||||||
|
Column(Modifier.align(Alignment.BottomStart).padding(start = 6.dp, bottom = 4.dp)) {
|
||||||
|
if (showLog) {
|
||||||
|
Surface(
|
||||||
|
modifier = Modifier.padding(bottom = 6.dp),
|
||||||
|
shape = RoundedCornerShape(12.dp),
|
||||||
|
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.92f),
|
||||||
|
tonalElevation = 4.dp,
|
||||||
|
) {
|
||||||
|
CatanLog(state, Modifier.padding(8.dp).height(150.dp).width(260.dp))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
HudRoundButton("☰", caption = CatanText.LOG_BUTTON, diameter = 40.dp, onClick = onToggleLog)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bottom right: place / cancel a lined-up piece, trade, and the turn button.
|
||||||
|
Row(
|
||||||
|
Modifier.align(Alignment.BottomEnd).padding(end = 6.dp, bottom = 4.dp),
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
|
verticalAlignment = Alignment.Bottom,
|
||||||
|
) {
|
||||||
|
HudConfirmButtons(staged = staged != null, onConfirm = onConfirm, onCancel = onCancelStaged)
|
||||||
|
HudRoundButton("⇄", caption = CatanText.TRADE, enabled = actions.canTrade, diameter = 48.dp, onClick = onTrade)
|
||||||
|
PrimaryTurnButton(actions, onRoll, onEndTurn, onEndFreeRoads, onEndSmith, onRepickSetup)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (dragKind != null && dragAt == null) HudPill(CatanText.DRAG_HINT, Modifier.align(Alignment.TopCenter))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The one big button: roll, end the turn, finish roads, or step back from a setup choice. */
|
||||||
|
@Composable
|
||||||
|
private fun PrimaryTurnButton(
|
||||||
|
actions: CatanActions,
|
||||||
|
onRoll: () -> Unit,
|
||||||
|
onEndTurn: () -> Unit,
|
||||||
|
onEndFreeRoads: () -> Unit,
|
||||||
|
onEndSmith: () -> Unit,
|
||||||
|
onRepickSetup: () -> Unit,
|
||||||
|
) {
|
||||||
|
val (glyph, caption, enabled, click) = when {
|
||||||
|
actions.canRoll -> Quad("🎲", CatanText.ROLL_SHORT, true, onRoll)
|
||||||
|
actions.canEndFreeRoads -> Quad("✔", CatanText.DONE_SHORT, true, onEndFreeRoads)
|
||||||
|
actions.canEndSmith -> Quad("✔", CatanText.DONE_SHORT, true, onEndSmith)
|
||||||
|
actions.canRepickSetup -> Quad("↺", CatanText.CANCEL, true, onRepickSetup)
|
||||||
|
else -> Quad("➜", CatanText.END_SHORT, actions.canEndTurn, onEndTurn)
|
||||||
|
}
|
||||||
|
HudRoundButton(glyph, caption = caption, enabled = enabled, primary = true, diameter = 72.dp, onClick = click)
|
||||||
|
}
|
||||||
|
|
||||||
|
private data class Quad(val glyph: String, val caption: String, val enabled: Boolean, val click: () -> Unit)
|
||||||
|
|
||||||
|
/** Everyone's colour, name, points and card count in one thin row across the top. */
|
||||||
|
@Composable
|
||||||
|
private fun HudPlayerStrip(
|
||||||
|
state: org.prolibertate.games.game.catan.CatanState,
|
||||||
|
seats: CatanSeats,
|
||||||
|
pointsOf: (Int) -> Int,
|
||||||
|
style: CatanStyle,
|
||||||
|
) {
|
||||||
|
Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp, vertical = 2.dp), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
(0 until state.playerCount).forEach { seat ->
|
||||||
|
val onTurn = seat == state.turn
|
||||||
|
val shape = RoundedCornerShape(10.dp)
|
||||||
|
Row(
|
||||||
|
Modifier.weight(1f)
|
||||||
|
.clip(shape)
|
||||||
|
.background(MaterialTheme.colorScheme.surfaceVariant)
|
||||||
|
.border(if (onTurn) 2.dp else 1.dp, if (onTurn) MaterialTheme.colorScheme.primary else Color(0x33000000), shape)
|
||||||
|
.padding(horizontal = 8.dp, vertical = 4.dp),
|
||||||
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
|
) {
|
||||||
|
Box(
|
||||||
|
Modifier.size(14.dp).clip(CircleShape).background(style.seats[seat]).border(1.dp, style.pieceOutline, CircleShape),
|
||||||
|
)
|
||||||
|
Text(seats.label(seat), fontSize = 12.sp, fontWeight = FontWeight.Bold, maxLines = 1, modifier = Modifier.weight(1f))
|
||||||
|
// Trade, politics, science: the three improvement levels.
|
||||||
|
if (state.isCk) {
|
||||||
|
Text(
|
||||||
|
text = org.prolibertate.games.game.catan.Track.entries.joinToString(" ") {
|
||||||
|
"${it.name.first()}${org.prolibertate.games.game.catan.CatanCk.improvement(state, seat, it)}"
|
||||||
|
},
|
||||||
|
fontSize = 12.sp,
|
||||||
|
maxLines = 1,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
Text("${pointsOf(seat)} VP · ${state.resourceCount(seat)}🂠", fontSize = 12.sp, maxLines = 1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -2,45 +2,114 @@ package org.prolibertate.games.ui.game.catan
|
|||||||
|
|
||||||
import org.prolibertate.games.game.catan.AcceptCounter
|
import org.prolibertate.games.game.catan.AcceptCounter
|
||||||
import org.prolibertate.games.game.catan.AcceptTrade
|
import org.prolibertate.games.game.catan.AcceptTrade
|
||||||
|
import org.prolibertate.games.game.catan.ActivateKnight
|
||||||
import org.prolibertate.games.game.catan.BuildCity
|
import org.prolibertate.games.game.catan.BuildCity
|
||||||
import org.prolibertate.games.game.catan.BuildRoad
|
import org.prolibertate.games.game.catan.BuildRoad
|
||||||
|
import org.prolibertate.games.game.catan.BuildShip
|
||||||
|
import org.prolibertate.games.game.catan.MovePirate
|
||||||
|
import org.prolibertate.games.game.catan.MoveShip
|
||||||
|
import org.prolibertate.games.game.catan.Topology
|
||||||
import org.prolibertate.games.game.catan.BuildSettlement
|
import org.prolibertate.games.game.catan.BuildSettlement
|
||||||
|
import org.prolibertate.games.game.catan.BuildWall
|
||||||
import org.prolibertate.games.game.catan.BuyDevCard
|
import org.prolibertate.games.game.catan.BuyDevCard
|
||||||
|
import org.prolibertate.games.game.catan.BuyImprovement
|
||||||
import org.prolibertate.games.game.catan.CatanBoard
|
import org.prolibertate.games.game.catan.CatanBoard
|
||||||
import org.prolibertate.games.game.catan.CatanMove
|
import org.prolibertate.games.game.catan.CatanMove
|
||||||
import org.prolibertate.games.game.catan.CatanPhase
|
import org.prolibertate.games.game.catan.CatanPhase
|
||||||
import org.prolibertate.games.game.catan.CatanRules
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
import org.prolibertate.games.game.catan.CatanState
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.ChaseRobber
|
||||||
|
import org.prolibertate.games.game.catan.Chore
|
||||||
import org.prolibertate.games.game.catan.CounterTrade
|
import org.prolibertate.games.game.catan.CounterTrade
|
||||||
import org.prolibertate.games.game.catan.DeclineTrade
|
import org.prolibertate.games.game.catan.DeclineTrade
|
||||||
import org.prolibertate.games.game.catan.DevCard
|
import org.prolibertate.games.game.catan.DevCard
|
||||||
import org.prolibertate.games.game.catan.DevCardType
|
import org.prolibertate.games.game.catan.DevCardType
|
||||||
import org.prolibertate.games.game.catan.Discard
|
import org.prolibertate.games.game.catan.Discard
|
||||||
import org.prolibertate.games.game.catan.EndFreeRoads
|
import org.prolibertate.games.game.catan.EndFreeRoads
|
||||||
|
import org.prolibertate.games.game.catan.EndSmith
|
||||||
import org.prolibertate.games.game.catan.EndTurn
|
import org.prolibertate.games.game.catan.EndTurn
|
||||||
|
import org.prolibertate.games.game.catan.CounterGoods
|
||||||
|
import org.prolibertate.games.game.catan.GoodsBankTrade
|
||||||
|
import org.prolibertate.games.game.catan.GoodsCounter
|
||||||
|
import org.prolibertate.games.game.catan.Good
|
||||||
import org.prolibertate.games.game.catan.HexCoord
|
import org.prolibertate.games.game.catan.HexCoord
|
||||||
|
import org.prolibertate.games.game.catan.HireKnight
|
||||||
import org.prolibertate.games.game.catan.MaritimeTrade
|
import org.prolibertate.games.game.catan.MaritimeTrade
|
||||||
|
import org.prolibertate.games.game.catan.MoveKnight
|
||||||
import org.prolibertate.games.game.catan.MoveRobber
|
import org.prolibertate.games.game.catan.MoveRobber
|
||||||
|
import org.prolibertate.games.game.catan.OfferGoods
|
||||||
import org.prolibertate.games.game.catan.OfferTrade
|
import org.prolibertate.games.game.catan.OfferTrade
|
||||||
|
import org.prolibertate.games.game.catan.PickGold
|
||||||
|
import org.prolibertate.games.game.catan.PillageCity
|
||||||
|
import org.prolibertate.games.game.catan.PlaceKnight
|
||||||
|
import org.prolibertate.games.game.catan.PlaceMetropolis
|
||||||
import org.prolibertate.games.game.catan.TradeCounter
|
import org.prolibertate.games.game.catan.TradeCounter
|
||||||
import org.prolibertate.games.game.catan.PlayKnight
|
import org.prolibertate.games.game.catan.PlayKnight
|
||||||
import org.prolibertate.games.game.catan.PlayMonopoly
|
import org.prolibertate.games.game.catan.PlayMonopoly
|
||||||
|
import org.prolibertate.games.game.catan.PlayProgress
|
||||||
import org.prolibertate.games.game.catan.PlayRoadBuilding
|
import org.prolibertate.games.game.catan.PlayRoadBuilding
|
||||||
import org.prolibertate.games.game.catan.PlayYearOfPlenty
|
import org.prolibertate.games.game.catan.PlayYearOfPlenty
|
||||||
|
import org.prolibertate.games.game.catan.ProgressCard
|
||||||
|
import org.prolibertate.games.game.catan.ProgressType
|
||||||
|
import org.prolibertate.games.game.catan.PromoteKnight
|
||||||
|
import org.prolibertate.games.game.catan.RelocateKnight
|
||||||
|
import org.prolibertate.games.game.catan.RemoveKnight
|
||||||
import org.prolibertate.games.game.catan.Resource
|
import org.prolibertate.games.game.catan.Resource
|
||||||
import org.prolibertate.games.game.catan.RollDice
|
import org.prolibertate.games.game.catan.RollDice
|
||||||
import org.prolibertate.games.game.catan.SetupPlace
|
import org.prolibertate.games.game.catan.SetupPlace
|
||||||
|
import org.prolibertate.games.game.catan.Track
|
||||||
|
|
||||||
/** What a player can ask to build by tapping the board. */
|
/**
|
||||||
enum class BuildKind { ROAD, SETTLEMENT, CITY }
|
* What a player can ask to build by tapping the board. Wall and Knight exist
|
||||||
|
* only in Cities & Knights; the base game's build menu lists the first three.
|
||||||
|
*/
|
||||||
|
enum class BuildKind {
|
||||||
|
ROAD, SETTLEMENT, CITY, WALL, KNIGHT,
|
||||||
|
|
||||||
/** The parts of the board the player may tap right now. Everything else is inert. */
|
/** Seafarers: a ship, laid on a sea edge. */
|
||||||
|
SHIP;
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val BASE: List<BuildKind> = listOf(ROAD, SETTLEMENT, CITY)
|
||||||
|
|
||||||
|
/** Seafarers adds the ship, listed after the road it sails beside. */
|
||||||
|
val SEAFARERS: List<BuildKind> = listOf(ROAD, SHIP, SETTLEMENT, CITY)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The parts of the board the player may tap right now. Everything else is inert.
|
||||||
|
* [knights] are crossings holding one of the player's own knights that can do
|
||||||
|
* something this turn: tapping one opens its menu.
|
||||||
|
*/
|
||||||
data class BoardTargets(
|
data class BoardTargets(
|
||||||
val vertices: Set<Int> = emptySet(),
|
val vertices: Set<Int> = emptySet(),
|
||||||
val edges: Set<Int> = emptySet(),
|
val edges: Set<Int> = emptySet(),
|
||||||
val hexes: Set<Int> = emptySet(),
|
val hexes: Set<Int> = emptySet(),
|
||||||
|
val knights: Set<Int> = emptySet(),
|
||||||
|
/** Seafarers: the player's ships that can sail this turn, tapped to pick one up. */
|
||||||
|
val ships: Set<Int> = emptySet(),
|
||||||
|
/** The player's other knights: tappable for their menu, but with nothing to do, so not ringed. */
|
||||||
|
val idleKnights: Set<Int> = emptySet(),
|
||||||
) {
|
) {
|
||||||
val isEmpty: Boolean get() = vertices.isEmpty() && edges.isEmpty() && hexes.isEmpty()
|
val isEmpty: Boolean
|
||||||
|
get() = vertices.isEmpty() && edges.isEmpty() && hexes.isEmpty() && knights.isEmpty() &&
|
||||||
|
idleKnights.isEmpty() && ships.isEmpty()
|
||||||
|
|
||||||
|
/** Every crossing a tap can land on. */
|
||||||
|
val tappableVertices: Set<Int> get() = vertices + knights + idleKnights
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A progress card that is waiting for a tap on the board: [plays] are every play
|
||||||
|
* of it the engine accepts, and the player's tap picks one. [firstHex] is the
|
||||||
|
* first of the two hexes an Inventor swaps, once tapped.
|
||||||
|
*/
|
||||||
|
data class ArmedCard(val kind: ProgressType, val plays: List<PlayProgress>, val firstHex: Int? = null)
|
||||||
|
|
||||||
|
/** One progress card in the local player's hand, and the plays the engine allows for it. */
|
||||||
|
data class ProgressInHand(val card: ProgressCard, val plays: List<PlayProgress>) {
|
||||||
|
val playable: Boolean get() = plays.isNotEmpty()
|
||||||
}
|
}
|
||||||
|
|
||||||
/** What a tap on the board amounts to. */
|
/** What a tap on the board amounts to. */
|
||||||
@@ -54,8 +123,17 @@ sealed interface TapOutcome {
|
|||||||
/** Setup: remember this settlement; the road that goes with it is tapped next. */
|
/** Setup: remember this settlement; the road that goes with it is tapped next. */
|
||||||
data class PickSetupVertex(val vertex: Int) : TapOutcome
|
data class PickSetupVertex(val vertex: Int) : TapOutcome
|
||||||
|
|
||||||
/** The robber's hex has more than one possible victim: ask which. */
|
/** The robber's (or the pirate's) hex has more than one possible victim: ask which. */
|
||||||
data class PickRobberVictim(val hex: HexCoord, val victims: List<Int>) : TapOutcome
|
data class PickRobberVictim(val hex: HexCoord, val victims: List<Int>, val pirate: Boolean = false) : TapOutcome
|
||||||
|
|
||||||
|
/** Seafarers: one of the player's ships was tapped; its destination is tapped next. */
|
||||||
|
data class PickShip(val edge: Int) : TapOutcome
|
||||||
|
|
||||||
|
/** One of the player's own knights was tapped: open its menu. */
|
||||||
|
data class PickKnight(val vertex: Int) : TapOutcome
|
||||||
|
|
||||||
|
/** An Inventor's first hex was tapped; the second completes the swap. */
|
||||||
|
data class PickFirstHex(val hex: Int) : TapOutcome
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -81,6 +159,43 @@ data class DevCardInHand(val card: DevCard, val plays: List<CatanMove>) {
|
|||||||
*/
|
*/
|
||||||
object CatanInteraction {
|
object CatanInteraction {
|
||||||
|
|
||||||
|
// --- Staged placements and drag-to-build ------------------------------------
|
||||||
|
|
||||||
|
/** A place on the board a dragged piece is over: one crossing or one edge. */
|
||||||
|
data class Spot(val vertex: Int? = null, val edge: Int? = null)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The spot a finger at [at] (board pixels) is nearest to, among [targets]. [reach] is
|
||||||
|
* generous (fingers cover what they point at), and edges are only offered when no
|
||||||
|
* crossing is lit, matching what a tap would do.
|
||||||
|
*/
|
||||||
|
fun snap(layout: BoardLayout, targets: BoardTargets, at: Pt, reach: Float): Spot? = when {
|
||||||
|
targets.tappableVertices.isNotEmpty() ->
|
||||||
|
layout.nearestVertex(at, reach, targets.tappableVertices)?.let { Spot(vertex = it) }
|
||||||
|
|
||||||
|
targets.edges.isNotEmpty() -> layout.nearestEdge(at, reach, targets.edges)?.let { Spot(edge = it) }
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The move a build tap or drop would make, if it is a placement that waits for ✓. */
|
||||||
|
fun stageable(outcome: TapOutcome, building: BuildKind?): CatanMove? {
|
||||||
|
if (building == null || outcome !is TapOutcome.Submit) return null
|
||||||
|
return outcome.move.takeIf {
|
||||||
|
it is BuildRoad || it is BuildShip || it is BuildSettlement || it is BuildCity || it is BuildWall || it is HireKnight
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Where a staged move sits on the board, for drawing its ghost. */
|
||||||
|
fun spotOf(move: CatanMove?): Spot = when (move) {
|
||||||
|
is BuildRoad -> Spot(edge = move.edge)
|
||||||
|
is BuildShip -> Spot(edge = move.edge)
|
||||||
|
is BuildSettlement -> Spot(vertex = move.vertex)
|
||||||
|
is BuildCity -> Spot(vertex = move.vertex)
|
||||||
|
is BuildWall -> Spot(vertex = move.vertex)
|
||||||
|
is HireKnight -> Spot(vertex = move.vertex)
|
||||||
|
else -> Spot()
|
||||||
|
}
|
||||||
|
|
||||||
// --- Board ---------------------------------------------------------------
|
// --- Board ---------------------------------------------------------------
|
||||||
|
|
||||||
fun targets(
|
fun targets(
|
||||||
@@ -88,6 +203,12 @@ object CatanInteraction {
|
|||||||
legal: List<CatanMove>,
|
legal: List<CatanMove>,
|
||||||
building: BuildKind?,
|
building: BuildKind?,
|
||||||
setupVertex: Int?,
|
setupVertex: Int?,
|
||||||
|
movingKnight: Int? = null,
|
||||||
|
armed: ArmedCard? = null,
|
||||||
|
/** The local seat, so its sleeping knights can be tapped for their menu too. */
|
||||||
|
localSeat: Int? = null,
|
||||||
|
/** Seafarers: the ship that has been picked up and is waiting for a destination. */
|
||||||
|
movingShip: Int? = null,
|
||||||
): BoardTargets {
|
): BoardTargets {
|
||||||
val setup = legal.filterIsInstance<SetupPlace>()
|
val setup = legal.filterIsInstance<SetupPlace>()
|
||||||
if (setup.isNotEmpty()) {
|
if (setup.isNotEmpty()) {
|
||||||
@@ -99,30 +220,220 @@ object CatanInteraction {
|
|||||||
}
|
}
|
||||||
|
|
||||||
val robber = legal.filterIsInstance<MoveRobber>()
|
val robber = legal.filterIsInstance<MoveRobber>()
|
||||||
if (robber.isNotEmpty()) {
|
val pirate = legal.filterIsInstance<MovePirate>()
|
||||||
return BoardTargets(hexes = robber.mapNotNull { CatanBoard.hexIndex[it.hex] }.toSet())
|
if (robber.isNotEmpty() || pirate.isNotEmpty()) {
|
||||||
|
return BoardTargets(
|
||||||
|
hexes = (robber.map { it.hex } + pirate.map { it.hex }).mapNotNull { state.topo.hexIndex[it] }.toSet(),
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Cities & Knights: answers to a queued chore are taps on the board.
|
||||||
|
val chore = choreVertices(legal)
|
||||||
|
if (chore.isNotEmpty()) return BoardTargets(vertices = chore)
|
||||||
|
|
||||||
val roads = legal.filterIsInstance<BuildRoad>().map { it.edge }.toSet()
|
val roads = legal.filterIsInstance<BuildRoad>().map { it.edge }.toSet()
|
||||||
if (state.phase == CatanPhase.FREE_ROADS) return BoardTargets(edges = roads)
|
val ships = legal.filterIsInstance<BuildShip>().map { it.edge }.toSet()
|
||||||
|
if (state.phase == CatanPhase.FREE_ROADS) return BoardTargets(edges = roads + ships)
|
||||||
|
|
||||||
|
if (movingShip != null) {
|
||||||
|
return BoardTargets(
|
||||||
|
edges = legal.filterIsInstance<MoveShip>().filter { it.from == movingShip }.map { it.to }.toSet(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (armed != null) return armedTargets(armed)
|
||||||
|
|
||||||
|
if (movingKnight != null) {
|
||||||
|
return BoardTargets(
|
||||||
|
vertices = legal.filterIsInstance<MoveKnight>().filter { it.from == movingKnight }.map { it.to }.toSet(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
return when (building) {
|
return when (building) {
|
||||||
BuildKind.ROAD -> BoardTargets(edges = roads)
|
BuildKind.ROAD -> BoardTargets(edges = roads)
|
||||||
|
BuildKind.SHIP -> BoardTargets(edges = ships)
|
||||||
BuildKind.SETTLEMENT ->
|
BuildKind.SETTLEMENT ->
|
||||||
BoardTargets(vertices = legal.filterIsInstance<BuildSettlement>().map { it.vertex }.toSet())
|
BoardTargets(vertices = legal.filterIsInstance<BuildSettlement>().map { it.vertex }.toSet())
|
||||||
|
|
||||||
BuildKind.CITY ->
|
BuildKind.CITY ->
|
||||||
BoardTargets(vertices = legal.filterIsInstance<BuildCity>().map { it.vertex }.toSet())
|
BoardTargets(vertices = legal.filterIsInstance<BuildCity>().map { it.vertex }.toSet())
|
||||||
|
|
||||||
null -> BoardTargets()
|
BuildKind.WALL ->
|
||||||
|
BoardTargets(vertices = legal.filterIsInstance<BuildWall>().map { it.vertex }.toSet())
|
||||||
|
|
||||||
|
BuildKind.KNIGHT ->
|
||||||
|
BoardTargets(vertices = legal.filterIsInstance<HireKnight>().map { it.vertex }.toSet())
|
||||||
|
|
||||||
|
null -> {
|
||||||
|
val ready = knightsWithActions(legal)
|
||||||
|
val mine = if (localSeat != null && legal.isNotEmpty()) {
|
||||||
|
state.ck?.knights?.filter { it.owner == localSeat }?.map { it.vertex }?.toSet().orEmpty()
|
||||||
|
} else {
|
||||||
|
emptySet()
|
||||||
|
}
|
||||||
|
BoardTargets(
|
||||||
|
knights = ready,
|
||||||
|
idleKnights = mine - ready,
|
||||||
|
ships = legal.filterIsInstance<MoveShip>().map { it.from }.toSet(),
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The crossings a queued chore is asking the player to tap, from the legal list. */
|
||||||
|
private fun choreVertices(legal: List<CatanMove>): Set<Int> = buildSet {
|
||||||
|
legal.forEach { move ->
|
||||||
|
when (move) {
|
||||||
|
is PillageCity -> add(move.vertex)
|
||||||
|
is PlaceMetropolis -> add(move.vertex)
|
||||||
|
is RelocateKnight -> add(move.to)
|
||||||
|
is RemoveKnight -> add(move.vertex)
|
||||||
|
is PlaceKnight -> add(move.vertex)
|
||||||
|
else -> Unit
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// A Smith's promotions are knights to tap, while the chore is open.
|
||||||
|
if (legal.any { it is EndSmith }) {
|
||||||
|
legal.filterIsInstance<PromoteKnight>().forEach { add(it.vertex) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun choreMove(legal: List<CatanMove>, vertex: Int): CatanMove? = legal.firstOrNull { move ->
|
||||||
|
when (move) {
|
||||||
|
is PillageCity -> move.vertex == vertex
|
||||||
|
is PlaceMetropolis -> move.vertex == vertex
|
||||||
|
is RelocateKnight -> move.to == vertex
|
||||||
|
is RemoveKnight -> move.vertex == vertex
|
||||||
|
is PlaceKnight -> move.vertex == vertex
|
||||||
|
is PromoteKnight -> legal.any { it is EndSmith } && move.vertex == vertex
|
||||||
|
else -> false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Cities & Knights: knights ---------------------------------------------
|
||||||
|
|
||||||
|
/** Crossings of the player's knights that have an action available. */
|
||||||
|
fun knightsWithActions(legal: List<CatanMove>): Set<Int> = buildSet {
|
||||||
|
legal.forEach { move ->
|
||||||
|
when (move) {
|
||||||
|
is ActivateKnight -> add(move.vertex)
|
||||||
|
is MoveKnight -> add(move.from)
|
||||||
|
is ChaseRobber -> add(move.vertex)
|
||||||
|
is PromoteKnight -> if (legal.none { it is EndSmith }) add(move.vertex)
|
||||||
|
else -> Unit
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** What the knight on [vertex] can do right now, in the order its menu lists them. */
|
||||||
|
fun knightActions(legal: List<CatanMove>, vertex: Int): List<CatanMove> =
|
||||||
|
legal.filter { move ->
|
||||||
|
when (move) {
|
||||||
|
is ActivateKnight -> move.vertex == vertex
|
||||||
|
is PromoteKnight -> move.vertex == vertex && legal.none { it is EndSmith }
|
||||||
|
is ChaseRobber -> move.vertex == vertex
|
||||||
|
else -> false
|
||||||
|
}
|
||||||
|
} + listOfNotNull(legal.firstOrNull { it is MoveKnight && it.from == vertex })
|
||||||
|
|
||||||
|
fun canEndSmith(legal: List<CatanMove>): Boolean = legal.any { it is EndSmith }
|
||||||
|
|
||||||
|
// --- Cities & Knights: progress cards --------------------------------------
|
||||||
|
|
||||||
|
/** [seat]'s progress cards, each with the plays the engine currently allows. */
|
||||||
|
fun progressHand(state: CatanState, seat: Int, legal: List<CatanMove>): List<ProgressInHand> =
|
||||||
|
state.ck?.progressHands?.getOrNull(seat).orEmpty().map { card ->
|
||||||
|
ProgressInHand(card, legal.filterIsInstance<PlayProgress>().filter { it.card == card.id })
|
||||||
|
}.sortedWith(compareBy({ it.card.kind.track.ordinal }, { it.card.kind.ordinal }, { it.card.id }))
|
||||||
|
|
||||||
|
/** The cards that are played by tapping the board, not by choosing in a dialog. */
|
||||||
|
val BOARD_CARDS: Set<ProgressType> = setOf(
|
||||||
|
ProgressType.ENGINEER, ProgressType.MEDICINE, ProgressType.MERCHANT,
|
||||||
|
ProgressType.DIPLOMAT, ProgressType.INTRIGUE, ProgressType.INVENTOR,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun armedTargets(armed: ArmedCard): BoardTargets = when (armed.kind) {
|
||||||
|
ProgressType.ENGINEER, ProgressType.MEDICINE, ProgressType.INTRIGUE ->
|
||||||
|
BoardTargets(vertices = armed.plays.mapNotNull { it.vertex }.toSet())
|
||||||
|
|
||||||
|
ProgressType.DIPLOMAT -> BoardTargets(edges = armed.plays.mapNotNull { it.edge }.toSet())
|
||||||
|
|
||||||
|
ProgressType.MERCHANT -> BoardTargets(hexes = armed.plays.mapNotNull { it.hexA }.toSet())
|
||||||
|
|
||||||
|
ProgressType.INVENTOR -> {
|
||||||
|
val first = armed.firstHex
|
||||||
|
val all = armed.plays.flatMap { listOfNotNull(it.hexA, it.hexB) }.toSet()
|
||||||
|
if (first == null) {
|
||||||
|
BoardTargets(hexes = all)
|
||||||
|
} else {
|
||||||
|
BoardTargets(
|
||||||
|
hexes = armed.plays
|
||||||
|
.filter { it.hexA == first || it.hexB == first }
|
||||||
|
.flatMap { listOfNotNull(it.hexA, it.hexB) }
|
||||||
|
.filter { it != first }
|
||||||
|
.toSet(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> BoardTargets()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The improvement tracks the player can buy a level of right now. */
|
||||||
|
fun improvable(legal: List<CatanMove>): Set<Track> =
|
||||||
|
legal.filterIsInstance<BuyImprovement>().map { it.track }.toSet()
|
||||||
|
|
||||||
|
// --- Cities & Knights: goods ----------------------------------------------
|
||||||
|
|
||||||
|
/** The gold pick that names exactly [selection], if the engine allows it. */
|
||||||
|
fun goldMove(legal: List<CatanMove>, selection: List<Resource>): PickGold? {
|
||||||
|
val want = selection.groupingBy { it }.eachCount()
|
||||||
|
return legal.filterIsInstance<PickGold>().firstOrNull { it.cards.groupingBy { c -> c }.eachCount() == want }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** How many cards the gold pick on offer must name. */
|
||||||
|
fun goldCount(legal: List<CatanMove>): Int = legal.filterIsInstance<PickGold>().firstOrNull()?.cards?.size ?: 0
|
||||||
|
|
||||||
|
/** Bank trades on offer in Cities & Knights: what can be given, and for what. */
|
||||||
|
fun goodsBankTrades(legal: List<CatanMove>): Map<Good, List<Good>> =
|
||||||
|
legal.filterIsInstance<GoodsBankTrade>()
|
||||||
|
.groupBy({ it.give }, { it.get })
|
||||||
|
.mapValues { (_, gets) -> gets.sortedBy { it.ordinal } }
|
||||||
|
.toSortedMap(compareBy<Good> { it.ordinal })
|
||||||
|
|
||||||
|
fun goodsOfferAllowed(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
to: Int?,
|
||||||
|
give: List<Good>,
|
||||||
|
get: List<Good>,
|
||||||
|
): Boolean = give.isNotEmpty() && get.isNotEmpty() &&
|
||||||
|
CatanRules.isLegalMove(state, seat, OfferGoods(to, give, get))
|
||||||
|
|
||||||
|
/** Whether [seat] may answer the goods offer on the table with [give] for [get]. */
|
||||||
|
fun goodsCounterAllowed(state: CatanState, seat: Int, give: List<Good>, get: List<Good>): Boolean =
|
||||||
|
give.isNotEmpty() && get.isNotEmpty() &&
|
||||||
|
CatanRules.isLegalMove(state, seat, CounterGoods(give, get))
|
||||||
|
|
||||||
|
/** The goods counter-offers the offerer may take right now, in the order they came in. */
|
||||||
|
fun goodsCounterChoices(state: CatanState, legal: List<CatanMove>): List<GoodsCounter> {
|
||||||
|
val takeable = legal.filterIsInstance<AcceptCounter>().map { it.seat }.toSet()
|
||||||
|
return state.ck?.goodsOffer?.counters.orEmpty().filter { it.by in takeable }
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The chore at the front of the queue, if the table is waiting on one. */
|
||||||
|
fun chore(state: CatanState): Chore? =
|
||||||
|
if (state.phase == CatanPhase.CHORE) state.ck?.chores?.firstOrNull() else null
|
||||||
|
|
||||||
fun onVertexTap(
|
fun onVertexTap(
|
||||||
vertex: Int,
|
vertex: Int,
|
||||||
legal: List<CatanMove>,
|
legal: List<CatanMove>,
|
||||||
building: BuildKind?,
|
building: BuildKind?,
|
||||||
setupVertex: Int?,
|
setupVertex: Int?,
|
||||||
|
movingKnight: Int? = null,
|
||||||
|
armed: ArmedCard? = null,
|
||||||
|
/** The local player's knights, which can be tapped for their menu even with nothing to do. */
|
||||||
|
ownKnights: Set<Int> = emptySet(),
|
||||||
): TapOutcome {
|
): TapOutcome {
|
||||||
val setup = legal.filterIsInstance<SetupPlace>()
|
val setup = legal.filterIsInstance<SetupPlace>()
|
||||||
if (setup.isNotEmpty()) {
|
if (setup.isNotEmpty()) {
|
||||||
@@ -134,10 +445,27 @@ object CatanInteraction {
|
|||||||
TapOutcome.Ignored
|
TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
choreMove(legal, vertex)?.let { return TapOutcome.Submit(it) }
|
||||||
|
|
||||||
|
if (armed != null) {
|
||||||
|
val play = armed.plays.firstOrNull { it.vertex == vertex } ?: return TapOutcome.Ignored
|
||||||
|
return if (play in legal) TapOutcome.Submit(play) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
if (movingKnight != null) {
|
||||||
|
val move = MoveKnight(movingKnight, vertex)
|
||||||
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
|
||||||
val move: CatanMove = when (building) {
|
val move: CatanMove = when (building) {
|
||||||
BuildKind.SETTLEMENT -> BuildSettlement(vertex)
|
BuildKind.SETTLEMENT -> BuildSettlement(vertex)
|
||||||
BuildKind.CITY -> BuildCity(vertex)
|
BuildKind.CITY -> BuildCity(vertex)
|
||||||
else -> return TapOutcome.Ignored
|
BuildKind.WALL -> BuildWall(vertex)
|
||||||
|
BuildKind.KNIGHT -> HireKnight(vertex)
|
||||||
|
else -> return if (building == null && (vertex in knightsWithActions(legal) || vertex in ownKnights)) {
|
||||||
|
TapOutcome.PickKnight(vertex)
|
||||||
|
} else {
|
||||||
|
TapOutcome.Ignored
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
@@ -147,27 +475,81 @@ object CatanInteraction {
|
|||||||
legal: List<CatanMove>,
|
legal: List<CatanMove>,
|
||||||
building: BuildKind?,
|
building: BuildKind?,
|
||||||
setupVertex: Int?,
|
setupVertex: Int?,
|
||||||
|
armed: ArmedCard? = null,
|
||||||
|
/** Seafarers: the ship picked up and waiting for a destination. */
|
||||||
|
movingShip: Int? = null,
|
||||||
): TapOutcome {
|
): TapOutcome {
|
||||||
if (legal.any { it is SetupPlace }) {
|
if (legal.any { it is SetupPlace }) {
|
||||||
if (setupVertex == null) return TapOutcome.Ignored
|
if (setupVertex == null) return TapOutcome.Ignored
|
||||||
val move = SetupPlace(setupVertex, edge)
|
val move = SetupPlace(setupVertex, edge)
|
||||||
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
// Free roads need no build mode; a paid road does.
|
if (armed != null) {
|
||||||
val canBuild = building == BuildKind.ROAD || legal.any { it is EndFreeRoads }
|
val play = armed.plays.firstOrNull { it.edge == edge } ?: return TapOutcome.Ignored
|
||||||
|
return if (play in legal) TapOutcome.Submit(play) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
if (movingShip != null) {
|
||||||
|
val move = MoveShip(movingShip, edge)
|
||||||
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
// Free roads (and free ships) need no build mode; a paid one does.
|
||||||
|
val free = legal.any { it is EndFreeRoads }
|
||||||
|
if (building == BuildKind.SHIP || (free && BuildShip(edge) in legal)) {
|
||||||
|
val move = BuildShip(edge)
|
||||||
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
if (building == null && !free) {
|
||||||
|
// Nothing armed: tapping one of your own ships that can sail picks it up.
|
||||||
|
return if (legal.any { it is MoveShip && it.from == edge }) TapOutcome.PickShip(edge) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
val canBuild = building == BuildKind.ROAD || free
|
||||||
if (!canBuild) return TapOutcome.Ignored
|
if (!canBuild) return TapOutcome.Ignored
|
||||||
val move = BuildRoad(edge)
|
val move = BuildRoad(edge)
|
||||||
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
return if (move in legal) TapOutcome.Submit(move) else TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
|
|
||||||
fun onHexTap(hex: Int, legal: List<CatanMove>): TapOutcome {
|
fun onHexTap(
|
||||||
val coord = CatanBoard.HEXES.getOrNull(hex) ?: return TapOutcome.Ignored
|
hex: Int,
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
armed: ArmedCard? = null,
|
||||||
|
/** The board the hex index belongs to (the standard island unless the game is Seafarers). */
|
||||||
|
topo: Topology = CatanBoard.base,
|
||||||
|
): TapOutcome {
|
||||||
|
if (armed != null) return onArmedHexTap(hex, legal, armed)
|
||||||
|
val coord = topo.HEXES.getOrNull(hex) ?: return TapOutcome.Ignored
|
||||||
val moves = legal.filterIsInstance<MoveRobber>().filter { it.hex == coord }
|
val moves = legal.filterIsInstance<MoveRobber>().filter { it.hex == coord }
|
||||||
|
val pirates = legal.filterIsInstance<MovePirate>().filter { it.hex == coord }
|
||||||
return when {
|
return when {
|
||||||
moves.isEmpty() -> TapOutcome.Ignored
|
moves.isNotEmpty() -> if (moves.size == 1) {
|
||||||
moves.size == 1 -> TapOutcome.Submit(moves.first())
|
TapOutcome.Submit(moves.first())
|
||||||
else -> TapOutcome.PickRobberVictim(coord, moves.mapNotNull { it.victim })
|
} else {
|
||||||
|
TapOutcome.PickRobberVictim(coord, moves.mapNotNull { it.victim })
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pirates.isNotEmpty() -> if (pirates.size == 1) {
|
||||||
|
TapOutcome.Submit(pirates.first())
|
||||||
|
} else {
|
||||||
|
TapOutcome.PickRobberVictim(coord, pirates.mapNotNull { it.victim }, pirate = true)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun onArmedHexTap(hex: Int, legal: List<CatanMove>, armed: ArmedCard): TapOutcome {
|
||||||
|
if (armed.kind == ProgressType.INVENTOR) {
|
||||||
|
val first = armed.firstHex ?: return if (hex in armedTargets(armed).hexes) {
|
||||||
|
TapOutcome.PickFirstHex(hex)
|
||||||
|
} else {
|
||||||
|
TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
val play = armed.plays.firstOrNull {
|
||||||
|
(it.hexA == first && it.hexB == hex) || (it.hexA == hex && it.hexB == first)
|
||||||
|
} ?: return TapOutcome.Ignored
|
||||||
|
return if (play in legal) TapOutcome.Submit(play) else TapOutcome.Ignored
|
||||||
|
}
|
||||||
|
val play = armed.plays.firstOrNull { it.hexA == hex } ?: return TapOutcome.Ignored
|
||||||
|
return if (play in legal) TapOutcome.Submit(play) else TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- Action bar ------------------------------------------------------------
|
// --- Action bar ------------------------------------------------------------
|
||||||
@@ -188,7 +570,7 @@ object CatanInteraction {
|
|||||||
}
|
}
|
||||||
val total = state.lastDice.sum()
|
val total = state.lastDice.sum()
|
||||||
if (total == 7) return emptySet()
|
if (total == 7) return emptySet()
|
||||||
return (0 until CatanBoard.HEX_COUNT)
|
return (0 until state.topo.HEX_COUNT)
|
||||||
.filter { state.numbers[it] == total && it != state.robber }
|
.filter { state.numbers[it] == total && it != state.robber }
|
||||||
.toSet()
|
.toSet()
|
||||||
}
|
}
|
||||||
@@ -201,8 +583,11 @@ object CatanInteraction {
|
|||||||
|
|
||||||
fun canBuild(legal: List<CatanMove>): Set<BuildKind> = buildSet {
|
fun canBuild(legal: List<CatanMove>): Set<BuildKind> = buildSet {
|
||||||
if (legal.any { it is BuildRoad }) add(BuildKind.ROAD)
|
if (legal.any { it is BuildRoad }) add(BuildKind.ROAD)
|
||||||
|
if (legal.any { it is BuildShip }) add(BuildKind.SHIP)
|
||||||
if (legal.any { it is BuildSettlement }) add(BuildKind.SETTLEMENT)
|
if (legal.any { it is BuildSettlement }) add(BuildKind.SETTLEMENT)
|
||||||
if (legal.any { it is BuildCity }) add(BuildKind.CITY)
|
if (legal.any { it is BuildCity }) add(BuildKind.CITY)
|
||||||
|
if (legal.any { it is BuildWall }) add(BuildKind.WALL)
|
||||||
|
if (legal.any { it is HireKnight }) add(BuildKind.KNIGHT)
|
||||||
}
|
}
|
||||||
|
|
||||||
fun tradeResponses(legal: List<CatanMove>): Pair<Boolean, Boolean> =
|
fun tradeResponses(legal: List<CatanMove>): Pair<Boolean, Boolean> =
|
||||||
|
|||||||
@@ -40,10 +40,15 @@ import androidx.compose.ui.text.style.TextAlign
|
|||||||
import androidx.compose.ui.text.style.TextOverflow
|
import androidx.compose.ui.text.style.TextOverflow
|
||||||
import androidx.compose.ui.unit.dp
|
import androidx.compose.ui.unit.dp
|
||||||
import androidx.compose.ui.unit.sp
|
import androidx.compose.ui.unit.sp
|
||||||
|
import org.prolibertate.games.game.catan.BuildingType
|
||||||
|
import org.prolibertate.games.game.catan.CatanCk
|
||||||
import org.prolibertate.games.game.catan.CatanPhase
|
import org.prolibertate.games.game.catan.CatanPhase
|
||||||
import org.prolibertate.games.game.catan.CatanRules
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
import org.prolibertate.games.game.catan.CatanState
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.EventFace
|
||||||
|
import org.prolibertate.games.game.catan.Good
|
||||||
import org.prolibertate.games.game.catan.Resource
|
import org.prolibertate.games.game.catan.Resource
|
||||||
|
import org.prolibertate.games.game.catan.Track
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Stateless building blocks for the Katan screen.
|
* Stateless building blocks for the Katan screen.
|
||||||
@@ -102,7 +107,52 @@ fun ResourceTile(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** The local player's cards: one tile per resource, in a row that wraps. */
|
/**
|
||||||
|
* One card type — a resource or a commodity — as a coloured tile with its count.
|
||||||
|
* Cities & Knights hands, discards and trades use this so commodities look the
|
||||||
|
* same everywhere.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun GoodTile(
|
||||||
|
good: Good,
|
||||||
|
count: Int,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
selected: Boolean = false,
|
||||||
|
enabled: Boolean = true,
|
||||||
|
style: CatanStyle = LocalCatanStyle.current,
|
||||||
|
onClick: (() -> Unit)? = null,
|
||||||
|
) {
|
||||||
|
val resource = good.resource
|
||||||
|
if (resource != null) {
|
||||||
|
ResourceTile(resource, count, modifier, selected, enabled, style, onClick)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
val commodity = good.commodity!!
|
||||||
|
val shape = RoundedCornerShape(10.dp)
|
||||||
|
val ink = style.commodityInk.getValue(commodity)
|
||||||
|
Column(
|
||||||
|
modifier = modifier
|
||||||
|
.defaultMinSize(minWidth = 56.dp)
|
||||||
|
.clip(shape)
|
||||||
|
.background(style.commodity.getValue(commodity).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 = ink, fontWeight = FontWeight.Bold, fontSize = 20.sp)
|
||||||
|
Text(text = CatanText.good(good), color = ink, fontSize = 11.sp, maxLines = 1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The local player's cards: one tile per resource, and in Cities & Knights one
|
||||||
|
* per commodity as well, in a row that wraps.
|
||||||
|
*/
|
||||||
@OptIn(ExperimentalLayoutApi::class)
|
@OptIn(ExperimentalLayoutApi::class)
|
||||||
@Composable
|
@Composable
|
||||||
fun CatanHand(
|
fun CatanHand(
|
||||||
@@ -115,11 +165,16 @@ fun CatanHand(
|
|||||||
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
verticalArrangement = Arrangement.spacedBy(6.dp),
|
verticalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
) {
|
) {
|
||||||
|
if (state.isCk) {
|
||||||
|
val held = CatanCk.goodsOf(state, seat)
|
||||||
|
Good.entries.forEach { good -> GoodTile(good, held[good] ?: 0) }
|
||||||
|
} else {
|
||||||
Resource.entries.forEach { resource ->
|
Resource.entries.forEach { resource ->
|
||||||
ResourceTile(resource, state.resources[seat][resource] ?: 0)
|
ResourceTile(resource, state.resources[seat][resource] ?: 0)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// Players
|
// Players
|
||||||
@@ -175,6 +230,41 @@ fun CatanPlayerCard(
|
|||||||
CardLine(seats.label(seat), MaterialTheme.typography.labelLarge, FontWeight.Bold)
|
CardLine(seats.label(seat), MaterialTheme.typography.labelLarge, FontWeight.Bold)
|
||||||
}
|
}
|
||||||
CardLine("$points VP", MaterialTheme.typography.titleMedium, FontWeight.Bold)
|
CardLine("$points VP", MaterialTheme.typography.titleMedium, FontWeight.Bold)
|
||||||
|
val ck = state.ck
|
||||||
|
if (ck != null) {
|
||||||
|
val cards = CatanCk.goodsCount(state, seat)
|
||||||
|
val strength = CatanCk.strength(state, seat)
|
||||||
|
if (compact) {
|
||||||
|
CardLine("$cards cards · ⚔$strength", MaterialTheme.typography.bodySmall)
|
||||||
|
} else {
|
||||||
|
CardLine("$cards cards · ${ck.progressCounts[seat]} progress", MaterialTheme.typography.bodySmall)
|
||||||
|
CardLine(
|
||||||
|
"⚔ ${CatanCk.knightsOf(state, seat).size} · str $strength · " +
|
||||||
|
"Road ${CatanRules.longestRoadFor(state, seat)}",
|
||||||
|
MaterialTheme.typography.bodySmall,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
// Trade, politics, science: the three improvement levels.
|
||||||
|
CardLine(
|
||||||
|
Track.entries.joinToString(" ") { "${it.name.first()}${CatanCk.improvement(state, seat, it)}" },
|
||||||
|
MaterialTheme.typography.bodySmall,
|
||||||
|
color = Color.Unspecified,
|
||||||
|
)
|
||||||
|
val ckAwards = buildList {
|
||||||
|
if (state.longestRoadOwner == seat) add(if (compact) "Road" else "Longest road")
|
||||||
|
ck.metropolises.forEach { (track, at) ->
|
||||||
|
if (at.seat == seat) add(if (compact) track.name.first().toString() else "${CatanText.track(track)} metropolis")
|
||||||
|
}
|
||||||
|
if (ck.merchant?.seat == seat) add("Merchant")
|
||||||
|
}
|
||||||
|
CardLine(
|
||||||
|
text = ckAwards.joinToString(" · ").ifEmpty { BLANK },
|
||||||
|
style = MaterialTheme.typography.labelSmall,
|
||||||
|
weight = FontWeight.Bold,
|
||||||
|
color = MaterialTheme.colorScheme.primary,
|
||||||
|
)
|
||||||
|
return@Column
|
||||||
|
}
|
||||||
if (compact) {
|
if (compact) {
|
||||||
CardLine("${state.resourceCount(seat)} cards", MaterialTheme.typography.bodySmall)
|
CardLine("${state.resourceCount(seat)} cards", MaterialTheme.typography.bodySmall)
|
||||||
} else {
|
} else {
|
||||||
@@ -226,21 +316,36 @@ private fun CardLine(
|
|||||||
// Dice
|
// Dice
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
/** The two dice as last rolled, with their total. Blank until the first roll. */
|
/**
|
||||||
|
* The two dice as last rolled, with their total. Blank until the first roll. In
|
||||||
|
* Cities & Knights the dice are yellow and red (the red one decides progress
|
||||||
|
* cards) and a third, the event die, shows a ship or a coloured city gate.
|
||||||
|
*/
|
||||||
@Composable
|
@Composable
|
||||||
fun CatanDice(dice: List<Int>, modifier: Modifier = Modifier) {
|
fun CatanDice(
|
||||||
|
dice: List<Int>,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
ck: Boolean = false,
|
||||||
|
event: EventFace? = null,
|
||||||
|
style: CatanStyle = LocalCatanStyle.current,
|
||||||
|
) {
|
||||||
Row(
|
Row(
|
||||||
modifier = modifier,
|
modifier = modifier,
|
||||||
verticalAlignment = Alignment.CenterVertically,
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
) {
|
) {
|
||||||
val shown = if (dice.size == 2) dice else listOf(null, null)
|
val shown = if (dice.size == 2) dice else listOf(null, null)
|
||||||
shown.forEach { value ->
|
shown.forEachIndexed { index, value ->
|
||||||
|
val face = when {
|
||||||
|
!ck -> Color.White
|
||||||
|
index == 0 -> Color(0xFFFFF176)
|
||||||
|
else -> Color(0xFFEF9A9A)
|
||||||
|
}
|
||||||
Box(
|
Box(
|
||||||
modifier = Modifier
|
modifier = Modifier
|
||||||
.size(36.dp)
|
.size(36.dp)
|
||||||
.clip(RoundedCornerShape(8.dp))
|
.clip(RoundedCornerShape(8.dp))
|
||||||
.background(Color.White)
|
.background(face)
|
||||||
.border(1.dp, Color(0x55000000), RoundedCornerShape(8.dp)),
|
.border(1.dp, Color(0x55000000), RoundedCornerShape(8.dp)),
|
||||||
contentAlignment = Alignment.Center,
|
contentAlignment = Alignment.Center,
|
||||||
) {
|
) {
|
||||||
@@ -253,6 +358,31 @@ fun CatanDice(dice: List<Int>, modifier: Modifier = Modifier) {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if (ck) {
|
||||||
|
val gate = when (event) {
|
||||||
|
EventFace.TRADE -> style.track.getValue(Track.TRADE)
|
||||||
|
EventFace.POLITICS -> style.track.getValue(Track.POLITICS)
|
||||||
|
EventFace.SCIENCE -> style.track.getValue(Track.SCIENCE)
|
||||||
|
EventFace.SHIP -> style.barbarian
|
||||||
|
null -> Color(0x33000000)
|
||||||
|
}
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.size(width = 52.dp, height = 36.dp)
|
||||||
|
.clip(RoundedCornerShape(8.dp))
|
||||||
|
.background(gate)
|
||||||
|
.border(1.dp, Color(0x55000000), RoundedCornerShape(8.dp)),
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) {
|
||||||
|
Text(
|
||||||
|
text = if (event == EventFace.SHIP) "⛵ Ship" else CatanText.event(event),
|
||||||
|
color = if (event == EventFace.TRADE) Color(0xFF1C1B1F) else Color.White,
|
||||||
|
fontWeight = FontWeight.Bold,
|
||||||
|
fontSize = 11.sp,
|
||||||
|
maxLines = 1,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
// Always drawn ("= –" before the first roll) so the row never changes width.
|
// Always drawn ("= –" before the first roll) so the row never changes width.
|
||||||
Text(
|
Text(
|
||||||
text = if (dice.size == 2) "= ${dice.sum()}" else "= –",
|
text = if (dice.size == 2) "= ${dice.sum()}" else "= –",
|
||||||
@@ -262,6 +392,48 @@ fun CatanDice(dice: List<Int>, modifier: Modifier = Modifier) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Cities & Knights: how close the barbarians are, and how the cities on the
|
||||||
|
* island compare with the knights standing ready. **Fixed height**, like every
|
||||||
|
* other strip around the board.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun CatanBarbarians(state: CatanState, modifier: Modifier = Modifier, style: CatanStyle = LocalCatanStyle.current) {
|
||||||
|
val ck = state.ck ?: return
|
||||||
|
val cities = state.buildings.count { it?.type == BuildingType.CITY }
|
||||||
|
val defence = (0 until state.playerCount).sumOf { CatanCk.strength(state, it) }
|
||||||
|
Row(
|
||||||
|
modifier = modifier.fillMaxWidth().height(24.dp),
|
||||||
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
|
horizontalArrangement = Arrangement.spacedBy(6.dp),
|
||||||
|
) {
|
||||||
|
Text("⛵", fontSize = 14.sp)
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(2.dp), modifier = Modifier.weight(1f)) {
|
||||||
|
// The ship starts seven steps out and lands when the last box fills.
|
||||||
|
val sailed = BARBARIAN_STEPS_DISPLAY - ck.barbarians
|
||||||
|
for (i in 0 until BARBARIAN_STEPS_DISPLAY) {
|
||||||
|
Box(
|
||||||
|
modifier = Modifier
|
||||||
|
.weight(1f)
|
||||||
|
.height(10.dp)
|
||||||
|
.clip(RoundedCornerShape(3.dp))
|
||||||
|
.background(if (i < sailed) style.barbarian else Color(0x33000000)),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
val verdict = if (defence >= cities) "holds" else "falls"
|
||||||
|
Text(
|
||||||
|
text = "${CatanText.barbarianSteps(ck.barbarians)} · knights $defence v. $cities cities ($verdict)",
|
||||||
|
style = MaterialTheme.typography.labelSmall,
|
||||||
|
maxLines = 1,
|
||||||
|
overflow = TextOverflow.Ellipsis,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Steps shown on the barbarian strip: the engine's seven. */
|
||||||
|
private const val BARBARIAN_STEPS_DISPLAY = org.prolibertate.games.game.catan.BARBARIAN_STEPS
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// Actions
|
// Actions
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -278,6 +450,14 @@ data class CatanActions(
|
|||||||
val canEndFreeRoads: Boolean = false,
|
val canEndFreeRoads: Boolean = false,
|
||||||
/** A setup settlement is chosen and a different one may still be picked. */
|
/** A setup settlement is chosen and a different one may still be picked. */
|
||||||
val canRepickSetup: Boolean = false,
|
val canRepickSetup: Boolean = false,
|
||||||
|
/** Which kinds the Build menu lists: three in the base game, five in Cities & Knights. */
|
||||||
|
val buildKinds: List<BuildKind> = BuildKind.BASE,
|
||||||
|
/** Cities & Knights: the table plays the expansion, so the bar shows its buttons instead. */
|
||||||
|
val ck: Boolean = false,
|
||||||
|
val canImprove: Boolean = false,
|
||||||
|
val canPlayProgress: Boolean = false,
|
||||||
|
val progressCount: Int = 0,
|
||||||
|
val canEndSmith: Boolean = false,
|
||||||
)
|
)
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -305,6 +485,9 @@ fun CatanActionBar(
|
|||||||
modifier: Modifier = Modifier,
|
modifier: Modifier = Modifier,
|
||||||
/** Small screens: fold Road / Settlement / City into one "Build" button with a menu. */
|
/** Small screens: fold Road / Settlement / City into one "Build" button with a menu. */
|
||||||
compact: Boolean = false,
|
compact: Boolean = false,
|
||||||
|
onImprove: () -> Unit = {},
|
||||||
|
onProgress: () -> Unit = {},
|
||||||
|
onEndSmith: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
Column(modifier = modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(modifier = modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
Row(
|
Row(
|
||||||
@@ -315,6 +498,7 @@ fun CatanActionBar(
|
|||||||
if (actions.canRoll) Button(onClick = onRoll) { Text(CatanText.ROLL) }
|
if (actions.canRoll) Button(onClick = onRoll) { Text(CatanText.ROLL) }
|
||||||
if (actions.canRepickSetup) OutlinedButton(onClick = onRepickSetup) { Text(CatanText.CANCEL) }
|
if (actions.canRepickSetup) OutlinedButton(onClick = onRepickSetup) { Text(CatanText.CANCEL) }
|
||||||
if (actions.canEndFreeRoads) Button(onClick = onEndFreeRoads) { Text(CatanText.STOP_ROADS) }
|
if (actions.canEndFreeRoads) Button(onClick = onEndFreeRoads) { Text(CatanText.STOP_ROADS) }
|
||||||
|
if (actions.canEndSmith) Button(onClick = onEndSmith) { Text(CatanText.STOP_SMITH) }
|
||||||
if (actions.canEndTurn) Button(onClick = onEndTurn) { Text(CatanText.END_TURN) }
|
if (actions.canEndTurn) Button(onClick = onEndTurn) { Text(CatanText.END_TURN) }
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -323,19 +507,28 @@ fun CatanActionBar(
|
|||||||
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
verticalArrangement = Arrangement.spacedBy(8.dp),
|
verticalArrangement = Arrangement.spacedBy(8.dp),
|
||||||
) {
|
) {
|
||||||
if (compact) {
|
if (compact || actions.ck) {
|
||||||
BuildMenuButton(actions, onBuild)
|
BuildMenuButton(actions, onBuild)
|
||||||
} else {
|
} else {
|
||||||
BuildButton(BuildKind.ROAD, CatanText.ROAD, CatanText.ROAD_COST, actions, onBuild)
|
BuildButton(BuildKind.ROAD, CatanText.ROAD, CatanText.ROAD_COST, actions, onBuild)
|
||||||
BuildButton(BuildKind.SETTLEMENT, CatanText.SETTLEMENT, CatanText.SETTLEMENT_COST, actions, onBuild)
|
BuildButton(BuildKind.SETTLEMENT, CatanText.SETTLEMENT, CatanText.SETTLEMENT_COST, actions, onBuild)
|
||||||
BuildButton(BuildKind.CITY, CatanText.CITY, CatanText.CITY_COST, actions, onBuild)
|
BuildButton(BuildKind.CITY, CatanText.CITY, CatanText.CITY_COST, actions, onBuild)
|
||||||
}
|
}
|
||||||
|
if (actions.ck) {
|
||||||
|
OutlinedButton(onClick = onImprove, enabled = actions.canImprove) {
|
||||||
|
LabelWithCost(CatanText.IMPROVE, CatanText.NO_COST)
|
||||||
|
}
|
||||||
|
OutlinedButton(onClick = onProgress, enabled = actions.canPlayProgress) {
|
||||||
|
LabelWithCost(CatanText.CARDS_BUTTON, "${actions.progressCount} held")
|
||||||
|
}
|
||||||
|
} else {
|
||||||
OutlinedButton(onClick = onBuyCard, enabled = actions.canBuyCard) {
|
OutlinedButton(onClick = onBuyCard, enabled = actions.canBuyCard) {
|
||||||
LabelWithCost(CatanText.BUY_CARD, CatanText.DEV_COST)
|
LabelWithCost(CatanText.BUY_CARD, CatanText.DEV_COST)
|
||||||
}
|
}
|
||||||
OutlinedButton(onClick = onPlayCard, enabled = actions.canPlayCard) {
|
OutlinedButton(onClick = onPlayCard, enabled = actions.canPlayCard) {
|
||||||
LabelWithCost(CatanText.PLAY_CARD, CatanText.NO_COST)
|
LabelWithCost(CatanText.PLAY_CARD, CatanText.NO_COST)
|
||||||
}
|
}
|
||||||
|
}
|
||||||
OutlinedButton(onClick = onTrade, enabled = actions.canTrade) {
|
OutlinedButton(onClick = onTrade, enabled = actions.canTrade) {
|
||||||
LabelWithCost(CatanText.TRADE, CatanText.NO_COST)
|
LabelWithCost(CatanText.TRADE, CatanText.NO_COST)
|
||||||
}
|
}
|
||||||
@@ -384,7 +577,7 @@ private fun BuildMenuButton(actions: CatanActions, onBuild: (BuildKind?) -> Unit
|
|||||||
OutlinedButton(onClick = { open = true }, enabled = anyEnabled) { label() }
|
OutlinedButton(onClick = { open = true }, enabled = anyEnabled) { label() }
|
||||||
}
|
}
|
||||||
DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
|
DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
|
||||||
for (kind in BuildKind.entries) {
|
for (kind in actions.buildKinds) {
|
||||||
DropdownMenuItem(
|
DropdownMenuItem(
|
||||||
text = { LabelWithCost(buildLabel(kind), buildCost(kind)) },
|
text = { LabelWithCost(buildLabel(kind), buildCost(kind)) },
|
||||||
enabled = kind in actions.canBuild,
|
enabled = kind in actions.canBuild,
|
||||||
@@ -402,12 +595,18 @@ private fun buildLabel(kind: BuildKind): String = when (kind) {
|
|||||||
BuildKind.ROAD -> CatanText.ROAD
|
BuildKind.ROAD -> CatanText.ROAD
|
||||||
BuildKind.SETTLEMENT -> CatanText.SETTLEMENT
|
BuildKind.SETTLEMENT -> CatanText.SETTLEMENT
|
||||||
BuildKind.CITY -> CatanText.CITY
|
BuildKind.CITY -> CatanText.CITY
|
||||||
|
BuildKind.WALL -> CatanText.WALL
|
||||||
|
BuildKind.KNIGHT -> CatanText.KNIGHT
|
||||||
|
BuildKind.SHIP -> CatanText.SHIP
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun buildCost(kind: BuildKind): String = when (kind) {
|
private fun buildCost(kind: BuildKind): String = when (kind) {
|
||||||
BuildKind.ROAD -> CatanText.ROAD_COST
|
BuildKind.ROAD -> CatanText.ROAD_COST
|
||||||
BuildKind.SETTLEMENT -> CatanText.SETTLEMENT_COST
|
BuildKind.SETTLEMENT -> CatanText.SETTLEMENT_COST
|
||||||
BuildKind.CITY -> CatanText.CITY_COST
|
BuildKind.CITY -> CatanText.CITY_COST
|
||||||
|
BuildKind.WALL -> CatanText.WALL_COST
|
||||||
|
BuildKind.KNIGHT -> CatanText.KNIGHT_COST
|
||||||
|
BuildKind.SHIP -> CatanText.SHIP_COST_TEXT
|
||||||
}
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
|
|||||||
@@ -9,6 +9,15 @@ import androidx.compose.foundation.layout.Row
|
|||||||
import androidx.compose.foundation.layout.fillMaxSize
|
import androidx.compose.foundation.layout.fillMaxSize
|
||||||
import androidx.compose.foundation.layout.fillMaxWidth
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
import androidx.compose.foundation.layout.height
|
import androidx.compose.foundation.layout.height
|
||||||
|
import androidx.compose.foundation.layout.padding
|
||||||
|
import androidx.compose.foundation.horizontalScroll
|
||||||
|
import androidx.compose.foundation.background
|
||||||
|
import androidx.compose.material3.Surface
|
||||||
|
import androidx.compose.ui.geometry.Offset
|
||||||
|
import androidx.compose.ui.layout.LayoutCoordinates
|
||||||
|
import androidx.compose.ui.layout.onGloballyPositioned
|
||||||
|
import androidx.compose.ui.unit.IntSize
|
||||||
|
import org.prolibertate.games.game.catan.BuildRoad
|
||||||
import androidx.compose.foundation.rememberScrollState
|
import androidx.compose.foundation.rememberScrollState
|
||||||
import androidx.compose.foundation.verticalScroll
|
import androidx.compose.foundation.verticalScroll
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
@@ -22,24 +31,38 @@ import androidx.compose.runtime.getValue
|
|||||||
import androidx.compose.runtime.mutableStateOf
|
import androidx.compose.runtime.mutableStateOf
|
||||||
import androidx.compose.runtime.remember
|
import androidx.compose.runtime.remember
|
||||||
import androidx.compose.runtime.setValue
|
import androidx.compose.runtime.setValue
|
||||||
|
import androidx.compose.ui.platform.LocalConfiguration
|
||||||
import androidx.compose.ui.Alignment
|
import androidx.compose.ui.Alignment
|
||||||
import androidx.compose.ui.Modifier
|
import androidx.compose.ui.Modifier
|
||||||
import androidx.compose.ui.graphics.Color
|
import androidx.compose.ui.graphics.Color
|
||||||
import androidx.compose.ui.text.style.TextOverflow
|
import androidx.compose.ui.text.style.TextOverflow
|
||||||
import androidx.compose.ui.unit.dp
|
import androidx.compose.ui.unit.dp
|
||||||
import org.prolibertate.games.game.catan.AcceptTrade
|
import org.prolibertate.games.game.catan.AcceptTrade
|
||||||
|
import org.prolibertate.games.game.catan.AqueductChore
|
||||||
import org.prolibertate.games.game.catan.BuyDevCard
|
import org.prolibertate.games.game.catan.BuyDevCard
|
||||||
|
import org.prolibertate.games.game.catan.CatanCk
|
||||||
import org.prolibertate.games.game.catan.CatanMove
|
import org.prolibertate.games.game.catan.CatanMove
|
||||||
import org.prolibertate.games.game.catan.CatanPhase
|
import org.prolibertate.games.game.catan.CatanPhase
|
||||||
import org.prolibertate.games.game.catan.CatanRules
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
import org.prolibertate.games.game.catan.CatanState
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
import org.prolibertate.games.game.catan.DeclineTrade
|
import org.prolibertate.games.game.catan.DeclineTrade
|
||||||
|
import org.prolibertate.games.game.catan.DiscardChore
|
||||||
|
import org.prolibertate.games.game.catan.DiscardGoods
|
||||||
|
import org.prolibertate.games.game.catan.DropProgress
|
||||||
|
import org.prolibertate.games.game.catan.DropProgressChore
|
||||||
import org.prolibertate.games.game.catan.DismissCounters
|
import org.prolibertate.games.game.catan.DismissCounters
|
||||||
import org.prolibertate.games.game.catan.EndFreeRoads
|
import org.prolibertate.games.game.catan.EndFreeRoads
|
||||||
|
import org.prolibertate.games.game.catan.EndSmith
|
||||||
import org.prolibertate.games.game.catan.EndTurn
|
import org.prolibertate.games.game.catan.EndTurn
|
||||||
|
import org.prolibertate.games.game.catan.GiveChore
|
||||||
|
import org.prolibertate.games.game.catan.GiveGoods
|
||||||
|
import org.prolibertate.games.game.catan.MoveKnight
|
||||||
|
import org.prolibertate.games.game.catan.MoveShip
|
||||||
import org.prolibertate.games.game.catan.MoveRobber
|
import org.prolibertate.games.game.catan.MoveRobber
|
||||||
|
import org.prolibertate.games.game.catan.PickDeckChore
|
||||||
import org.prolibertate.games.game.catan.RollDice
|
import org.prolibertate.games.game.catan.RollDice
|
||||||
import org.prolibertate.games.game.catan.SetupPlace
|
import org.prolibertate.games.game.catan.SetupPlace
|
||||||
|
import org.prolibertate.games.game.catan.SpyChore
|
||||||
import org.prolibertate.games.net.MatchController
|
import org.prolibertate.games.net.MatchController
|
||||||
import org.prolibertate.games.ui.ScreenScaffold
|
import org.prolibertate.games.ui.ScreenScaffold
|
||||||
|
|
||||||
@@ -85,6 +108,27 @@ fun CatanScreen(
|
|||||||
var showTrade by remember { mutableStateOf(false) }
|
var showTrade by remember { mutableStateOf(false) }
|
||||||
var confirmingEnd by remember { mutableStateOf(false) }
|
var confirmingEnd by remember { mutableStateOf(false) }
|
||||||
var resultDismissed by remember { mutableStateOf(false) }
|
var resultDismissed by remember { mutableStateOf(false) }
|
||||||
|
// Cities & Knights: the knight whose menu is open, the one about to move,
|
||||||
|
// a progress card waiting for a tap on the board, and the two list dialogs.
|
||||||
|
var knightMenu by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var movingKnight by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var armed by remember { mutableStateOf<ArmedCard?>(null) }
|
||||||
|
// Seafarers: the ship that has been picked up and is waiting for somewhere to sail.
|
||||||
|
var movingShip by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var showImprove by remember { mutableStateOf(false) }
|
||||||
|
var showProgress by remember { mutableStateOf(false) }
|
||||||
|
// The landscape HUD: a placement waiting for its ✓, the piece being dragged from the
|
||||||
|
// build column (and where the finger is, in window pixels), the log popup, and the board.
|
||||||
|
var staged by remember { mutableStateOf<CatanMove?>(null) }
|
||||||
|
var dragKind by remember { mutableStateOf<BuildKind?>(null) }
|
||||||
|
var dragAt by remember { mutableStateOf<Offset?>(null) }
|
||||||
|
var showLog by remember { mutableStateOf(false) }
|
||||||
|
var boardCoords by remember { mutableStateOf<LayoutCoordinates?>(null) }
|
||||||
|
|
||||||
|
val config = LocalConfiguration.current
|
||||||
|
// Landscape gets the heads-up display; portrait keeps the stacked layout.
|
||||||
|
val wide = config.screenWidthDp > config.screenHeightDp * 1.1f
|
||||||
|
val staging = wide
|
||||||
|
|
||||||
val dark = isSystemInDarkTheme()
|
val dark = isSystemInDarkTheme()
|
||||||
val style = remember(dark) { catanStyle(dark) }
|
val style = remember(dark) { catanStyle(dark) }
|
||||||
@@ -95,13 +139,23 @@ fun CatanScreen(
|
|||||||
// settlement that is no longer pending).
|
// settlement that is no longer pending).
|
||||||
LaunchedEffect(legal) {
|
LaunchedEffect(legal) {
|
||||||
if (building != null && building !in CatanInteraction.canBuild(legal)) building = null
|
if (building != null && building !in CatanInteraction.canBuild(legal)) building = null
|
||||||
|
if (staged != null && staged !in legal) staged = null
|
||||||
if (setupVertex != null && legal.none { it is SetupPlace && it.vertex == setupVertex }) {
|
if (setupVertex != null && legal.none { it is SetupPlace && it.vertex == setupVertex }) {
|
||||||
setupVertex = null
|
setupVertex = null
|
||||||
}
|
}
|
||||||
|
if (movingKnight != null && legal.none { it is MoveKnight && it.from == movingKnight }) movingKnight = null
|
||||||
|
if (movingShip != null && legal.none { it is MoveShip && it.from == movingShip }) movingShip = null
|
||||||
|
armed?.let { card -> if (card.plays.none { it in legal }) armed = null }
|
||||||
if (legal.isEmpty()) {
|
if (legal.isEmpty()) {
|
||||||
showCards = false
|
showCards = false
|
||||||
showTrade = false
|
showTrade = false
|
||||||
victimChoice = null
|
victimChoice = null
|
||||||
|
showImprove = false
|
||||||
|
showProgress = false
|
||||||
|
knightMenu = null
|
||||||
|
movingKnight = null
|
||||||
|
armed = null
|
||||||
|
staged = null
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -112,6 +166,15 @@ fun CatanScreen(
|
|||||||
victimChoice = null
|
victimChoice = null
|
||||||
showCards = false
|
showCards = false
|
||||||
showTrade = false
|
showTrade = false
|
||||||
|
showImprove = false
|
||||||
|
showProgress = false
|
||||||
|
knightMenu = null
|
||||||
|
movingKnight = null
|
||||||
|
movingShip = null
|
||||||
|
armed = null
|
||||||
|
staged = null
|
||||||
|
dragKind = null
|
||||||
|
dragAt = null
|
||||||
}
|
}
|
||||||
|
|
||||||
val endGameAction: @Composable () -> Unit = {
|
val endGameAction: @Composable () -> Unit = {
|
||||||
@@ -128,10 +191,22 @@ fun CatanScreen(
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
val targets = CatanInteraction.targets(current, legal, building, setupVertex)
|
val targets = CatanInteraction.targets(current, legal, building, setupVertex, movingKnight, armed, localSeat, movingShip)
|
||||||
|
val ownKnights = current.ck?.knights?.filter { it.owner == localSeat }?.map { it.vertex }?.toSet().orEmpty()
|
||||||
val devHand = CatanInteraction.devHand(current, localSeat, legal)
|
val devHand = CatanInteraction.devHand(current, localSeat, legal)
|
||||||
|
val progressHand = CatanInteraction.progressHand(current, localSeat, legal)
|
||||||
val playing = current.phase == CatanPhase.PLAYING && legal.isNotEmpty()
|
val playing = current.phase == CatanPhase.PLAYING && legal.isNotEmpty()
|
||||||
val actions = CatanActions(
|
val actions = CatanActions(
|
||||||
|
buildKinds = when {
|
||||||
|
current.isCk -> BuildKind.entries.filter { it != BuildKind.SHIP }
|
||||||
|
current.isSea -> BuildKind.SEAFARERS
|
||||||
|
else -> BuildKind.BASE
|
||||||
|
},
|
||||||
|
ck = current.isCk,
|
||||||
|
canImprove = CatanInteraction.improvable(legal).isNotEmpty(),
|
||||||
|
canPlayProgress = progressHand.any { it.playable },
|
||||||
|
progressCount = progressHand.size,
|
||||||
|
canEndSmith = CatanInteraction.canEndSmith(legal),
|
||||||
canRoll = CatanInteraction.canRoll(legal),
|
canRoll = CatanInteraction.canRoll(legal),
|
||||||
canBuild = CatanInteraction.canBuild(legal),
|
canBuild = CatanInteraction.canBuild(legal),
|
||||||
building = building,
|
building = building,
|
||||||
@@ -143,14 +218,29 @@ fun CatanScreen(
|
|||||||
canRepickSetup = setupVertex != null,
|
canRepickSetup = setupVertex != null,
|
||||||
)
|
)
|
||||||
val rolledHexes = CatanInteraction.rolledHexes(current)
|
val rolledHexes = CatanInteraction.rolledHexes(current)
|
||||||
val prompt = CatanText.prompt(current, seats, setupVertexChosen = setupVertex != null, building = building)
|
val prompt = CatanText.prompt(
|
||||||
|
current,
|
||||||
|
seats,
|
||||||
|
setupVertexChosen = setupVertex != null,
|
||||||
|
building = building,
|
||||||
|
movingKnight = movingKnight != null,
|
||||||
|
armed = armed?.kind,
|
||||||
|
movingShip = movingShip != null,
|
||||||
|
)
|
||||||
|
|
||||||
val handle: (TapOutcome) -> Unit = { outcome ->
|
val handle: (TapOutcome) -> Unit = { outcome ->
|
||||||
when (outcome) {
|
val wait = if (staging) CatanInteraction.stageable(outcome, building) else null
|
||||||
|
when {
|
||||||
|
wait != null -> staged = wait
|
||||||
|
else -> when (outcome) {
|
||||||
TapOutcome.Ignored -> Unit
|
TapOutcome.Ignored -> Unit
|
||||||
is TapOutcome.Submit -> submit(outcome.move)
|
is TapOutcome.Submit -> submit(outcome.move)
|
||||||
is TapOutcome.PickSetupVertex -> setupVertex = outcome.vertex
|
is TapOutcome.PickSetupVertex -> setupVertex = outcome.vertex
|
||||||
is TapOutcome.PickRobberVictim -> victimChoice = outcome
|
is TapOutcome.PickRobberVictim -> victimChoice = outcome
|
||||||
|
is TapOutcome.PickKnight -> knightMenu = outcome.vertex
|
||||||
|
is TapOutcome.PickShip -> movingShip = outcome.edge
|
||||||
|
is TapOutcome.PickFirstHex -> armed = armed?.copy(firstHex = outcome.hex)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -162,21 +252,36 @@ fun CatanScreen(
|
|||||||
CompositionLocalProvider(LocalCatanStyle provides style) {
|
CompositionLocalProvider(LocalCatanStyle provides style) {
|
||||||
ScreenScaffold(title = CatanText.TITLE, onBack = onExit, actions = endGameAction) { modifier ->
|
ScreenScaffold(title = CatanText.TITLE, onBack = onExit, actions = endGameAction) { modifier ->
|
||||||
BoxWithConstraints(modifier = modifier) {
|
BoxWithConstraints(modifier = modifier) {
|
||||||
val wide = maxWidth > maxHeight * 1.1f
|
|
||||||
// Phones (either way up) get the one-button build menu.
|
// Phones (either way up) get the one-button build menu.
|
||||||
val compactBuild = !wide || maxWidth < 600.dp
|
val compactBuild = !wide || maxWidth < 600.dp
|
||||||
|
|
||||||
|
val hoverSpot = if (dragKind != null) dragSpot(boardCoords, dragAt, targets) else null
|
||||||
|
val stagedSpot = CatanInteraction.spotOf(staged)
|
||||||
|
val ghostVertex = hoverSpot?.vertex ?: stagedSpot.vertex
|
||||||
|
val ghostEdge = hoverSpot?.edge ?: stagedSpot.edge
|
||||||
|
|
||||||
val board: @Composable (Modifier) -> Unit = { boardModifier ->
|
val board: @Composable (Modifier) -> Unit = { boardModifier ->
|
||||||
CatanBoardView(
|
CatanBoardView(
|
||||||
state = current,
|
state = current,
|
||||||
targets = targets,
|
targets = targets,
|
||||||
selectedVertex = setupVertex,
|
selectedVertex = setupVertex,
|
||||||
onVertexTap = { handle(CatanInteraction.onVertexTap(it, legal, building, setupVertex)) },
|
onVertexTap = {
|
||||||
onEdgeTap = { handle(CatanInteraction.onEdgeTap(it, legal, building, setupVertex)) },
|
handle(
|
||||||
onHexTap = { handle(CatanInteraction.onHexTap(it, legal)) },
|
CatanInteraction.onVertexTap(
|
||||||
|
it, legal, building, setupVertex, movingKnight, armed,
|
||||||
|
ownKnights = if (legal.isNotEmpty()) ownKnights else emptySet(),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
},
|
||||||
|
onEdgeTap = { handle(CatanInteraction.onEdgeTap(it, legal, building, setupVertex, armed, movingShip)) },
|
||||||
|
onHexTap = { handle(CatanInteraction.onHexTap(it, legal, armed, current.topo)) },
|
||||||
modifier = boardModifier,
|
modifier = boardModifier,
|
||||||
style = style,
|
style = style,
|
||||||
rolledHexes = rolledHexes,
|
rolledHexes = rolledHexes,
|
||||||
|
selectedKnight = movingKnight ?: knightMenu,
|
||||||
|
stagedVertex = ghostVertex,
|
||||||
|
stagedEdge = ghostEdge,
|
||||||
|
stagedSeat = localSeat,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
val players: @Composable (Boolean) -> Unit = { grid ->
|
val players: @Composable (Boolean) -> Unit = { grid ->
|
||||||
@@ -201,28 +306,73 @@ fun CatanScreen(
|
|||||||
},
|
},
|
||||||
onRepickSetup = { setupVertex = null },
|
onRepickSetup = { setupVertex = null },
|
||||||
compact = compactBuild,
|
compact = compactBuild,
|
||||||
|
onImprove = { showImprove = true },
|
||||||
|
onProgress = { showProgress = true },
|
||||||
|
onEndSmith = { legal.firstOrNull { m -> m is EndSmith }?.let(submit) },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (wide) {
|
if (wide) {
|
||||||
Row(Modifier.fillMaxSize(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
|
CatanHud(
|
||||||
Box(Modifier.weight(1.5f).fillMaxSize(), contentAlignment = Alignment.Center) {
|
state = current,
|
||||||
board(Modifier)
|
seats = seats,
|
||||||
}
|
style = style,
|
||||||
Column(
|
actions = actions,
|
||||||
modifier = Modifier.weight(1f).fillMaxSize().verticalScroll(rememberScrollState()),
|
prompt = prompt,
|
||||||
verticalArrangement = Arrangement.spacedBy(8.dp),
|
notice = notice,
|
||||||
) {
|
legal = legal,
|
||||||
players(true)
|
localSeat = localSeat,
|
||||||
promptRow()
|
targets = targets,
|
||||||
handAndActions()
|
pointsOf = pointsOf,
|
||||||
CatanLog(current, Modifier.fillMaxWidth().height(120.dp))
|
staged = staged,
|
||||||
}
|
dragKind = dragKind,
|
||||||
|
dragAt = dragAt,
|
||||||
|
showLog = showLog,
|
||||||
|
boardCoords = boardCoords,
|
||||||
|
building = building,
|
||||||
|
onBoardCoords = { boardCoords = it },
|
||||||
|
onToggleLog = { showLog = !showLog },
|
||||||
|
onArm = { kind -> building = if (building == kind) null else kind; staged = null },
|
||||||
|
onDragStart = { kind, at ->
|
||||||
|
building = kind
|
||||||
|
staged = null
|
||||||
|
dragKind = kind
|
||||||
|
dragAt = at
|
||||||
|
},
|
||||||
|
onDrag = { dragAt = it },
|
||||||
|
onDragEnd = {
|
||||||
|
val spot = dragSpot(boardCoords, dragAt, targets)
|
||||||
|
dragKind = null
|
||||||
|
dragAt = null
|
||||||
|
val outcome = when {
|
||||||
|
spot?.vertex != null -> CatanInteraction.onVertexTap(
|
||||||
|
spot.vertex, legal, building, setupVertex,
|
||||||
|
ownKnights = if (legal.isNotEmpty()) ownKnights else emptySet(),
|
||||||
|
)
|
||||||
|
spot?.edge != null -> CatanInteraction.onEdgeTap(spot.edge, legal, building, setupVertex, armed, movingShip)
|
||||||
|
else -> TapOutcome.Ignored
|
||||||
}
|
}
|
||||||
|
handle(outcome)
|
||||||
|
},
|
||||||
|
onConfirm = { staged?.let(submit) },
|
||||||
|
onCancelStaged = { staged = null; building = null },
|
||||||
|
onRoll = { submit(RollDice()) },
|
||||||
|
onEndTurn = { legal.firstOrNull { m -> m is EndTurn }?.let(submit) },
|
||||||
|
onEndFreeRoads = { legal.firstOrNull { m -> m is EndFreeRoads }?.let(submit) },
|
||||||
|
onEndSmith = { legal.firstOrNull { m -> m is EndSmith }?.let(submit) },
|
||||||
|
onRepickSetup = { setupVertex = null },
|
||||||
|
onBuyCard = { legal.firstOrNull { m -> m is BuyDevCard }?.let(submit) },
|
||||||
|
onPlayCard = { showCards = true },
|
||||||
|
onTrade = { showTrade = true },
|
||||||
|
onImprove = { showImprove = true },
|
||||||
|
onProgress = { showProgress = true },
|
||||||
|
board = { m -> board(m) },
|
||||||
|
)
|
||||||
} else {
|
} else {
|
||||||
Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
players(false)
|
players(false)
|
||||||
|
if (current.isCk) CatanBarbarians(current, style = style)
|
||||||
promptRow()
|
promptRow()
|
||||||
Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) {
|
Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) {
|
||||||
board(Modifier)
|
board(Modifier)
|
||||||
@@ -230,6 +380,39 @@ fun CatanScreen(
|
|||||||
handAndActions()
|
handAndActions()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The trade board slides up over the bottom of the island (base game; Cities &
|
||||||
|
// Knights trades goods and still uses its dialogs).
|
||||||
|
val offerToMe = current.pendingTrade?.takeIf {
|
||||||
|
current.phase == CatanPhase.TRADE_PENDING && it.asking == localSeat && !current.isCk
|
||||||
|
}
|
||||||
|
val boardsAllowed = abandoned == null && !confirmingEnd && current.phase != CatanPhase.GAME_OVER
|
||||||
|
if (boardsAllowed && offerToMe != null) {
|
||||||
|
CatanTradeReplyBoard(
|
||||||
|
state = current,
|
||||||
|
seat = localSeat,
|
||||||
|
offer = offerToMe,
|
||||||
|
seats = seats,
|
||||||
|
canAccept = CatanInteraction.tradeResponses(legal).first,
|
||||||
|
onAccept = { submit(AcceptTrade) },
|
||||||
|
onDecline = { submit(DeclineTrade) },
|
||||||
|
onCounter = submit,
|
||||||
|
modifier = Modifier.align(Alignment.BottomCenter),
|
||||||
|
style = style,
|
||||||
|
)
|
||||||
|
} else if (boardsAllowed && showTrade && !current.isCk) {
|
||||||
|
CatanTradeBoard(
|
||||||
|
state = current,
|
||||||
|
seat = localSeat,
|
||||||
|
seats = seats,
|
||||||
|
legal = legal,
|
||||||
|
onBank = submit,
|
||||||
|
onOffer = submit,
|
||||||
|
onClose = { showTrade = false },
|
||||||
|
modifier = Modifier.align(Alignment.BottomCenter),
|
||||||
|
style = style,
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
CatanDialogHost(
|
CatanDialogHost(
|
||||||
@@ -244,6 +427,21 @@ fun CatanScreen(
|
|||||||
showCards = showCards,
|
showCards = showCards,
|
||||||
showTrade = showTrade,
|
showTrade = showTrade,
|
||||||
devHand = devHand,
|
devHand = devHand,
|
||||||
|
knightMenu = knightMenu,
|
||||||
|
showImprove = showImprove,
|
||||||
|
showProgress = showProgress,
|
||||||
|
progressHand = progressHand,
|
||||||
|
onMoveKnight = { from ->
|
||||||
|
knightMenu = null
|
||||||
|
movingKnight = from
|
||||||
|
},
|
||||||
|
onArmCard = { card ->
|
||||||
|
showProgress = false
|
||||||
|
armed = card
|
||||||
|
},
|
||||||
|
onCancelKnight = { knightMenu = null },
|
||||||
|
onCancelImprove = { showImprove = false },
|
||||||
|
onCancelProgress = { showProgress = false },
|
||||||
onExit = onExit,
|
onExit = onExit,
|
||||||
onSubmit = submit,
|
onSubmit = submit,
|
||||||
onStay = controller::dismissAbandoned,
|
onStay = controller::dismissAbandoned,
|
||||||
@@ -316,7 +514,7 @@ private fun PromptRow(prompt: String, notice: String?, state: CatanState) {
|
|||||||
overflow = TextOverflow.Ellipsis,
|
overflow = TextOverflow.Ellipsis,
|
||||||
modifier = Modifier.weight(1f),
|
modifier = Modifier.weight(1f),
|
||||||
)
|
)
|
||||||
CatanDice(state.lastDice)
|
CatanDice(state.lastDice, ck = state.isCk, event = state.ck?.eventDie)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -338,6 +536,15 @@ private fun CatanDialogHost(
|
|||||||
showCards: Boolean,
|
showCards: Boolean,
|
||||||
showTrade: Boolean,
|
showTrade: Boolean,
|
||||||
devHand: List<DevCardInHand>,
|
devHand: List<DevCardInHand>,
|
||||||
|
knightMenu: Int?,
|
||||||
|
showImprove: Boolean,
|
||||||
|
showProgress: Boolean,
|
||||||
|
progressHand: List<ProgressInHand>,
|
||||||
|
onMoveKnight: (Int) -> Unit,
|
||||||
|
onArmCard: (ArmedCard) -> Unit,
|
||||||
|
onCancelKnight: () -> Unit,
|
||||||
|
onCancelImprove: () -> Unit,
|
||||||
|
onCancelProgress: () -> Unit,
|
||||||
onExit: () -> Unit,
|
onExit: () -> Unit,
|
||||||
onSubmit: (CatanMove) -> Unit,
|
onSubmit: (CatanMove) -> Unit,
|
||||||
onStay: () -> Unit,
|
onStay: () -> Unit,
|
||||||
@@ -347,7 +554,7 @@ private fun CatanDialogHost(
|
|||||||
onCancelCards: () -> Unit,
|
onCancelCards: () -> Unit,
|
||||||
onCancelTrade: () -> Unit,
|
onCancelTrade: () -> Unit,
|
||||||
) {
|
) {
|
||||||
val offer = state.pendingTrade
|
val goodsOffer = state.ck?.goodsOffer
|
||||||
when {
|
when {
|
||||||
abandoned != null -> CatanAbandonedDialog(abandoned, onExit, onStay)
|
abandoned != null -> CatanAbandonedDialog(abandoned, onExit, onStay)
|
||||||
|
|
||||||
@@ -364,11 +571,17 @@ private fun CatanDialogHost(
|
|||||||
onSubmit = onSubmit,
|
onSubmit = onSubmit,
|
||||||
)
|
)
|
||||||
|
|
||||||
state.phase == CatanPhase.TRADE_PENDING && offer != null && offer.asking == localSeat ->
|
state.phase == CatanPhase.GOLD && CatanRules.currentSeat(state) == localSeat && legal.isNotEmpty() ->
|
||||||
CatanTradeResponseDialog(
|
CatanGoldDialog(legal, onSubmit)
|
||||||
|
|
||||||
|
state.phase == CatanPhase.CHORE && CatanRules.currentSeat(state) == localSeat ->
|
||||||
|
ChoreDialog(state, localSeat, legal, onSubmit)
|
||||||
|
|
||||||
|
state.phase == CatanPhase.TRADE_PENDING && goodsOffer != null && goodsOffer.asking == localSeat ->
|
||||||
|
CatanGoodsTradeResponseDialog(
|
||||||
state = state,
|
state = state,
|
||||||
seat = localSeat,
|
seat = localSeat,
|
||||||
offer = offer,
|
offer = goodsOffer,
|
||||||
seats = seats,
|
seats = seats,
|
||||||
canAccept = CatanInteraction.tradeResponses(legal).first,
|
canAccept = CatanInteraction.tradeResponses(legal).first,
|
||||||
onAccept = { onSubmit(AcceptTrade) },
|
onAccept = { onSubmit(AcceptTrade) },
|
||||||
@@ -376,6 +589,14 @@ private fun CatanDialogHost(
|
|||||||
onCounter = onSubmit,
|
onCounter = onSubmit,
|
||||||
)
|
)
|
||||||
|
|
||||||
|
state.phase == CatanPhase.TRADE_COUNTERS && goodsOffer != null && state.turn == localSeat && legal.isNotEmpty() ->
|
||||||
|
CatanGoodsCounterChoiceDialog(
|
||||||
|
counters = CatanInteraction.goodsCounterChoices(state, legal),
|
||||||
|
seats = seats,
|
||||||
|
onTake = onSubmit,
|
||||||
|
onNoDeal = { onSubmit(DismissCounters) },
|
||||||
|
)
|
||||||
|
|
||||||
state.phase == CatanPhase.TRADE_COUNTERS && state.turn == localSeat && legal.isNotEmpty() ->
|
state.phase == CatanPhase.TRADE_COUNTERS && state.turn == localSeat && legal.isNotEmpty() ->
|
||||||
CatanCounterChoiceDialog(
|
CatanCounterChoiceDialog(
|
||||||
counters = CatanInteraction.counterChoices(state, legal),
|
counters = CatanInteraction.counterChoices(state, legal),
|
||||||
@@ -388,14 +609,50 @@ private fun CatanDialogHost(
|
|||||||
CatanVictimDialog(
|
CatanVictimDialog(
|
||||||
victims = victimChoice.victims,
|
victims = victimChoice.victims,
|
||||||
seats = seats,
|
seats = seats,
|
||||||
onPick = { victim -> onSubmit(MoveRobber(victimChoice.hex, victim)) },
|
onPick = { victim ->
|
||||||
|
onSubmit(
|
||||||
|
if (victimChoice.pirate) {
|
||||||
|
org.prolibertate.games.game.catan.MovePirate(victimChoice.hex, victim)
|
||||||
|
} else {
|
||||||
|
MoveRobber(victimChoice.hex, victim)
|
||||||
|
},
|
||||||
|
)
|
||||||
|
},
|
||||||
onCancel = onCancelVictim,
|
onCancel = onCancelVictim,
|
||||||
)
|
)
|
||||||
|
|
||||||
|
knightMenu != null ->
|
||||||
|
CatanKnightDialog(
|
||||||
|
state = state,
|
||||||
|
vertex = knightMenu,
|
||||||
|
actions = CatanInteraction.knightActions(legal, knightMenu),
|
||||||
|
onDo = onSubmit,
|
||||||
|
onMove = onMoveKnight,
|
||||||
|
onCancel = onCancelKnight,
|
||||||
|
)
|
||||||
|
|
||||||
|
showImprove ->
|
||||||
|
CatanImproveDialog(
|
||||||
|
state = state,
|
||||||
|
seat = localSeat,
|
||||||
|
legal = legal,
|
||||||
|
onBuy = onSubmit,
|
||||||
|
onCancel = onCancelImprove,
|
||||||
|
)
|
||||||
|
|
||||||
|
showProgress ->
|
||||||
|
CatanProgressDialog(
|
||||||
|
hand = progressHand,
|
||||||
|
seats = seats,
|
||||||
|
onPlay = onSubmit,
|
||||||
|
onArm = onArmCard,
|
||||||
|
onCancel = onCancelProgress,
|
||||||
|
)
|
||||||
|
|
||||||
showCards -> CatanPlayCardDialog(devHand, onPlay = onSubmit, onCancel = onCancelCards)
|
showCards -> CatanPlayCardDialog(devHand, onPlay = onSubmit, onCancel = onCancelCards)
|
||||||
|
|
||||||
showTrade ->
|
showTrade && state.isCk ->
|
||||||
CatanTradeDialog(
|
CatanGoodsTradeDialog(
|
||||||
state = state,
|
state = state,
|
||||||
seat = localSeat,
|
seat = localSeat,
|
||||||
seats = seats,
|
seats = seats,
|
||||||
@@ -406,3 +663,69 @@ private fun CatanDialogHost(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The dialog for the chore at the front of the queue, when it is the local
|
||||||
|
* player's. Chores that are answered by tapping the board (a city to lose, a
|
||||||
|
* metropolis site, a knight to place) have no dialog: the prompt line tells the
|
||||||
|
* player what to tap.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
private fun ChoreDialog(
|
||||||
|
state: CatanState,
|
||||||
|
localSeat: Int,
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
onSubmit: (CatanMove) -> Unit,
|
||||||
|
) {
|
||||||
|
val ck = state.ck ?: return
|
||||||
|
val check: (List<org.prolibertate.games.game.catan.Good>, (List<org.prolibertate.games.game.catan.Good>) -> CatanMove) -> Boolean =
|
||||||
|
{ cards, make -> CatanRules.isLegalMove(state, localSeat, make(cards)) }
|
||||||
|
when (val chore = ck.chores.firstOrNull()) {
|
||||||
|
is DiscardChore -> {
|
||||||
|
val quota = minOf(chore.count, CatanCk.goodsCount(state, localSeat))
|
||||||
|
CatanGoodsPickDialog(
|
||||||
|
title = "Discard $quota cards",
|
||||||
|
intro = "Choose $quota cards to give up",
|
||||||
|
held = CatanCk.goodsOf(state, localSeat),
|
||||||
|
quota = quota,
|
||||||
|
confirmLabel = "Discard",
|
||||||
|
selectable = { true },
|
||||||
|
allowed = { check(it, ::DiscardGoods) },
|
||||||
|
onConfirm = { onSubmit(DiscardGoods(it)) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
is GiveChore -> {
|
||||||
|
val pool = CatanCk.goodsOf(state, localSeat).filterKeys { !chore.commoditiesOnly || it.isCommodity }
|
||||||
|
val quota = minOf(chore.count, pool.values.sum())
|
||||||
|
CatanGoodsPickDialog(
|
||||||
|
title = "Hand over $quota ${if (quota == 1) "card" else "cards"}",
|
||||||
|
intro = if (chore.commoditiesOnly) "Choose a commodity to give" else "Choose which cards to give",
|
||||||
|
held = pool,
|
||||||
|
quota = quota,
|
||||||
|
confirmLabel = "Give",
|
||||||
|
selectable = { !chore.commoditiesOnly || it.isCommodity },
|
||||||
|
allowed = { check(it, ::GiveGoods) },
|
||||||
|
onConfirm = { onSubmit(GiveGoods(it)) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
is PickDeckChore -> CatanPickDeckDialog(legal) { onSubmit(it) }
|
||||||
|
|
||||||
|
is DropProgressChore -> CatanDropProgressDialog(ck.progressHands[localSeat]) { onSubmit(it) }
|
||||||
|
|
||||||
|
is AqueductChore -> CatanAqueductDialog(legal) { onSubmit(it) }
|
||||||
|
|
||||||
|
is SpyChore -> CatanSpyDialog(ck.progressHands[chore.target], legal) { onSubmit(it) }
|
||||||
|
|
||||||
|
else -> Unit
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The board spot under a dragged finger ([at], in window pixels), or null off the board. */
|
||||||
|
private fun dragSpot(coords: LayoutCoordinates?, at: Offset?, targets: BoardTargets): CatanInteraction.Spot? {
|
||||||
|
if (coords == null || at == null || !coords.isAttached) return null
|
||||||
|
val local = coords.windowToLocal(at)
|
||||||
|
val layout = CatanGeometry.fit(coords.size.width.toFloat(), coords.size.height.toFloat())
|
||||||
|
return CatanInteraction.snap(layout, targets, Pt(local.x, local.y), layout.radius * 1.2f)
|
||||||
|
}
|
||||||
|
|||||||
@@ -3,8 +3,10 @@ package org.prolibertate.games.ui.game.catan
|
|||||||
import androidx.compose.runtime.Immutable
|
import androidx.compose.runtime.Immutable
|
||||||
import androidx.compose.runtime.staticCompositionLocalOf
|
import androidx.compose.runtime.staticCompositionLocalOf
|
||||||
import androidx.compose.ui.graphics.Color
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import org.prolibertate.games.game.catan.Commodity
|
||||||
import org.prolibertate.games.game.catan.Resource
|
import org.prolibertate.games.game.catan.Resource
|
||||||
import org.prolibertate.games.game.catan.Terrain
|
import org.prolibertate.games.game.catan.Terrain
|
||||||
|
import org.prolibertate.games.game.catan.Track
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Every visual decision for the Katan screen, in one place.
|
* Every visual decision for the Katan screen, in one place.
|
||||||
@@ -46,6 +48,19 @@ data class CatanStyle(
|
|||||||
val resource: Map<Resource, Color>,
|
val resource: Map<Resource, Color>,
|
||||||
val resourceInk: Color,
|
val resourceInk: Color,
|
||||||
|
|
||||||
|
// --- Cities & Knights ---------------------------------------------------
|
||||||
|
/** Commodity cards: cloth, coin and paper. */
|
||||||
|
val commodity: Map<Commodity, Color> = LightCommodities,
|
||||||
|
/** Ink on a commodity tile (paper is pale, so it is not white). */
|
||||||
|
val commodityInk: Map<Commodity, Color> = LightCommodityInk,
|
||||||
|
/** The colour of each improvement track, its city gate, its deck and its metropolis. */
|
||||||
|
val track: Map<Track, Color> = LightTracks,
|
||||||
|
/** Wall round a city, and the barbarian strip. */
|
||||||
|
val wall: Color = Color(0xFF5D4037),
|
||||||
|
val barbarian: Color = Color(0xFFB71C1C),
|
||||||
|
/** The halo round a knight that is awake. White, so it is not mistaken for the yellow tap ring. */
|
||||||
|
val knightReady: Color = Color(0xFFFFFFFF),
|
||||||
|
|
||||||
// --- Players ------------------------------------------------------------
|
// --- Players ------------------------------------------------------------
|
||||||
/** One colour per seat, in seat order. Roads, settlements, cities, player strip. */
|
/** One colour per seat, in seat order. Roads, settlements, cities, player strip. */
|
||||||
val seats: List<Color>,
|
val seats: List<Color>,
|
||||||
@@ -66,12 +81,34 @@ data class CatanStyle(
|
|||||||
val citySize: Float = 0.42f,
|
val citySize: Float = 0.42f,
|
||||||
val tokenRadius: Float = 0.36f,
|
val tokenRadius: Float = 0.36f,
|
||||||
val robberSize: Float = 0.34f,
|
val robberSize: Float = 0.34f,
|
||||||
|
/** Seafarers: the pirate's flag, and the hull and sail of a ship. */
|
||||||
|
val pirate: Color = Color(0xFF000000),
|
||||||
|
val shipSail: Color = Color(0xFFFFFFFF),
|
||||||
val portRadius: Float = 0.46f,
|
val portRadius: Float = 0.46f,
|
||||||
val targetRadius: Float = 0.20f,
|
val targetRadius: Float = 0.20f,
|
||||||
/** How close a tap must land to a vertex / edge / hex centre to count. */
|
/** How close a tap must land to a vertex / edge / hex centre to count. */
|
||||||
val tapReach: Float = 0.55f,
|
val tapReach: Float = 0.55f,
|
||||||
val tokenText: Float = 0.34f,
|
val tokenText: Float = 0.34f,
|
||||||
val portText: Float = 0.27f,
|
val portText: Float = 0.27f,
|
||||||
|
val knightSize: Float = 0.30f,
|
||||||
|
)
|
||||||
|
|
||||||
|
private val LightCommodities = mapOf(
|
||||||
|
Commodity.CLOTH to Color(0xFF7E57C2),
|
||||||
|
Commodity.COIN to Color(0xFFF9A825),
|
||||||
|
Commodity.PAPER to Color(0xFFECEFF1),
|
||||||
|
)
|
||||||
|
|
||||||
|
private val LightCommodityInk = mapOf(
|
||||||
|
Commodity.CLOTH to Color(0xFFFFFFFF),
|
||||||
|
Commodity.COIN to Color(0xFF3E2723),
|
||||||
|
Commodity.PAPER to Color(0xFF263238),
|
||||||
|
)
|
||||||
|
|
||||||
|
private val LightTracks = mapOf(
|
||||||
|
Track.TRADE to Color(0xFFF2C300),
|
||||||
|
Track.POLITICS to Color(0xFF1E6FD9),
|
||||||
|
Track.SCIENCE to Color(0xFF2E9E4F),
|
||||||
)
|
)
|
||||||
|
|
||||||
/** The light palette, which is also the reference for the dark one. */
|
/** The light palette, which is also the reference for the dark one. */
|
||||||
@@ -84,6 +121,9 @@ private val LightStyle = CatanStyle(
|
|||||||
Terrain.HILLS to Color(0xFFB4532F),
|
Terrain.HILLS to Color(0xFFB4532F),
|
||||||
Terrain.MOUNTAINS to Color(0xFF7C8794),
|
Terrain.MOUNTAINS to Color(0xFF7C8794),
|
||||||
Terrain.DESERT to Color(0xFFE6D3A0),
|
Terrain.DESERT to Color(0xFFE6D3A0),
|
||||||
|
// Seafarers. Sea hexes are drawn as a faint wash over the water; gold is a rich yellow.
|
||||||
|
Terrain.SEA to Color(0xFF3A7CA5),
|
||||||
|
Terrain.GOLD to Color(0xFFF2B01E),
|
||||||
),
|
),
|
||||||
hexEdge = Color(0x55000000),
|
hexEdge = Color(0x55000000),
|
||||||
token = Color(0xFFF7EFD9),
|
token = Color(0xFFF7EFD9),
|
||||||
|
|||||||
@@ -1,12 +1,29 @@
|
|||||||
package org.prolibertate.games.ui.game.catan
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import org.prolibertate.games.game.catan.AqueductChore
|
||||||
|
import org.prolibertate.games.game.catan.CatanCk
|
||||||
import org.prolibertate.games.game.catan.CatanPhase
|
import org.prolibertate.games.game.catan.CatanPhase
|
||||||
import org.prolibertate.games.game.catan.CatanRules
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
import org.prolibertate.games.game.catan.CatanState
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
import org.prolibertate.games.game.catan.DevCardType
|
import org.prolibertate.games.game.catan.DevCardType
|
||||||
|
import org.prolibertate.games.game.catan.DiscardChore
|
||||||
|
import org.prolibertate.games.game.catan.DropProgressChore
|
||||||
|
import org.prolibertate.games.game.catan.EventFace
|
||||||
|
import org.prolibertate.games.game.catan.GiveChore
|
||||||
|
import org.prolibertate.games.game.catan.Good
|
||||||
|
import org.prolibertate.games.game.catan.MetropolisChore
|
||||||
|
import org.prolibertate.games.game.catan.PickDeckChore
|
||||||
|
import org.prolibertate.games.game.catan.PillageChore
|
||||||
|
import org.prolibertate.games.game.catan.PlaceKnightChore
|
||||||
import org.prolibertate.games.game.catan.Port
|
import org.prolibertate.games.game.catan.Port
|
||||||
|
import org.prolibertate.games.game.catan.ProgressType
|
||||||
|
import org.prolibertate.games.game.catan.RelocateChore
|
||||||
|
import org.prolibertate.games.game.catan.RemoveKnightChore
|
||||||
import org.prolibertate.games.game.catan.Resource
|
import org.prolibertate.games.game.catan.Resource
|
||||||
|
import org.prolibertate.games.game.catan.SmithChore
|
||||||
|
import org.prolibertate.games.game.catan.SpyChore
|
||||||
import org.prolibertate.games.game.catan.Terrain
|
import org.prolibertate.games.game.catan.Terrain
|
||||||
|
import org.prolibertate.games.game.catan.Track
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Who is who at the table, for wording. [names] may be empty or short — a
|
* Who is who at the table, for wording. [names] may be empty or short — a
|
||||||
@@ -55,6 +72,8 @@ object CatanText {
|
|||||||
Terrain.HILLS -> "Hills"
|
Terrain.HILLS -> "Hills"
|
||||||
Terrain.MOUNTAINS -> "Mountains"
|
Terrain.MOUNTAINS -> "Mountains"
|
||||||
Terrain.DESERT -> "Desert"
|
Terrain.DESERT -> "Desert"
|
||||||
|
Terrain.SEA -> "Sea"
|
||||||
|
Terrain.GOLD -> "Gold field"
|
||||||
}
|
}
|
||||||
|
|
||||||
fun devCard(type: DevCardType): String = when (type) {
|
fun devCard(type: DevCardType): String = when (type) {
|
||||||
@@ -91,6 +110,11 @@ object CatanText {
|
|||||||
|
|
||||||
// --- Buttons and headings --------------------------------------------------
|
// --- Buttons and headings --------------------------------------------------
|
||||||
|
|
||||||
|
const val SEA_ROBBER = "Move the robber (tap a land hex) or the pirate (tap a sea hex)."
|
||||||
|
const val SHIP = "Ship"
|
||||||
|
const val SHIP_COST_TEXT = "1 lumber + 1 wool"
|
||||||
|
const val GOLD_TITLE = "Gold field"
|
||||||
|
const val GOLD_TAKE = "Take"
|
||||||
const val ROLL = "Roll dice"
|
const val ROLL = "Roll dice"
|
||||||
const val END_TURN = "End turn"
|
const val END_TURN = "End turn"
|
||||||
const val ROAD = "Road"
|
const val ROAD = "Road"
|
||||||
@@ -122,6 +146,28 @@ object CatanText {
|
|||||||
const val YOU_GIVE = "You give"
|
const val YOU_GIVE = "You give"
|
||||||
const val YOU_GET = "You get"
|
const val YOU_GET = "You get"
|
||||||
const val SEND_OFFER = "Send offer"
|
const val SEND_OFFER = "Send offer"
|
||||||
|
|
||||||
|
// --- Trade board and HUD -----------------------------------------------------
|
||||||
|
const val TAB_PLAYER = "Player"
|
||||||
|
const val TAB_BANK = "Bank"
|
||||||
|
const val YOU_RECEIVE_ROW = "You get"
|
||||||
|
const val YOU_GIVE_ROW = "You give"
|
||||||
|
const val TRADE_HINT_PLAYER = "Tap cards to build an offer. Tap a player to address it to them alone."
|
||||||
|
const val TRADE_HINT_BANK = "Tap what you give, then what you want."
|
||||||
|
const val TRADE_HINT_BANK_EMPTY = "You do not hold enough of any one resource to trade with the bank."
|
||||||
|
const val TRADE_HINT_COUNTER = "Change the terms, then send them back."
|
||||||
|
const val HIDE = "Hide"
|
||||||
|
const val DENY = "Deny"
|
||||||
|
const val CONFIRM_BUILD = "Place"
|
||||||
|
const val CANCEL_BUILD = "Cancel"
|
||||||
|
const val DRAG_HINT = "Drag a piece onto the board"
|
||||||
|
const val LOG_BUTTON = "Log"
|
||||||
|
const val CARDS_SHORT = "Cards"
|
||||||
|
const val BUY_SHORT = "Buy"
|
||||||
|
const val ROLL_SHORT = "Roll"
|
||||||
|
const val END_SHORT = "End"
|
||||||
|
const val DONE_SHORT = "Done"
|
||||||
|
const val LOG_TITLE = "Table log"
|
||||||
const val NO_LOG = "Nothing has happened yet."
|
const val NO_LOG = "Nothing has happened yet."
|
||||||
const val END_GAME = "End game"
|
const val END_GAME = "End game"
|
||||||
const val LOOK_AT_BOARD = "Look at the board"
|
const val LOOK_AT_BOARD = "Look at the board"
|
||||||
@@ -140,7 +186,14 @@ object CatanText {
|
|||||||
seats: CatanSeats,
|
seats: CatanSeats,
|
||||||
setupVertexChosen: Boolean,
|
setupVertexChosen: Boolean,
|
||||||
building: BuildKind?,
|
building: BuildKind?,
|
||||||
|
/** Cities & Knights: a knight has been picked to move, and its destination is awaited. */
|
||||||
|
movingKnight: Boolean = false,
|
||||||
|
/** Cities & Knights: a progress card is waiting for a tap on the board. */
|
||||||
|
armed: ProgressType? = null,
|
||||||
|
/** Seafarers: a ship has been picked to sail, and its destination is awaited. */
|
||||||
|
movingShip: Boolean = false,
|
||||||
): String {
|
): String {
|
||||||
|
if (state.isCk) return ckPrompt(state, seats, setupVertexChosen, building, movingKnight, armed)
|
||||||
val me = seats.me
|
val me = seats.me
|
||||||
val onClock = CatanRules.currentSeat(state)
|
val onClock = CatanRules.currentSeat(state)
|
||||||
val mine = onClock == me
|
val mine = onClock == me
|
||||||
@@ -176,10 +229,23 @@ object CatanText {
|
|||||||
}
|
}
|
||||||
|
|
||||||
CatanPhase.ROBBER ->
|
CatanPhase.ROBBER ->
|
||||||
if (mine) "Move the robber. Tap a hex." else "$turn is moving the robber…"
|
if (mine) {
|
||||||
|
if (state.isSea) SEA_ROBBER else "Move the robber. Tap a hex."
|
||||||
|
} else {
|
||||||
|
"$turn is moving the robber…"
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.GOLD ->
|
||||||
|
if (mine) {
|
||||||
|
"Gold! Choose ${state.sea?.gold?.firstOrNull()?.count ?: 1} resource cards."
|
||||||
|
} else {
|
||||||
|
"${seats.label(onClock ?: state.turn)} is choosing from the gold…"
|
||||||
|
}
|
||||||
|
|
||||||
CatanPhase.PLAYING -> when {
|
CatanPhase.PLAYING -> when {
|
||||||
!mine -> "$turn is playing…"
|
!mine -> "$turn is playing…"
|
||||||
|
movingShip -> "Tap the sea edge to sail the ship to."
|
||||||
|
building == BuildKind.SHIP -> "Tap a sea edge beside your fleet or a harbour town to launch a ship."
|
||||||
building == BuildKind.ROAD -> "Tap an edge to build a road."
|
building == BuildKind.ROAD -> "Tap an edge to build a road."
|
||||||
building == BuildKind.SETTLEMENT -> "Tap an empty crossing to build a settlement."
|
building == BuildKind.SETTLEMENT -> "Tap an empty crossing to build a settlement."
|
||||||
building == BuildKind.CITY -> "Tap one of your settlements to upgrade it."
|
building == BuildKind.CITY -> "Tap one of your settlements to upgrade it."
|
||||||
@@ -194,6 +260,8 @@ object CatanText {
|
|||||||
"$turn is placing free roads…"
|
"$turn is placing free roads…"
|
||||||
}
|
}
|
||||||
|
|
||||||
|
CatanPhase.CHORE -> "Waiting for ${seats.label(onClock ?: state.turn)}…"
|
||||||
|
|
||||||
CatanPhase.TRADE_PENDING -> {
|
CatanPhase.TRADE_PENDING -> {
|
||||||
val offer = state.pendingTrade
|
val offer = state.pendingTrade
|
||||||
when {
|
when {
|
||||||
@@ -236,4 +304,218 @@ object CatanText {
|
|||||||
val winner = state.winner ?: return "Game over"
|
val winner = state.winner ?: return "Game over"
|
||||||
return if (winner == seats.me) "You won!" else "${seats.label(winner)} won"
|
return if (winner == seats.me) "You won!" else "${seats.label(winner)} won"
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// --- Cities & Knights ----------------------------------------------------
|
||||||
|
|
||||||
|
fun good(good: Good): String = when (good) {
|
||||||
|
Good.LUMBER -> "Lumber"
|
||||||
|
Good.BRICK -> "Brick"
|
||||||
|
Good.WOOL -> "Wool"
|
||||||
|
Good.GRAIN -> "Grain"
|
||||||
|
Good.ORE -> "Ore"
|
||||||
|
Good.CLOTH -> "Cloth"
|
||||||
|
Good.COIN -> "Coin"
|
||||||
|
Good.PAPER -> "Paper"
|
||||||
|
}
|
||||||
|
|
||||||
|
/** "2 Lumber + 1 Cloth" for a flat list of goods. */
|
||||||
|
fun goods(cards: List<Good>): String =
|
||||||
|
cards.groupingBy { it }.eachCount().entries
|
||||||
|
.sortedBy { it.key.ordinal }
|
||||||
|
.joinToString(" + ") { (g, n) -> "$n ${good(g)}" }
|
||||||
|
.ifEmpty { "nothing" }
|
||||||
|
|
||||||
|
fun track(track: Track): String = when (track) {
|
||||||
|
Track.TRADE -> "Trade"
|
||||||
|
Track.POLITICS -> "Politics"
|
||||||
|
Track.SCIENCE -> "Science"
|
||||||
|
}
|
||||||
|
|
||||||
|
/** What the third level of a track gives, for the improvement dialog. */
|
||||||
|
fun trackPower(track: Track): String = when (track) {
|
||||||
|
Track.TRADE -> "From level 3, trade commodities with the bank two for one."
|
||||||
|
Track.POLITICS -> "From level 3, knights can be promoted to mighty."
|
||||||
|
Track.SCIENCE -> "From level 3, when the dice pay you nothing, take any resource."
|
||||||
|
}
|
||||||
|
|
||||||
|
fun knightName(level: Int): String = when (level) {
|
||||||
|
1 -> "Basic knight"
|
||||||
|
2 -> "Strong knight"
|
||||||
|
else -> "Mighty knight"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun event(face: EventFace?): String = when (face) {
|
||||||
|
null -> "–"
|
||||||
|
EventFace.SHIP -> "Ship"
|
||||||
|
EventFace.TRADE -> "Trade"
|
||||||
|
EventFace.POLITICS -> "Politics"
|
||||||
|
EventFace.SCIENCE -> "Science"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun progress(kind: ProgressType): String = CatanCk.progressName(kind)
|
||||||
|
|
||||||
|
fun progressHelp(kind: ProgressType): String = when (kind) {
|
||||||
|
ProgressType.ALCHEMIST -> "Before rolling, choose what the two number dice show."
|
||||||
|
ProgressType.CRANE -> "Your next city improvement costs one commodity less."
|
||||||
|
ProgressType.ENGINEER -> "Raise a wall round one of your cities for free."
|
||||||
|
ProgressType.INVENTOR -> "Swap two number tokens (not 2, 6, 8 or 12)."
|
||||||
|
ProgressType.IRRIGATION -> "Take 2 grain for each fields hex beside your settlements and cities."
|
||||||
|
ProgressType.MEDICINE -> "Upgrade a settlement to a city for 2 ore and 1 grain."
|
||||||
|
ProgressType.MINING -> "Take 2 ore for each mountains hex beside your settlements and cities."
|
||||||
|
ProgressType.PRINTER -> "One victory point."
|
||||||
|
ProgressType.ROAD_BUILDING -> "Build two roads for free."
|
||||||
|
ProgressType.SMITH -> "Promote up to two of your knights one level for free."
|
||||||
|
ProgressType.BISHOP -> "Move the robber and take a card from every player beside its new hex."
|
||||||
|
ProgressType.CONSTITUTION -> "One victory point."
|
||||||
|
ProgressType.DESERTER -> "Another player removes a knight; you place a free one of the same strength."
|
||||||
|
ProgressType.DIPLOMAT -> "Remove an open road. If it was yours, build it again anywhere for free."
|
||||||
|
ProgressType.INTRIGUE -> "Drive an opponent's knight off a crossing beside one of your roads."
|
||||||
|
ProgressType.SABOTEUR -> "Every player with as many points as you or more discards half their cards."
|
||||||
|
ProgressType.SPY -> "Look at another player's progress cards and take one."
|
||||||
|
ProgressType.WARLORD -> "Wake all your knights without paying grain."
|
||||||
|
ProgressType.WEDDING -> "Every player with more points gives you 2 cards."
|
||||||
|
ProgressType.COMMERCIAL_HARBOR -> "Offer a resource to each player; each swaps it for a commodity."
|
||||||
|
ProgressType.MASTER_MERCHANT -> "Take 2 cards from a player with more points."
|
||||||
|
ProgressType.MERCHANT -> "Put the merchant beside your settlement: trade that resource 2:1 and score a point."
|
||||||
|
ProgressType.MERCHANT_FLEET -> "This turn, trade one chosen card type with the bank two for one."
|
||||||
|
ProgressType.RESOURCE_MONOPOLY -> "Name a resource. Every other player gives you 2 of it."
|
||||||
|
ProgressType.TRADE_MONOPOLY -> "Name a commodity. Every other player gives you 1 of it."
|
||||||
|
}
|
||||||
|
|
||||||
|
const val IMPROVE = "Improve"
|
||||||
|
const val KNIGHTS = "Knights"
|
||||||
|
const val CARDS_BUTTON = "Progress"
|
||||||
|
const val WALL = "Wall"
|
||||||
|
const val KNIGHT = "Knight"
|
||||||
|
const val STOP_SMITH = "Done promoting"
|
||||||
|
|
||||||
|
val KNIGHT_COST: String get() = cost(CatanCk.KNIGHT_COST)
|
||||||
|
val ACTIVATE_COST: String get() = cost(CatanCk.ACTIVATE_COST)
|
||||||
|
val WALL_COST: String get() = cost(CatanCk.WALL_COST)
|
||||||
|
|
||||||
|
private fun ckPrompt(
|
||||||
|
state: CatanState,
|
||||||
|
seats: CatanSeats,
|
||||||
|
setupVertexChosen: Boolean,
|
||||||
|
building: BuildKind?,
|
||||||
|
movingKnight: Boolean,
|
||||||
|
armed: ProgressType?,
|
||||||
|
): String {
|
||||||
|
val me = seats.me
|
||||||
|
val onClock = CatanRules.currentSeat(state)
|
||||||
|
val mine = onClock == me
|
||||||
|
val turn = seats.label(state.turn)
|
||||||
|
val ck = state.ck!!
|
||||||
|
|
||||||
|
return when (state.phase) {
|
||||||
|
CatanPhase.GOLD -> ""
|
||||||
|
|
||||||
|
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 piece: it is a city, and earns resources from the hexes around it."
|
||||||
|
|
||||||
|
else -> "Place a settlement, then a road."
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.AWAIT_ROLL -> when {
|
||||||
|
!mine -> "$turn is rolling…"
|
||||||
|
armed != null -> armedPrompt(armed)
|
||||||
|
movingKnight -> "Tap where the knight should go."
|
||||||
|
else -> "Your turn. Roll the dice, or wake knights and play progress cards first."
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.ROBBER -> when {
|
||||||
|
!mine -> "$turn is moving the robber…"
|
||||||
|
ck.bishop -> "The bishop: tap a hex. Everyone beside it pays you a card."
|
||||||
|
else -> "Move the robber. Tap a hex."
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.PLAYING -> when {
|
||||||
|
!mine -> "$turn is playing…"
|
||||||
|
armed != null -> armedPrompt(armed)
|
||||||
|
movingKnight -> "Tap where the knight should go."
|
||||||
|
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."
|
||||||
|
building == BuildKind.WALL -> "Tap one of your cities to raise a wall."
|
||||||
|
building == BuildKind.KNIGHT -> "Tap an empty crossing at the end of your road to hire a knight."
|
||||||
|
else -> "Your turn. Build, improve, trade, or end the turn. Tap a knight to use it."
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.FREE_ROADS ->
|
||||||
|
if (mine) {
|
||||||
|
"Place ${state.pendingFreeRoads} free " +
|
||||||
|
if (state.pendingFreeRoads == 1) "road." else "roads."
|
||||||
|
} else {
|
||||||
|
"$turn is placing free roads…"
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.TRADE_PENDING -> {
|
||||||
|
val offer = ck.goodsOffer
|
||||||
|
val asking = offer?.asking?.takeIf { it >= 0 }
|
||||||
|
when {
|
||||||
|
offer == null || asking == null -> "Waiting for a reply…"
|
||||||
|
asking == me -> "${seats.label(offer.by)} offers you a trade."
|
||||||
|
offer.by == me -> "Waiting for ${seats.label(asking)} to answer your offer…"
|
||||||
|
else -> "${seats.label(offer.by)} has offered ${seats.label(asking)} a trade."
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.TRADE_COUNTERS ->
|
||||||
|
if (mine) {
|
||||||
|
"Nobody accepted, but there are counter-offers. Take one or turn them down."
|
||||||
|
} else {
|
||||||
|
"$turn is weighing counter-offers…"
|
||||||
|
}
|
||||||
|
|
||||||
|
CatanPhase.DISCARDING -> "Discarding…"
|
||||||
|
|
||||||
|
CatanPhase.CHORE -> {
|
||||||
|
val chore = ck.chores.firstOrNull()
|
||||||
|
val who = seats.label(chore?.seat ?: state.turn)
|
||||||
|
if (chore == null || chore.seat != me) {
|
||||||
|
when (chore) {
|
||||||
|
is PillageChore -> "The barbarians have landed. $who must give up a city."
|
||||||
|
is DiscardChore -> "$who must discard ${chore.count} cards."
|
||||||
|
else -> "Waiting for $who…"
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
when (chore) {
|
||||||
|
is DiscardChore -> "Discard ${chore.count} cards."
|
||||||
|
is GiveChore -> "Give ${chore.count} card${if (chore.count == 1) "" else "s"} to ${seats.lower(chore.to)}."
|
||||||
|
is PillageChore -> "The barbarians won. Tap a city of yours to give up."
|
||||||
|
is PickDeckChore -> "Choose a progress deck to draw from."
|
||||||
|
is DropProgressChore -> "You hold too many progress cards. Give one back."
|
||||||
|
is MetropolisChore -> "Tap the city that will bear the ${track(chore.track).lowercase()} metropolis."
|
||||||
|
is AqueductChore -> "Your aqueduct pays. Take any resource."
|
||||||
|
is RelocateChore -> "Your knight was driven off. Tap where it goes."
|
||||||
|
is RemoveKnightChore -> "Tap one of your knights to remove."
|
||||||
|
is PlaceKnightChore -> "Tap where your free ${knightName(chore.level).lowercase()} stands."
|
||||||
|
is SpyChore -> "Choose a progress card to take."
|
||||||
|
is SmithChore -> "Tap a knight to promote (${chore.left} left), or stop."
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun armedPrompt(kind: ProgressType): String = when (kind) {
|
||||||
|
ProgressType.ENGINEER -> "Engineer: tap a city to wall."
|
||||||
|
ProgressType.MEDICINE -> "Medicine: tap a settlement to upgrade."
|
||||||
|
ProgressType.MERCHANT -> "Merchant: tap a hex beside one of your buildings."
|
||||||
|
ProgressType.DIPLOMAT -> "Diplomat: tap an open road to remove."
|
||||||
|
ProgressType.INTRIGUE -> "Intrigue: tap an enemy knight beside your road."
|
||||||
|
ProgressType.INVENTOR -> "Inventor: tap two hexes to swap their tokens."
|
||||||
|
else -> "Tap the board."
|
||||||
|
}
|
||||||
|
|
||||||
|
/** "6 steps away", "1 step away" for the barbarian ship. */
|
||||||
|
fun barbarianSteps(steps: Int): String = "$steps ${if (steps == 1) "step" else "steps"} away"
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,415 @@
|
|||||||
|
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.horizontalScroll
|
||||||
|
import androidx.compose.foundation.layout.Arrangement
|
||||||
|
import androidx.compose.foundation.layout.Box
|
||||||
|
import androidx.compose.foundation.layout.Column
|
||||||
|
import androidx.compose.foundation.layout.Row
|
||||||
|
import androidx.compose.foundation.layout.fillMaxWidth
|
||||||
|
import androidx.compose.foundation.layout.heightIn
|
||||||
|
import androidx.compose.foundation.layout.padding
|
||||||
|
import androidx.compose.foundation.layout.size
|
||||||
|
import androidx.compose.foundation.layout.width
|
||||||
|
import androidx.compose.foundation.rememberScrollState
|
||||||
|
import androidx.compose.foundation.shape.CircleShape
|
||||||
|
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||||
|
import androidx.compose.material3.HorizontalDivider
|
||||||
|
import androidx.compose.material3.MaterialTheme
|
||||||
|
import androidx.compose.material3.Surface
|
||||||
|
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.alpha
|
||||||
|
import androidx.compose.ui.draw.clip
|
||||||
|
import androidx.compose.ui.graphics.Color
|
||||||
|
import androidx.compose.ui.text.font.FontWeight
|
||||||
|
import androidx.compose.ui.unit.dp
|
||||||
|
import androidx.compose.ui.unit.sp
|
||||||
|
import org.prolibertate.games.game.catan.CatanMove
|
||||||
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.CounterTrade
|
||||||
|
import org.prolibertate.games.game.catan.MaritimeTrade
|
||||||
|
import org.prolibertate.games.game.catan.OfferTrade
|
||||||
|
import org.prolibertate.games.game.catan.Resource
|
||||||
|
import org.prolibertate.games.game.catan.TradeOffer
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The trade board: the 2D version of Catan Universe's trade panel (see
|
||||||
|
* docs/RE-catan-universe.md). One panel slides up over the bottom of the board:
|
||||||
|
*
|
||||||
|
* header [Player | Bank] hint rival buttons
|
||||||
|
* top row the cards you GET, tinted with the other side's colour
|
||||||
|
* arrows
|
||||||
|
* bottom row the cards you GIVE, tinted with your colour
|
||||||
|
* right ▾ hide ✕ deny ✓ accept
|
||||||
|
*
|
||||||
|
* Like every Katan panel it decides nothing: what may be offered is asked of
|
||||||
|
* [CatanInteraction], and what a bank trade costs comes from the engine's legal list.
|
||||||
|
*/
|
||||||
|
|
||||||
|
private enum class TradeMode { PLAYER, BANK }
|
||||||
|
|
||||||
|
private fun Map<Resource, Int>.cards(): List<Resource> =
|
||||||
|
Resource.entries.flatMap { r -> List(this[r] ?: 0) { r } }
|
||||||
|
|
||||||
|
/** The panel for starting a trade: with the bank, or an offer to one rival or everyone. */
|
||||||
|
@Composable
|
||||||
|
fun CatanTradeBoard(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
seats: CatanSeats,
|
||||||
|
legal: List<CatanMove>,
|
||||||
|
onBank: (MaritimeTrade) -> Unit,
|
||||||
|
onOffer: (OfferTrade) -> Unit,
|
||||||
|
onClose: () -> Unit,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
style: CatanStyle = LocalCatanStyle.current,
|
||||||
|
) {
|
||||||
|
var mode by remember { mutableStateOf(TradeMode.BANK) }
|
||||||
|
var to by remember { mutableStateOf<Int?>(null) }
|
||||||
|
var give by remember { mutableStateOf(emptyMap<Resource, Int>()) }
|
||||||
|
var get by remember { mutableStateOf(emptyMap<Resource, Int>()) }
|
||||||
|
var bankGive by remember { mutableStateOf<Resource?>(null) }
|
||||||
|
var bankGet by remember { mutableStateOf<Resource?>(null) }
|
||||||
|
|
||||||
|
val bank = CatanInteraction.bankTrades(legal)
|
||||||
|
val giveCards = give.cards()
|
||||||
|
val getCards = get.cards()
|
||||||
|
val canSend = CatanInteraction.offerAllowed(state, seat, to, giveCards, getCards)
|
||||||
|
val bankMove = bankGive?.let { g -> bankGet?.takeIf { it in bank[g].orEmpty() }?.let { MaritimeTrade(g, it) } }
|
||||||
|
|
||||||
|
val rivals = (0 until state.playerCount).filter { it != seat }
|
||||||
|
val headerRight: @Composable () -> Unit = {
|
||||||
|
if (mode == TradeMode.PLAYER) {
|
||||||
|
RivalButtons(rivals, to, style, seats) { to = if (to == it) null else it }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
TradeBoardFrame(
|
||||||
|
modifier = modifier,
|
||||||
|
topTint = if (mode == TradeMode.PLAYER && to != null) style.seats[to!!] else Color.Gray,
|
||||||
|
bottomTint = style.seats[seat],
|
||||||
|
header = {
|
||||||
|
TradeTab(CatanText.TAB_BANK, mode == TradeMode.BANK) { mode = TradeMode.BANK }
|
||||||
|
TradeTab(CatanText.TAB_PLAYER, mode == TradeMode.PLAYER) { mode = TradeMode.PLAYER }
|
||||||
|
},
|
||||||
|
headline = when {
|
||||||
|
mode == TradeMode.PLAYER -> CatanText.TRADE_HINT_PLAYER
|
||||||
|
bank.isEmpty() -> CatanText.TRADE_HINT_BANK_EMPTY
|
||||||
|
else -> CatanText.TRADE_HINT_BANK
|
||||||
|
},
|
||||||
|
headerRight = headerRight,
|
||||||
|
topLabel = CatanText.YOU_RECEIVE_ROW,
|
||||||
|
bottomLabel = CatanText.YOU_GIVE_ROW,
|
||||||
|
topRow = {
|
||||||
|
if (mode == TradeMode.PLAYER) {
|
||||||
|
TradeCardRow(
|
||||||
|
counts = get,
|
||||||
|
limit = { 9 },
|
||||||
|
onChange = { get = it },
|
||||||
|
)
|
||||||
|
} else {
|
||||||
|
val choices = bankGive?.let { bank[it] }.orEmpty().toSet()
|
||||||
|
TradeCardRow(
|
||||||
|
counts = bankGet?.let { mapOf(it to 1) } ?: emptyMap(),
|
||||||
|
limit = { if (it in choices) 1 else 0 },
|
||||||
|
enabledOf = { it in choices },
|
||||||
|
onChange = {},
|
||||||
|
pick = { bankGet = if (bankGet == it) null else it },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
bottomRow = {
|
||||||
|
if (mode == TradeMode.PLAYER) {
|
||||||
|
TradeCardRow(
|
||||||
|
counts = give,
|
||||||
|
limit = { state.resources[seat][it] ?: 0 },
|
||||||
|
onChange = { give = it },
|
||||||
|
)
|
||||||
|
} else {
|
||||||
|
TradeCardRow(
|
||||||
|
counts = bank.keys.associateWith { CatanInteraction.bankRatio(state, seat, it) },
|
||||||
|
limit = { 0 },
|
||||||
|
enabledOf = { it in bank },
|
||||||
|
selected = bankGive,
|
||||||
|
caption = { r -> if (r in bank) "${CatanInteraction.bankRatio(state, seat, r)} : 1" else " " },
|
||||||
|
onChange = {},
|
||||||
|
pick = { r ->
|
||||||
|
bankGive = if (bankGive == r) null else r
|
||||||
|
bankGet = null
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
acceptEnabled = if (mode == TradeMode.PLAYER) canSend else bankMove != null,
|
||||||
|
onAccept = {
|
||||||
|
if (mode == TradeMode.PLAYER) {
|
||||||
|
onOffer(OfferTrade(to, giveCards, getCards))
|
||||||
|
} else {
|
||||||
|
bankMove?.let(onBank)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
denyEnabled = true,
|
||||||
|
onDeny = {
|
||||||
|
give = emptyMap()
|
||||||
|
get = emptyMap()
|
||||||
|
bankGive = null
|
||||||
|
bankGet = null
|
||||||
|
to = null
|
||||||
|
},
|
||||||
|
onHide = onClose,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The panel for an offer made to the local player: the same layout, read-only. ✓ accepts,
|
||||||
|
* ✕ declines, and *Counter…* turns the rows editable, pre-filled with the mirror of the offer.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
fun CatanTradeReplyBoard(
|
||||||
|
state: CatanState,
|
||||||
|
seat: Int,
|
||||||
|
offer: TradeOffer,
|
||||||
|
seats: CatanSeats,
|
||||||
|
canAccept: Boolean,
|
||||||
|
onAccept: () -> Unit,
|
||||||
|
onDecline: () -> Unit,
|
||||||
|
onCounter: (CounterTrade) -> Unit,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
style: CatanStyle = LocalCatanStyle.current,
|
||||||
|
) {
|
||||||
|
var countering by remember(offer) { mutableStateOf(false) }
|
||||||
|
var give by remember(offer) { mutableStateOf(offer.get.groupingBy { it }.eachCount()) }
|
||||||
|
var get by remember(offer) { mutableStateOf(offer.give.groupingBy { it }.eachCount()) }
|
||||||
|
val counter = CounterTrade(give.cards(), get.cards())
|
||||||
|
|
||||||
|
TradeBoardFrame(
|
||||||
|
modifier = modifier,
|
||||||
|
topTint = style.seats[offer.by],
|
||||||
|
bottomTint = style.seats[seat],
|
||||||
|
header = {
|
||||||
|
TradeTab(CatanText.COUNTER, countering) { countering = !countering }
|
||||||
|
},
|
||||||
|
headline = if (countering) {
|
||||||
|
CatanText.TRADE_HINT_COUNTER
|
||||||
|
} else {
|
||||||
|
CatanText.tradeSummary(
|
||||||
|
by = seats.label(offer.by),
|
||||||
|
to = if (offer.to == null) "the table" else "you",
|
||||||
|
give = offer.give,
|
||||||
|
get = offer.get,
|
||||||
|
)
|
||||||
|
},
|
||||||
|
headerRight = {},
|
||||||
|
topLabel = CatanText.YOU_RECEIVE_ROW,
|
||||||
|
bottomLabel = CatanText.YOU_GIVE_ROW,
|
||||||
|
topRow = {
|
||||||
|
if (countering) {
|
||||||
|
TradeCardRow(get, limit = { state.resources[offer.by][it] ?: 0 }, onChange = { get = it })
|
||||||
|
} else {
|
||||||
|
TradeCardRow(offer.give.groupingBy { it }.eachCount(), limit = { 0 }, onChange = {})
|
||||||
|
}
|
||||||
|
},
|
||||||
|
bottomRow = {
|
||||||
|
if (countering) {
|
||||||
|
TradeCardRow(give, limit = { state.resources[seat][it] ?: 0 }, onChange = { give = it })
|
||||||
|
} else {
|
||||||
|
TradeCardRow(offer.get.groupingBy { it }.eachCount(), limit = { 0 }, onChange = {})
|
||||||
|
}
|
||||||
|
},
|
||||||
|
acceptEnabled = if (countering) {
|
||||||
|
CatanInteraction.counterAllowed(state, seat, counter.give, counter.get)
|
||||||
|
} else {
|
||||||
|
canAccept
|
||||||
|
},
|
||||||
|
onAccept = { if (countering) onCounter(counter) else onAccept() },
|
||||||
|
denyEnabled = true,
|
||||||
|
onDeny = onDecline,
|
||||||
|
onHide = null,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Pieces
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun TradeBoardFrame(
|
||||||
|
topTint: Color,
|
||||||
|
bottomTint: Color,
|
||||||
|
header: @Composable () -> Unit,
|
||||||
|
headline: String,
|
||||||
|
headerRight: @Composable () -> Unit,
|
||||||
|
topLabel: String,
|
||||||
|
bottomLabel: String,
|
||||||
|
topRow: @Composable () -> Unit,
|
||||||
|
bottomRow: @Composable () -> Unit,
|
||||||
|
acceptEnabled: Boolean,
|
||||||
|
onAccept: () -> Unit,
|
||||||
|
denyEnabled: Boolean,
|
||||||
|
onDeny: () -> Unit,
|
||||||
|
onHide: (() -> Unit)?,
|
||||||
|
modifier: Modifier = Modifier,
|
||||||
|
) {
|
||||||
|
Surface(
|
||||||
|
modifier = modifier.fillMaxWidth(),
|
||||||
|
shape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp),
|
||||||
|
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.97f),
|
||||||
|
tonalElevation = 6.dp,
|
||||||
|
shadowElevation = 12.dp,
|
||||||
|
) {
|
||||||
|
Row(Modifier.padding(horizontal = 12.dp, vertical = 8.dp)) {
|
||||||
|
Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
header()
|
||||||
|
Text(
|
||||||
|
headline,
|
||||||
|
style = MaterialTheme.typography.bodySmall,
|
||||||
|
// Two lines, always: the panel keeps its height whatever is said.
|
||||||
|
minLines = 2,
|
||||||
|
maxLines = 2,
|
||||||
|
modifier = Modifier.weight(1f),
|
||||||
|
)
|
||||||
|
headerRight()
|
||||||
|
}
|
||||||
|
HorizontalDivider()
|
||||||
|
TintedRow(topTint, topLabel, topRow)
|
||||||
|
Text("⇣ ⇣ ⇣", modifier = Modifier.align(Alignment.CenterHorizontally), fontSize = 14.sp)
|
||||||
|
TintedRow(bottomTint, bottomLabel, bottomRow)
|
||||||
|
}
|
||||||
|
Column(
|
||||||
|
modifier = Modifier.padding(start = 10.dp).width(72.dp),
|
||||||
|
verticalArrangement = Arrangement.spacedBy(6.dp, Alignment.CenterVertically),
|
||||||
|
horizontalAlignment = Alignment.CenterHorizontally,
|
||||||
|
) {
|
||||||
|
// Always three slots, so the column does not shift when there is nothing to hide.
|
||||||
|
if (onHide != null) {
|
||||||
|
HudRoundButton("▾", caption = CatanText.HIDE, diameter = 48.dp, onClick = onHide)
|
||||||
|
} else {
|
||||||
|
Box(Modifier.size(48.dp))
|
||||||
|
}
|
||||||
|
HudRoundButton("✕", caption = CatanText.DENY, enabled = denyEnabled, tint = Color(0xFFC62828), diameter = 52.dp, onClick = onDeny)
|
||||||
|
HudRoundButton("✓", caption = CatanText.ACCEPT, enabled = acceptEnabled, tint = Color(0xFF2E7D32), diameter = 60.dp, onClick = onAccept)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun TintedRow(tint: Color, label: String, content: @Composable () -> Unit) {
|
||||||
|
val shape = RoundedCornerShape(12.dp)
|
||||||
|
Column(
|
||||||
|
Modifier
|
||||||
|
.fillMaxWidth()
|
||||||
|
.clip(shape)
|
||||||
|
.background(tint.copy(alpha = 0.18f))
|
||||||
|
.border(1.dp, tint.copy(alpha = 0.5f), shape)
|
||||||
|
.padding(horizontal = 8.dp, vertical = 4.dp),
|
||||||
|
) {
|
||||||
|
Text(label, fontSize = 10.sp, fontWeight = FontWeight.Bold)
|
||||||
|
Box(Modifier.horizontalScroll(rememberScrollState())) { content() }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Five resource cards in a row. Tapping a card adds one (up to [limit]); the "−" under it
|
||||||
|
* takes one back. A bank row passes [pick] instead, and a tap selects the card.
|
||||||
|
*/
|
||||||
|
@Composable
|
||||||
|
private fun TradeCardRow(
|
||||||
|
counts: Map<Resource, Int>,
|
||||||
|
limit: (Resource) -> Int,
|
||||||
|
onChange: (Map<Resource, Int>) -> Unit,
|
||||||
|
enabledOf: (Resource) -> Boolean = { true },
|
||||||
|
selected: Resource? = null,
|
||||||
|
caption: ((Resource) -> String)? = null,
|
||||||
|
pick: ((Resource) -> Unit)? = null,
|
||||||
|
) {
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||||
|
Resource.entries.forEach { resource ->
|
||||||
|
val n = counts[resource] ?: 0
|
||||||
|
Column(horizontalAlignment = Alignment.CenterHorizontally) {
|
||||||
|
ResourceTile(
|
||||||
|
resource = resource,
|
||||||
|
count = n,
|
||||||
|
selected = selected == resource,
|
||||||
|
enabled = enabledOf(resource) && (pick != null || n > 0 || limit(resource) > 0),
|
||||||
|
onClick = {
|
||||||
|
if (pick != null) {
|
||||||
|
pick(resource)
|
||||||
|
} else if (n < limit(resource)) {
|
||||||
|
onChange(counts + (resource to n + 1))
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)
|
||||||
|
if (caption != null) {
|
||||||
|
Text(caption(resource), fontSize = 11.sp, fontWeight = FontWeight.Bold)
|
||||||
|
} else {
|
||||||
|
// Always laid out so the row never changes height.
|
||||||
|
Text(
|
||||||
|
"−",
|
||||||
|
fontSize = 20.sp,
|
||||||
|
fontWeight = FontWeight.Bold,
|
||||||
|
modifier = Modifier
|
||||||
|
.alpha(if (n > 0 && pick == null && limit(resource) >= 0) 1f else 0f)
|
||||||
|
.clickable(enabled = n > 0 && pick == null) {
|
||||||
|
onChange(counts + (resource to n - 1))
|
||||||
|
}
|
||||||
|
.padding(horizontal = 14.dp),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Composable
|
||||||
|
private fun TradeTab(label: String, selected: Boolean, onClick: () -> Unit) {
|
||||||
|
val shape = RoundedCornerShape(50)
|
||||||
|
Text(
|
||||||
|
label,
|
||||||
|
fontSize = 13.sp,
|
||||||
|
fontWeight = FontWeight.Bold,
|
||||||
|
color = if (selected) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurface,
|
||||||
|
modifier = Modifier
|
||||||
|
.clip(shape)
|
||||||
|
.background(if (selected) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant)
|
||||||
|
.clickable(onClick = onClick)
|
||||||
|
.padding(horizontal = 14.dp, vertical = 8.dp),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** One round button per rival: tap to address the offer to them alone, tap again for everyone. */
|
||||||
|
@Composable
|
||||||
|
private fun RivalButtons(
|
||||||
|
rivals: List<Int>,
|
||||||
|
chosen: Int?,
|
||||||
|
style: CatanStyle,
|
||||||
|
seats: CatanSeats,
|
||||||
|
onTap: (Int) -> Unit,
|
||||||
|
) {
|
||||||
|
Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
|
||||||
|
rivals.forEach { rival ->
|
||||||
|
val picked = chosen == rival
|
||||||
|
Box(
|
||||||
|
Modifier
|
||||||
|
.size(40.dp)
|
||||||
|
.clip(CircleShape)
|
||||||
|
.background(style.seats[rival])
|
||||||
|
.border(if (picked) 4.dp else 1.dp, if (picked) Color.White else Color(0x55000000), CircleShape)
|
||||||
|
.clickable { onTap(rival) },
|
||||||
|
contentAlignment = Alignment.Center,
|
||||||
|
) {
|
||||||
|
Text(seats.label(rival).take(1).uppercase(), color = Color.White, fontWeight = FontWeight.Bold, fontSize = 14.sp)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -106,30 +106,33 @@ class CatalogTest {
|
|||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun `every reference game in the catalogue can be played`() {
|
fun `every game in the catalogue can be played`() {
|
||||||
// Every game the app ships is playable. The one exception is Katan,
|
// `available` is the release gate. Nothing is held back at the moment,
|
||||||
// listed so the slot exists and marked *Coming soon* until its engine
|
// so a production menu lists every game; a game parked behind the gate
|
||||||
// and screen land — `available = false` is what keeps an unfinished
|
// belongs in `devPreview`, and must say so rather than being quietly
|
||||||
// game out of a production build while leaving it visible on a dev one.
|
// unavailable everywhere.
|
||||||
assertEquals(
|
GameCatalog.all.filterNot { it.available }.forEach { game ->
|
||||||
listOf(GameCatalog.CATAN),
|
assertTrue("${game.id} is unavailable but not a dev preview", game.devPreview)
|
||||||
GameCatalog.all.filterNot { it.available }.map { it.id },
|
}
|
||||||
)
|
GameMenu.entries.forEach { menu ->
|
||||||
// It is also the only difference the two channels see in a menu.
|
val held = GameCatalog.inMenu(menu, includeComingSoon = true) -
|
||||||
val hiddenFromProduction = GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = true) -
|
GameCatalog.inMenu(menu, includeComingSoon = false).toSet()
|
||||||
GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = false)
|
held.forEach { assertTrue("${it.id} hidden from production without a preview flag", it.devPreview) }
|
||||||
assertEquals(listOf(GameCatalog.byId(GameCatalog.CATAN)!!), hiddenFromProduction)
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun `a preview game opens on a dev build and nowhere else`() {
|
fun `a preview game opens on a dev build and nowhere else`() {
|
||||||
val preview = GameCatalog.all.filter { it.devPreview }
|
GameCatalog.all.filter { it.devPreview }.forEach { game ->
|
||||||
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)
|
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))
|
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))
|
assertFalse("${game.id} must not open in production", game.playableIn(devBuild = false))
|
||||||
}
|
}
|
||||||
|
// The two games that were once previews now open everywhere.
|
||||||
|
listOf(GameCatalog.CATAN, GameCatalog.MEOWDOKU).forEach { id ->
|
||||||
|
val game = GameCatalog.byId(id)!!
|
||||||
|
assertTrue("$id should open in production", game.playableIn(devBuild = false))
|
||||||
|
}
|
||||||
// An ordinary finished game opens everywhere.
|
// An ordinary finished game opens everywhere.
|
||||||
val chess = GameCatalog.byId(GameCatalog.CHESS)!!
|
val chess = GameCatalog.byId(GameCatalog.CHESS)!!
|
||||||
assertTrue(chess.playableIn(devBuild = true) && chess.playableIn(devBuild = false))
|
assertTrue(chess.playableIn(devBuild = true) && chess.playableIn(devBuild = false))
|
||||||
@@ -174,6 +177,8 @@ class CatalogTest {
|
|||||||
GameCatalog.MASTERMIND,
|
GameCatalog.MASTERMIND,
|
||||||
GameCatalog.BACKGAMMON,
|
GameCatalog.BACKGAMMON,
|
||||||
GameCatalog.PIRATES,
|
GameCatalog.PIRATES,
|
||||||
|
GameCatalog.CATAN,
|
||||||
|
GameCatalog.MEOWDOKU,
|
||||||
),
|
),
|
||||||
GameCatalog.playable.map { it.id }.toSet(),
|
GameCatalog.playable.map { it.id }.toSet(),
|
||||||
)
|
)
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,182 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
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
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Engines playing Cities & Knights against each other. These are the
|
||||||
|
* playtests: every move is checked for legality, the state is round-tripped
|
||||||
|
* through its wire format as it goes, nothing may leave a seat without a move,
|
||||||
|
* and the game has to reach a result.
|
||||||
|
*/
|
||||||
|
class CatanCkSelfPlayTest {
|
||||||
|
|
||||||
|
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,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** What one game looked like, for the summary printed at the end. */
|
||||||
|
private data class Report(
|
||||||
|
val seed: Long,
|
||||||
|
val moves: Int,
|
||||||
|
val turns: Int,
|
||||||
|
val attacks: Int,
|
||||||
|
val progressPlayed: Int,
|
||||||
|
val metropolises: Int,
|
||||||
|
val winner: Int?,
|
||||||
|
val points: List<Int>,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun playOut(options: CatanOptions, seed: Long, cap: Int = 30_000): Pair<CatanState, Report> {
|
||||||
|
val ai = CatanAi()
|
||||||
|
var state = CatanRules.initialState(config(options, seed))
|
||||||
|
var moves = 0
|
||||||
|
var attacks = 0
|
||||||
|
var progress = 0
|
||||||
|
while (!CatanRules.isFinished(state)) {
|
||||||
|
assertTrue("seed $seed ran past $cap moves; log tail: ${state.log.takeLast(8)}", moves++ < cap)
|
||||||
|
val seat = CatanRules.currentSeat(state)
|
||||||
|
?: error("seed $seed: nobody on the clock in ${state.phase}; log tail: ${state.log.takeLast(8)}")
|
||||||
|
val legal = CatanRules.legalMoves(state, seat)
|
||||||
|
assertTrue("seed $seed: seat $seat has no legal move in ${state.phase}", legal.isNotEmpty())
|
||||||
|
val move = ai.chooseMove(state, seat, legal)
|
||||||
|
assertTrue(
|
||||||
|
"seed $seed: seat $seat chose the illegal move $move in ${state.phase}; " +
|
||||||
|
"log tail: ${state.log.takeLast(5)}",
|
||||||
|
CatanRules.isLegalMove(state, seat, move),
|
||||||
|
)
|
||||||
|
val before = state.ck!!.attacked
|
||||||
|
val wasAttacks = state.log.count { it.contains("The barbarians land") }
|
||||||
|
state = CatanRules.applyMove(state, seat, move)
|
||||||
|
attacks += state.log.count { it.contains("The barbarians land") } - wasAttacks
|
||||||
|
if (move is PlayProgress) progress++
|
||||||
|
if (!before && state.ck!!.attacked) Unit
|
||||||
|
|
||||||
|
if (moves % 97 == 0) {
|
||||||
|
val back = CatanRules.decodeState(CatanRules.encodeState(state))
|
||||||
|
assertEquals("seed $seed: the state did not survive its wire format", state, back)
|
||||||
|
// A seat's view never carries another seat's progress cards or the decks.
|
||||||
|
for (viewer in 0 until options.playerCount) {
|
||||||
|
val view = CatanRules.viewFor(state, viewer)
|
||||||
|
assertTrue(view.ck!!.decks.values.all { it.isEmpty() })
|
||||||
|
for (other in 0 until options.playerCount) {
|
||||||
|
if (other != viewer) {
|
||||||
|
val spied = (state.ck!!.chores.firstOrNull() as? SpyChore)
|
||||||
|
val allowed = spied != null && spied.seat == viewer && spied.target == other
|
||||||
|
if (!allowed) assertTrue(view.ck!!.progressHands[other].isEmpty())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
checkInvariants(state, seed)
|
||||||
|
}
|
||||||
|
val ck = state.ck!!
|
||||||
|
return state to Report(
|
||||||
|
seed = seed,
|
||||||
|
moves = moves,
|
||||||
|
turns = state.turnNumber,
|
||||||
|
attacks = attacks,
|
||||||
|
progressPlayed = progress,
|
||||||
|
metropolises = ck.metropolises.size,
|
||||||
|
winner = state.winner,
|
||||||
|
points = CatanRules.publicVictoryPoints(state),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Things that must hold in every state of every game. */
|
||||||
|
private fun checkInvariants(state: CatanState, seed: Long) {
|
||||||
|
val ck = state.ck!!
|
||||||
|
val tag = "seed $seed turn ${state.turnNumber}"
|
||||||
|
// Cards are conserved: no good is held in more copies than the bank started with.
|
||||||
|
for (good in Good.entries) {
|
||||||
|
val held = (0 until state.playerCount).sumOf { CatanCk.goodsOf(state, it)[good] ?: 0 }
|
||||||
|
val cap = if (good.isCommodity) BANK_PER_COMMODITY else BANK_PER_RESOURCE
|
||||||
|
assertTrue("$tag: $held ${good} cards exist, the bank only had $cap", held in 0..cap)
|
||||||
|
}
|
||||||
|
for (seat in 0 until state.playerCount) {
|
||||||
|
assertTrue(
|
||||||
|
"$tag: seat $seat holds negative cards",
|
||||||
|
CatanCk.goodsOf(state, seat).values.all { it >= 0 },
|
||||||
|
)
|
||||||
|
for (level in 1..3) {
|
||||||
|
assertTrue(
|
||||||
|
"$tag: seat $seat has more than two level-$level knights",
|
||||||
|
ck.knights.count { it.owner == seat && it.level == level } <= KNIGHTS_PER_LEVEL,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
assertTrue("$tag: too many progress cards in seat $seat's hand", ck.progressHands[seat].size <= PROGRESS_HAND_MAX + 1)
|
||||||
|
assertTrue("$tag: seat $seat has more than three walls", CatanCk.wallsOf(state, seat) <= MAX_WALLS)
|
||||||
|
assertTrue(
|
||||||
|
"$tag: seat $seat has more than five settlements",
|
||||||
|
state.buildings.count { it == CatanBuilding(BuildingType.SETTLEMENT, seat) } <= MAX_SETTLEMENTS,
|
||||||
|
)
|
||||||
|
assertTrue(
|
||||||
|
"$tag: seat $seat has more than four cities",
|
||||||
|
state.buildings.count { it == CatanBuilding(BuildingType.CITY, seat) } <= MAX_CITIES,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
// A knight stands on a crossing nothing else stands on, and no two share one.
|
||||||
|
assertEquals("$tag: two knights share a crossing", ck.knights.size, ck.knights.map { it.vertex }.toSet().size)
|
||||||
|
for (k in ck.knights) {
|
||||||
|
assertTrue("$tag: a knight stands on a building at ${k.vertex}", state.buildings[k.vertex] == null)
|
||||||
|
}
|
||||||
|
// Metropolises stand on cities of their owners.
|
||||||
|
for ((_, m) in ck.metropolises) {
|
||||||
|
assertEquals(
|
||||||
|
"$tag: a metropolis is not on its owner's city",
|
||||||
|
CatanBuilding(BuildingType.CITY, m.seat),
|
||||||
|
state.buildings[m.vertex],
|
||||||
|
)
|
||||||
|
}
|
||||||
|
// Every progress card exists exactly once, in a deck or a hand, or was played face up.
|
||||||
|
val cards = ck.decks.values.sumOf { it.size } + ck.progressHands.sumOf { it.size } + ck.progressVp.sum()
|
||||||
|
assertEquals("$tag: progress cards were lost or duplicated", 54, cards)
|
||||||
|
assertTrue("$tag: barbarians out of range", ck.barbarians in 1..BARBARIAN_STEPS)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `three engines play Cities and Knights to a finish`() {
|
||||||
|
val reports = (1L..12L).map { seed ->
|
||||||
|
val (state, report) = playOut(
|
||||||
|
CatanOptions(playerCount = 3, pointsToWin = 13, ruleSet = CatanRuleSet.CITIES_AND_KNIGHTS),
|
||||||
|
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!!) >= 13,
|
||||||
|
)
|
||||||
|
report
|
||||||
|
}
|
||||||
|
reports.forEach { println("CK3 $it") }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `four engines play Cities and Knights to a finish`() {
|
||||||
|
val reports = (101L..108L).map { seed ->
|
||||||
|
val (state, report) = playOut(
|
||||||
|
CatanOptions(playerCount = 4, pointsToWin = 13, ruleSet = CatanRuleSet.CITIES_AND_KNIGHTS),
|
||||||
|
seed,
|
||||||
|
)
|
||||||
|
assertEquals("seed $seed", CatanPhase.GAME_OVER, state.phase)
|
||||||
|
report
|
||||||
|
}
|
||||||
|
reports.forEach { println("CK4 $it") }
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,325 @@
|
|||||||
|
package org.prolibertate.games.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNotEquals
|
||||||
|
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 CatanSeafarersTest {
|
||||||
|
|
||||||
|
private val json = Json { encodeDefaults = true }
|
||||||
|
|
||||||
|
private fun options(players: Int = 3) =
|
||||||
|
CatanOptions(playerCount = players, pointsToWin = 12, ruleSet = CatanRuleSet.SEAFARERS)
|
||||||
|
|
||||||
|
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,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun start(players: Int = 3, seed: Long = 7L): CatanState =
|
||||||
|
CatanRules.initialState(config(options(players), seed))
|
||||||
|
|
||||||
|
/** A mid-game table on seat 0's turn with plenty of cards. */
|
||||||
|
private fun playing(seed: Long = 7L, adjust: CatanState.() -> CatanState = { this }): CatanState =
|
||||||
|
start(seed = seed).copy(
|
||||||
|
phase = CatanPhase.PLAYING,
|
||||||
|
turn = 0,
|
||||||
|
turnNumber = 1,
|
||||||
|
resources = List(3) { Resource.entries.associateWith { 5 } },
|
||||||
|
).adjust()
|
||||||
|
|
||||||
|
private fun CatanState.settle(vertex: Int, seat: Int, type: BuildingType = BuildingType.SETTLEMENT) =
|
||||||
|
copy(buildings = buildings.toMutableList().also { it[vertex] = CatanBuilding(type, seat) })
|
||||||
|
|
||||||
|
private fun CatanState.withShip(edge: Int, seat: Int) =
|
||||||
|
copy(sea = sea!!.let { it.copy(ships = it.ships.toMutableList().also { l -> l[edge] = seat }) })
|
||||||
|
|
||||||
|
private fun CatanState.withRoad(edge: Int, seat: Int) =
|
||||||
|
copy(roads = roads.toMutableList().also { it[edge] = seat })
|
||||||
|
|
||||||
|
/** A home-island vertex that touches open water, with a sea edge leaving it. */
|
||||||
|
private fun CatanState.coastVertex(): Int {
|
||||||
|
val topo = topo
|
||||||
|
return (0 until topo.VERTEX_COUNT).first { v ->
|
||||||
|
topo.vertexIsland[v] == sea!!.home &&
|
||||||
|
topo.VERTEX_EDGES[v].any { topo.edgeSea[it] && !topo.edgeLand[it] }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- The map -------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the new shores map is a big home island and three small ones`() {
|
||||||
|
val topo = SeaBoards.topology(SeaScenario.NEW_SHORES)
|
||||||
|
assertEquals(4, topo.islandCount)
|
||||||
|
val sizes = (0 until topo.islandCount).map { i -> topo.islandOf.count { it == i } }.sorted()
|
||||||
|
assertEquals(listOf(2, 3, 3, 21), sizes)
|
||||||
|
// Every coast is closed: nothing on land touches the edge of the frame.
|
||||||
|
for (e in 0 until topo.EDGE_COUNT) {
|
||||||
|
if (topo.EDGE_HEXES[e].size == 1) assertFalse("land on the frame edge at $e", topo.land[topo.EDGE_HEXES[e][0]])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a new game has gold, a desert, numbers on every other land hex, a pirate at sea and nine harbours`() {
|
||||||
|
repeat(5) { i ->
|
||||||
|
val s = start(seed = 100L + i)
|
||||||
|
val topo = s.topo
|
||||||
|
assertEquals(2, s.terrains.count { it == Terrain.GOLD })
|
||||||
|
assertEquals(1, s.terrains.count { it == Terrain.DESERT })
|
||||||
|
for (h in 0 until topo.HEX_COUNT) {
|
||||||
|
val land = s.terrains[h] != Terrain.SEA
|
||||||
|
assertEquals("hex $h", topo.land[h], land)
|
||||||
|
assertEquals("hex $h", land && s.terrains[h] != Terrain.DESERT, s.numbers[h] != 0)
|
||||||
|
}
|
||||||
|
assertEquals(Terrain.SEA, s.terrains[s.sea!!.pirate])
|
||||||
|
assertTrue(s.terrains[s.robber] == Terrain.DESERT)
|
||||||
|
assertEquals(9, s.ports.size)
|
||||||
|
// The red numbers are never neighbours.
|
||||||
|
val reds = (0 until topo.HEX_COUNT).filter { s.numbers[it] == 6 || s.numbers[it] == 8 }
|
||||||
|
for (a in reds) for (b in reds) if (a < b) assertFalse(topo.hexesAdjacent(a, b))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `setup places both settlements on the home island, with roads rather than ships`() {
|
||||||
|
val s = start()
|
||||||
|
val moves = CatanRules.legalMoves(s, 0).filterIsInstance<SetupPlace>()
|
||||||
|
assertTrue(moves.isNotEmpty())
|
||||||
|
assertTrue(moves.all { s.topo.vertexIsland[it.vertex] == s.sea!!.home })
|
||||||
|
assertTrue(moves.all { s.topo.edgeLand[it.edge] })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the state survives its wire format`() {
|
||||||
|
val s = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
assertEquals(s, CatanRules.decodeState(CatanRules.encodeState(s)))
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Ships ---------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a ship launches from a harbour town onto a sea edge and costs a lumber and a wool`() {
|
||||||
|
val s = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
val ships = CatanRules.legalMoves(s, 0).filterIsInstance<BuildShip>()
|
||||||
|
assertTrue(ships.isNotEmpty())
|
||||||
|
assertTrue(ships.all { s.topo.edgeSea[it.edge] })
|
||||||
|
val after = CatanRules.applyMove(s, 0, ships.first())
|
||||||
|
assertEquals(0, after.sea!!.ships.indexOfFirst { it == 0 }.let { if (it == ships.first().edge) 0 else 1 })
|
||||||
|
assertEquals(4, after.resources[0].getValue(Resource.LUMBER))
|
||||||
|
assertEquals(4, after.resources[0].getValue(Resource.WOOL))
|
||||||
|
assertEquals(5, after.resources[0].getValue(Resource.BRICK))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `no ship without the cards, and none sails out of nothing`() {
|
||||||
|
val bare = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
.let { it.copy(resources = it.resources.toMutableList().also { r -> r[0] = Resource.entries.associateWith { 0 } }) }
|
||||||
|
assertTrue(CatanRules.legalMoves(bare, 0).none { it is BuildShip })
|
||||||
|
// Nobody has a town or a fleet: there is nowhere to start from.
|
||||||
|
val nothing = playing()
|
||||||
|
assertTrue(CatanRules.legalMoves(nothing, 0).none { it is BuildShip })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the pirate keeps ships off the edges round its hex`() {
|
||||||
|
val s = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
val ship = CatanRules.legalMoves(s, 0).filterIsInstance<BuildShip>().first()
|
||||||
|
val seaHex = s.topo.EDGE_HEXES[ship.edge].first { !s.topo.land[it] }
|
||||||
|
val blocked = s.copy(sea = s.sea!!.copy(pirate = seaHex))
|
||||||
|
assertTrue(CatanRules.legalMoves(blocked, 0).filterIsInstance<BuildShip>().none { seaHex in s.topo.EDGE_HEXES[it.edge] })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a ship cannot sail the turn it is built, but can the next, from the open end only`() {
|
||||||
|
val s0 = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
val first = CatanRules.legalMoves(s0, 0).filterIsInstance<BuildShip>().first()
|
||||||
|
val s1 = CatanRules.applyMove(s0, 0, first)
|
||||||
|
assertTrue(CatanRules.legalMoves(s1, 0).none { it is MoveShip })
|
||||||
|
|
||||||
|
// Next turn (after the others pass), the lone ship is at an open end and can sail.
|
||||||
|
val s2 = s1.copy(sea = s1.sea!!.copy(builtThisTurn = emptyList(), shipMoved = false))
|
||||||
|
val sails = CatanRules.legalMoves(s2, 0).filterIsInstance<MoveShip>()
|
||||||
|
assertTrue(sails.isNotEmpty())
|
||||||
|
assertTrue(sails.all { it.from == first.edge && it.to != first.edge })
|
||||||
|
|
||||||
|
// Sailing uses the turn's one move.
|
||||||
|
val s3 = CatanRules.applyMove(s2, 0, sails.first())
|
||||||
|
assertTrue(s3.sea!!.shipMoved)
|
||||||
|
assertEquals(NO_PLAYER, s3.sea!!.ships[first.edge])
|
||||||
|
assertEquals(0, s3.sea!!.ships[sails.first().to])
|
||||||
|
assertTrue(CatanRules.legalMoves(s3, 0).none { it is MoveShip })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a ship in the middle of a route is stuck`() {
|
||||||
|
// Town - ship A - ship B: A has the town at one end and B at the other, so only B is at an open end.
|
||||||
|
val s0 = playing().let { it.settle(it.coastVertex(), 0) }
|
||||||
|
val a = CatanRules.legalMoves(s0, 0).filterIsInstance<BuildShip>().first().edge
|
||||||
|
var s = s0.withShip(a, 0)
|
||||||
|
val far = s.topo.EDGE_VERTICES[a].toList().first { s.buildings[it] == null }
|
||||||
|
val b = s.topo.VERTEX_EDGES[far].first { it != a && s.topo.edgeSea[it] && s.roads[it] == NO_PLAYER }
|
||||||
|
s = s.withShip(b, 0)
|
||||||
|
val movers = CatanRules.legalMoves(s, 0).filterIsInstance<MoveShip>().map { it.from }.toSet()
|
||||||
|
assertEquals(setOf(b), movers)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a settlement can rise at the end of a ship route, and the first on a new island scores the bonus`() {
|
||||||
|
val base = playing()
|
||||||
|
val topo = base.topo
|
||||||
|
val sea = base.sea!!
|
||||||
|
// A vertex on a small island, and a ship chain reaching it is too long to build by hand,
|
||||||
|
// so give the player the ship on the edge beside that vertex.
|
||||||
|
val vertex = (0 until topo.VERTEX_COUNT).first { v ->
|
||||||
|
val island = topo.vertexIsland[v]
|
||||||
|
island != -1 && island != sea.home &&
|
||||||
|
topo.VERTEX_EDGES[v].any { topo.edgeSea[it] }
|
||||||
|
}
|
||||||
|
val edge = topo.VERTEX_EDGES[vertex].first { topo.edgeSea[it] }
|
||||||
|
var s = base.withShip(edge, 0)
|
||||||
|
assertTrue(CatanRules.legalMoves(s, 0).any { it == BuildSettlement(vertex) })
|
||||||
|
|
||||||
|
val before = CatanRules.publicVictoryPoints(s)[0]
|
||||||
|
s = CatanRules.applyMove(s, 0, BuildSettlement(vertex))
|
||||||
|
assertEquals(before + 1 + SeaRules.ISLAND_BONUS, CatanRules.publicVictoryPoints(s)[0])
|
||||||
|
assertEquals(0, s.sea!!.islandBonus[topo.vertexIsland[vertex]])
|
||||||
|
|
||||||
|
// A second settlement on that island scores no second bonus.
|
||||||
|
val again = SeaRules.claimIsland(s, 1, vertex)
|
||||||
|
assertEquals(0, again.sea!!.islandBonus[topo.vertexIsland[vertex]])
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a road and a ship join a route only at a town of your own`() {
|
||||||
|
val base = playing()
|
||||||
|
val topo = base.topo
|
||||||
|
val v = base.coastVertex()
|
||||||
|
val road = topo.VERTEX_EDGES[v].first { topo.edgeLand[it] }
|
||||||
|
val ship = topo.VERTEX_EDGES[v].first { topo.edgeSea[it] && !topo.edgeLand[it] }
|
||||||
|
|
||||||
|
// With a town at the junction, road + ship is one route of two.
|
||||||
|
val withTown = base.settle(v, 0).withRoad(road, 0).withShip(ship, 0)
|
||||||
|
assertEquals(2, SeaRules.longestRouteFor(withTown, 0))
|
||||||
|
|
||||||
|
// Without it, they are two separate pieces.
|
||||||
|
val noTown = base.withRoad(road, 0).withShip(ship, 0)
|
||||||
|
assertEquals(1, SeaRules.longestRouteFor(noTown, 0))
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Pirate --------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `on a seven the roller may move the robber to land or the pirate to sea, and the pirate robs a ship's owner`() {
|
||||||
|
val s0 = playing().let { it.settle(it.coastVertex(), 1) }
|
||||||
|
val ship = SeaRules.buildShipMoves(s0, 1).first().edge
|
||||||
|
val s = s0.withShip(ship, 1).copy(phase = CatanPhase.ROBBER)
|
||||||
|
val moves = CatanRules.legalMoves(s, 0)
|
||||||
|
assertTrue(moves.any { it is MoveRobber })
|
||||||
|
assertTrue(moves.any { it is MovePirate })
|
||||||
|
// Robber moves are on land only.
|
||||||
|
assertTrue(moves.filterIsInstance<MoveRobber>().all { s.topo.land[s.topo.hexIndex.getValue(it.hex)] })
|
||||||
|
assertTrue(moves.filterIsInstance<MovePirate>().all { !s.topo.land[s.topo.hexIndex.getValue(it.hex)] })
|
||||||
|
|
||||||
|
val robbery = moves.filterIsInstance<MovePirate>().first { it.victim == 1 }
|
||||||
|
val after = CatanRules.applyMove(s, 0, robbery)
|
||||||
|
assertEquals(CatanPhase.PLAYING, after.phase)
|
||||||
|
assertEquals(s.topo.hexIndex.getValue(robbery.hex), after.sea!!.pirate)
|
||||||
|
assertEquals(s.resourceCount(0) + 1, after.resourceCount(0))
|
||||||
|
assertEquals(s.resourceCount(1) - 1, after.resourceCount(1))
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Gold ----------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `gold pays a resource of the owner's choice`() {
|
||||||
|
val base = playing()
|
||||||
|
val topo = base.topo
|
||||||
|
val goldHex = base.terrains.indexOf(Terrain.GOLD)
|
||||||
|
val number = base.numbers[goldHex]
|
||||||
|
val v = topo.HEX_CORNERS[goldHex].first { topo.vertexLand[it] }
|
||||||
|
// Seat 0's town beside the gold field; nothing else of theirs produces on that number.
|
||||||
|
val s = base.settle(v, 0).copy(
|
||||||
|
robber = (0 until topo.HEX_COUNT).first { topo.land[it] && it != goldHex && v !in topo.HEX_CORNERS[it] },
|
||||||
|
resources = List(3) { Resource.entries.associateWith { 0 } },
|
||||||
|
phase = CatanPhase.AWAIT_ROLL,
|
||||||
|
)
|
||||||
|
val dice = if (number <= 7) listOf(number - 1, 1) else listOf(6, number - 6)
|
||||||
|
val rolled = CatanRules.applyMove(s, 0, RollDice(forced = dice))
|
||||||
|
assertEquals(CatanPhase.GOLD, rolled.phase)
|
||||||
|
assertEquals(0, CatanRules.currentSeat(rolled))
|
||||||
|
val picks = CatanRules.legalMoves(rolled, 0)
|
||||||
|
assertEquals(Resource.entries.size, picks.size)
|
||||||
|
val after = CatanRules.applyMove(rolled, 0, PickGold(listOf(Resource.ORE)))
|
||||||
|
assertEquals(CatanPhase.PLAYING, after.phase)
|
||||||
|
assertEquals(1, after.resources[0].getValue(Resource.ORE))
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Whole games ---------------------------------------------------------
|
||||||
|
|
||||||
|
private data class Report(val seed: Long, val moves: Int, val ships: Int, val islandsTaken: Int, val points: List<Int>)
|
||||||
|
|
||||||
|
private fun playOut(options: CatanOptions, seed: Long, cap: Int = 20_000): Pair<CatanState, Report> {
|
||||||
|
val ai = CatanAi()
|
||||||
|
var state = CatanRules.initialState(config(options, seed))
|
||||||
|
var moves = 0
|
||||||
|
while (!CatanRules.isFinished(state)) {
|
||||||
|
assertTrue("seed $seed ran past $cap moves; log tail: ${state.log.takeLast(8)}", moves++ < cap)
|
||||||
|
val seat = CatanRules.currentSeat(state)
|
||||||
|
?: error("seed $seed: nobody on the clock in ${state.phase}; log tail: ${state.log.takeLast(8)}")
|
||||||
|
val legal = CatanRules.legalMoves(state, seat)
|
||||||
|
assertTrue("seed $seed: seat $seat has no legal move in ${state.phase}", legal.isNotEmpty())
|
||||||
|
val move = ai.chooseMove(state, seat, legal)
|
||||||
|
assertTrue(
|
||||||
|
"seed $seed: seat $seat chose the illegal move $move in ${state.phase}; log tail: ${state.log.takeLast(5)}",
|
||||||
|
CatanRules.isLegalMove(state, seat, move),
|
||||||
|
)
|
||||||
|
val next = CatanRules.applyMove(state, seat, move)
|
||||||
|
// The wire format must carry everything, every step.
|
||||||
|
if (moves % 25 == 0) assertEquals(next, CatanRules.decodeState(CatanRules.encodeState(next)))
|
||||||
|
state = next
|
||||||
|
}
|
||||||
|
val sea = state.sea!!
|
||||||
|
return state to Report(
|
||||||
|
seed, moves,
|
||||||
|
ships = sea.ships.count { it != NO_PLAYER },
|
||||||
|
islandsTaken = sea.islandBonus.count { it != NO_PLAYER },
|
||||||
|
points = CatanRules.publicVictoryPoints(state),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `engines finish Seafarers games at three and four players`() {
|
||||||
|
val reports = mutableListOf<Report>()
|
||||||
|
for ((players, seeds) in listOf(3 to listOf(1L, 2L, 3L, 4L), 4 to listOf(5L, 6L, 7L))) {
|
||||||
|
for (seed in seeds) {
|
||||||
|
val (state, report) = playOut(options(players), 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,
|
||||||
|
)
|
||||||
|
reports += report
|
||||||
|
}
|
||||||
|
}
|
||||||
|
println("Seafarers self-play: " + reports.joinToString("; ") {
|
||||||
|
"seed ${it.seed}: ${it.moves} moves, ${it.ships} ships, ${it.islandsTaken} islands, points ${it.points}"
|
||||||
|
})
|
||||||
|
// The engines must actually go to sea in at least some of the games.
|
||||||
|
assertNotEquals("no engine ever built a ship", 0, reports.sumOf { it.ships })
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,119 @@
|
|||||||
|
package org.prolibertate.games.game.engine
|
||||||
|
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Rule
|
||||||
|
import org.junit.Test
|
||||||
|
import org.junit.rules.TemporaryFolder
|
||||||
|
import java.io.File
|
||||||
|
|
||||||
|
class SavedGameStoreTest {
|
||||||
|
|
||||||
|
@get:Rule
|
||||||
|
val folder = TemporaryFolder()
|
||||||
|
|
||||||
|
private fun store() = SavedGameStore(File(folder.root, "saves"))
|
||||||
|
|
||||||
|
private fun match(gameId: String = "chess", state: String = "{\"turn\":1}", at: Long = 1_000L) = SavedMatch(
|
||||||
|
gameId = gameId,
|
||||||
|
config = TableConfig(
|
||||||
|
gameId = gameId,
|
||||||
|
seats = listOf(
|
||||||
|
PlayerSlot(0, "You", PlayerKind.HUMAN_LOCAL, 0),
|
||||||
|
PlayerSlot(1, "Computer", PlayerKind.AI, 1),
|
||||||
|
),
|
||||||
|
optionsJson = "{}",
|
||||||
|
seed = 42L,
|
||||||
|
),
|
||||||
|
localSeat = 0,
|
||||||
|
stateJson = state,
|
||||||
|
savedAtMillis = at,
|
||||||
|
summary = "White to move",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a saved game comes back exactly as it went in`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match())
|
||||||
|
assertEquals(match(), s.load("chess"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `there is nothing to load before anything is saved`() {
|
||||||
|
assertNull(store().load("chess"))
|
||||||
|
assertTrue(store().all().isEmpty())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a game keeps one slot, and saving again replaces it`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match(state = "one", at = 1))
|
||||||
|
s.save(match(state = "two", at = 2))
|
||||||
|
assertEquals("two", s.load("chess")!!.stateJson)
|
||||||
|
assertEquals(1, s.all().size)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `clearing forgets the game and leaves the others`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match("chess"))
|
||||||
|
s.save(match("golf"))
|
||||||
|
s.clear("chess")
|
||||||
|
assertNull(s.load("chess"))
|
||||||
|
assertEquals("golf", s.load("golf")!!.gameId)
|
||||||
|
s.clear("chess") // clearing nothing is fine
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the most recently played game is listed first`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match("chess", at = 10))
|
||||||
|
s.save(match("golf", at = 30))
|
||||||
|
s.save(match("catan", at = 20))
|
||||||
|
assertEquals(listOf("golf", "catan", "chess"), s.all().map { it.gameId })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a file that cannot be read is dropped rather than thrown`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match())
|
||||||
|
File(folder.root, "saves/chess.json").writeText("{ this is not json")
|
||||||
|
assertNull(s.load("chess"))
|
||||||
|
assertFalse(File(folder.root, "saves/chess.json").exists())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a file holding another game is not served as this one`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match("golf"))
|
||||||
|
File(folder.root, "saves/golf.json").copyTo(File(folder.root, "saves/chess.json"))
|
||||||
|
assertNull(s.load("chess"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a save that was cut off half way leaves the previous position`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match(state = "good"))
|
||||||
|
// What a kill mid-write leaves behind: a stray temporary file.
|
||||||
|
File(folder.root, "saves/chess.json.tmp").writeText("{ half a wri")
|
||||||
|
assertEquals("good", s.load("chess")!!.stateJson)
|
||||||
|
assertEquals(1, s.all().size)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a game id cannot climb out of the folder`() {
|
||||||
|
val bad = runCatching { store().load("../secret") }
|
||||||
|
assertTrue(bad.isFailure)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `an unknown field from a newer build does not stop a save loading`() {
|
||||||
|
val s = store()
|
||||||
|
s.save(match())
|
||||||
|
val file = File(folder.root, "saves/chess.json")
|
||||||
|
file.writeText(file.readText().replaceFirst("{", "{\"addedLater\":true,"))
|
||||||
|
assertEquals("chess", s.load("chess")!!.gameId)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,343 @@
|
|||||||
|
package org.prolibertate.games.game.meowdoku
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNotNull
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertThrows
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The puzzle, the generator, and the referee.
|
||||||
|
*
|
||||||
|
* The generator is where a wrong board would hurt most — a second answer makes
|
||||||
|
* the deduction unfair and the hearts a lottery — so the generation tests run
|
||||||
|
* over seeds rather than one lucky one.
|
||||||
|
*/
|
||||||
|
class MeowdokuRulesTest {
|
||||||
|
|
||||||
|
private val json = Json { encodeDefaults = true }
|
||||||
|
|
||||||
|
private fun soloConfig(options: MeowdokuOptions, seed: Long = 7L) = TableConfig(
|
||||||
|
gameId = "meowdoku",
|
||||||
|
seats = listOf(PlayerSlot(seat = 0, name = "P0", kind = PlayerKind.HUMAN_LOCAL, team = 0)),
|
||||||
|
optionsJson = json.encodeToString(options),
|
||||||
|
seed = seed,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun dealt(side: Int, seed: Long = 7L) =
|
||||||
|
MeowdokuRules.initialState(soloConfig(MeowdokuOptions(side = side), seed))
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A puzzle that must exist, named so the assertions below read as facts
|
||||||
|
* rather than as unwrapping.
|
||||||
|
*/
|
||||||
|
private fun <T> required(value: T?, message: String): T {
|
||||||
|
assertNotNull(message, value)
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
return value as T
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- generator ---------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every dealt board has exactly one answer`() {
|
||||||
|
for (side in 4..8) {
|
||||||
|
for (seed in 1L..6L) {
|
||||||
|
val puzzle = required(
|
||||||
|
MeowdokuGenerator.generate(side, seed),
|
||||||
|
"no puzzle for side $side seed $seed",
|
||||||
|
)
|
||||||
|
assertEquals(
|
||||||
|
"the $side board dealt from seed $seed has more than one answer",
|
||||||
|
1,
|
||||||
|
MeowdokuGenerator.countSolutions(side, puzzle.regions),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the same seed deals the same board`() {
|
||||||
|
val a = MeowdokuGenerator.generate(6, 12345L)
|
||||||
|
val b = MeowdokuGenerator.generate(6, 12345L)
|
||||||
|
assertEquals(a, b)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the answer satisfies the cats' own rules`() {
|
||||||
|
for (seed in 0L..20L) {
|
||||||
|
val puzzle = required(MeowdokuGenerator.generate(7, seed), "no puzzle for seed $seed")
|
||||||
|
val cats = puzzle.solutionSquares()
|
||||||
|
assertEquals(7, cats.size)
|
||||||
|
assertEquals(7, cats.map { it.first }.distinct().size)
|
||||||
|
assertEquals(7, cats.map { it.second }.distinct().size)
|
||||||
|
for (i in cats.indices) {
|
||||||
|
for (j in i + 1 until cats.size) {
|
||||||
|
val (r1, c1) = cats[i]
|
||||||
|
val (r2, c2) = cats[j]
|
||||||
|
val touches = kotlin.math.abs(r1 - r2) <= 1 && kotlin.math.abs(c1 - c2) <= 1
|
||||||
|
assertFalse("cats $cats touch", touches)
|
||||||
|
assertFalse("two cats share a colour", puzzle.regionOf(r1, c1) == puzzle.regionOf(r2, c2))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every colour owns exactly one cat and is contiguous`() {
|
||||||
|
val puzzle = required(MeowdokuGenerator.generate(6, 99L), "no puzzle for seed 99")
|
||||||
|
val cells = (0 until 6).flatMap { r -> (0 until 6).map { c -> r to c } }
|
||||||
|
|
||||||
|
val owned = (0 until 6).map { region ->
|
||||||
|
cells.filter { (r, c) -> puzzle.regionOf(r, c) == region }
|
||||||
|
}
|
||||||
|
owned.forEach { cellsOfRegion ->
|
||||||
|
assertTrue("an empty colour", cellsOfRegion.isNotEmpty())
|
||||||
|
val cats = cellsOfRegion.count { (r, c) -> puzzle.catCols[r] == c }
|
||||||
|
assertEquals("a colour with ${cats}cats", 1, cats)
|
||||||
|
|
||||||
|
// Contiguous: a breadth-first walk from the first cell reaches all.
|
||||||
|
val rest = cellsOfRegion.toMutableSet()
|
||||||
|
val queue = ArrayDeque(listOf(rest.first()))
|
||||||
|
val reached = mutableSetOf(queue.first())
|
||||||
|
while (queue.isNotEmpty()) {
|
||||||
|
val (r, c) = queue.removeFirst()
|
||||||
|
for ((dr, dc) in listOf(0 to 1, 0 to -1, 1 to 0, -1 to 0)) {
|
||||||
|
val next = (r + dr) to (c + dc)
|
||||||
|
if (next in rest && reached.add(next)) queue.add(next)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals("a colour in two pieces", rest.size, reached.size)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the cats can always be settled`() {
|
||||||
|
// A four board is the smallest deal, and its answer is the point where
|
||||||
|
// no-touch and one-per-line first stop contradicting each other.
|
||||||
|
val rng = SeededRng(42)
|
||||||
|
val cols = MeowdokuGenerator.placeCats(4, rng)
|
||||||
|
assertEquals(4, cols.size)
|
||||||
|
// The placement the generator returns is internally consistent.
|
||||||
|
for (row in 0 until 4) {
|
||||||
|
for (earlier in 0 until row) {
|
||||||
|
assertFalse(MeowdokuGenerator.catFitsHere(row, cols[earlier], cols))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- the referee -------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the board opens empty and seated for one`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
assertTrue(state.cats.isEmpty())
|
||||||
|
assertTrue(state.marks.isEmpty())
|
||||||
|
assertEquals(6, state.side)
|
||||||
|
assertEquals(3, state.heartsLeft)
|
||||||
|
assertEquals(0, state.catsFound)
|
||||||
|
assertEquals(0, MeowdokuRules.currentSeat(state))
|
||||||
|
assertFalse(MeowdokuRules.isFinished(state))
|
||||||
|
assertTrue(MeowdokuRules.legalMoves(state, 1).isEmpty())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a correct tap lands a cat and a wrong tap costs a heart`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val square = Square(0, state.catCols[0])
|
||||||
|
val found = MeowdokuRules.applyMove(state, 0, PlaceCat(square))
|
||||||
|
assertTrue(square in found.cats)
|
||||||
|
assertEquals(3, found.heartsLeft)
|
||||||
|
|
||||||
|
val wrongRow = (0 until state.side).first { it != square.row }
|
||||||
|
val wrong = Square(wrongRow, if (state.catCols[wrongRow] == 0) 1 else 0)
|
||||||
|
val missed = MeowdokuRules.applyMove(found, 0, PlaceCat(wrong))
|
||||||
|
assertTrue(wrong in missed.marks)
|
||||||
|
assertFalse(wrong in missed.cats)
|
||||||
|
assertEquals(2, missed.heartsLeft)
|
||||||
|
assertEquals(1, missed.wrongCats)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a board is solved by finding every cat`() {
|
||||||
|
var state = dealt(5)
|
||||||
|
for (row in 0 until 5) {
|
||||||
|
state = MeowdokuRules.applyMove(state, 0, PlaceCat(Square(row, state.catCols[row])))
|
||||||
|
}
|
||||||
|
assertTrue(state.solved)
|
||||||
|
assertTrue(MeowdokuRules.isFinished(state))
|
||||||
|
assertNull(MeowdokuRules.currentSeat(state))
|
||||||
|
assertTrue(MeowdokuRules.legalMoves(state, 0).isEmpty())
|
||||||
|
assertTrue(MeowdokuRules.summary(state).startsWith("Solved"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `running out of hearts loses the board`() {
|
||||||
|
val state = dealt(8, seed = 3L)
|
||||||
|
var lost = state
|
||||||
|
var row = 0
|
||||||
|
while (lost.heartsLeft > 0) {
|
||||||
|
// A wrong square: not the answer's column, in a row with no cat.
|
||||||
|
val wrongCol = if (state.catCols[row] == 0) 1 else 0
|
||||||
|
val before = lost.catsFound
|
||||||
|
lost = MeowdokuRules.applyMove(lost, 0, PlaceCat(Square(row, wrongCol)))
|
||||||
|
assertEquals(before, lost.catsFound)
|
||||||
|
row = (row + 1) % state.side
|
||||||
|
}
|
||||||
|
assertTrue(lost.lost)
|
||||||
|
assertTrue(MeowdokuRules.isFinished(lost))
|
||||||
|
assertEquals(0, lost.catsFound)
|
||||||
|
assertTrue(MeowdokuRules.summary(lost).startsWith("Lost"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a crossed square still takes a cat attempt`() {
|
||||||
|
// The double tap is one gesture pair: the first tap crosses the square
|
||||||
|
// and the second asks it. The cross the pair drew cannot veto the
|
||||||
|
// question that follows it.
|
||||||
|
val state = dealt(6)
|
||||||
|
val truth = Square(0, state.catCols[0])
|
||||||
|
val crossed = MeowdokuRules.applyMove(state, 0, TogglePencil(truth))
|
||||||
|
assertTrue(truth in crossed.marks)
|
||||||
|
assertTrue(
|
||||||
|
"the attempt is offered over its own cross",
|
||||||
|
PlaceCat(truth) in MeowdokuRules.legalMoves(crossed, 0),
|
||||||
|
)
|
||||||
|
|
||||||
|
val placed = MeowdokuRules.applyMove(crossed, 0, PlaceCat(truth))
|
||||||
|
assertTrue(truth in placed.cats)
|
||||||
|
assertFalse("the cat replaces the cross", truth in placed.marks)
|
||||||
|
assertEquals(3, placed.heartsLeft)
|
||||||
|
assertEquals(0, placed.wrongCats)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a wrong pair keeps its cross and spends a heart`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val wrongCol = if (state.catCols[1] == 0) 1 else 0
|
||||||
|
val wrong = Square(1, wrongCol)
|
||||||
|
val crossed = MeowdokuRules.applyMove(state, 0, TogglePencil(wrong))
|
||||||
|
val judged = MeowdokuRules.applyMove(crossed, 0, PlaceCat(wrong))
|
||||||
|
assertTrue(wrong in judged.marks)
|
||||||
|
assertFalse(wrong in judged.cats)
|
||||||
|
assertEquals(2, judged.heartsLeft)
|
||||||
|
assertEquals(1, judged.wrongCats)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `pencil marks are free notes`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val square = Square(2, if (state.catCols[2] == 5) 4 else 5)
|
||||||
|
val marked = MeowdokuRules.applyMove(state, 0, TogglePencil(square))
|
||||||
|
assertTrue(square in marked.marks)
|
||||||
|
assertEquals(3, marked.heartsLeft)
|
||||||
|
assertEquals(0, marked.wrongCats)
|
||||||
|
|
||||||
|
val erased = MeowdokuRules.applyMove(marked, 0, TogglePencil(square))
|
||||||
|
assertTrue(erased.marks.isEmpty())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a cat square is never a pencil square`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val cat = Square(0, state.catCols[0])
|
||||||
|
val found = MeowdokuRules.applyMove(state, 0, PlaceCat(cat))
|
||||||
|
assertFalse(
|
||||||
|
"legal moves offer pencil on a cat",
|
||||||
|
MeowdokuRules.legalMoves(found, 0).any {
|
||||||
|
it is TogglePencil && it.square == cat
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a hint shows a missing cat and costs one token`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val hinted = MeowdokuRules.applyMove(state, 0, TakeHint)
|
||||||
|
assertEquals(1, hinted.catsFound)
|
||||||
|
assertEquals(2, hinted.hintsLeft)
|
||||||
|
|
||||||
|
// Out of hints the move stops being offered.
|
||||||
|
var drained = MeowdokuRules.applyMove(
|
||||||
|
MeowdokuRules.applyMove(hinted, 0, TakeHint),
|
||||||
|
0,
|
||||||
|
TakeHint,
|
||||||
|
)
|
||||||
|
assertEquals(0, drained.hintsLeft)
|
||||||
|
// A note on a square that is not a cat, so the pencil move is legal.
|
||||||
|
val note = Square(0, if (state.catCols[0] == 0) 1 else 0)
|
||||||
|
drained = MeowdokuRules.applyMove(drained, 0, TogglePencil(note))
|
||||||
|
assertFalse(TakeHint in MeowdokuRules.legalMoves(drained, 0))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a hint over a wrong pencil reveals the cat anyway`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val truth = Square(0, state.catCols[0])
|
||||||
|
val pencilled = MeowdokuRules.applyMove(state, 0, TogglePencil(truth))
|
||||||
|
val revealed = MeowdokuRules.applyMove(pencilled, 0, TakeHint)
|
||||||
|
assertTrue(truth in revealed.cats)
|
||||||
|
assertFalse(truth in revealed.marks)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the computer can finish any board it is handed`() {
|
||||||
|
var state = dealt(7)
|
||||||
|
var guard = 0
|
||||||
|
while (!MeowdokuRules.isFinished(state) && guard++ < 100) {
|
||||||
|
val legal = MeowdokuRules.legalMoves(state, 0)
|
||||||
|
assertFalse("stuck with cats still missing", legal.isEmpty())
|
||||||
|
state = MeowdokuRules.applyMove(state, 0, MeowdokuAi.chooseMove(state, 0, legal))
|
||||||
|
}
|
||||||
|
assertTrue("the AI did not solve the board", state.solved)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- state across the wire and the save slot ---------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `state and moves survive their json`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
val decoded = MeowdokuRules.decodeState(MeowdokuRules.encodeState(state))
|
||||||
|
assertEquals(state, decoded)
|
||||||
|
|
||||||
|
val move: MeowdokuMove = PlaceCat(Square(1, 1))
|
||||||
|
assertEquals(move, MeowdokuRules.decodeMove(MeowdokuRules.encodeMove(move)))
|
||||||
|
assertEquals(TakeHint, MeowdokuRules.decodeMove(MeowdokuRules.encodeMove(TakeHint)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `nothing is hidden from the only seat`() {
|
||||||
|
val state = dealt(6)
|
||||||
|
assertEquals(state, MeowdokuRules.viewFor(state, 0))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a table with two seats is refused`() {
|
||||||
|
val config = TableConfig(
|
||||||
|
gameId = "meowdoku",
|
||||||
|
seats = listOf(
|
||||||
|
PlayerSlot(0, "P0", PlayerKind.HUMAN_LOCAL, 0),
|
||||||
|
PlayerSlot(1, "P1", PlayerKind.AI, 1),
|
||||||
|
),
|
||||||
|
optionsJson = json.encodeToString(MeowdokuOptions()),
|
||||||
|
seed = 1L,
|
||||||
|
)
|
||||||
|
assertThrows(IllegalArgumentException::class.java) {
|
||||||
|
MeowdokuRules.initialState(config)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the options guard their own board`() {
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { MeowdokuOptions(side = 3) }
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { MeowdokuOptions(side = 11) }
|
||||||
|
assertThrows(IllegalArgumentException::class.java) { MeowdokuOptions(hearts = 0) }
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
package org.prolibertate.games.game.yahtzee
|
||||||
|
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
class YahtzeeStatsTest {
|
||||||
|
private fun game(total: Int, bonus: Boolean = false, yahtzees: Int = 0, won: Boolean = true) =
|
||||||
|
YahtzeeRecord(total, bonus, yahtzees, zeros = 0, players = 2, won = won)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun firstGameHasNothingToCompareTo() {
|
||||||
|
val c = compareToHistory(emptyList(), game(200))
|
||||||
|
assertEquals(1, c.rank)
|
||||||
|
assertEquals(0, c.previousGames)
|
||||||
|
assertNull(c.bestBefore)
|
||||||
|
assertNull(c.averageBefore)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun ranksAgainstPreviousGames() {
|
||||||
|
val history = listOf(game(150, bonus = true, yahtzees = 1), game(250), game(200, won = false))
|
||||||
|
val c = compareToHistory(history, game(220))
|
||||||
|
assertEquals(2, c.rank)
|
||||||
|
assertEquals(4, c.gamesRanked)
|
||||||
|
assertEquals(250, c.bestBefore)
|
||||||
|
assertEquals(200.0, c.averageBefore!!, 0.001)
|
||||||
|
assertEquals(1, c.yahtzeesBefore)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,191 @@
|
|||||||
|
package org.prolibertate.games.net
|
||||||
|
|
||||||
|
import kotlinx.coroutines.CoroutineScope
|
||||||
|
import kotlinx.coroutines.Dispatchers
|
||||||
|
import kotlinx.coroutines.Job
|
||||||
|
import kotlinx.coroutines.cancel
|
||||||
|
import kotlinx.coroutines.delay
|
||||||
|
import kotlinx.coroutines.runBlocking
|
||||||
|
import org.junit.After
|
||||||
|
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.Rule
|
||||||
|
import org.junit.Test
|
||||||
|
import org.junit.rules.TemporaryFolder
|
||||||
|
import org.prolibertate.games.game.engine.GameAi
|
||||||
|
import org.prolibertate.games.game.engine.GameRules
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.SavedGameStore
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
import java.io.File
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Saving a table as it is played, and starting a table from a save.
|
||||||
|
*
|
||||||
|
* The game here is a counter: one seat, a move adds one, and it is finished at
|
||||||
|
* [GOAL]. It has hidden state — [Counter.secret] — so the tests can check that
|
||||||
|
* what is saved is the true state, not the view a player is shown.
|
||||||
|
*/
|
||||||
|
class MatchSaverTest {
|
||||||
|
|
||||||
|
@get:Rule
|
||||||
|
val folder = TemporaryFolder()
|
||||||
|
|
||||||
|
private val scopes = mutableListOf<CoroutineScope>()
|
||||||
|
|
||||||
|
@After
|
||||||
|
fun tearDown() {
|
||||||
|
scopes.forEach { it.cancel() }
|
||||||
|
}
|
||||||
|
|
||||||
|
private data class Counter(val n: Int, val secret: String)
|
||||||
|
|
||||||
|
private object Rules : GameRules<Counter, String> {
|
||||||
|
override val gameId = "counter"
|
||||||
|
override fun initialState(config: TableConfig) = Counter(0, "hidden-${config.seed}")
|
||||||
|
override fun currentSeat(state: Counter): Int? = if (state.n >= GOAL) null else 0
|
||||||
|
override fun legalMoves(state: Counter, seat: Int) = if (state.n >= GOAL) emptyList() else listOf("add")
|
||||||
|
override fun applyMove(state: Counter, seat: Int, move: String) = state.copy(n = state.n + 1)
|
||||||
|
override fun isFinished(state: Counter) = state.n >= GOAL
|
||||||
|
override fun summary(state: Counter) = "at ${state.n}"
|
||||||
|
override fun viewFor(state: Counter, seat: Int) = state.copy(secret = "")
|
||||||
|
override fun encodeState(state: Counter) = "${state.n}|${state.secret}"
|
||||||
|
override fun decodeState(json: String): Counter {
|
||||||
|
val (n, secret) = json.split("|", limit = 2)
|
||||||
|
return Counter(n.toInt(), secret)
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun encodeMove(move: String) = move
|
||||||
|
override fun decodeMove(json: String) = json
|
||||||
|
}
|
||||||
|
|
||||||
|
private val config = TableConfig(
|
||||||
|
gameId = "counter",
|
||||||
|
seats = listOf(PlayerSlot(0, "You", PlayerKind.HUMAN_LOCAL, 0)),
|
||||||
|
optionsJson = "{}",
|
||||||
|
seed = 7L,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun scope() = CoroutineScope(Job() + Dispatchers.Default).also { scopes += it }
|
||||||
|
|
||||||
|
private fun controller(): MatchController<Counter, String> = MatchController(
|
||||||
|
rules = Rules,
|
||||||
|
ai = object : GameAi<Counter, String> {
|
||||||
|
override fun chooseMove(state: Counter, seat: Int, legal: List<String>) = legal.first()
|
||||||
|
},
|
||||||
|
config = config,
|
||||||
|
scope = scope(),
|
||||||
|
role = MatchController.Role.HOST,
|
||||||
|
localSeats = setOf(0),
|
||||||
|
primarySeat = 0,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun store() = SavedGameStore(File(folder.root, "saves"))
|
||||||
|
|
||||||
|
private fun waitFor(what: String, check: () -> Boolean) = runBlocking {
|
||||||
|
repeat(200) {
|
||||||
|
if (check()) return@runBlocking
|
||||||
|
delay(10)
|
||||||
|
}
|
||||||
|
error("Timed out waiting for $what")
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun saver(s: SavedGameStore, c: MatchController<Counter, String>) =
|
||||||
|
MatchSaver(s, "counter", config, localSeat = 0, scope = scope(), clock = { 123L }).also {
|
||||||
|
it.start()
|
||||||
|
c.onHostState = it::offer
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every position the table reaches is kept, with the true state`() {
|
||||||
|
val s = store()
|
||||||
|
val c = controller()
|
||||||
|
saver(s, c)
|
||||||
|
c.startAsHost(emptyList())
|
||||||
|
waitFor("the deal") { c.state.value != null }
|
||||||
|
c.submit("add")
|
||||||
|
c.submit("add")
|
||||||
|
waitFor("two moves") { s.load("counter")?.stateJson?.startsWith("2|") == true }
|
||||||
|
|
||||||
|
val saved = s.load("counter")!!
|
||||||
|
assertEquals("2|hidden-7", saved.stateJson) // the hidden part is saved; the view blanks it
|
||||||
|
assertEquals("at 2", saved.summary)
|
||||||
|
assertEquals(123L, saved.savedAtMillis)
|
||||||
|
assertEquals(config, saved.config)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a table started from a save carries on from where it stood`() {
|
||||||
|
val s = store()
|
||||||
|
val first = controller()
|
||||||
|
saver(s, first)
|
||||||
|
first.startAsHost(emptyList())
|
||||||
|
waitFor("the deal") { first.state.value != null }
|
||||||
|
repeat(3) { first.submit("add") }
|
||||||
|
waitFor("three moves") { s.load("counter")?.stateJson?.startsWith("3|") == true }
|
||||||
|
first.close()
|
||||||
|
|
||||||
|
val second = controller()
|
||||||
|
assertTrue(second.restore(s.load("counter")!!.stateJson))
|
||||||
|
second.startAsHost(emptyList())
|
||||||
|
waitFor("the restored table") { second.state.value != null }
|
||||||
|
assertEquals(3, second.state.value!!.n)
|
||||||
|
second.submit("add")
|
||||||
|
waitFor("a move after resuming") { second.state.value!!.n == 4 }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a save the game cannot read is refused and the table is dealt afresh`() {
|
||||||
|
val c = controller()
|
||||||
|
assertFalse(c.restore("not a counter"))
|
||||||
|
c.startAsHost(emptyList())
|
||||||
|
waitFor("a fresh deal") { c.state.value != null }
|
||||||
|
assertEquals(0, c.state.value!!.n)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a finished game is not kept`() {
|
||||||
|
val s = store()
|
||||||
|
val c = controller()
|
||||||
|
saver(s, c)
|
||||||
|
c.startAsHost(emptyList())
|
||||||
|
waitFor("the deal") { s.load("counter") != null }
|
||||||
|
repeat(GOAL) { c.submit("add") }
|
||||||
|
waitFor("the finish") { c.finished.value }
|
||||||
|
waitFor("the slot to clear") { s.load("counter") == null }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `flush writes the position the background writer has not reached`() {
|
||||||
|
val s = store()
|
||||||
|
val saver = MatchSaver(s, "counter", config, 0, scope(), clock = { 1L })
|
||||||
|
// Not started: nothing is written in the background at all.
|
||||||
|
saver.offer(MatchController.HostSnapshot(false, "at 5") { "5|x" })
|
||||||
|
assertNull(s.load("counter"))
|
||||||
|
saver.flush()
|
||||||
|
assertEquals("5|x", s.load("counter")!!.stateJson)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `ending a game on purpose forgets it and writes no more`() {
|
||||||
|
val s = store()
|
||||||
|
val saver = MatchSaver(s, "counter", config, 0, scope(), clock = { 1L })
|
||||||
|
saver.offer(MatchController.HostSnapshot(false, "at 1") { "1|x" })
|
||||||
|
saver.flush()
|
||||||
|
assertNotNull(s.load("counter"))
|
||||||
|
saver.discard()
|
||||||
|
assertNull(s.load("counter"))
|
||||||
|
// Leaving after ending must not put it back.
|
||||||
|
saver.offer(MatchController.HostSnapshot(false, "at 2") { "2|x" })
|
||||||
|
saver.flush()
|
||||||
|
assertNull(s.load("counter"))
|
||||||
|
}
|
||||||
|
|
||||||
|
private companion object {
|
||||||
|
const val GOAL = 5
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,177 @@
|
|||||||
|
package org.prolibertate.games.net
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
import org.prolibertate.games.game.GameCatalog
|
||||||
|
import org.prolibertate.games.game.engine.GameAi
|
||||||
|
import org.prolibertate.games.game.engine.GameRules
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
import org.prolibertate.games.ui.seatCountFor
|
||||||
|
import org.prolibertate.games.game.backgammon.BackgammonAi
|
||||||
|
import org.prolibertate.games.game.backgammon.BackgammonOptions
|
||||||
|
import org.prolibertate.games.game.backgammon.BackgammonRules
|
||||||
|
import org.prolibertate.games.game.catan.CatanAi
|
||||||
|
import org.prolibertate.games.game.catan.CatanOptions
|
||||||
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
|
import org.prolibertate.games.game.checkers.CheckersAi
|
||||||
|
import org.prolibertate.games.game.checkers.CheckersOptions
|
||||||
|
import org.prolibertate.games.game.checkers.CheckersRules
|
||||||
|
import org.prolibertate.games.game.chess.ChessAi
|
||||||
|
import org.prolibertate.games.game.chess.ChessOptions
|
||||||
|
import org.prolibertate.games.game.chess.ChessRules
|
||||||
|
import org.prolibertate.games.game.crazyeights.CrazyEightsAi
|
||||||
|
import org.prolibertate.games.game.crazyeights.CrazyEightsOptions
|
||||||
|
import org.prolibertate.games.game.crazyeights.CrazyEightsRules
|
||||||
|
import org.prolibertate.games.game.cribbage.CribbageAi
|
||||||
|
import org.prolibertate.games.game.cribbage.CribbageOptions
|
||||||
|
import org.prolibertate.games.game.cribbage.CribbageRules
|
||||||
|
import org.prolibertate.games.game.euchre.EuchreAi
|
||||||
|
import org.prolibertate.games.game.euchre.EuchreOptions
|
||||||
|
import org.prolibertate.games.game.euchre.EuchreRules
|
||||||
|
import org.prolibertate.games.game.freecell.FreeCellOptions
|
||||||
|
import org.prolibertate.games.game.freecell.FreeCellRules
|
||||||
|
import org.prolibertate.games.game.golf.GolfAi
|
||||||
|
import org.prolibertate.games.game.golf.GolfOptions
|
||||||
|
import org.prolibertate.games.game.golf.GolfRules
|
||||||
|
import org.prolibertate.games.game.hearts.HeartsAi
|
||||||
|
import org.prolibertate.games.game.hearts.HeartsOptions
|
||||||
|
import org.prolibertate.games.game.hearts.HeartsRules
|
||||||
|
import org.prolibertate.games.game.kaiser.KaiserAi
|
||||||
|
import org.prolibertate.games.game.kaiser.KaiserOptions
|
||||||
|
import org.prolibertate.games.game.kaiser.KaiserRules
|
||||||
|
import org.prolibertate.games.game.klondike.KlondikeAi
|
||||||
|
import org.prolibertate.games.game.klondike.KlondikeOptions
|
||||||
|
import org.prolibertate.games.game.klondike.KlondikeRules
|
||||||
|
import org.prolibertate.games.game.mastermind.MastermindAi
|
||||||
|
import org.prolibertate.games.game.mastermind.MastermindOptions
|
||||||
|
import org.prolibertate.games.game.mastermind.MastermindRules
|
||||||
|
import org.prolibertate.games.game.morris.MorrisAi
|
||||||
|
import org.prolibertate.games.game.morris.MorrisOptions
|
||||||
|
import org.prolibertate.games.game.morris.MorrisRules
|
||||||
|
import org.prolibertate.games.game.pegsolitaire.PegSolitaireAi
|
||||||
|
import org.prolibertate.games.game.pegsolitaire.PegSolitaireOptions
|
||||||
|
import org.prolibertate.games.game.pegsolitaire.PegSolitaireRules
|
||||||
|
import org.prolibertate.games.game.pirates.PiratesAi
|
||||||
|
import org.prolibertate.games.game.pirates.PiratesOptions
|
||||||
|
import org.prolibertate.games.game.pirates.PiratesRules
|
||||||
|
import org.prolibertate.games.game.president.PresidentAi
|
||||||
|
import org.prolibertate.games.game.president.PresidentOptions
|
||||||
|
import org.prolibertate.games.game.president.PresidentRules
|
||||||
|
import org.prolibertate.games.game.pyramid.PyramidOptions
|
||||||
|
import org.prolibertate.games.game.pyramid.PyramidRules
|
||||||
|
import org.prolibertate.games.game.sequence.SequenceAi
|
||||||
|
import org.prolibertate.games.game.sequence.SequenceOptions
|
||||||
|
import org.prolibertate.games.game.sequence.SequenceRules
|
||||||
|
import org.prolibertate.games.game.solitaire.FirstLegalAi
|
||||||
|
import org.prolibertate.games.game.spider.SpiderOptions
|
||||||
|
import org.prolibertate.games.game.spider.SpiderRules
|
||||||
|
import org.prolibertate.games.game.tayu.TayuAi
|
||||||
|
import org.prolibertate.games.game.tayu.TayuOptions
|
||||||
|
import org.prolibertate.games.game.tayu.TayuRules
|
||||||
|
import org.prolibertate.games.game.wizard.WizardAi
|
||||||
|
import org.prolibertate.games.game.wizard.WizardOptions
|
||||||
|
import org.prolibertate.games.game.wizard.WizardRules
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeAi
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeOptions
|
||||||
|
import org.prolibertate.games.game.yahtzee.YahtzeeRules
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Every game can be saved and picked up again.
|
||||||
|
*
|
||||||
|
* For each game in the catalogue a table is dealt and played by the computer, and
|
||||||
|
* at every single move the whole true state is encoded and decoded again — which
|
||||||
|
* is exactly what saving it to disk and resuming does — and play carries on from
|
||||||
|
* the decoded copy. A game whose state does not survive that, or that cannot make
|
||||||
|
* a legal move from a state it has been through it, fails here.
|
||||||
|
*/
|
||||||
|
class SaveRoundTripAllGamesTest {
|
||||||
|
|
||||||
|
private val json = Json { encodeDefaults = true }
|
||||||
|
|
||||||
|
private fun <S : Any, M : Any> exercise(
|
||||||
|
gameId: String,
|
||||||
|
rules: GameRules<S, M>,
|
||||||
|
ai: GameAi<S, M>,
|
||||||
|
optionsJson: String,
|
||||||
|
steps: Int = 120,
|
||||||
|
) {
|
||||||
|
val seats = seatCountFor(gameId, optionsJson)
|
||||||
|
val config = TableConfig(
|
||||||
|
gameId = gameId,
|
||||||
|
seats = (0 until seats).map {
|
||||||
|
PlayerSlot(it, "P$it", if (it == 0) PlayerKind.HUMAN_LOCAL else PlayerKind.AI, it)
|
||||||
|
},
|
||||||
|
optionsJson = optionsJson,
|
||||||
|
seed = 20240607L,
|
||||||
|
)
|
||||||
|
var state = rules.initialState(config)
|
||||||
|
var moves = 0
|
||||||
|
repeat(steps) {
|
||||||
|
if (rules.isFinished(state)) return
|
||||||
|
// The save and the resume: what goes to disk, and what comes back.
|
||||||
|
val saved = rules.encodeState(state)
|
||||||
|
val back = rules.decodeState(saved)
|
||||||
|
assertEquals("$gameId: a saved state encodes differently after a resume", saved, rules.encodeState(back))
|
||||||
|
assertEquals(
|
||||||
|
"$gameId: a resumed state is not on the same seat's turn",
|
||||||
|
rules.currentSeat(state),
|
||||||
|
rules.currentSeat(back),
|
||||||
|
)
|
||||||
|
assertEquals(
|
||||||
|
"$gameId: a resumed state has different legal moves",
|
||||||
|
rules.currentSeat(state)?.let { rules.legalMoves(state, it) },
|
||||||
|
rules.currentSeat(back)?.let { rules.legalMoves(back, it) },
|
||||||
|
)
|
||||||
|
state = back
|
||||||
|
|
||||||
|
val seat = rules.currentSeat(state) ?: return // waiting on a scoreboard, which is not a move
|
||||||
|
val legal = rules.legalMoves(state, seat)
|
||||||
|
if (legal.isEmpty()) return
|
||||||
|
val move = ai.chooseMove(state, seat, legal)
|
||||||
|
assertTrue("$gameId: move $move is not legal after a resume", rules.isLegalMove(state, seat, move))
|
||||||
|
state = rules.applyMove(state, seat, move)
|
||||||
|
moves++
|
||||||
|
}
|
||||||
|
assertTrue("$gameId: made no moves", moves > 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
private inline fun <reified O> opts(o: O) = json.encodeToString(o)
|
||||||
|
|
||||||
|
@Test fun euchre() = exercise(GameCatalog.EUCHRE, EuchreRules, EuchreAi(), opts(EuchreOptions()))
|
||||||
|
@Test fun sequence() = exercise(GameCatalog.SEQUENCE, SequenceRules, SequenceAi(), opts(SequenceOptions()))
|
||||||
|
@Test fun president() = exercise(GameCatalog.PRESIDENT, PresidentRules, PresidentAi(), opts(PresidentOptions()))
|
||||||
|
@Test fun golf() = exercise(GameCatalog.GOLF, GolfRules, GolfAi(), opts(GolfOptions()))
|
||||||
|
@Test fun kaiser() = exercise(GameCatalog.KAISER, KaiserRules, KaiserAi(), opts(KaiserOptions()))
|
||||||
|
@Test fun wizard() = exercise(GameCatalog.WIZARD, WizardRules, WizardAi(), opts(WizardOptions()))
|
||||||
|
@Test fun crazyEights() = exercise(GameCatalog.CRAZY_EIGHTS, CrazyEightsRules, CrazyEightsAi(), opts(CrazyEightsOptions()))
|
||||||
|
@Test fun cribbage() = exercise(GameCatalog.CRIBBAGE, CribbageRules, CribbageAi(), opts(CribbageOptions()))
|
||||||
|
@Test fun tayu() = exercise(GameCatalog.TAYU, TayuRules, TayuAi(), opts(TayuOptions()))
|
||||||
|
@Test fun checkers() = exercise(GameCatalog.CHECKERS, CheckersRules, CheckersAi(), opts(CheckersOptions()))
|
||||||
|
@Test fun backgammon() = exercise(GameCatalog.BACKGAMMON, BackgammonRules, BackgammonAi(), opts(BackgammonOptions()))
|
||||||
|
@Test fun mastermind() = exercise(GameCatalog.MASTERMIND, MastermindRules, MastermindAi(), opts(MastermindOptions()))
|
||||||
|
@Test fun pirates() = exercise(GameCatalog.PIRATES, PiratesRules, PiratesAi(), opts(PiratesOptions()))
|
||||||
|
@Test fun hearts() = exercise(GameCatalog.HEARTS, HeartsRules, HeartsAi, opts(HeartsOptions()))
|
||||||
|
@Test fun pegSolitaire() = exercise(GameCatalog.PEG_SOLITAIRE, PegSolitaireRules, PegSolitaireAi, opts(PegSolitaireOptions()))
|
||||||
|
@Test fun yahtzee() = exercise(GameCatalog.YAHTZEE, YahtzeeRules, YahtzeeAi, opts(YahtzeeOptions()))
|
||||||
|
@Test fun klondike() = exercise(GameCatalog.KLONDIKE, KlondikeRules, KlondikeAi, opts(KlondikeOptions()))
|
||||||
|
@Test fun freecell() = exercise(GameCatalog.FREECELL, FreeCellRules, FirstLegalAi(), opts(FreeCellOptions()))
|
||||||
|
@Test fun spider() = exercise(GameCatalog.SPIDER, SpiderRules, FirstLegalAi(), opts(SpiderOptions()))
|
||||||
|
@Test fun pyramid() = exercise(GameCatalog.PYRAMID, PyramidRules, FirstLegalAi(), opts(PyramidOptions()))
|
||||||
|
@Test fun morris() = exercise(GameCatalog.MORRIS, MorrisRules, MorrisAi(), opts(MorrisOptions()))
|
||||||
|
@Test fun chess() = exercise(GameCatalog.CHESS, ChessRules, ChessAi(), opts(ChessOptions()), steps = 24)
|
||||||
|
@Test fun catan() = exercise(GameCatalog.CATAN, CatanRules, CatanAi(), opts(CatanOptions()), steps = 400)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun catanCitiesAndKnights() = exercise(
|
||||||
|
GameCatalog.CATAN,
|
||||||
|
CatanRules,
|
||||||
|
CatanAi(),
|
||||||
|
opts(CatanOptions(3, 13, org.prolibertate.games.game.catan.CatanRuleSet.CITIES_AND_KNIGHTS)),
|
||||||
|
steps = 600,
|
||||||
|
)
|
||||||
|
}
|
||||||
@@ -145,6 +145,11 @@ class ScorekeeperSessionTest {
|
|||||||
await("$name to be asking") { host.state.requests.any { it.id == deviceId } }
|
await("$name to be asking") { host.state.requests.any { it.id == deviceId } }
|
||||||
host.session.allow(deviceId)
|
host.session.allow(deviceId)
|
||||||
await("$name to be let in") { guest.state.value.connected }
|
await("$name to be let in") { guest.state.value.connected }
|
||||||
|
// The sheet follows the connection over the socket, so `connected` can
|
||||||
|
// flip while it is still in flight. Callers read the guest's sheet at
|
||||||
|
// once (its players, its rounds), and on a slow runner that was an empty
|
||||||
|
// one: wait until the guest is looking at the host's.
|
||||||
|
await("$name to receive the sheet") { guest.state.value.sheet == host.state.sheet }
|
||||||
return guest
|
return guest
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,30 @@
|
|||||||
|
package org.prolibertate.games.score
|
||||||
|
|
||||||
|
import org.junit.Test
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
|
||||||
|
class RecentNamesTest {
|
||||||
|
@Test
|
||||||
|
fun newestComesFirst() {
|
||||||
|
assertEquals(listOf("Bo", "Al"), RecentNames.with(listOf("Al"), "Bo"))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun repeatMovesToFrontIgnoringCase() {
|
||||||
|
assertEquals(listOf("al", "Bo"), RecentNames.with(listOf("Bo", "Al"), " al "))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun blankChangesNothing() {
|
||||||
|
assertEquals(listOf("Al"), RecentNames.with(listOf("Al"), " "))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun keepsOnlyTen() {
|
||||||
|
val names = (1..10).map { "n$it" }
|
||||||
|
val result = RecentNames.with(names, "new")
|
||||||
|
assertEquals(10, result.size)
|
||||||
|
assertEquals("new", result.first())
|
||||||
|
assertEquals("n9", result.last())
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -199,6 +199,14 @@ class ScoreSheetTest {
|
|||||||
assertEquals(ScoringMode.ROUNDS, StartSheet(3).applyTo(ScoreSheet()).mode)
|
assertEquals(ScoringMode.ROUNDS, StartSheet(3).applyTo(ScoreSheet()).mode)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun startingWithNamesSeatsThemInOrderAndLeavesTheRestUnnamed() {
|
||||||
|
val sheet = StartSheet(3, names = listOf("Ann", "")).applyTo(ScoreSheet())
|
||||||
|
assertEquals(listOf("Ann", "", ""), sheet.players.map { it.name })
|
||||||
|
assertEquals("Ann", sheet.displayName(sheet.players[0]))
|
||||||
|
assertEquals("Player 2", sheet.displayName(sheet.players[1]))
|
||||||
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun `tally entries add up per player and can be taken back`() {
|
fun `tally entries add up per player and can be taken back`() {
|
||||||
val sheet = ScoreSheet.of(2, ScoringMode.TALLY)
|
val sheet = ScoreSheet.of(2, ScoringMode.TALLY)
|
||||||
|
|||||||
@@ -0,0 +1,27 @@
|
|||||||
|
package org.prolibertate.games.ui
|
||||||
|
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
class SavedGameTextTest {
|
||||||
|
private val minute = 60_000L
|
||||||
|
private val hour = 60 * minute
|
||||||
|
private val day = 24 * hour
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `how long ago reads like a person would say it`() {
|
||||||
|
assertEquals("just now", agoText(1_000, 1_000))
|
||||||
|
assertEquals("just now", agoText(30_000, 0))
|
||||||
|
assertEquals("a minute ago", agoText(minute + 20_000, 0))
|
||||||
|
assertEquals("5 minutes ago", agoText(5 * minute, 0))
|
||||||
|
assertEquals("an hour ago", agoText(90 * minute, 0))
|
||||||
|
assertEquals("3 hours ago", agoText(3 * hour, 0))
|
||||||
|
assertEquals("yesterday", agoText(30 * hour, 0))
|
||||||
|
assertEquals("4 days ago", agoText(4 * day, 0))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a clock that ran backwards does not say nonsense`() {
|
||||||
|
assertEquals("just now", agoText(0, 10 * minute))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,291 @@
|
|||||||
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
import org.prolibertate.games.game.GameCatalog
|
||||||
|
import org.prolibertate.games.game.catan.AcceptCounter
|
||||||
|
import org.prolibertate.games.game.catan.AcceptTrade
|
||||||
|
import org.prolibertate.games.game.catan.CounterGoods
|
||||||
|
import org.prolibertate.games.game.catan.DismissCounters
|
||||||
|
import org.prolibertate.games.game.catan.ActivateKnight
|
||||||
|
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.BuildWall
|
||||||
|
import org.prolibertate.games.game.catan.BuyImprovement
|
||||||
|
import org.prolibertate.games.game.catan.CatanAi
|
||||||
|
import org.prolibertate.games.game.catan.CatanBoard
|
||||||
|
import org.prolibertate.games.game.catan.CatanMove
|
||||||
|
import org.prolibertate.games.game.catan.CatanOptions
|
||||||
|
import org.prolibertate.games.game.catan.CatanPhase
|
||||||
|
import org.prolibertate.games.game.catan.CatanRuleSet
|
||||||
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.ChaseRobber
|
||||||
|
import org.prolibertate.games.game.catan.DeclineTrade
|
||||||
|
import org.prolibertate.games.game.catan.DiscardGoods
|
||||||
|
import org.prolibertate.games.game.catan.DropProgress
|
||||||
|
import org.prolibertate.games.game.catan.EndFreeRoads
|
||||||
|
import org.prolibertate.games.game.catan.EndSmith
|
||||||
|
import org.prolibertate.games.game.catan.EndTurn
|
||||||
|
import org.prolibertate.games.game.catan.GiveGoods
|
||||||
|
import org.prolibertate.games.game.catan.GoodsBankTrade
|
||||||
|
import org.prolibertate.games.game.catan.HireKnight
|
||||||
|
import org.prolibertate.games.game.catan.MoveKnight
|
||||||
|
import org.prolibertate.games.game.catan.MoveRobber
|
||||||
|
import org.prolibertate.games.game.catan.OfferGoods
|
||||||
|
import org.prolibertate.games.game.catan.PickDeck
|
||||||
|
import org.prolibertate.games.game.catan.PillageCity
|
||||||
|
import org.prolibertate.games.game.catan.PlaceKnight
|
||||||
|
import org.prolibertate.games.game.catan.PlaceMetropolis
|
||||||
|
import org.prolibertate.games.game.catan.PlayProgress
|
||||||
|
import org.prolibertate.games.game.catan.PromoteKnight
|
||||||
|
import org.prolibertate.games.game.catan.RelocateKnight
|
||||||
|
import org.prolibertate.games.game.catan.RemoveKnight
|
||||||
|
import org.prolibertate.games.game.catan.RollDice
|
||||||
|
import org.prolibertate.games.game.catan.SetupPlace
|
||||||
|
import org.prolibertate.games.game.catan.SpyTake
|
||||||
|
import org.prolibertate.games.game.catan.TakeAqueduct
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Cities & Knights has no device in this test suite, so the screen's logic is
|
||||||
|
* checked another way: engines play whole games, and at every position the
|
||||||
|
* player on the clock is treated as the local one. For every move the engine says
|
||||||
|
* is legal, [CatanInteraction] (and the dialogs' own filters) must offer a way to
|
||||||
|
* make it — a tap, a button or a dialog choice. A legal move that no control can
|
||||||
|
* produce would be a stuck game on a real phone.
|
||||||
|
*/
|
||||||
|
class CatanCkInteractionTest {
|
||||||
|
|
||||||
|
private val json = Json { encodeDefaults = true }
|
||||||
|
|
||||||
|
private fun config(players: Int, seed: Long) = TableConfig(
|
||||||
|
gameId = GameCatalog.CATAN,
|
||||||
|
seats = (0 until players).map { PlayerSlot(seat = it, name = "P$it", kind = PlayerKind.AI, team = it) },
|
||||||
|
optionsJson = json.encodeToString(
|
||||||
|
CatanOptions(players, pointsToWin = 13, ruleSet = CatanRuleSet.CITIES_AND_KNIGHTS),
|
||||||
|
),
|
||||||
|
seed = seed,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** How a move reaches the engine from the screen, or null if nothing can produce it. */
|
||||||
|
private fun reachable(state: CatanState, legal: List<CatanMove>, move: CatanMove): String? {
|
||||||
|
fun tapVertex(vertex: Int, building: BuildKind? = null, moving: Int? = null, armed: ArmedCard? = null): TapOutcome =
|
||||||
|
CatanInteraction.onVertexTap(vertex, legal, building, null, moving, armed)
|
||||||
|
|
||||||
|
return when (move) {
|
||||||
|
is SetupPlace -> {
|
||||||
|
val vertex = CatanInteraction.targets(state, legal, null, null).vertices
|
||||||
|
val edges = CatanInteraction.targets(state, legal, null, move.vertex).edges
|
||||||
|
"setup".takeIf {
|
||||||
|
move.vertex in vertex && move.edge in edges &&
|
||||||
|
CatanInteraction.onVertexTap(move.vertex, legal, null, null) is TapOutcome.PickSetupVertex &&
|
||||||
|
CatanInteraction.onEdgeTap(move.edge, legal, null, move.vertex) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is BuildRoad -> {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, BuildKind.ROAD, null)
|
||||||
|
"road".takeIf {
|
||||||
|
move.edge in targets.edges &&
|
||||||
|
CatanInteraction.onEdgeTap(move.edge, legal, BuildKind.ROAD, null) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is BuildSettlement -> viaBuild(state, legal, BuildKind.SETTLEMENT, move.vertex, move)
|
||||||
|
is BuildCity -> viaBuild(state, legal, BuildKind.CITY, move.vertex, move)
|
||||||
|
is BuildWall -> viaBuild(state, legal, BuildKind.WALL, move.vertex, move)
|
||||||
|
is HireKnight -> viaBuild(state, legal, BuildKind.KNIGHT, move.vertex, move)
|
||||||
|
|
||||||
|
is MoveRobber -> {
|
||||||
|
val hex = CatanBoard.hexIndex.getValue(move.hex)
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null)
|
||||||
|
val tap = CatanInteraction.onHexTap(hex, legal)
|
||||||
|
"robber".takeIf {
|
||||||
|
hex in targets.hexes &&
|
||||||
|
(tap == TapOutcome.Submit(move) || (tap is TapOutcome.PickRobberVictim && move.victim in tap.victims))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is MoveKnight -> {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null, movingKnight = move.from)
|
||||||
|
"moveKnight".takeIf {
|
||||||
|
move.to in targets.vertices && tapVertex(move.to, moving = move.from) == TapOutcome.Submit(move) &&
|
||||||
|
move.from in CatanInteraction.targets(state, legal, null, null).knights &&
|
||||||
|
CatanInteraction.knightActions(legal, move.from).any { it is MoveKnight }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is ActivateKnight, is ChaseRobber, is PromoteKnight -> {
|
||||||
|
val vertex = when (move) {
|
||||||
|
is ActivateKnight -> move.vertex
|
||||||
|
is ChaseRobber -> move.vertex
|
||||||
|
else -> (move as PromoteKnight).vertex
|
||||||
|
}
|
||||||
|
val smith = legal.any { it is EndSmith }
|
||||||
|
if (move is PromoteKnight && smith) {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null)
|
||||||
|
"smith".takeIf {
|
||||||
|
vertex in targets.vertices && tapVertex(vertex) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null)
|
||||||
|
"knightMenu".takeIf {
|
||||||
|
vertex in targets.knights && tapVertex(vertex) == TapOutcome.PickKnight(vertex) &&
|
||||||
|
move in CatanInteraction.knightActions(legal, vertex)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
is PillageCity -> viaChore(state, legal, move.vertex, move)
|
||||||
|
is PlaceMetropolis -> viaChore(state, legal, move.vertex, move)
|
||||||
|
is RelocateKnight -> viaChore(state, legal, move.to, move)
|
||||||
|
is RemoveKnight -> viaChore(state, legal, move.vertex, move)
|
||||||
|
is PlaceKnight -> viaChore(state, legal, move.vertex, move)
|
||||||
|
|
||||||
|
is PlayProgress -> viaCard(state, legal, move)
|
||||||
|
|
||||||
|
is BuyImprovement -> "improve".takeIf { move.track in CatanInteraction.improvable(legal) }
|
||||||
|
|
||||||
|
is GoodsBankTrade ->
|
||||||
|
"bankTrade".takeIf { move.get in CatanInteraction.goodsBankTrades(legal)[move.give].orEmpty() }
|
||||||
|
|
||||||
|
RollDice(), is RollDice -> "roll".takeIf { CatanInteraction.canRoll(legal) }
|
||||||
|
EndTurn -> "endTurn".takeIf { CatanInteraction.canEndTurn(legal) }
|
||||||
|
EndFreeRoads -> "endRoads".takeIf { CatanInteraction.canEndFreeRoads(legal) }
|
||||||
|
EndSmith -> "endSmith".takeIf { CatanInteraction.canEndSmith(legal) }
|
||||||
|
AcceptTrade, DeclineTrade -> "tradeReply".takeIf { CatanInteraction.tradeResponses(legal) != (false to false) }
|
||||||
|
|
||||||
|
// Answered in a dialog that offers exactly the moves in the legal list.
|
||||||
|
is PickDeck, is DropProgress, is TakeAqueduct, is SpyTake -> "choreDialog"
|
||||||
|
|
||||||
|
// Structural: the discard and give dialogs build these and ask the engine.
|
||||||
|
is DiscardGoods, is GiveGoods -> "goodsDialog"
|
||||||
|
is OfferGoods, is CounterGoods -> "tradeDialog"
|
||||||
|
is AcceptCounter, DismissCounters -> "counterDialog"
|
||||||
|
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun viaBuild(state: CatanState, legal: List<CatanMove>, kind: BuildKind, vertex: Int, move: CatanMove): String? {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, kind, null)
|
||||||
|
return "build $kind".takeIf {
|
||||||
|
vertex in targets.vertices &&
|
||||||
|
CatanInteraction.onVertexTap(vertex, legal, kind, null) == TapOutcome.Submit(move) &&
|
||||||
|
kind in CatanInteraction.canBuild(legal)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun viaChore(state: CatanState, legal: List<CatanMove>, vertex: Int, move: CatanMove): String? {
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null)
|
||||||
|
return "chore".takeIf {
|
||||||
|
vertex in targets.vertices &&
|
||||||
|
CatanInteraction.onVertexTap(vertex, legal, null, null) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun viaCard(state: CatanState, legal: List<CatanMove>, move: PlayProgress): String? {
|
||||||
|
val seat = CatanRules.currentSeat(state) ?: return null
|
||||||
|
val entry = CatanInteraction.progressHand(state, seat, legal).firstOrNull { it.card.id == move.card }
|
||||||
|
?: return null
|
||||||
|
val kind = entry.card.kind
|
||||||
|
if (move !in entry.plays) return null
|
||||||
|
if (kind !in CatanInteraction.BOARD_CARDS) return "cardDialog"
|
||||||
|
|
||||||
|
val armed = ArmedCard(kind, entry.plays)
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null, armed = armed)
|
||||||
|
return when (kind) {
|
||||||
|
org.prolibertate.games.game.catan.ProgressType.DIPLOMAT ->
|
||||||
|
"armed".takeIf {
|
||||||
|
move.edge in targets.edges &&
|
||||||
|
CatanInteraction.onEdgeTap(move.edge!!, legal, null, null, armed) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
|
||||||
|
org.prolibertate.games.game.catan.ProgressType.MERCHANT ->
|
||||||
|
"armed".takeIf {
|
||||||
|
move.hexA in targets.hexes &&
|
||||||
|
CatanInteraction.onHexTap(move.hexA!!, legal, armed) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
|
||||||
|
org.prolibertate.games.game.catan.ProgressType.INVENTOR -> {
|
||||||
|
val first = CatanInteraction.onHexTap(move.hexA!!, legal, armed)
|
||||||
|
if (first != TapOutcome.PickFirstHex(move.hexA!!)) return null
|
||||||
|
val second = armed.copy(firstHex = move.hexA)
|
||||||
|
val partners = CatanInteraction.targets(state, legal, null, null, armed = second).hexes
|
||||||
|
"armed".takeIf {
|
||||||
|
move.hexB in partners &&
|
||||||
|
CatanInteraction.onHexTap(move.hexB!!, legal, second) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
else ->
|
||||||
|
"armed".takeIf {
|
||||||
|
move.vertex in targets.vertices &&
|
||||||
|
CatanInteraction.onVertexTap(move.vertex!!, legal, null, null, null, armed) == TapOutcome.Submit(move)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun playAndCheck(players: Int, seed: Long): Map<String, Int> {
|
||||||
|
val ai = CatanAi()
|
||||||
|
var state = CatanRules.initialState(config(players, seed))
|
||||||
|
val seen = mutableMapOf<String, Int>()
|
||||||
|
var moves = 0
|
||||||
|
while (!CatanRules.isFinished(state) && moves++ < 20_000) {
|
||||||
|
val seat = CatanRules.currentSeat(state) ?: break
|
||||||
|
val legal = CatanRules.legalMoves(state, seat)
|
||||||
|
for (move in legal) {
|
||||||
|
val how = reachable(state, legal, move)
|
||||||
|
assertTrue(
|
||||||
|
"seed $seed: no control produces $move in ${state.phase} " +
|
||||||
|
"(chore ${state.ck?.chores?.firstOrNull()}); log tail: ${state.log.takeLast(3)}",
|
||||||
|
how != null,
|
||||||
|
)
|
||||||
|
seen.merge(how!!, 1, Int::plus)
|
||||||
|
}
|
||||||
|
state = CatanRules.applyMove(state, seat, ai.chooseMove(state, seat, legal))
|
||||||
|
}
|
||||||
|
return seen
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every legal move in a full game has a control that produces it`() {
|
||||||
|
val total = mutableMapOf<String, Int>()
|
||||||
|
listOf(3 to 21L, 4 to 22L, 3 to 23L, 4 to 24L).forEach { (players, seed) ->
|
||||||
|
playAndCheck(players, seed).forEach { (k, v) -> total.merge(k, v, Int::plus) }
|
||||||
|
}
|
||||||
|
println("CK UI coverage: ${total.toSortedMap()}")
|
||||||
|
// The ways the screen builds, moves and answers all got exercised.
|
||||||
|
listOf("setup", "road", "build SETTLEMENT", "build CITY", "knightMenu", "improve", "bankTrade", "roll", "endTurn")
|
||||||
|
.forEach { assertTrue("never exercised: $it in $total", (total[it] ?: 0) > 0) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a sleeping knight with nothing to do can still be tapped for its menu`() {
|
||||||
|
val base = CatanRules.initialState(config(3, 5L))
|
||||||
|
.copy(phase = CatanPhase.PLAYING, turn = 0, turnNumber = 1)
|
||||||
|
val state = base.copy(
|
||||||
|
ck = base.ck!!.copy(knights = listOf(org.prolibertate.games.game.catan.Knight(10, 0, 1))),
|
||||||
|
)
|
||||||
|
val legal = CatanRules.legalMoves(state, 0)
|
||||||
|
assertTrue("no grain, so nothing to do", CatanInteraction.knightActions(legal, 10).isEmpty())
|
||||||
|
|
||||||
|
val targets = CatanInteraction.targets(state, legal, null, null, localSeat = 0)
|
||||||
|
assertTrue(10 in targets.idleKnights)
|
||||||
|
assertTrue("no tap ring for a knight with nothing to do", 10 !in targets.knights)
|
||||||
|
assertTrue(10 in targets.tappableVertices)
|
||||||
|
assertEquals(
|
||||||
|
TapOutcome.PickKnight(10),
|
||||||
|
CatanInteraction.onVertexTap(10, legal, null, null, ownKnights = setOf(10)),
|
||||||
|
)
|
||||||
|
// On somebody else's turn the legal list is empty and nothing is offered.
|
||||||
|
assertTrue(CatanInteraction.targets(state, emptyList(), null, null, localSeat = 0).idleKnights.isEmpty())
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,75 @@
|
|||||||
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
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.CatanRuleSet
|
||||||
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
|
import org.prolibertate.games.game.catan.ProgressType
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
import org.prolibertate.games.ui.catanDefaultPoints
|
||||||
|
import org.prolibertate.games.ui.catanPointsChoices
|
||||||
|
import org.prolibertate.games.ui.catanSwitchRules
|
||||||
|
|
||||||
|
class CatanCkTextTest {
|
||||||
|
|
||||||
|
private val json = Json { encodeDefaults = true }
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every position of a Cities and Knights game has a prompt for every seat`() {
|
||||||
|
val config = TableConfig(
|
||||||
|
gameId = GameCatalog.CATAN,
|
||||||
|
seats = (0 until 3).map { PlayerSlot(seat = it, name = "P$it", kind = PlayerKind.AI, team = it) },
|
||||||
|
optionsJson = json.encodeToString(
|
||||||
|
CatanOptions(3, 13, CatanRuleSet.CITIES_AND_KNIGHTS),
|
||||||
|
),
|
||||||
|
seed = 31L,
|
||||||
|
)
|
||||||
|
var state = CatanRules.initialState(config)
|
||||||
|
val ai = CatanAi()
|
||||||
|
var moves = 0
|
||||||
|
while (!CatanRules.isFinished(state) && moves++ < 20_000) {
|
||||||
|
for (me in 0 until 3) {
|
||||||
|
val seats = CatanSeats(me, listOf("A", "B", "C"))
|
||||||
|
val text = CatanText.prompt(state, seats, setupVertexChosen = false, building = null)
|
||||||
|
assertTrue("blank prompt in ${state.phase} for seat $me", text.isNotBlank())
|
||||||
|
}
|
||||||
|
val seat = CatanRules.currentSeat(state) ?: break
|
||||||
|
state = CatanRules.applyMove(state, seat, ai.chooseMove(state, seat, CatanRules.legalMoves(state, seat)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `every progress card has a name and a description`() {
|
||||||
|
ProgressType.entries.forEach {
|
||||||
|
assertTrue(CatanText.progress(it).isNotBlank())
|
||||||
|
assertTrue("no help for $it", CatanText.progressHelp(it).length > 10)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the setup screen offers each rule set its own targets and switches sensibly`() {
|
||||||
|
assertEquals(listOf(5, 8, 10, 12), catanPointsChoices(CatanRuleSet.BASE))
|
||||||
|
assertEquals(listOf(8, 10, 13, 15), catanPointsChoices(CatanRuleSet.CITIES_AND_KNIGHTS))
|
||||||
|
assertEquals(10, catanDefaultPoints(CatanRuleSet.BASE))
|
||||||
|
assertEquals(13, catanDefaultPoints(CatanRuleSet.CITIES_AND_KNIGHTS))
|
||||||
|
|
||||||
|
val base = CatanOptions()
|
||||||
|
val ck = catanSwitchRules(base, CatanRuleSet.CITIES_AND_KNIGHTS)
|
||||||
|
assertEquals(CatanRuleSet.CITIES_AND_KNIGHTS, ck.ruleSet)
|
||||||
|
assertEquals("the published target for the new rules", 13, ck.pointsToWin)
|
||||||
|
assertEquals(10, catanSwitchRules(ck, CatanRuleSet.BASE).pointsToWin)
|
||||||
|
|
||||||
|
// A short game picked on purpose is kept when both menus have it.
|
||||||
|
val short = catanSwitchRules(base.copy(pointsToWin = 8), CatanRuleSet.CITIES_AND_KNIGHTS)
|
||||||
|
assertEquals(8, short.pointsToWin)
|
||||||
|
assertEquals(3, ck.playerCount)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,56 @@
|
|||||||
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertNotNull
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Test
|
||||||
|
import org.prolibertate.games.game.catan.BuildRoad
|
||||||
|
import org.prolibertate.games.game.catan.BuildSettlement
|
||||||
|
import org.prolibertate.games.game.catan.EndTurn
|
||||||
|
|
||||||
|
/** The pure half of the landscape HUD: drag-to-build snapping and the staged ✓ / ✗ placement. */
|
||||||
|
class CatanHudTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a build tap is staged, not sent, but only while a build mode is armed`() {
|
||||||
|
val road = BuildRoad(0)
|
||||||
|
|
||||||
|
val outcome = TapOutcome.Submit(road)
|
||||||
|
assertEquals(road, CatanInteraction.stageable(outcome, BuildKind.ROAD))
|
||||||
|
assertNull(CatanInteraction.stageable(outcome, null))
|
||||||
|
// Ending the turn is never a placement.
|
||||||
|
assertNull(CatanInteraction.stageable(TapOutcome.Submit(EndTurn), BuildKind.ROAD))
|
||||||
|
assertNull(CatanInteraction.stageable(TapOutcome.Ignored, BuildKind.ROAD))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the ghost of a staged move sits on its crossing or its edge`() {
|
||||||
|
assertEquals(CatanInteraction.Spot(vertex = 4), CatanInteraction.spotOf(BuildSettlement(4)))
|
||||||
|
assertEquals(CatanInteraction.Spot(edge = 9), CatanInteraction.spotOf(BuildRoad(9)))
|
||||||
|
assertEquals(CatanInteraction.Spot(), CatanInteraction.spotOf(null))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a dragged finger snaps to the nearest lit crossing within reach, and off the board to nothing`() {
|
||||||
|
val layout = CatanGeometry.fit(800f, 600f)
|
||||||
|
val lit = setOf(3, 10, 21)
|
||||||
|
val targets = BoardTargets(vertices = lit)
|
||||||
|
val target = layout.vertex(10)
|
||||||
|
|
||||||
|
// A little off the crossing, well inside reach.
|
||||||
|
val near = Pt(target.x + layout.radius * 0.3f, target.y - layout.radius * 0.2f)
|
||||||
|
assertEquals(CatanInteraction.Spot(vertex = 10), CatanInteraction.snap(layout, targets, near, layout.radius * 1.2f))
|
||||||
|
|
||||||
|
// Far from every lit crossing.
|
||||||
|
assertNull(CatanInteraction.snap(layout, targets, Pt(-500f, -500f), layout.radius * 1.2f))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `with edges lit and no crossings, the drop snaps to an edge`() {
|
||||||
|
val layout = CatanGeometry.fit(800f, 600f)
|
||||||
|
val targets = BoardTargets(edges = setOf(5, 6))
|
||||||
|
val mid = layout.edgeMidpoint(6)
|
||||||
|
assertNotNull(CatanInteraction.snap(layout, targets, mid, layout.radius))
|
||||||
|
assertEquals(CatanInteraction.Spot(edge = 6), CatanInteraction.snap(layout, targets, mid, layout.radius))
|
||||||
|
}
|
||||||
|
}
|
||||||
+149
@@ -0,0 +1,149 @@
|
|||||||
|
package org.prolibertate.games.ui.game.catan
|
||||||
|
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
import org.prolibertate.games.game.GameCatalog
|
||||||
|
import org.prolibertate.games.game.catan.BuildShip
|
||||||
|
import org.prolibertate.games.game.catan.BuildingType
|
||||||
|
import org.prolibertate.games.game.catan.CatanAi
|
||||||
|
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.CatanRuleSet
|
||||||
|
import org.prolibertate.games.game.catan.CatanRules
|
||||||
|
import org.prolibertate.games.game.catan.CatanState
|
||||||
|
import org.prolibertate.games.game.catan.MovePirate
|
||||||
|
import org.prolibertate.games.game.catan.MoveRobber
|
||||||
|
import org.prolibertate.games.game.catan.MoveShip
|
||||||
|
import org.prolibertate.games.game.catan.PickGold
|
||||||
|
import org.prolibertate.games.game.catan.Resource
|
||||||
|
import org.prolibertate.games.game.catan.Terrain
|
||||||
|
import org.prolibertate.games.game.engine.PlayerKind
|
||||||
|
import org.prolibertate.games.game.engine.PlayerSlot
|
||||||
|
import org.prolibertate.games.game.engine.TableConfig
|
||||||
|
|
||||||
|
/** What the screen offers on a Seafarers board: ships, the pirate, and gold. */
|
||||||
|
class CatanSeafarersInteractionTest {
|
||||||
|
|
||||||
|
private fun fresh(): CatanState {
|
||||||
|
val options = CatanOptions(playerCount = 3, pointsToWin = 12, ruleSet = CatanRuleSet.SEAFARERS)
|
||||||
|
return CatanRules.initialState(
|
||||||
|
TableConfig(
|
||||||
|
gameId = GameCatalog.CATAN,
|
||||||
|
seats = (0 until 3).map { PlayerSlot(it, "P$it", PlayerKind.AI, it) },
|
||||||
|
optionsJson = Json { encodeDefaults = true }.encodeToString(options),
|
||||||
|
seed = 7L,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Seat 0, mid-game, a harbour town on the coast of the home island and plenty of cards. */
|
||||||
|
private fun harbour(): CatanState {
|
||||||
|
val s = fresh().copy(
|
||||||
|
phase = CatanPhase.PLAYING,
|
||||||
|
turn = 0,
|
||||||
|
turnNumber = 1,
|
||||||
|
resources = List(3) { Resource.entries.associateWith { 5 } },
|
||||||
|
)
|
||||||
|
val topo = s.topo
|
||||||
|
val v = (0 until topo.VERTEX_COUNT).first { vertex ->
|
||||||
|
topo.vertexIsland[vertex] == s.sea!!.home &&
|
||||||
|
topo.VERTEX_EDGES[vertex].any { topo.edgeSea[it] && !topo.edgeLand[it] }
|
||||||
|
}
|
||||||
|
return s.copy(buildings = s.buildings.toMutableList().also { it[v] = CatanBuilding(BuildingType.SETTLEMENT, 0) })
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the ship is on the build menu, and arming it lights the sea edges a ship can take`() {
|
||||||
|
val s = harbour()
|
||||||
|
val legal = CatanRules.legalMoves(s, 0)
|
||||||
|
assertTrue(BuildKind.SHIP in CatanInteraction.canBuild(legal))
|
||||||
|
|
||||||
|
val targets = CatanInteraction.targets(s, legal, BuildKind.SHIP, null)
|
||||||
|
assertEquals(legal.filterIsInstance<BuildShip>().map { it.edge }.toSet(), targets.edges)
|
||||||
|
|
||||||
|
val edge = targets.edges.first { !s.topo.edgeLand[it] }
|
||||||
|
assertEquals(
|
||||||
|
TapOutcome.Submit(BuildShip(edge)),
|
||||||
|
CatanInteraction.onEdgeTap(edge, legal, BuildKind.SHIP, null),
|
||||||
|
)
|
||||||
|
// The same tap with the road armed means nothing: a road cannot lie between two sea hexes.
|
||||||
|
assertEquals(TapOutcome.Ignored, CatanInteraction.onEdgeTap(edge, legal, BuildKind.ROAD, null))
|
||||||
|
// A build tap waits for ✓ like any other piece.
|
||||||
|
assertEquals(BuildShip(edge), CatanInteraction.stageable(TapOutcome.Submit(BuildShip(edge)), BuildKind.SHIP))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `tapping a ship that can sail picks it up, and the next tap on a lit sea edge sails it`() {
|
||||||
|
val s0 = harbour()
|
||||||
|
val built = CatanRules.legalMoves(s0, 0).filterIsInstance<BuildShip>().first()
|
||||||
|
val s = CatanRules.applyMove(s0, 0, built)
|
||||||
|
.let { it.copy(sea = it.sea!!.copy(builtThisTurn = emptyList())) }
|
||||||
|
val legal = CatanRules.legalMoves(s, 0)
|
||||||
|
|
||||||
|
val idle = CatanInteraction.targets(s, legal, null, null)
|
||||||
|
assertEquals(setOf(built.edge), idle.ships)
|
||||||
|
assertEquals(TapOutcome.PickShip(built.edge), CatanInteraction.onEdgeTap(built.edge, legal, null, null))
|
||||||
|
|
||||||
|
val sailing = CatanInteraction.targets(s, legal, null, null, movingShip = built.edge)
|
||||||
|
val to = sailing.edges.first()
|
||||||
|
assertEquals(
|
||||||
|
TapOutcome.Submit(MoveShip(built.edge, to)),
|
||||||
|
CatanInteraction.onEdgeTap(to, legal, null, null, movingShip = built.edge),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `after a seven a land hex moves the robber and a sea hex moves the pirate`() {
|
||||||
|
val s = harbour().copy(phase = CatanPhase.ROBBER)
|
||||||
|
val legal = CatanRules.legalMoves(s, 0)
|
||||||
|
val targets = CatanInteraction.targets(s, legal, null, null)
|
||||||
|
val land = targets.hexes.first { s.terrains[it] != Terrain.SEA }
|
||||||
|
val sea = targets.hexes.first { s.terrains[it] == Terrain.SEA }
|
||||||
|
|
||||||
|
val robber = CatanInteraction.onHexTap(land, legal, topo = s.topo)
|
||||||
|
assertTrue(robber is TapOutcome.Submit && robber.move is MoveRobber)
|
||||||
|
val pirate = CatanInteraction.onHexTap(sea, legal, topo = s.topo)
|
||||||
|
assertTrue(pirate is TapOutcome.Submit && pirate.move is MovePirate)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `a gold pick is found by the cards it names`() {
|
||||||
|
val picks = listOf(PickGold(listOf(Resource.ORE)), PickGold(listOf(Resource.WOOL)))
|
||||||
|
assertEquals(PickGold(listOf(Resource.WOOL)), CatanInteraction.goldMove(picks, listOf(Resource.WOOL)))
|
||||||
|
assertEquals(null, CatanInteraction.goldMove(picks, listOf(Resource.WOOL, Resource.WOOL)))
|
||||||
|
assertEquals(1, CatanInteraction.goldCount(picks))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `the engines' own choices are always something the screen can make`() {
|
||||||
|
// Every legal move in a played-out game is reachable: a tap, a button or a dialog choice.
|
||||||
|
val ai = CatanAi()
|
||||||
|
var s = fresh()
|
||||||
|
var n = 0
|
||||||
|
while (!CatanRules.isFinished(s) && n++ < 600) {
|
||||||
|
val seat = CatanRules.currentSeat(s) ?: break
|
||||||
|
val legal = CatanRules.legalMoves(s, seat)
|
||||||
|
val ships = legal.filterIsInstance<BuildShip>()
|
||||||
|
if (s.phase == CatanPhase.PLAYING && ships.isNotEmpty()) {
|
||||||
|
val armed = CatanInteraction.targets(s, legal, BuildKind.SHIP, null)
|
||||||
|
ships.forEach { ship ->
|
||||||
|
assertTrue("ship ${ship.edge} not lit", ship.edge in armed.edges)
|
||||||
|
assertEquals(TapOutcome.Submit(ship), CatanInteraction.onEdgeTap(ship.edge, legal, BuildKind.SHIP, null))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
legal.filterIsInstance<MoveShip>().forEach { sail ->
|
||||||
|
val lit = CatanInteraction.targets(s, legal, null, null, movingShip = sail.from)
|
||||||
|
assertTrue(sail.to in lit.edges)
|
||||||
|
assertEquals(
|
||||||
|
TapOutcome.Submit(sail),
|
||||||
|
CatanInteraction.onEdgeTap(sail.to, legal, null, null, movingShip = sail.from),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
s = CatanRules.applyMove(s, seat, ai.chooseMove(s, seat, legal))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,73 @@
|
|||||||
|
# Catan Universe 2.7.5 — what the reverse engineering showed
|
||||||
|
|
||||||
|
Source: `Catan+Universe_2.7.5_APKPure.xapk` (Unity, IL2CPP). Method: the Unity scenes
|
||||||
|
(`level3` is the match scene) were parsed with UnityPy for the uGUI hierarchy (names,
|
||||||
|
anchors, sizes, which objects start hidden), and `global-metadata.dat` was searched for
|
||||||
|
class, method and game-action names. Code bodies were not decompiled; behaviour below
|
||||||
|
that is not visible in a hierarchy is marked *inferred*.
|
||||||
|
|
||||||
|
The game is **landscape-only**; the canvas is laid out against a 1920×1080 reference.
|
||||||
|
|
||||||
|
## Match HUD (`InGameUI_mobile`)
|
||||||
|
|
||||||
|
| Region | Contents |
|
||||||
|
| --- | --- |
|
||||||
|
| Top | `PlayerFrames`: one frame per player (avatar, colour, VP, card count, timer), a "shuffle stats" button at the right |
|
||||||
|
| Bottom bar | `ResourceContainer`, centred (anchors 25–75 % of the width, 90 px tall): one entry per resource (Lumber, Brick, Wool, Grain, Ore; Cloth, Coins, Paper for C&K; Fish, Feather, Coca for other expansions, hidden otherwise) |
|
||||||
|
| Bottom right | `BtnTurn` (140 px, roll / end turn), `BtnTrade` immediately to its left (counter-offer and "blocked" badge variants), `BtnAddDevCard`, a chat/log `BubblePanel` |
|
||||||
|
| Left edge | `Drag&DropBuild`: a column of piece icons. **The player drags a piece from it onto the board** (`Drag&DropBuildRemove` is the drop target that cancels) |
|
||||||
|
| Mid right | `ConfirmButtonGroup`: a ✓ (`CatanConfirmBuildButton`) over a ✗ (`CatanCancelBuildButton`). A drop only *previews*; the ✓ commits |
|
||||||
|
| Board | `CandidateFactory` makes highlight markers for every legal spot (corner, edge, face); `QuickBuildTrigger{Corner,Edge,Face}` are hit zones for a one-tap/hold build; a candidate ticker shows the one-line instruction |
|
||||||
|
| Centre | Played-card panel, progress-card chooser, discard panel (`CardPanel` slides up over the bottom bar with a header) |
|
||||||
|
|
||||||
|
Gestures (`CatanGestureHandler`, `BaseGesture`, `TapHoldHandler`): one finger pans the
|
||||||
|
board, two-finger pinch zooms (`GetPinchZoomMagnitude`, `AutomaticZoom`), tap selects a
|
||||||
|
candidate, hold opens quick-build. Camera is a fixed-pitch table view.
|
||||||
|
|
||||||
|
## Trade board (`TradeBoard_mobile`)
|
||||||
|
|
||||||
|
A full-width panel that slides up over the bottom of the screen (`Animator`, collapsible):
|
||||||
|
|
||||||
|
```
|
||||||
|
┌────────────────────────────────────────────────────────────┬──────┐
|
||||||
|
│ [Player] [Bank] headline / description ☐ Block trade │ P1 P2│ header
|
||||||
|
├────────────────────────────────────────────────────────────┤ P3 P4│ (135 px)
|
||||||
|
│ OPPONENT row — cards you get (tinted by the opponent's │ │
|
||||||
|
│ colour) │ Hide │
|
||||||
|
│ ⇣⇣⇣ arrows (or the bank ratio chips 4:1 3:1 2:1) │ Deny │
|
||||||
|
│ PLAYER row — cards you give (tinted by your colour) │Accept│
|
||||||
|
└────────────────────────────────────────────────────────────┴──────┘
|
||||||
|
```
|
||||||
|
|
||||||
|
* **Header.** A *Player / Bank* toggle (extra toggles for the Inka 3:2 / 2:1 rules). A
|
||||||
|
**Block trade** checkbox refuses all incoming offers. One round button per rival
|
||||||
|
(`Player1…5`, with a selected border) picks whom the offer is addressed to; none
|
||||||
|
selected means everyone.
|
||||||
|
* **Content.** Two rows of resource cards separated by arrows. The top row is what you
|
||||||
|
*want*, the bottom row what you *give*. Tapping a card in a row adds one; tapping a
|
||||||
|
selected card removes one (*inferred from `AddFieldToTradePayment`/`ApplyCancelTradeResource`*).
|
||||||
|
In Bank mode a ratio row (`CardRatios`) shows the best rate per resource (harbours).
|
||||||
|
* **Right column (180 px).** Hide/collapse, **Deny** (✗), **Accept** (✓). When you
|
||||||
|
are the one receiving an offer, ✓ accepts and the chip-icon variant `Icon_CounterOffer`
|
||||||
|
turns the ✓ into a *counter-offer* send. A circular turn timer wraps the ✓.
|
||||||
|
* **Incoming offers** (`IncomingTradeContainer`) show in the same panel; the offerer's
|
||||||
|
colour tints the opponent row. Counter-offers land back in the proposer's panel with
|
||||||
|
an `AcceptCounterOfferButtonImage`.
|
||||||
|
|
||||||
|
## Seafarers game actions (from the metadata)
|
||||||
|
|
||||||
|
`CatanSeafarer_*_GameAction` names show what the mode adds to the base game:
|
||||||
|
|
||||||
|
* **Ships:** `BuildShip`, `MoveShip` (only the ship at the open end of a route, not on
|
||||||
|
the turn it was built), `BuildFreeRoad`; roads and ships share `AvailableCandidatesRoadAndShip`.
|
||||||
|
* **Pirate** alongside the robber: `RobberPirat_Move`, `RobberPirat_SelectPlayer`;
|
||||||
|
ships cannot be built or moved past a pirate-blocked edge.
|
||||||
|
* **Gold fields:** `ChooseGoldfieldResource` (a hex that pays any resource of choice).
|
||||||
|
* **Fog islands:** `Check_FogField`, `DistributeFogField` (hidden hex revealed when a
|
||||||
|
road/ship reaches it, the player takes the resource), `Shuffle_Islands`, `Shuffle_TileValueList`.
|
||||||
|
* **Treasure islands / Oasis / Great Canal** are Catan Universe scenario extras and are
|
||||||
|
**not** part of the physical Seafarers rules; they are out of scope here.
|
||||||
|
* **Setup:** `StartPhase_BuildSettlement`, `StartPhase_BuildRoadShip`, `PlaceValueChip`
|
||||||
|
(number tokens placed per scenario), `Shuffle_Harbors`.
|
||||||
|
* **Island bonus:** special victory points for the first settlement on a new island
|
||||||
|
(`AllIslandIds`, `CatanIslandState`).
|
||||||
+4
-1
@@ -24,9 +24,10 @@ Naming: the catalogue id, lowercase, e.g. `crazy8s` → `RULES-crazy8s.md`.
|
|||||||
| Golf | [RULES-golf.md](RULES-golf.md) |
|
| Golf | [RULES-golf.md](RULES-golf.md) |
|
||||||
| Hearts | — (TODO) |
|
| Hearts | — (TODO) |
|
||||||
| Kaiser | [RULES-kaiser.md](RULES-kaiser.md) |
|
| Kaiser | [RULES-kaiser.md](RULES-kaiser.md) |
|
||||||
| Katan (catalogue id `catan`) | [RULES-catan.md](RULES-catan.md) |
|
| Katan (catalogue id `catan`) | [RULES-catan.md](RULES-catan.md) — and its expansion rule sets, [RULES-catan-ck.md](RULES-catan-ck.md) and [RULES-catan-seafarers.md](RULES-catan-seafarers.md) |
|
||||||
| Klondike | — (TODO) |
|
| Klondike | — (TODO) |
|
||||||
| Mastermind | [RULES-mastermind.md](RULES-mastermind.md) |
|
| Mastermind | [RULES-mastermind.md](RULES-mastermind.md) |
|
||||||
|
| Meowdoku | [RULES-meowdoku.md](RULES-meowdoku.md) |
|
||||||
| Morris | [RULES-morris.md](RULES-morris.md) |
|
| Morris | [RULES-morris.md](RULES-morris.md) |
|
||||||
| Peg solitaire | — (TODO) |
|
| Peg solitaire | — (TODO) |
|
||||||
| Pirates | [RULES-pirates.md](RULES-pirates.md) |
|
| Pirates | [RULES-pirates.md](RULES-pirates.md) |
|
||||||
@@ -42,6 +43,8 @@ Naming: the catalogue id, lowercase, e.g. `crazy8s` → `RULES-crazy8s.md`.
|
|||||||
|
|
||||||
- Build, CI, releases and OTA are described in the CI section of the root
|
- Build, CI, releases and OTA are described in the CI section of the root
|
||||||
[README](../README.md).
|
[README](../README.md).
|
||||||
|
- [SAVED-GAMES.md](SAVED-GAMES.md) — how a game in progress is kept between sessions, and what is
|
||||||
|
not kept.
|
||||||
- [UI-catan.md](UI-catan.md) — how the Katan screen is layered, and how to restyle,
|
- [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.
|
re-copy or re-lay-out it without touching the rules.
|
||||||
- `licenses/` — third-party licences that must travel with the app
|
- `licenses/` — third-party licences that must travel with the app
|
||||||
|
|||||||
@@ -0,0 +1,222 @@
|
|||||||
|
# Katan: Cities & Knights — implemented rules
|
||||||
|
|
||||||
|
This is the second rule set of Katan (see [RULES-catan.md](RULES-catan.md) for the
|
||||||
|
base game). It is chosen on the setup screen — **Rules: Base game / Cities &
|
||||||
|
Knights** — and stored as `CatanOptions.ruleSet` (`CatanRuleSet.CITIES_AND_KNIGHTS`).
|
||||||
|
A table plays one or the other; the choice reaches guests with the rest of the
|
||||||
|
options.
|
||||||
|
|
||||||
|
The expansion is a whole rule set rather than a toggle, because it replaces rules
|
||||||
|
(no development cards, no Largest Army, a different seven) as well as adding them.
|
||||||
|
Everything it needs lives behind `CatanState.ck`, which is `null` in the base game,
|
||||||
|
so a base game's state and rules are untouched. The code is:
|
||||||
|
|
||||||
|
| File | Holds |
|
||||||
|
| --- | --- |
|
||||||
|
| `CatanCkModel.kt` | the data: commodities, improvement tracks, progress cards, knights, the chore queue, every new move |
|
||||||
|
| `CatanCk.kt` | the rules: legal moves, applying them, the roll, the barbarians, scoring |
|
||||||
|
| `CatanCkAi.kt` | the computer opponent for this rule set |
|
||||||
|
| `CatanRules.kt` | the single entry point; calls into `CatanCk` whenever `state.ck != null` |
|
||||||
|
|
||||||
|
Behaviour is pinned by `CatanCkRulesTest` (each rule on a crafted position) and
|
||||||
|
`CatanCkSelfPlayTest` (whole games, engine against engine). Three or four players,
|
||||||
|
as in the base game.
|
||||||
|
|
||||||
|
## Verification
|
||||||
|
|
||||||
|
The rules were checked against the in-game almanac of Catan Universe (rules text
|
||||||
|
only: costs, card wordings, the barbarian and improvement rules). Where the almanac
|
||||||
|
is silent or ambiguous the reading chosen is listed under *Choices made here* below.
|
||||||
|
|
||||||
|
## What changes from the base game
|
||||||
|
|
||||||
|
| | Base game | Cities & Knights |
|
||||||
|
| --- | --- | --- |
|
||||||
|
| Points to win | 10 | **13** (setup offers 8 / 10 / 13 / 15) |
|
||||||
|
| Development cards | 25-card deck | **none** — knights and progress cards replace them |
|
||||||
|
| Largest Army | 5 *(see RULES-catan.md)* | **none** |
|
||||||
|
| Longest Road | 5 *(see RULES-catan.md)* | **2** |
|
||||||
|
| Second setup piece | settlement | **city** (resources only, no commodities) |
|
||||||
|
| Dice | two | **two number dice + the event die** |
|
||||||
|
| A seven | discard half over 7; robber moves | discard half over **7 + 2 per wall**; the robber **only moves after the first barbarian attack** |
|
||||||
|
| Cities | 2 of a resource | forest: 1 lumber + **1 paper**; pasture: 1 wool + **1 cloth**; mountains: 1 ore + **1 coin**; hills / fields: 2 of the resource |
|
||||||
|
|
||||||
|
## The dice
|
||||||
|
|
||||||
|
The yellow die and the red die are added for production, as in the base game. The
|
||||||
|
**event die** has three ships and one gate each of yellow (trade), blue (politics)
|
||||||
|
and green (science). It is resolved **before** production:
|
||||||
|
|
||||||
|
- **Ship** — the barbarians come one step nearer (they start 7 steps out).
|
||||||
|
- **Gate** — every player with at least one level of improvement in that colour,
|
||||||
|
**in turn order from the roller**, whose **red die is no higher than their level**
|
||||||
|
in that track, draws a progress card of that colour.
|
||||||
|
|
||||||
|
`RollDice(forced, event)` stages both for tests, like the base game's forced roll.
|
||||||
|
An **Alchemist** played before the roll sets the two number dice (the event die is
|
||||||
|
still rolled).
|
||||||
|
|
||||||
|
## Commodities
|
||||||
|
|
||||||
|
Three commodities — **cloth, coin, paper** — join the five resources. The bank holds
|
||||||
|
12 of each (19 of each resource). Hands, discards, thefts and trades all treat them as
|
||||||
|
cards; progress cards are not cards for any of these purposes.
|
||||||
|
|
||||||
|
When the bank cannot meet the demand for a card type: with **one** seat owed it,
|
||||||
|
that seat takes what is left; with **two or more** owed, nobody receives it.
|
||||||
|
|
||||||
|
## The barbarians
|
||||||
|
|
||||||
|
The strip shows how many steps away the ship is. On the seventh ship it **lands**:
|
||||||
|
|
||||||
|
- Barbarian strength is the **number of cities on the board** (a metropolis is a city).
|
||||||
|
- Catan's strength is the sum of the strengths of every **active** knight (basic 1,
|
||||||
|
strong 2, mighty 3).
|
||||||
|
- If Catan's strength is **at least** the barbarians', Catan holds: the player with
|
||||||
|
the strictly highest contribution takes a **Defender of Catan** card (one point);
|
||||||
|
if several tie for highest, **each draws a progress card from a deck of their
|
||||||
|
choice** instead.
|
||||||
|
- Otherwise Catan falls: among the players who own a city that is not a metropolis,
|
||||||
|
those who contributed **least** each lose one city, **to their own choice**. A lost
|
||||||
|
city becomes a settlement (or, if the seat has no settlement piece left, is removed),
|
||||||
|
and its wall goes. **A metropolis can never be pillaged.**
|
||||||
|
- Either way every knight stands down, the ship returns to seven steps, and the
|
||||||
|
**robber wakes** — until now it has not been on the board.
|
||||||
|
|
||||||
|
## Knights
|
||||||
|
|
||||||
|
Each seat has **two knights of each strength** (six in all).
|
||||||
|
|
||||||
|
| Action | Cost | Rule |
|
||||||
|
| --- | --- | --- |
|
||||||
|
| Hire | 1 ore + 1 wool | a **basic** knight on an empty crossing at the end of one of your roads; only if one of your two basic knights is free |
|
||||||
|
| Activate | 1 grain | a sleeping knight wakes; only active knights count against the barbarians |
|
||||||
|
| Promote | 1 ore + 1 wool | one level, once per knight per turn; a **mighty** knight needs **level three of politics** (the fortress); the next level's pieces must be free |
|
||||||
|
| Move | — | an active knight moves along **its own roads** to an empty crossing, or onto a **strictly weaker** foreign knight, driving it off; it then rests |
|
||||||
|
| Chase the robber | — | an active knight on a crossing of the robber's hex sends the robber off (only once the robber is awake); it then rests, and the robber move follows |
|
||||||
|
|
||||||
|
- **A knight cannot act on the turn it woke.** It can be woken again after it acts.
|
||||||
|
- A driven-off knight is moved by **its owner** along its own roads to any empty
|
||||||
|
crossing it can reach; if there is none, it is lost.
|
||||||
|
- A knight is a wall, like an opposing building: roads cannot be laid past an enemy
|
||||||
|
knight, a settlement cannot be built on a knight, and the knight cuts **Longest Road**.
|
||||||
|
- Knights can act (wake, move, chase) **before the roll** as well as after.
|
||||||
|
|
||||||
|
## City walls
|
||||||
|
|
||||||
|
2 brick, on a city without a wall, **three per player**. Each wall raises the hand
|
||||||
|
limit on a seven by two (so a seven discards when you hold more than `7 + 2 × walls`).
|
||||||
|
|
||||||
|
## City improvements
|
||||||
|
|
||||||
|
Three tracks, five levels each, bought with the track's commodity: **trade (cloth,
|
||||||
|
yellow), politics (coin, blue), science (paper, green)**. Level *n* costs *n* of the
|
||||||
|
commodity. You must own a city to improve.
|
||||||
|
|
||||||
|
| Track | Level 3 gives |
|
||||||
|
| --- | --- |
|
||||||
|
| Trade | commodities trade with the bank **2:1** |
|
||||||
|
| Politics | knights may be promoted to **mighty** |
|
||||||
|
| Science | the **aqueduct**: when the dice pay you nothing, take any resource |
|
||||||
|
|
||||||
|
The level names (Trading Post … Grand Bazaar, Town Hall … Palace, Abbey … University)
|
||||||
|
are this app's own.
|
||||||
|
|
||||||
|
### Metropolises
|
||||||
|
|
||||||
|
The first player to reach **level four** in a track takes that track's **metropolis**
|
||||||
|
(a marker on one of their cities: +2 points; a city carries at most one). Reaching
|
||||||
|
**level five** takes it from a holder who is still on four. A player with several
|
||||||
|
cities chooses which; with one it is placed at once; a player with no free city
|
||||||
|
**waits**, and claims it when a city is built.
|
||||||
|
|
||||||
|
## Progress cards
|
||||||
|
|
||||||
|
54 cards: 18 in each of three decks. A card played returns to the **bottom** of its
|
||||||
|
deck. A hand holds **four**; a fifth must be given back at once. They can be played at
|
||||||
|
any point of your own turn (before or after the roll), except where noted.
|
||||||
|
|
||||||
|
**Science (green)** — Alchemist ×2 *(before the roll only)*, Crane ×2, Engineer, Inventor ×2,
|
||||||
|
Irrigation ×2, Medicine ×2, Mining ×2, Printer, Road Building ×2, Smith ×2.
|
||||||
|
|
||||||
|
**Politics (blue)** — Bishop ×2 *(after the first attack)*, Constitution, Deserter ×2,
|
||||||
|
Diplomat ×2, Intrigue ×2, Saboteur ×2, Spy ×3, Warlord ×2, Wedding ×2.
|
||||||
|
|
||||||
|
**Trade (yellow)** — Commercial Harbor ×2, Master Merchant ×2, Merchant ×6,
|
||||||
|
Merchant Fleet ×2, Resource Monopoly ×4, Trade Monopoly ×2.
|
||||||
|
|
||||||
|
**Printer** and **Constitution** are one point each and are **laid face up the moment
|
||||||
|
they are drawn**; they never sit in a hand.
|
||||||
|
|
||||||
|
How each plays is shown on the card in the app (`CatanText.progressHelp`); the engine's
|
||||||
|
behaviour is in `CatanCk.applyProgress`. Points worth knowing:
|
||||||
|
|
||||||
|
- **Saboteur** hits every other player with **as many points as you or more**, who each
|
||||||
|
discard half their cards (rounded down). **Wedding** takes two cards (or what they
|
||||||
|
have) from each player with **more** points. **Master Merchant** needs a victim with
|
||||||
|
more points, and takes two cards you choose.
|
||||||
|
- **Spy**: you see the target's progress cards and take one; nobody else sees them.
|
||||||
|
- **Merchant**: placed beside one of your buildings; you trade that hex's resource 2:1
|
||||||
|
and hold a victory point until someone else plays a Merchant.
|
||||||
|
- **Deserter**: the victim removes a knight of *their* choice; you place a free one of the
|
||||||
|
same strength (or a basic if yours is not free), awake or asleep as theirs was.
|
||||||
|
- **Diplomat**: removes a road with a loose end (an end touching no other road, building
|
||||||
|
or knight); if it was yours you may rebuild it anywhere for free.
|
||||||
|
- **Inventor** swaps two tokens, never a 2, 6, 8 or 12.
|
||||||
|
|
||||||
|
## The chore queue
|
||||||
|
|
||||||
|
Anything that needs an answer from somebody — a discard, a city to lose, a progress card
|
||||||
|
to hand over, a metropolis site, a knight to place — is queued as a **chore**
|
||||||
|
(`CatanPhase.CHORE`, `CkState.chores`). The game waits on the seat the first chore names
|
||||||
|
(not always the player whose turn it is), then resumes where `CkState.back` says. This is
|
||||||
|
how a seven, a barbarian landing, a wedding or a spy are all one mechanism, and why
|
||||||
|
the AI and the network driver needed no new concepts.
|
||||||
|
|
||||||
|
The two free-form chores — **discarding** and **handing over** cards — are structural
|
||||||
|
like the base game's trade offers: the engine checks them in `isLegalMove` and the legal
|
||||||
|
list carries one example, so a seat is never without a move.
|
||||||
|
|
||||||
|
## Scoring and winning
|
||||||
|
|
||||||
|
Settlement 1, city 2, **metropolis +2**, **Longest Road 2**, **Defender of Catan 1** each,
|
||||||
|
**Printer / Constitution 1** each, **the Merchant 1**. Nothing is hidden. Win at 13 (default),
|
||||||
|
checked after every move and when a turn arrives.
|
||||||
|
|
||||||
|
## Choices made here, and why
|
||||||
|
|
||||||
|
- **The red die must be no higher than the improvement level** to draw a progress card
|
||||||
|
(level 1 draws on a 1, level 5 on 1–5). The almanac says the red die must match a
|
||||||
|
number on one of your improvements and that the number rises with the level; this is
|
||||||
|
the reading that makes both true.
|
||||||
|
- **One resource is offered to every player for a Commercial Harbor.** The printed card
|
||||||
|
lets you offer a different one to each.
|
||||||
|
- **The merchant cannot go on the desert**, which produces nothing to trade.
|
||||||
|
- **Improvements need a city** to be built.
|
||||||
|
- **A 3:1 harbour trades commodities too**; a 2:1 harbour trades only its own resource.
|
||||||
|
- **A knight that cannot find a refuge is lost**, as the almanac says of an intrigue.
|
||||||
|
- **A claim on a metropolis with no city to carry it waits** and is made when a city is
|
||||||
|
built.
|
||||||
|
- **Domestic trade** works as in the base game — an offer to one seat or to the whole
|
||||||
|
table, asked in seat order, each seat accepting, declining or countering — and may
|
||||||
|
include commodities (`OfferGoods`, `CounterGoods`; accepting and dismissing counters
|
||||||
|
reuse the base game's `AcceptCounter` and `DismissCounters`).
|
||||||
|
- **No Seafarers, no 5–6 player extension**, no scenario or variant of any kind.
|
||||||
|
|
||||||
|
## The computer opponent
|
||||||
|
|
||||||
|
`CatanCkAi` plays a safe, unambitious game: it settles and raises cities as the base AI
|
||||||
|
does, spends commodities on improvements as soon as it can (leaning to politics), hires
|
||||||
|
and wakes knights as the barbarians draw near, chases the robber off hexes it needs, plays
|
||||||
|
the progress cards whose value is obvious, and answers every chore with the card it values
|
||||||
|
least. It never plans a knight's route, never plays an Alchemist, Inventor, Diplomat,
|
||||||
|
Deserter or Intrigue, and makes no domestic offers (though it answers them). Every engine
|
||||||
|
game in `CatanCkSelfPlayTest` ends in a win at thirteen points.
|
||||||
|
|
||||||
|
## Known gaps
|
||||||
|
|
||||||
|
- The screen is built and its logic is tested, but **not yet verified on two real
|
||||||
|
devices**; the catalogue entry stays a dev-channel preview.
|
||||||
|
- No animation for the event die, the barbarian landing or a knight's move.
|
||||||
|
- The Commercial Harbor offers a single resource type (see above).
|
||||||
|
- The AI is not a strong opponent and makes no claim to be.
|
||||||
@@ -0,0 +1,71 @@
|
|||||||
|
# Katan: Seafarers
|
||||||
|
|
||||||
|
The Seafarers rule set is chosen at setup next to *Base game* and *Cities & Knights*. It is the base
|
||||||
|
game ([RULES-catan.md](RULES-catan.md)) with a sea, ships, a pirate, gold fields and islands to
|
||||||
|
settle. Code: `game/catan/CatanSeaRules.kt` (the additions), `CatanSeaBoard.kt` (the map),
|
||||||
|
`CatanBoard.kt` (`Topology`, the geometry shared by every map), state behind `CatanState.sea`
|
||||||
|
(null in the other rule sets). It cannot be combined with Cities & Knights.
|
||||||
|
|
||||||
|
Where the published rules leave room, or where this game differs, it says so below.
|
||||||
|
|
||||||
|
## The map
|
||||||
|
|
||||||
|
One map, *Heading for New Shores*: a large **home island** (21 hexes, one desert) and three small
|
||||||
|
islands (3, 3 and 2 hexes) across the water, inside a ring of sea. Which land hexes are gold, which
|
||||||
|
are the desert and where the sea lies is fixed; the **resources on the other hexes, the number tokens
|
||||||
|
and the nine harbours are shuffled** for each game. The red numbers (6, 8) are never on neighbouring
|
||||||
|
hexes. Players take three or four seats; the default target is **12 points** (menu: 8, 10, 12, 14).
|
||||||
|
|
||||||
|
The geometry is the same lattice as the base island, generalised (`Topology`): a hex is land or sea,
|
||||||
|
a crossing can hold a town if any hex touching it is land, an edge can hold a road if any hex touching
|
||||||
|
it is land and a ship if any hex touching it is sea (so a coastal edge takes either, never both).
|
||||||
|
|
||||||
|
## What changes
|
||||||
|
|
||||||
|
**Setup.** Both starting settlements (and their roads) go on the home island. A starting piece is a
|
||||||
|
road, never a ship. The second settlement collects from the hexes round it as usual (gold pays nothing
|
||||||
|
at setup).
|
||||||
|
|
||||||
|
**Ships.** A ship costs 1 lumber and 1 wool and lies on a sea edge.
|
||||||
|
|
||||||
|
* It must join your fleet or a town of yours: one end of the edge touches your town, or another of your ships.
|
||||||
|
An opponent's town is a wall.
|
||||||
|
* Roads and ships connect **only at a town of your own**: a road cannot start from a ship's end, nor a
|
||||||
|
ship from a road's, unless a settlement or city of yours stands on that crossing. A settlement may be
|
||||||
|
built at the end of a ship route exactly as at the end of a road route.
|
||||||
|
* No more than 15 ships. Road Building may lay two roads, two ships or one of each.
|
||||||
|
* **Sailing.** Once per turn you may move one ship, never one built or moved this turn, and only a ship at the
|
||||||
|
**open end** of a route (one end touches nothing else of yours). It goes to any edge it could be built on
|
||||||
|
with it lifted off.
|
||||||
|
|
||||||
|
**The pirate.** Starts in the open sea. On a seven (and with a Knight card) the player moves either the
|
||||||
|
robber, to any land hex, or the pirate, to any sea hex. The robber works as before. The pirate **blocks the six
|
||||||
|
edges round its hex**: no ship may be built or sail onto them (ships already there stay). It robs one card
|
||||||
|
at random from a player with a ship on an edge of its hex.
|
||||||
|
|
||||||
|
**Gold.** A gold field has a number like any hex. When it comes up, each town beside it (one card; a city two)
|
||||||
|
pays its owner **any resource of their choice**, chosen after the ordinary production is dealt, in seat order from
|
||||||
|
the roller. The robber blocks a gold field like any hex. If the bank cannot supply the choice it is limited to
|
||||||
|
what it holds.
|
||||||
|
|
||||||
|
**New islands.** The first player to settle on each island other than the home island scores **2 bonus points**,
|
||||||
|
permanently (`SeaState.islandBonus`). A second settlement there earns nothing extra.
|
||||||
|
|
||||||
|
**Longest route.** Longest Road counts roads and ships together, as a path of your pieces that never runs
|
||||||
|
through an opponent's town and changes between road and ship only at a town of yours. Five or more, as before.
|
||||||
|
|
||||||
|
Everything else (development cards, trading, harbours, Largest Army, the discard on a seven) is the base game.
|
||||||
|
|
||||||
|
## Not included
|
||||||
|
|
||||||
|
The physical expansion has more scenarios and the Catan Universe app adds more still. These are **out of scope here**:
|
||||||
|
fog islands, treasure islands, the oasis, the great canal, the Explorers & Pirates and Cities & Knights combinations,
|
||||||
|
the scenarios after the first, and trade ships. The `SeaScenario` enum and `SeaBoards` are built so a second map
|
||||||
|
is a new text map and a new enum entry.
|
||||||
|
|
||||||
|
## How the AI plays it
|
||||||
|
|
||||||
|
It settles first and sails second. A ship is built when a settlement spot reachable by sea (up to five steps from its
|
||||||
|
open end) is worth having, with a bonus for an island nobody has landed on, and ahead of a development card when that
|
||||||
|
bonus is in play. It chooses the resource it values most from gold, always moves the robber (never the pirate) and does
|
||||||
|
not sail ships it has already launched. See `CatanAi.shipValue`.
|
||||||
+20
-1
@@ -12,14 +12,27 @@ players, as published.
|
|||||||
The engine is a pure state machine (`CatanRules`) with no Android types, and its
|
The engine is a pure state machine (`CatanRules`) with no Android types, and its
|
||||||
behaviour is pinned by `CatanBoardTest`, `CatanRulesTest` and `CatanAiTest`.
|
behaviour is pinned by `CatanBoardTest`, `CatanRulesTest` and `CatanAiTest`.
|
||||||
|
|
||||||
|
## Rule sets
|
||||||
|
|
||||||
|
A table plays one of two rule sets, chosen on the setup screen
|
||||||
|
(`CatanOptions.ruleSet`):
|
||||||
|
|
||||||
|
- **Base game** — everything in this document.
|
||||||
|
- **Cities & Knights** — the expansion, documented in
|
||||||
|
[RULES-catan-ck.md](RULES-catan-ck.md). It reuses this document's board, setup,
|
||||||
|
building, robber and trade rules and changes or replaces the rest; its state lives
|
||||||
|
behind `CatanState.ck`, which is `null` in the base game.
|
||||||
|
|
||||||
## Table
|
## Table
|
||||||
|
|
||||||
|
- **Rules — *toggle*.** Base game or Cities & Knights (`CatanOptions.ruleSet`).
|
||||||
- **Players — *toggle*.** Three or four. `CatanOptions.playerCount`; the engine
|
- **Players — *toggle*.** Three or four. `CatanOptions.playerCount`; the engine
|
||||||
refuses anything else.
|
refuses anything else.
|
||||||
- **Points to win — *toggle*.** Defaults to 10. `CatanOptions.pointsToWin`, at
|
- **Points to win — *toggle*.** Defaults to 10. `CatanOptions.pointsToWin`, at
|
||||||
least 2. A lower target makes a test game short.
|
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).
|
The setup screen exposes all three (players: 3 or 4; game to 5, 8, 10 or 12 points in the
|
||||||
|
base game, 8, 10, 13 or 15 in Cities & Knights, whose published target is 13).
|
||||||
|
|
||||||
## Board
|
## Board
|
||||||
|
|
||||||
@@ -311,6 +324,12 @@ timing rules; Longest Road and Largest Army worth five; victory at ten.
|
|||||||
|
|
||||||
## Known gaps
|
## Known gaps
|
||||||
|
|
||||||
|
- **Longest Road and Largest Army are worth 5 each here.** The published base game awards
|
||||||
|
**2** each (Catan Universe's almanac says so for Largest Army, and the printed rules
|
||||||
|
for both). Cities & Knights scores Longest Road at 2, as printed. Left unchanged in
|
||||||
|
the base game so far; it is a one-constant change in `publicVictoryPoints`.
|
||||||
|
- **A bank short of a resource pays nobody that roll**, even when only one player is owed
|
||||||
|
it. The published ruling lets a lone claimant take what is left; Cities & Knights does.
|
||||||
- **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.
|
- **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.
|
- **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.
|
- **No trading away a development card.** Not part of the base game.
|
||||||
|
|||||||
@@ -0,0 +1,98 @@
|
|||||||
|
# Meowdoku
|
||||||
|
|
||||||
|
A board of colours, and a cat in every row, column and colour — no two sharing
|
||||||
|
even a corner.
|
||||||
|
|
||||||
|
## The puzzle
|
||||||
|
|
||||||
|
The board is **N by N** and coloured into **N regions**. Exactly one cat hides
|
||||||
|
in every row, every column and every region, and no two cats may touch — not
|
||||||
|
along a side and not at a corner, so a cat rules out all eight squares around
|
||||||
|
itself. Those four constraints together always leave exactly one arrangement.
|
||||||
|
|
||||||
|
Uniqueness is not decoration. The game is deduction, and a second answer means
|
||||||
|
a square the player cannot prove either way. Every board is therefore generated
|
||||||
|
and then searched: build the colours, count the ways a board can be answered,
|
||||||
|
and if it is more than one, throw the board away and deal another. The count is
|
||||||
|
a plain depth-first search over the rows with the obvious exclusions propagated,
|
||||||
|
and it sees only the colours and the rules — never the cats it was grown from.
|
||||||
|
|
||||||
|
## Playing it
|
||||||
|
|
||||||
|
Controls are the original's, and they carry the game's whole psychology:
|
||||||
|
|
||||||
|
- **One tap crosses a square over.** Free, instant, erasable — the note you
|
||||||
|
make while thinking.
|
||||||
|
- **A second tap on the same square within 350 ms is the cat attempt.** The
|
||||||
|
board judges it against the answer it was dealt: correct, the cross is
|
||||||
|
replaced by a cat; wrong, the cross stays and a heart goes. This is why a
|
||||||
|
guess feels like a decision: your own note has to survive one more tap
|
||||||
|
before it becomes a bet.
|
||||||
|
- **Drag to cross a line.** The stroke paints the same note every square it
|
||||||
|
enters: start on a blank square and it crosses the row or column you drag
|
||||||
|
along; start on a crossed square and the stroke erases them instead. Cats
|
||||||
|
are skipped — placed cats are permanent.
|
||||||
|
|
||||||
|
A square you pencilled over can still be tapped for a cat, and the cross is
|
||||||
|
forgiven: the attempt replaces it if it is right. The one thing no gesture
|
||||||
|
undoes is a cat once placed.
|
||||||
|
|
||||||
|
The original ships a fifth gesture — a **draft** scratchpad mode, a tool you
|
||||||
|
buy, where crosses and cats are laid down without judgement and applied all at
|
||||||
|
once — and it is left out here with the rest of the shop: a scratchpad whose
|
||||||
|
notes cost nothing is what tapping already is.
|
||||||
|
|
||||||
|
A **Hint** spends a token and shows the cat in the first row that still lacks
|
||||||
|
one, replacing any cross drawn over it. The original sells these as tools; here
|
||||||
|
they are simply counted, three per board by default, which keeps the hint a
|
||||||
|
decision rather than a reflex.
|
||||||
|
|
||||||
|
## The heart
|
||||||
|
|
||||||
|
Why a wrong tap costs anything at all: the puzzle is only hard if guessing is.
|
||||||
|
A board with no penalty is a board you can solve by tapping every square, and
|
||||||
|
the hearts are what make the deduction on a colour you have not reasoned about
|
||||||
|
yet feel like a choice. Three is the number the original deals, and it stays
|
||||||
|
three by default.
|
||||||
|
|
||||||
|
## Options
|
||||||
|
|
||||||
|
| | |
|
||||||
|
| --- | --- |
|
||||||
|
| **Board** | 4×4 up to 10×10; the number of cats equals the side |
|
||||||
|
| **Hearts** | 1 to 5, default 3 |
|
||||||
|
| **Hints** | 0 to 3, default 3 |
|
||||||
|
|
||||||
|
Boards are dealt from the table's seed, so a saved game resumes to the same
|
||||||
|
cats in the same colours, and **New puzzle** moves the seed to deal a different
|
||||||
|
board. Smaller sides are gentler: a 4×4 is the shortest way to learn what
|
||||||
|
no-touch does to a corner, and the ten-wide boards are for people who have
|
||||||
|
already made that mistake.
|
||||||
|
|
||||||
|
## How a board is dealt
|
||||||
|
|
||||||
|
The order matters, and it is the order the original game uses:
|
||||||
|
|
||||||
|
1. **Settle the cats first.** One per row, one per column, no two touching,
|
||||||
|
chosen by backtracking over shuffled column orders.
|
||||||
|
2. **Grow the colours around them.** Each region starts as its cat's square and
|
||||||
|
expands outwards one square at a time; some regions are grown as straight
|
||||||
|
bars along the cat's row or column, which is what stops the board reading as
|
||||||
|
texture, and the rest take whichever neighbour is smallest so nothing
|
||||||
|
sprawls while another dies young.
|
||||||
|
3. **Check the answer.** Count solutions up to two; keep the board only when
|
||||||
|
the count comes back exactly one.
|
||||||
|
|
||||||
|
The generator's rejection loop is why the same seed can take a few attempts:
|
||||||
|
most boards are unique on the first try, and the odd seed has to walk until it
|
||||||
|
finds one.
|
||||||
|
|
||||||
|
## Where this engine differs from the original
|
||||||
|
|
||||||
|
The app is a game collection, not a live-service puzzle, so what sits around
|
||||||
|
the original's gameplay is left behind: lives-as-monetisation (watching an ad
|
||||||
|
for a heart), daily streaks and leaderboards, an Elo-matched bank of
|
||||||
|
hand-authored levels, and the cosmetic layer (cat animations, combo feedback,
|
||||||
|
confetti). This engine **deals its boards from a seed** instead of shipping a
|
||||||
|
level bank, and the rules are the part worth keeping: the cats, the colours,
|
||||||
|
the no-touch, the hearts, the one answer.
|
||||||
@@ -0,0 +1,43 @@
|
|||||||
|
# Saved games
|
||||||
|
|
||||||
|
A game played against the computer (or on one device) is kept as it is played, and can be
|
||||||
|
picked up again after the app has been closed.
|
||||||
|
|
||||||
|
## What the player sees
|
||||||
|
|
||||||
|
- **Main menu → Continue.** Each game left half-played is listed, most recent first
|
||||||
|
("Chess · saved 5 minutes ago"); tapping it resumes.
|
||||||
|
- **A game's setup screen** shows a *Game in progress* card with **Resume** and **Discard**.
|
||||||
|
Starting a new game from that screen replaces the saved one.
|
||||||
|
- **Leaving the table** (the back arrow, or the app being closed or sent to the background)
|
||||||
|
keeps the position. **End game → End the game** is the deliberate way to throw it away.
|
||||||
|
- A game that is **finished** is not kept.
|
||||||
|
- A **networked** table is not kept: the other player's seat cannot be held for them. Only a
|
||||||
|
table with no remote human at it (`PlayerKind.HUMAN_REMOTE`) is saved.
|
||||||
|
|
||||||
|
One slot per game: there is one saved Chess game, one saved Katan game, and so on.
|
||||||
|
|
||||||
|
## How it works
|
||||||
|
|
||||||
|
| Piece | Where | Does |
|
||||||
|
| --- | --- | --- |
|
||||||
|
| `SavedMatch`, `SavedGameStore` | `game/engine/SavedGame.kt` | one JSON file per game under `filesDir/saved-games/`, written atomically (temp file, then renamed); an unreadable file is deleted and read as absent |
|
||||||
|
| `MatchController.onHostState`, `restore` | `net/MatchController.kt` | the host reports every position it reaches; `restore(json)` starts the table from a saved position instead of dealing |
|
||||||
|
| `MatchSaver` | `net/MatchSaver.kt` | takes the newest position and writes it off the main thread; `flush()` writes synchronously on leaving or on `ON_STOP`; `discard()` forgets the game |
|
||||||
|
| `StartMatch` | `ui/PlayScreen.kt` | wires the two together for every game; consumes the resume state once, so a solitaire "new deal" is not put back |
|
||||||
|
| `LocalEndGameHandle` | `ui/EndGameHandle.kt` | how each *End game* dialog tells the table to forget its save |
|
||||||
|
|
||||||
|
What is saved is `rules.encodeState` of the **host's true state** (hidden cards included),
|
||||||
|
plus the `TableConfig` (seed, seats, options) and the local seat. Nothing in the store knows
|
||||||
|
which game it is holding, so a new game is saved with no work, provided its state encodes.
|
||||||
|
|
||||||
|
A save this build cannot decode (one written by an older version whose state has since
|
||||||
|
changed shape) is thrown away and a fresh game is dealt.
|
||||||
|
|
||||||
|
## Tests
|
||||||
|
|
||||||
|
- `SavedGameStoreTest` — the files: round trip, one slot, ordering, corruption, a cut-off write.
|
||||||
|
- `MatchSaverTest` — saving as a table is played, resuming from a save, finished games, flush, discard.
|
||||||
|
- `SaveRoundTripAllGamesTest` — **every game in the catalogue**: the whole state is encoded and
|
||||||
|
decoded at every move of a computer-played game, and play carries on from the decoded copy.
|
||||||
|
A new game should be added to it.
|
||||||
@@ -22,6 +22,8 @@ truth, so the UI can only ever offer a move the rules would accept.
|
|||||||
| **Board drawing** | `CatanBoardView.kt` | The `Canvas`: tiles, tokens, ports, robber, roads, pieces, highlights | Change how a piece is drawn (art, shapes, animation) |
|
| **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 |
|
| **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 |
|
| **Dialogs** | `CatanDialogs.kt` | Discard, robber victim, play card, trade, trade reply, game over | Change a dialog's flow or look |
|
||||||
|
| **HUD** | `CatanHud.kt` | The landscape controls: build column, ✓ / ✗, round turn / trade buttons, pinch-pan board | Move or restyle a landscape control |
|
||||||
|
| **Trade board** | `CatanTradeBoard.kt` | The base-game trade panel (offer, bank, reply) | Change how trades are composed or answered |
|
||||||
| **Screen** | `CatanScreen.kt` | Wiring to `MatchController`, portrait/landscape layout, which dialog shows | Change the layout or add a new element |
|
| **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 |
|
| **Previews** | `CatanPreviews.kt` | Android Studio previews of real positions | Iterate on the look without a match |
|
||||||
|
|
||||||
@@ -121,6 +123,34 @@ and play a game on a dev build.
|
|||||||
- The board has a content description but no per-hex semantics; a screen-reader
|
- The board has a content description but no per-hex semantics; a screen-reader
|
||||||
mode would need one.
|
mode would need one.
|
||||||
|
|
||||||
|
## Cities & Knights on the screen
|
||||||
|
|
||||||
|
The same layers carry the expansion; the screen only adds pieces, and **none of them
|
||||||
|
decides what is legal** — each reads the engine's legal-move list.
|
||||||
|
|
||||||
|
| Layer | What it adds |
|
||||||
|
| --- | --- |
|
||||||
|
| `CatanStyle.kt` | commodity colours, a colour per improvement track, the wall and barbarian colours, the awake-knight halo |
|
||||||
|
| `CatanText.kt` | goods, track, knight and progress-card names and help text; the prompts for every chore |
|
||||||
|
| `CatanInteraction.kt` | `BuildKind.WALL` / `KNIGHT`; chore taps; the moving-knight and armed-card modes; `knightActions`, `progressHand`, `goodsBankTrades` |
|
||||||
|
| `CatanBoardView.kt` | shields for knights (strength dots; faded when asleep, white halo when awake), dashed walls, a pennant for each metropolis, the merchant coin, a faint robber until the first attack |
|
||||||
|
| `CatanPanels.kt` | commodity tiles in the hand, the barbarian strip, the yellow / red / event dice, the extra player-card lines, the Improve and Progress buttons |
|
||||||
|
| `CatanCkDialogs.kt` | goods picker (discard, wedding, harbour), improvements, progress cards, the knight menu, deck / aqueduct / spy / drop choices, goods trade |
|
||||||
|
| `CatanScreen.kt` | the visual state: knight menu, moving knight, armed card, and which chore dialog shows |
|
||||||
|
|
||||||
|
**Interaction model.** Tap one of your own knights (it gets a yellow ring when it can do
|
||||||
|
something) for its menu: wake, promote, move or chase the robber. *Move* arms the board
|
||||||
|
with the crossings the knight can reach. A progress card that needs a place on the board
|
||||||
|
(Engineer, Medicine, Merchant, Diplomat, Intrigue, Inventor) closes the dialog and
|
||||||
|
**arms** the board; the next tap plays it. Chores that are answered with a place — a city
|
||||||
|
to lose, a metropolis site, a driven knight's refuge, a free knight — light the crossings
|
||||||
|
on the board and the prompt line says what to tap; the others open a dialog that cannot
|
||||||
|
be dismissed, because the game is waiting on it.
|
||||||
|
|
||||||
|
**Testing.** `CatanCkInteractionTest` plays whole games and checks that for *every* legal
|
||||||
|
move at *every* position some control (a tap, a button or a dialog choice) produces it, so
|
||||||
|
a legal move with no way to make it — a stuck phone — fails the build.
|
||||||
|
|
||||||
## Status and known gaps
|
## Status and known gaps
|
||||||
|
|
||||||
The screen is **playable and feature-complete for the engine's rules**, but is
|
The screen is **playable and feature-complete for the engine's rules**, but is
|
||||||
@@ -141,3 +171,40 @@ Not done yet, in rough priority order:
|
|||||||
4. A timer or cancel button on offers (the engine has neither).
|
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).
|
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.
|
6. Landscape polish on large tablets; the right-hand panel scrolls but is plain.
|
||||||
|
|
||||||
|
## Landscape HUD and trade board (from Catan Universe)
|
||||||
|
|
||||||
|
Landscape screens use the control scheme of Catan Universe's match view, redrawn in 2D
|
||||||
|
(what was learned, and from where: [RE-catan-universe.md](RE-catan-universe.md)). Portrait keeps the stacked layout.
|
||||||
|
|
||||||
|
* **Drag to build.** The left column holds Road / Settlement / City (and Wall / Knight in
|
||||||
|
Cities & Knights). Drag a piece onto the island: lit spots snap under the finger
|
||||||
|
(`CatanInteraction.snap`), release over one to **stage** it, then press **✓** to place or **✕**
|
||||||
|
to cancel (`CatanInteraction.stageable`, `spotOf`). A tap on a piece still arms the board for
|
||||||
|
tapping a spot. Setup placements, free roads and chores are not staged: they commit on tap.
|
||||||
|
* **Pinch and pan** the island (`ZoomPanBox`). The board is drawn through a graphics layer, so
|
||||||
|
taps and drops arrive in board coordinates; hit-testing is unchanged.
|
||||||
|
* **Round buttons**, bottom right: the big one is roll / end turn / done (whatever the engine
|
||||||
|
currently allows); ⇄ is trade; the small pair is buy / play card (Improve / Cards in C&K).
|
||||||
|
* **Trade board** (`CatanTradeBoard`, base game): a panel over the bottom of the island with a
|
||||||
|
Bank / Player toggle, a round button per rival to address an offer to one player, a *get* row on
|
||||||
|
top, a *give* row below, and ▾ hide / ✕ clear / ✓ send on the right. Bank mode shows each resource's
|
||||||
|
ratio under the *give* card. An offer made to you opens the same panel read-only: ✓ accepts,
|
||||||
|
✕ declines, *Counter…* makes the rows editable.
|
||||||
|
Cities & Knights goods trades and the counter-offer chooser still use dialogs.
|
||||||
|
|
||||||
|
## Seafarers on the screen
|
||||||
|
|
||||||
|
| Layer | What it adds |
|
||||||
|
| --- | --- |
|
||||||
|
| `CatanGeometry.kt` | `BoardLayout` and `CatanGeometry.fit` take the game's `Topology`, so a map of islands fits the box like the standard island does |
|
||||||
|
| `CatanStyle.kt` | gold-field colour, the pirate's and the ship sail's colours |
|
||||||
|
| `CatanBoardView.kt` | sea hexes (a faint grid, no fill), ships (hull with a sail), the pirate (a flagged hull), a ring on ships that can sail |
|
||||||
|
| `CatanInteraction.kt` | `BuildKind.SHIP`; `PickShip`, `movingShip`, ship targets; the robber's and the pirate's hexes; `goldMove` |
|
||||||
|
| `CatanDialogs.kt` | `CatanGoldDialog`, the choice of what a gold field pays |
|
||||||
|
| `CatanScreen.kt` | the picked-up ship, the ship on the build menu / column |
|
||||||
|
|
||||||
|
**Interaction model.** Arm *Ship* (or drag it from the build column) and tap a lit sea edge: ✓ places it. To sail,
|
||||||
|
tap one of your ships that has a ring, then a lit sea edge. After a seven, tap a land hex for the robber or a sea
|
||||||
|
hex for the pirate. A gold field opens a dialog that cannot be dismissed. `CatanSeafarersInteractionTest` checks
|
||||||
|
that every build and sail the engine offers has a tap that produces it.
|
||||||
|
|||||||
Reference in New Issue
Block a user