Compare commits

..
Author SHA1 Message Date
Claude 8990dde363 Yahtzee: two-column score card with larger text, scrolls sideways when needed
CI / Build and check (pull_request) Successful in 8m45s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_0177JQTtqM7EzJyXYiZYEJTX
2026-10-27 03:50:51 +00:00
devadmin c2b21a07f5 Merge pull request 'Yahtzee: pip dice, confirm zero scores; text size setting' (#21) from yahtzee-improvements into dev
CI / Build and check (push) Successful in 8m43s
CI / Deploy to Cloudflare Pages (push) Successful in 29s
2026-10-26 20:03:26 -06:00
Claude e98afbfd8d Yahtzee: pip dice, confirm zero scores; add text size setting
CI / Build and check (pull_request) Successful in 8m45s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_0177JQTtqM7EzJyXYiZYEJTX
2026-10-27 01:52:15 +00:00
devadmin 2c90de66d1 Merge pull request 'Release Katan and Meowdoku to production' (#19) from fix/release-katan-meowdoku into dev
CI / Build and check (push) Successful in 8m50s
CI / Build and check (pull_request) Successful in 8m50s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
CI / Deploy to Cloudflare Pages (push) Successful in 34s
2026-10-26 12:23:15 -06:00
Claude f93eba88e5 Release Katan and Meowdoku: open the production gate
CI / Build and check (pull_request) Successful in 8m43s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01S8evMuUxrft6TQj6NdAoqQ
2026-10-26 18:14:12 +00:00
devadmin 36ab518309 Merge pull request 'Scorekeeper: name players at setup; refocus after a round' (#17) from feature/scorekeeper-setup-names into dev
CI / Build and check (push) Successful in 9m36s
CI / Build and check (pull_request) Successful in 9m34s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
CI / Deploy to Cloudflare Pages (push) Successful in 36s
2026-10-26 10:35:39 -06:00
Claude 77cc6c5a05 Scorekeeper: ask for each player's name at setup; refocus first cell after a round
CI / Build and check (pull_request) Successful in 9m40s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01S8evMuUxrft6TQj6NdAoqQ
2026-10-26 04:24:25 +00:00
devadmin 166f85734b Merge pull request 'Scorekeeper: remember the last 10 player names' (#16) from feature/scorekeeper-memory into dev
CI / Build and check (push) Successful in 8m44s
CI / Deploy to Cloudflare Pages (push) Successful in 30s
2026-10-25 21:34:23 -06:00
Claude 25e38c4bf8 Scorekeeper: remember the last 10 player names and offer them when naming a column
CI / Build and check (pull_request) Successful in 8m50s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01S8evMuUxrft6TQj6NdAoqQ
2026-10-26 03:16:53 +00:00
devadmin 6bf7522042 Merge pull request 'Meowdoku: rules, AI and screen refinements' (#15) from meow2 into dev
CI / Build and check (push) Successful in 20m52s
CI / Deploy to Cloudflare Pages (push) Successful in 33s
2026-10-25 20:29:24 -06:00
Claude 7942adeaf7 Meowdoku: rules, AI and screen refinements
CI / Build and check (pull_request) Successful in 10m1s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01S8evMuUxrft6TQj6NdAoqQ
2026-10-26 01:14:45 +00:00
devadmin 488f600f15 Merge pull request 'Katan: Catan Universe style HUD and trade board (2D)' (#13) from CatanImprovements into dev
CI / Build and check (push) Successful in 8m49s
CI / Deploy to Cloudflare Pages (push) Successful in 31s
2026-10-24 11:13:07 -06:00
Claude 9b938ffd8b Merge remote-tracking branch 'origin/dev' into CatanImprovements
CI / Build and check (pull_request) Successful in 8m41s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
2026-10-24 16:58:58 +00:00
Claude ccf8d5a1ba Katan HUD: compact landscape layout for phone heights
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01WrH771kLJmTHnEfcmV2YDx
2026-10-24 16:58:58 +00:00
devadmin a00df43a44 Merge pull request 'Meowdoku: cat puzzle engine, screen and docs' (#12) from meow into dev
CI / Build and check (push) Successful in 8m38s
CI / Deploy to Cloudflare Pages (push) Successful in 30s
2026-10-24 10:54:17 -06:00
Claude d568ff7750 Meowdoku: one cat per row, column and colour, no two touching
CI / Build and check (pull_request) Successful in 8m34s
CI / Deploy to Cloudflare Pages (pull_request) Skipped
2026-10-24 16:32:39 +00:00
23 changed files with 2134 additions and 131 deletions
@@ -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
@@ -361,12 +362,18 @@ object GameCatalog {
maxPlayers = 4, maxPlayers = 4,
teamBased = false, teamBased = false,
blurb = "Trade, build, and settle the island, in the base game or Cities & Knights.", 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,
), ),
) )
@@ -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,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 }
} }
@@ -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
@@ -139,7 +141,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,
@@ -50,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
@@ -109,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()) }
@@ -140,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)
@@ -205,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 }
@@ -1134,6 +1140,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)) {
@@ -7,6 +7,7 @@ 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.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
@@ -87,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
@@ -131,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
@@ -544,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>(
@@ -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(
@@ -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") } },
)
}
@@ -6,7 +6,11 @@ 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
@@ -30,6 +34,7 @@ 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
@@ -69,6 +74,7 @@ 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) }
val endGameAction: @Composable () -> Unit = { val endGameAction: @Composable () -> Unit = {
TextButton(onClick = { confirmingEnd = true }) { Text("End game") } TextButton(onClick = { confirmingEnd = true }) { Text("End game") }
@@ -138,8 +144,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()
}
}, },
) )
@@ -150,8 +162,30 @@ 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 }
confirmingZero?.let { category ->
ZeroScoreDialog(
category = category,
onConfirm = {
confirmingZero = null
controller.submit(ScoreIn(category))
kept.clear()
},
onCancel = { confirmingZero = null },
)
} }
} }
}
@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(
@@ -190,12 +224,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)
} }
} }
@@ -206,29 +257,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
@@ -244,12 +328,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 ->
@@ -263,7 +347,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,
) )
} }
@@ -272,18 +356,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,
) )
} }
@@ -101,7 +101,7 @@ fun HudBuildColumn(
onDrag: (Offset) -> Unit, onDrag: (Offset) -> Unit,
onDragEnd: () -> Unit, onDragEnd: () -> Unit,
) { ) {
Column(modifier, verticalArrangement = Arrangement.spacedBy(6.dp), horizontalAlignment = Alignment.CenterHorizontally) { Column(modifier, verticalArrangement = Arrangement.spacedBy(3.dp), horizontalAlignment = Alignment.CenterHorizontally) {
kinds.forEach { kind -> kinds.forEach { kind ->
BuildChip(kind, enabled = kind in canBuild, armed = armed == kind, onTap, onDragStart, onDrag, onDragEnd) BuildChip(kind, enabled = kind in canBuild, armed = armed == kind, onTap, onDragStart, onDrag, onDragEnd)
} }
@@ -127,7 +127,7 @@ private fun BuildChip(
Column(horizontalAlignment = Alignment.CenterHorizontally) { Column(horizontalAlignment = Alignment.CenterHorizontally) {
Box( Box(
modifier = Modifier modifier = Modifier
.size(52.dp) .size(46.dp)
.clip(shape) .clip(shape)
.background( .background(
when { when {
@@ -183,7 +183,7 @@ object CatanHudGlyphs {
} }
} }
/** ✓ over ✗: confirm or cancel a staged placement. Always laid out; enabled only while something is staged. */ /** ✓ beside ✗: confirm or cancel a staged placement. Always laid out; enabled only while something is staged. */
@Composable @Composable
fun HudConfirmButtons( fun HudConfirmButtons(
staged: Boolean, staged: Boolean,
@@ -191,9 +191,9 @@ fun HudConfirmButtons(
onConfirm: () -> Unit, onConfirm: () -> Unit,
onCancel: () -> Unit, onCancel: () -> Unit,
) { ) {
Column(modifier, verticalArrangement = Arrangement.spacedBy(8.dp), horizontalAlignment = Alignment.CenterHorizontally) { Row(modifier, horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.Bottom) {
HudRoundButton("✓", caption = CatanText.CONFIRM_BUILD, enabled = staged, tint = Color(0xFF2E7D32), onClick = onConfirm) 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), onClick = onCancel) HudRoundButton("✕", caption = CatanText.CANCEL_BUILD, enabled = staged, tint = Color(0xFFC62828), diameter = 48.dp, onClick = onCancel)
} }
} }
@@ -309,23 +309,24 @@ fun CatanHud(
onProgress: () -> Unit, onProgress: () -> Unit,
board: @Composable (Modifier) -> Unit, board: @Composable (Modifier) -> Unit,
) { ) {
Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(4.dp)) { Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(2.dp)) {
HudPlayerStrip(state, seats, pointsOf, style) HudPlayerStrip(state, seats, pointsOf, style)
Box(Modifier.weight(1f).fillMaxWidth()) { Box(Modifier.weight(1f).fillMaxWidth()) {
ZoomPanBox(Modifier.fillMaxSize().padding(start = 76.dp, end = 76.dp, top = 52.dp, bottom = 96.dp)) { // 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)) board(Modifier.onGloballyPositioned(onBoardCoords))
} }
// What is going on, and the dice. Two lines, always. // What is going on, and the dice. Two lines, always.
Row( Row(
Modifier.align(Alignment.TopCenter).fillMaxWidth().padding(horizontal = 8.dp) Modifier.align(Alignment.TopCenter).padding(horizontal = 64.dp)
.clip(RoundedCornerShape(12.dp)) .clip(RoundedCornerShape(10.dp))
.background(MaterialTheme.colorScheme.surface.copy(alpha = 0.78f)) .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.8f))
.padding(horizontal = 10.dp, vertical = 2.dp), .padding(horizontal = 8.dp, vertical = 1.dp),
verticalAlignment = Alignment.CenterVertically, verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp),
) { ) {
androidx.compose.material3.Text( Text(
text = notice ?: prompt, text = notice ?: prompt,
style = MaterialTheme.typography.bodySmall, style = MaterialTheme.typography.bodySmall,
color = if (notice != null) MaterialTheme.colorScheme.error else Color.Unspecified, color = if (notice != null) MaterialTheme.colorScheme.error else Color.Unspecified,
@@ -341,32 +342,39 @@ fun CatanHud(
kinds = actions.buildKinds, kinds = actions.buildKinds,
canBuild = actions.canBuild, canBuild = actions.canBuild,
armed = building, armed = building,
modifier = Modifier.align(Alignment.CenterStart).padding(start = 8.dp, top = 40.dp), modifier = Modifier.align(Alignment.CenterStart).padding(start = 6.dp),
onTap = onArm, onTap = onArm,
onDragStart = onDragStart, onDragStart = onDragStart,
onDrag = onDrag, onDrag = onDrag,
onDragEnd = onDragEnd, onDragEnd = onDragEnd,
) )
// Right, middle: place or cancel the lined-up piece. // Right, middle: the card actions.
HudConfirmButtons( Column(
staged = staged != null, Modifier.align(Alignment.CenterEnd).padding(end = 6.dp),
modifier = Modifier.align(Alignment.CenterEnd).padding(end = 8.dp, top = 40.dp), verticalArrangement = Arrangement.spacedBy(4.dp),
onConfirm = onConfirm, horizontalAlignment = Alignment.CenterHorizontally,
onCancel = onCancelStaged, ) {
) 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. // Bottom centre: your cards.
Box( Box(
Modifier.align(Alignment.BottomCenter).padding(bottom = 10.dp, start = 120.dp, end = 250.dp) Modifier.align(Alignment.BottomCenter).padding(bottom = 4.dp, start = 80.dp, end = 270.dp)
.clip(RoundedCornerShape(14.dp)) .clip(RoundedCornerShape(12.dp))
.background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f)) .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f))
.horizontalScroll(rememberScrollState()) .horizontalScroll(rememberScrollState())
.padding(8.dp), .padding(6.dp),
) { CatanHand(state, localSeat) } ) { CatanHand(state, localSeat) }
// Bottom left: the log. // Bottom left: the log.
Column(Modifier.align(Alignment.BottomStart).padding(start = 8.dp, bottom = 10.dp)) { Column(Modifier.align(Alignment.BottomStart).padding(start = 6.dp, bottom = 4.dp)) {
if (showLog) { if (showLog) {
Surface( Surface(
modifier = Modifier.padding(bottom = 6.dp), modifier = Modifier.padding(bottom = 6.dp),
@@ -377,29 +385,19 @@ fun CatanHud(
CatanLog(state, Modifier.padding(8.dp).height(150.dp).width(260.dp)) CatanLog(state, Modifier.padding(8.dp).height(150.dp).width(260.dp))
} }
} }
HudRoundButton("☰", caption = CatanText.LOG_BUTTON, diameter = 44.dp, onClick = onToggleLog) HudRoundButton("☰", caption = CatanText.LOG_BUTTON, diameter = 40.dp, onClick = onToggleLog)
} }
// Bottom right: the turn button, trade, and the card actions. // Bottom right: place / cancel a lined-up piece, trade, and the turn button.
Column( Row(
Modifier.align(Alignment.BottomEnd).padding(end = 8.dp, bottom = 10.dp), Modifier.align(Alignment.BottomEnd).padding(end = 6.dp, bottom = 4.dp),
horizontalAlignment = Alignment.End, horizontalArrangement = Arrangement.spacedBy(6.dp),
verticalArrangement = Arrangement.spacedBy(4.dp), verticalAlignment = Alignment.Bottom,
) { ) {
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { HudConfirmButtons(staged = staged != null, onConfirm = onConfirm, onCancel = onCancelStaged)
if (actions.ck) { HudRoundButton("⇄", caption = CatanText.TRADE, enabled = actions.canTrade, diameter = 48.dp, onClick = onTrade)
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)
}
}
Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.Bottom) {
HudRoundButton("⇄", caption = CatanText.TRADE, enabled = actions.canTrade, diameter = 56.dp, onClick = onTrade)
PrimaryTurnButton(actions, onRoll, onEndTurn, onEndFreeRoads, onEndSmith, onRepickSetup) PrimaryTurnButton(actions, onRoll, onEndTurn, onEndFreeRoads, onEndSmith, onRepickSetup)
} }
}
if (dragKind != null && dragAt == null) HudPill(CatanText.DRAG_HINT, Modifier.align(Alignment.TopCenter)) if (dragKind != null && dragAt == null) HudPill(CatanText.DRAG_HINT, Modifier.align(Alignment.TopCenter))
} }
@@ -428,7 +426,7 @@ private fun PrimaryTurnButton(
private data class Quad(val glyph: String, val caption: String, val enabled: Boolean, val click: () -> Unit) 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 row across the top. */ /** Everyone's colour, name, points and card count in one thin row across the top. */
@Composable @Composable
private fun HudPlayerStrip( private fun HudPlayerStrip(
state: org.prolibertate.games.game.catan.CatanState, state: org.prolibertate.games.game.catan.CatanState,
@@ -436,17 +434,25 @@ private fun HudPlayerStrip(
pointsOf: (Int) -> Int, pointsOf: (Int) -> Int,
style: CatanStyle, style: CatanStyle,
) { ) {
Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp), horizontalArrangement = Arrangement.spacedBy(6.dp)) { Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp, vertical = 2.dp), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
(0 until state.playerCount).forEach { seat -> (0 until state.playerCount).forEach { seat ->
CatanPlayerCard( val onTurn = seat == state.turn
state = state, val shape = RoundedCornerShape(10.dp)
seat = seat, Row(
seats = seats, Modifier.weight(1f)
points = pointsOf(seat), .clip(shape)
modifier = Modifier.weight(1f), .background(MaterialTheme.colorScheme.surfaceVariant)
style = style, .border(if (onTurn) 2.dp else 1.dp, if (onTurn) MaterialTheme.colorScheme.primary else Color(0x33000000), shape)
compact = true, .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))
Text("${pointsOf(seat)} VP · ${state.resourceCount(seat)}🂠", fontSize = 12.sp, maxLines = 1)
}
} }
} }
} }
@@ -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(),
) )
@@ -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.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)
+1
View File
@@ -27,6 +27,7 @@ Naming: the catalogue id, lowercase, e.g. `crazy8s` → `RULES-crazy8s.md`.
| Katan (catalogue id `catan`) | [RULES-catan.md](RULES-catan.md) — and its expansion rule set, [RULES-catan-ck.md](RULES-catan-ck.md) | | Katan (catalogue id `catan`) | [RULES-catan.md](RULES-catan.md) — and its expansion rule set, [RULES-catan-ck.md](RULES-catan-ck.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) |
+98
View File
@@ -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.