diff --git a/app/src/main/java/org/prolibertate/games/MainActivity.kt b/app/src/main/java/org/prolibertate/games/MainActivity.kt index 1e6b2ab..fd05752 100644 --- a/app/src/main/java/org/prolibertate/games/MainActivity.kt +++ b/app/src/main/java/org/prolibertate/games/MainActivity.kt @@ -10,6 +10,7 @@ import org.prolibertate.games.net.LobbyController import org.prolibertate.games.net.ScorekeeperSession import org.prolibertate.games.score.ScorekeeperRepository import org.prolibertate.games.settings.SettingsRepository +import org.prolibertate.games.settings.YahtzeeStatsRepository import org.prolibertate.games.ui.AppEnv import org.prolibertate.games.ui.AppRoot import org.prolibertate.games.ui.theme.ProLibertateTheme @@ -43,6 +44,7 @@ class MainActivity : ComponentActivity() { ), peerId = peerId, saves = SavedGameStore(File(filesDir, "saved-games")), + yahtzeeStats = YahtzeeStatsRepository(applicationContext), ) setContent { diff --git a/app/src/main/java/org/prolibertate/games/game/Catalog.kt b/app/src/main/java/org/prolibertate/games/game/Catalog.kt index ed028bf..f0dcd2a 100644 --- a/app/src/main/java/org/prolibertate/games/game/Catalog.kt +++ b/app/src/main/java/org/prolibertate/games/game/Catalog.kt @@ -362,12 +362,7 @@ object GameCatalog { maxPlayers = 4, teamBased = false, 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 - // devices yet. Dev builds can open it as a *Preview*; a production - // build does not list it. Flip `available` on, and `devPreview` - // off, once two-device play has been verified. - available = false, - devPreview = true, + available = true, ), GameDescriptor( id = MEOWDOKU, @@ -378,8 +373,7 @@ object GameCatalog { 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 = false, - devPreview = true, + available = true, ), ) diff --git a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuAi.kt b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuAi.kt index 93bd59e..b7c2cd3 100644 --- a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuAi.kt +++ b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuAi.kt @@ -25,19 +25,12 @@ object MeowdokuAi : GameAi { require(legal.isNotEmpty()) { "No move available" } val places = legal.filterIsInstance().associateBy { it.square } - // The first cat still missing. A pencil cross in front of it is the - // player's own note being wrong, so erase it; a hint spends one token - // and reveals the square regardless. + // 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) { - val missing = state.cats.none { it.row == row } - if (!missing) continue - val square = Square(row, state.catCols[row]) - places[square]?.let { return it } - if (square in state.marks) { - if (TakeHint in legal && state.hintsLeft > 0) return TakeHint - legal.filterIsInstance() - .firstOrNull { it.square == square } - ?.let { return it } + if (state.cats.none { it.row == row }) { + places[Square(row, state.catCols[row])]?.let { return it } } } diff --git a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuModel.kt b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuModel.kt index cae5e88..089426e 100644 --- a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuModel.kt +++ b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuModel.kt @@ -4,11 +4,11 @@ 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. The player -// taps the squares they believe hold a cat; the board only ever accepts a -// correct tap, so a cat that lands is a cat that was always going to be there. -// A wrong tap costs a heart and crosses the square over, which is what makes -// pencil marks a choice rather than a necessity. +// 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 @@ -83,23 +83,25 @@ data class MeowdokuState( sealed interface MeowdokuMove /** - * Taps a square expecting a cat. + * 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. A square that is already - * crossed over has to be un-crossed first — the tap that made the cross is - * exactly the tap this would repeat. + * 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 pencil cross on a square with no cat on it. + * Draws or erases a cross on a square with no cat on it. * - * Free, and it cannot be undone by the board: crosses are the player's notes, - * not the puzzle's. A cross on a square that actually holds a cat costs nothing - * to erase, which is why placing a cat never consults the marks. + * 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") diff --git a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuRules.kt b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuRules.kt index be53e8e..ed2a0a4 100644 --- a/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuRules.kt +++ b/app/src/main/java/org/prolibertate/games/game/meowdoku/MeowdokuRules.kt @@ -69,10 +69,14 @@ object MeowdokuRules : GameRules { /** * Every tap the board would take. * - * Cats go on squares that are neither cat nor cross; pencils work any - * square without a cat on it, adding or erasing a cross; a hint is offered - * while there are hints left and cats still missing. The list is written - * row by row, which is also the order the hint engine uses. + * 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 { if (seat != SOLO_SEAT || isFinished(state)) return emptyList() @@ -82,7 +86,7 @@ object MeowdokuRules : GameRules { for (col in 0 until state.side) { val square = Square(row, col) if (square in state.cats) continue - if (square !in state.marks) cats += PlaceCat(square) + cats += PlaceCat(square) pencils += TogglePencil(square) } } @@ -105,17 +109,18 @@ object MeowdokuRules : GameRules { } /** - * The tap that is the whole game: found a cat, or lost a heart. + * The second tap of a double tap: found a cat, or lost a heart. * - * The square was already crossed? Then the tap is not offered at all — see - * [legalMoves] — so a player who pencilled over the truth has to notice and - * erase before tapping. That is the one way a board can be lost that the - * board itself did not do. + * 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, ) diff --git a/app/src/main/java/org/prolibertate/games/game/yahtzee/YahtzeeStats.kt b/app/src/main/java/org/prolibertate/games/game/yahtzee/YahtzeeStats.kt new file mode 100644 index 0000000..45d6ddf --- /dev/null +++ b/app/src/main/java/org/prolibertate/games/game/yahtzee/YahtzeeStats.kt @@ -0,0 +1,58 @@ +package org.prolibertate.games.game.yahtzee + +import kotlinx.serialization.Serializable + +/** What one finished game says about the local player's card. */ +@Serializable +data class YahtzeeRecord( + val total: Int, + val gotBonus: Boolean, + /** Yahtzees scored, counting the extra ones that earned the hundred. */ + val yahtzees: Int, + /** Boxes written in as nothing. */ + val zeros: Int, + val players: Int, + val won: Boolean, +) + +/** Builds the record of [seat]'s card in a finished game. Ties for first count as a win. */ +fun recordOf(state: YahtzeeState, seat: Int): YahtzeeRecord { + val card = state.cards[seat] + val mine = state.totalFor(seat) + val best = state.cards.indices.maxOf { state.totalFor(it) } + return YahtzeeRecord( + total = mine, + gotBonus = card.upperBonus > 0, + yahtzees = (if (card[YahtzeeCategory.YAHTZEE] == YAHTZEE_SCORE) 1 else 0) + + state.yahtzeeBonuses[seat] / YAHTZEE_BONUS, + zeros = card.boxes.count { it == 0 }, + players = state.cards.size, + won = mine >= best, + ) +} + +/** A game set against the ones before it. [rank] is 1 for a new best. */ +data class YahtzeeComparison( + val current: YahtzeeRecord, + val previousGames: Int, + val bestBefore: Int?, + val averageBefore: Double?, + val rank: Int, + val gamesRanked: Int, + val bonusRateBefore: Double?, + val yahtzeesBefore: Int, + val winRateBefore: Double?, +) + +fun compareToHistory(previous: List, current: YahtzeeRecord): YahtzeeComparison = + YahtzeeComparison( + current = current, + previousGames = previous.size, + bestBefore = previous.maxOfOrNull { it.total }, + averageBefore = previous.takeIf { it.isNotEmpty() }?.map { it.total }?.average(), + rank = 1 + previous.count { it.total > current.total }, + gamesRanked = previous.size + 1, + bonusRateBefore = previous.takeIf { it.isNotEmpty() }?.let { p -> p.count { it.gotBonus }.toDouble() / p.size }, + yahtzeesBefore = previous.sumOf { it.yahtzees }, + winRateBefore = previous.takeIf { it.isNotEmpty() }?.let { p -> p.count { it.won }.toDouble() / p.size }, + ) diff --git a/app/src/main/java/org/prolibertate/games/score/RecentNames.kt b/app/src/main/java/org/prolibertate/games/score/RecentNames.kt new file mode 100644 index 0000000..7ab976b --- /dev/null +++ b/app/src/main/java/org/prolibertate/games/score/RecentNames.kt @@ -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, name: String): List { + val typed = name.trim() + if (typed.isEmpty()) return names + return (listOf(typed) + names.filterNot { it.equals(typed, ignoreCase = true) }).take(LIMIT) + } +} diff --git a/app/src/main/java/org/prolibertate/games/score/ScorekeeperRepository.kt b/app/src/main/java/org/prolibertate/games/score/ScorekeeperRepository.kt index 0394199..05e171d 100644 --- a/app/src/main/java/org/prolibertate/games/score/ScorekeeperRepository.kt +++ b/app/src/main/java/org/prolibertate/games/score/ScorekeeperRepository.kt @@ -29,6 +29,7 @@ class ScorekeeperRepository(private val context: Context) { private object Keys { 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 @@ -45,6 +46,24 @@ class ScorekeeperRepository(private val context: Context) { ?: ScoreSheet() } + /** The names last used on a sheet, most recent first, for the rename dialog. */ + val recentNames: Flow> = context.scorekeeperDataStore.data.map { prefs -> + prefs[Keys.RECENT_NAMES] + ?.let { stored -> + runCatching { json.decodeFromString>(stored) }.getOrNull() + } + ?: emptyList() + } + + suspend fun rememberName(name: String) { + context.scorekeeperDataStore.edit { prefs -> + val current = prefs[Keys.RECENT_NAMES] + ?.let { runCatching { json.decodeFromString>(it) }.getOrNull() } + .orEmpty() + prefs[Keys.RECENT_NAMES] = json.encodeToString(RecentNames.with(current, name)) + } + } + suspend fun save(sheet: ScoreSheet) { context.scorekeeperDataStore.edit { it[Keys.SHEET] = json.encodeToString(sheet) } } diff --git a/app/src/main/java/org/prolibertate/games/score/SheetOp.kt b/app/src/main/java/org/prolibertate/games/score/SheetOp.kt index 102e8d6..90ff81d 100644 --- a/app/src/main/java/org/prolibertate/games/score/SheetOp.kt +++ b/app/src/main/java/org/prolibertate/games/score/SheetOp.kt @@ -31,8 +31,18 @@ sealed interface SheetOp { /** Sets a fresh sheet up for [count] players, scored by round or by tally. */ @Serializable @SerialName("start") -data class StartSheet(val count: Int, val mode: ScoringMode = ScoringMode.ROUNDS) : SheetOp { - override fun applyTo(sheet: ScoreSheet): ScoreSheet = ScoreSheet.of(count, mode) +data class StartSheet( + 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 = 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. */ diff --git a/app/src/main/java/org/prolibertate/games/settings/SettingsRepository.kt b/app/src/main/java/org/prolibertate/games/settings/SettingsRepository.kt index ccbb2d0..ae2b75f 100644 --- a/app/src/main/java/org/prolibertate/games/settings/SettingsRepository.kt +++ b/app/src/main/java/org/prolibertate/games/settings/SettingsRepository.kt @@ -24,6 +24,8 @@ data class Settings( val soundEnabled: Boolean = true, val animationSpeed: Float = 1.0f, 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 * mid-edit. Nothing substitutes a default into this value: doing so meant @@ -46,6 +48,8 @@ data class Settings( companion object { const val MIN_SPEED = 0.5f 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" } } @@ -56,6 +60,7 @@ class SettingsRepository(private val context: Context) { val SOUND = booleanPreferencesKey("sound_enabled") val SPEED = floatPreferencesKey("animation_speed") val UPDATE_ON_LAUNCH = booleanPreferencesKey("check_updates_on_launch") + val TEXT_SCALE = floatPreferencesKey("text_scale") val NAME = stringPreferencesKey("player_name") // There is deliberately no update-channel key. The channel is a // 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, animationSpeed = prefs[Keys.SPEED] ?: 1.0f, 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] ?: "", ) } @@ -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) { context.dataStore.edit { it[Keys.UPDATE_ON_LAUNCH] = enabled } } diff --git a/app/src/main/java/org/prolibertate/games/settings/YahtzeeStatsRepository.kt b/app/src/main/java/org/prolibertate/games/settings/YahtzeeStatsRepository.kt new file mode 100644 index 0000000..2d4020d --- /dev/null +++ b/app/src/main/java/org/prolibertate/games/settings/YahtzeeStatsRepository.kt @@ -0,0 +1,42 @@ +package org.prolibertate.games.settings + +import android.content.Context +import androidx.datastore.core.DataStore +import androidx.datastore.preferences.core.Preferences +import androidx.datastore.preferences.core.edit +import androidx.datastore.preferences.core.stringPreferencesKey +import androidx.datastore.preferences.preferencesDataStore +import kotlinx.coroutines.flow.first +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import org.prolibertate.games.game.yahtzee.YahtzeeComparison +import org.prolibertate.games.game.yahtzee.YahtzeeRecord +import org.prolibertate.games.game.yahtzee.compareToHistory + +private val Context.yahtzeeStatsStore: DataStore by preferencesDataStore( + name = "yahtzee_stats", +) + +/** The local player's finished Yahtzee games, newest last, kept to the last [KEEP]. */ +class YahtzeeStatsRepository(private val context: Context) { + + private val key = stringPreferencesKey("games") + private val json = Json { ignoreUnknownKeys = true } + + private fun decode(stored: String?): List = + stored?.let { runCatching { json.decodeFromString>(it) }.getOrNull() } + .orEmpty() + + /** Compares [record] with every earlier game, then adds it to the history. */ + suspend fun finish(record: YahtzeeRecord): YahtzeeComparison { + val previous = decode(context.yahtzeeStatsStore.data.first()[key]) + context.yahtzeeStatsStore.edit { + it[key] = json.encodeToString((previous + record).takeLast(KEEP)) + } + return compareToHistory(previous, record) + } + + private companion object { + const val KEEP = 500 + } +} diff --git a/app/src/main/java/org/prolibertate/games/ui/AppRoot.kt b/app/src/main/java/org/prolibertate/games/ui/AppRoot.kt index e464b49..7ac58f1 100644 --- a/app/src/main/java/org/prolibertate/games/ui/AppRoot.kt +++ b/app/src/main/java/org/prolibertate/games/ui/AppRoot.kt @@ -20,6 +20,8 @@ import androidx.compose.material3.Card import androidx.compose.material3.CardDefaults import androidx.compose.material3.ExperimentalMaterial3Api 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.Scaffold import androidx.compose.material3.Text @@ -49,6 +51,7 @@ import org.prolibertate.games.net.ScorekeeperSession import org.prolibertate.games.score.ScorekeeperRepository import org.prolibertate.games.settings.Settings import org.prolibertate.games.settings.SettingsRepository +import org.prolibertate.games.settings.YahtzeeStatsRepository import org.prolibertate.games.ui.game.LocalCardSpeed import org.prolibertate.games.update.UpdateChannel import org.prolibertate.games.update.Updater @@ -68,6 +71,7 @@ class AppEnv( val peerId: String, /** Games in progress, kept between sessions. */ val saves: SavedGameStore, + val yahtzeeStats: YahtzeeStatsRepository, ) /** @@ -139,7 +143,14 @@ fun AppRoot(env: AppEnv) { // Card motion reads its speed from here rather than from a parameter. // Every card screen animates, most of them several layers deep, and the // 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( env = env, settings = settings, diff --git a/app/src/main/java/org/prolibertate/games/ui/PlayScreen.kt b/app/src/main/java/org/prolibertate/games/ui/PlayScreen.kt index 50435f0..ff3039b 100644 --- a/app/src/main/java/org/prolibertate/games/ui/PlayScreen.kt +++ b/app/src/main/java/org/prolibertate/games/ui/PlayScreen.kt @@ -594,7 +594,12 @@ fun PlayScreen( ) } StartMatch(env, controller, route) - YahtzeeScreen(controller = controller, localSeat = route.localSeat, onExit = onExit) + YahtzeeScreen( + controller = controller, + localSeat = route.localSeat, + stats = env.yahtzeeStats, + onExit = onExit, + ) } GameCatalog.KLONDIKE -> { diff --git a/app/src/main/java/org/prolibertate/games/ui/ScorekeeperScreen.kt b/app/src/main/java/org/prolibertate/games/ui/ScorekeeperScreen.kt index e4b40e3..1757024 100644 --- a/app/src/main/java/org/prolibertate/games/ui/ScorekeeperScreen.kt +++ b/app/src/main/java/org/prolibertate/games/ui/ScorekeeperScreen.kt @@ -36,6 +36,7 @@ import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateListOf import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember @@ -114,6 +115,8 @@ fun ScorekeeperScreen( local = repository.sheet.first() 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 role = shared.role @@ -220,7 +223,7 @@ fun ScorekeeperScreen( role == Role.GUEST -> Column(modifier = modifier) { 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 -> @@ -228,11 +231,16 @@ fun ScorekeeperScreen( !sheet.started -> SetupPane( 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 }, ) - else -> Scoring(modifier = modifier, sheet = sheet, onOp = change) + else -> Scoring(modifier, sheet, change, recentNames, nameUsed) } } @@ -289,9 +297,46 @@ fun ScorekeeperScreen( @OptIn(ExperimentalLayoutApi::class) @Composable -private fun SetupPane(modifier: Modifier, onStart: (Int, ScoringMode) -> Unit, onJoin: () -> Unit) { +private fun SetupPane( + modifier: Modifier, + recentNames: List, + onStart: (Int, ScoringMode, List) -> Unit, + onJoin: () -> Unit, +) { var count by remember { mutableStateOf(ScoreSheet.DEFAULT_PLAYERS) } 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() } + + 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( modifier = modifier.verticalScroll(rememberScrollState()), @@ -339,33 +384,98 @@ private fun SetupPane(modifier: Modifier, onStart: (Int, ScoringMode) -> Unit, o } } Text( - text = "Names come next: tap a column head to name it. Players can be " + - "added, removed or dragged into a different order at any point " + - "without losing anybody's score.", + text = "You will be asked for each name next, or skip them and tap a " + + "column head later. Players can be added, removed or dragged into " + + "a different order at any point without losing anybody's score.", 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()) { 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, + 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 // --------------------------------------------------------------------------- @Composable -private fun Scoring(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) { +private fun Scoring( + modifier: Modifier, + sheet: ScoreSheet, + onOp: (SheetOp) -> Unit, + recentNames: List, + onNameUsed: (String) -> Unit, +) { if (sheet.mode == ScoringMode.TALLY) { - TallySheet(modifier = modifier, sheet = sheet, onOp = onOp) + TallySheet(modifier, sheet, onOp, recentNames, onNameUsed) } else { - Sheet(modifier = modifier, sheet = sheet, onOp = onOp) + Sheet(modifier, sheet, onOp, recentNames, onNameUsed) } } @Composable -private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) { +private fun Sheet( + modifier: Modifier, + sheet: ScoreSheet, + onOp: (SheetOp) -> Unit, + recentNames: List, + onNameUsed: (String) -> Unit, +) { // 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 // 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) } // The cell to put the cursor in when a round is opened by tapping it. 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 @@ -513,7 +626,7 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit ) }, trailing = { EmptyCell(width = ADD_COLUMN, height = ROW_HEIGHT) }, - ) { _, player -> + ) { index, player -> if (correcting >= 0) { // A round is being corrected above; what is typed here // 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 { PointsField( text = pending[player.id].orEmpty(), + autoFocus = index == 0 && nextRoundFocus > 0, + focusRequest = nextRoundFocus, onText = { pending[player.id] = it lastTyped = player.id @@ -563,6 +678,7 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit onOp(AddRound(amountsAsPoints(pending))) pending.clear() } + nextRoundFocus += 1 lastTyped = -1 focusPlayer = -1 }, @@ -587,6 +703,8 @@ private fun Sheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit RenameDialog( sheet = sheet, player = renamed, + recentNames = recentNames, + onNameUsed = onNameUsed, onName = { onOp(RenamePlayer(renamed.id, it)) }, onRemove = { 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. */ @Composable -private fun TallySheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> Unit) { +private fun TallySheet( + modifier: Modifier, + sheet: ScoreSheet, + onOp: (SheetOp) -> Unit, + recentNames: List, + onNameUsed: (String) -> Unit, +) { var renaming by remember { mutableStateOf(-1) } Column(modifier = modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) { @@ -676,6 +800,8 @@ private fun TallySheet(modifier: Modifier, sheet: ScoreSheet, onOp: (SheetOp) -> RenameDialog( sheet = sheet, player = renamed, + recentNames = recentNames, + onNameUsed = onNameUsed, onName = { onOp(RenamePlayer(renamed.id, it)) }, onRemove = { 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. */ @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() } - LaunchedEffect(autoFocus) { if (autoFocus) focus.requestFocus() } + LaunchedEffect(autoFocus, focusRequest) { if (autoFocus) focus.requestFocus() } BasicTextField( value = text, onValueChange = { onText(sanitiseAmount(it)) }, @@ -1064,16 +1195,27 @@ private fun ActionBar( } } +@OptIn(ExperimentalLayoutApi::class) @Composable private fun RenameDialog( sheet: ScoreSheet, player: ScorePlayer, + recentNames: List, + onNameUsed: (String) -> Unit, onName: (String) -> Unit, onRemove: () -> 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( - onDismissRequest = onDismiss, + onDismissRequest = finish, title = { Text("Name this column") }, text = { Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { @@ -1084,6 +1226,21 @@ private fun RenameDialog( singleLine = true, 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( onClick = onRemove, // 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") } } }, - confirmButton = { TextButton(onClick = onDismiss) { Text("Done") } }, + confirmButton = { TextButton(onClick = finish) { Text("Done") } }, ) } diff --git a/app/src/main/java/org/prolibertate/games/ui/SettingsScreen.kt b/app/src/main/java/org/prolibertate/games/ui/SettingsScreen.kt index 26410ef..ce45e8b 100644 --- a/app/src/main/java/org/prolibertate/games/ui/SettingsScreen.kt +++ b/app/src/main/java/org/prolibertate/games/ui/SettingsScreen.kt @@ -24,6 +24,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import kotlinx.coroutines.launch +import kotlin.math.roundToInt import org.prolibertate.games.settings.Settings import org.prolibertate.games.update.Release import org.prolibertate.games.update.UpdateChannel @@ -83,6 +84,26 @@ fun SettingsScreen( 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 { Text("Your name", fontWeight = FontWeight.Bold) Text( diff --git a/app/src/main/java/org/prolibertate/games/ui/game/MeowdokuScreen.kt b/app/src/main/java/org/prolibertate/games/ui/game/MeowdokuScreen.kt index 87b5bdf..6fcb32a 100644 --- a/app/src/main/java/org/prolibertate/games/ui/game/MeowdokuScreen.kt +++ b/app/src/main/java/org/prolibertate/games/ui/game/MeowdokuScreen.kt @@ -2,7 +2,6 @@ package org.prolibertate.games.ui.game import androidx.compose.foundation.background import androidx.compose.foundation.border -import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.BoxWithConstraints @@ -12,6 +11,8 @@ 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 @@ -23,10 +24,13 @@ 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 @@ -41,9 +45,20 @@ 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. * @@ -66,16 +81,14 @@ private val RegionColours = listOf( Color(0xFFE3E7C1), // lime ) -/** What a tap does. The original game has a pencil tool too, and this is it. */ -private enum class TapMode { CATS, PENCIL } - /** - * The puzzle board. + * The puzzle board, tapped the way the original's is. * - * Cells are laid out by weight inside a square frame, which keeps the grid - * exactly as wide as it is tall on any screen, and scales the glyphs with the - * cell rather than the font setting: a cat is half a square no matter how big - * the square 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( @@ -87,7 +100,6 @@ fun MeowdokuScreen( val legal by controller.legalMoves.collectAsState() val abandoned by controller.abandoned.collectAsState() - var mode by remember { mutableStateOf(TapMode.CATS) } var confirmingEnd by remember { mutableStateOf(false) } val endGameAction: @Composable () -> Unit = { @@ -118,8 +130,8 @@ fun MeowdokuScreen( 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." - mode == TapMode.CATS -> "${current.catsFound} of ${current.side} cats found. Tap where a cat lives." - else -> "Tap to cross a square over, or to erase a cross." + else -> "${current.catsFound} of ${current.side} cats found. " + + "Tap to cross a square, tap it again for a cat." }, fontWeight = FontWeight.Bold, ) @@ -131,37 +143,20 @@ fun MeowdokuScreen( Board( state = current, - places = places, - pencils = pencils, - onTap = { square -> - when { - mode == TapMode.CATS && square in places -> - controller.submit(PlaceCat(square)) - - mode == TapMode.PENCIL && square in pencils -> - controller.submit(TogglePencil(square)) - } - }, + // 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)) }, ) - Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + if (TakeHint in legal) { FilterChip( - selected = mode == TapMode.CATS, - onClick = { mode = TapMode.CATS }, - label = { Text("Cats") }, + selected = false, + onClick = { controller.submit(TakeHint) }, + label = { Text("Hint") }, ) - FilterChip( - selected = mode == TapMode.PENCIL, - onClick = { mode = TapMode.PENCIL }, - label = { Text("Pencil") }, - ) - if (TakeHint in legal) { - FilterChip( - selected = false, - onClick = { controller.submit(TakeHint) }, - label = { Text("Hint") }, - ) - } } if (finished) { @@ -181,30 +176,110 @@ fun MeowdokuScreen( } } +/** + * 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, - places: Set, - pencils: Set, - onTap: (Square) -> Unit, + 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 / state.side - Column(modifier = Modifier.aspectRatio(1f)) { - for (row in 0 until state.side) { - Row(modifier = Modifier.weight(1f)) { - for (col in 0 until state.side) { - val square = Square(row, col) - CellView( - square = square, - state = state, - tappable = square in places || square in pencils, - glyphSize = (cell.value * 0.55f).sp, - modifier = Modifier.weight(1f), - onTap = { onTap(square) }, - ) + 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), + ) + } } } } @@ -212,14 +287,46 @@ private fun Board( } } +/** 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.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 { + 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, - tappable: Boolean, glyphSize: TextUnit, modifier: Modifier, - onTap: () -> Unit, ) { val isCat = square in state.cats val isMark = square in state.marks @@ -231,8 +338,7 @@ private fun CellView( .background(RegionColours[state.regionOf(square) % RegionColours.size]) .then( if (justWrong) Modifier.border(3.dp, CardRed) else Modifier - ) - .clickable(enabled = tappable) { onTap() }, + ), contentAlignment = Alignment.Center, ) { when { diff --git a/app/src/main/java/org/prolibertate/games/ui/game/YahtzeeScreen.kt b/app/src/main/java/org/prolibertate/games/ui/game/YahtzeeScreen.kt index 61e4caf..0202de1 100644 --- a/app/src/main/java/org/prolibertate/games/ui/game/YahtzeeScreen.kt +++ b/app/src/main/java/org/prolibertate/games/ui/game/YahtzeeScreen.kt @@ -6,7 +6,11 @@ import androidx.compose.foundation.border import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.width import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.Canvas import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding @@ -30,12 +34,17 @@ import androidx.compose.runtime.remember 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.text.font.FontWeight import androidx.compose.ui.unit.dp import org.prolibertate.games.game.yahtzee.DICE_COUNT import org.prolibertate.games.game.yahtzee.RollDice import org.prolibertate.games.game.yahtzee.ScoreIn import org.prolibertate.games.game.yahtzee.YahtzeeCategory +import org.prolibertate.games.game.yahtzee.YahtzeeComparison +import org.prolibertate.games.game.yahtzee.recordOf +import org.prolibertate.games.settings.YahtzeeStatsRepository +import kotlin.math.roundToInt import org.prolibertate.games.game.yahtzee.YahtzeeMove import org.prolibertate.games.game.yahtzee.YahtzeeSection import org.prolibertate.games.game.yahtzee.YahtzeeState @@ -61,6 +70,7 @@ private const val TITLE = "Yahtzee" fun YahtzeeScreen( controller: MatchController, localSeat: Int, + stats: YahtzeeStatsRepository, onExit: () -> Unit, ) { val state by controller.state.collectAsState() @@ -69,6 +79,11 @@ fun YahtzeeScreen( val kept = remember { mutableStateListOf() } var confirmingEnd by remember { mutableStateOf(false) } + var confirmingZero by remember { mutableStateOf(null) } + var comparison by remember { mutableStateOf(null) } + // Only a game seen to finish is recorded: reopening a saved game that was + // already over must not count it a second time. + var sawInProgress by remember { mutableStateOf(false) } val endGameAction: @Composable () -> Unit = { TextButton(onClick = { confirmingEnd = true }) { Text("End game") } @@ -89,6 +104,15 @@ fun YahtzeeScreen( // refused, and the Throw button would look broken again. LaunchedEffect(current.turn, current.round) { kept.clear() } + LaunchedEffect(current.isOver) { + if (!current.isOver) { + sawInProgress = true + } else if (sawInProgress) { + sawInProgress = false + comparison = stats.finish(recordOf(current, localSeat)) + } + } + val yours = current.turn == localSeat && !current.isOver val canRoll = legal.any { it is RollDice } val writable = legal.filterIsInstance().map { it.category }.toSet() @@ -138,8 +162,14 @@ fun YahtzeeScreen( localSeat = localSeat, writable = if (yours) writable else emptySet(), onWrite = { - controller.submit(ScoreIn(it)) - kept.clear() + // 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)) + kept.clear() + } }, ) @@ -150,9 +180,79 @@ fun YahtzeeScreen( abandoned?.let { LeftCardDialog(it, onExit, controller::dismissAbandoned) } if (confirmingEnd) EndCardDialog(onExit) { confirmingEnd = false } + comparison?.let { StatsDialog(it, onExit) { comparison = null } } + confirmingZero?.let { category -> + ZeroScoreDialog( + category = category, + onConfirm = { + confirmingZero = null + controller.submit(ScoreIn(category)) + kept.clear() + }, + onCancel = { confirmingZero = null }, + ) + } } } +@Composable +private fun StatsDialog(c: YahtzeeComparison, onLeave: () -> Unit, onClose: () -> Unit) { + fun pct(v: Double?) = v?.let { "${(it * 100).roundToInt()}%" } ?: "—" + val headline = when { + c.previousGames == 0 -> "Your first recorded game." + c.rank == 1 -> "A new personal best!" + else -> "${ordinal(c.rank)} best of ${c.gamesRanked} games." + } + AlertDialog( + onDismissRequest = onClose, + title = { Text("Game over: ${c.current.total} points") }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text(headline, fontWeight = FontWeight.Bold) + StatLine("", "This game", "Before") + StatLine("Score", "${c.current.total}", c.averageBefore?.let { "avg ${it.roundToInt()}, best ${c.bestBefore}" } ?: "—") + StatLine("Upper bonus", if (c.current.gotBonus) "Yes" else "No", pct(c.bonusRateBefore)) + StatLine("Yahtzees", "${c.current.yahtzees}", "${c.yahtzeesBefore} total") + StatLine("Zeroed boxes", "${c.current.zeros}", "") + if (c.current.players > 1) { + StatLine("Result", if (c.current.won) "Won" else "Lost", "won ${pct(c.winRateBefore)}") + } + Text( + "Games before this one: ${c.previousGames}", + style = MaterialTheme.typography.bodySmall, + ) + } + }, + confirmButton = { TextButton(onClick = onLeave) { Text("Leave the game") } }, + dismissButton = { TextButton(onClick = onClose) { Text("Look at the card") } }, + ) +} + +@Composable +private fun StatLine(label: String, now: String, before: String) { + Row(modifier = Modifier.fillMaxWidth()) { + Text(label, modifier = Modifier.weight(1.2f), fontWeight = FontWeight.Bold) + Text(now, modifier = Modifier.weight(1f)) + Text(before, modifier = Modifier.weight(1.6f)) + } +} + +private fun ordinal(n: Int): String { + val suffix = if (n % 100 in 11..13) "th" else when (n % 10) { 1 -> "st"; 2 -> "nd"; 3 -> "rd"; else -> "th" } + return "$n$suffix" +} + +@Composable +private fun ZeroScoreDialog(category: YahtzeeCategory, onConfirm: () -> Unit, onCancel: () -> Unit) { + AlertDialog( + onDismissRequest = onCancel, + title = { Text("Score zero?") }, + text = { Text("These dice are worth 0 in ${category.label}. Write the zero there?") }, + confirmButton = { TextButton(onClick = onConfirm) { Text("Score 0") } }, + dismissButton = { TextButton(onClick = onCancel) { Text("Choose another") } }, + ) +} + @Composable private fun DiceRow( dice: List, @@ -190,12 +290,29 @@ private fun Die(face: Int?, held: Boolean, enabled: Boolean, onClick: () -> Unit .clickable(enabled = enabled) { onClick() }, contentAlignment = Alignment.Center, ) { - Text( - text = face?.toString() ?: "·", - style = MaterialTheme.typography.titleLarge, - fontWeight = FontWeight.Bold, - color = WallaceRed, - ) + if (face != null) { + Canvas(modifier = Modifier.size(48.dp)) { + val radius = size.minDimension * 0.08f + pipPositions(face).forEach { (x, y) -> + 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> { + 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,28 +323,61 @@ private fun ScoreCard( writable: Set, onWrite: (YahtzeeCategory) -> Unit, ) { - Column(modifier = Modifier.fillMaxWidth()) { - Row(modifier = Modifier.fillMaxWidth()) { - Text("", modifier = Modifier.weight(2f), style = MaterialTheme.typography.labelSmall) - state.cards.indices.forEach { seat -> - Text( - text = if (seat == localSeat) "You" else "S$seat", - modifier = Modifier.weight(1f), - style = MaterialTheme.typography.labelSmall, - fontWeight = FontWeight.Bold, - ) - } - } - YahtzeeSection.entries.forEach { section -> - YahtzeeCategory.entries.filter { it.section == section }.forEach { category -> - CardRow(state, localSeat, category, writable, onWrite) - } - if (section == YahtzeeSection.UPPER) { + // 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) + } } - 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()) { + Text("", modifier = Modifier.weight(2f)) + state.cards.indices.forEach { seat -> + Text( + text = if (seat == localSeat) "You" else "S$seat", + modifier = Modifier.weight(1f), + style = MaterialTheme.typography.labelLarge, + fontWeight = FontWeight.Bold, + ) + } + } +} + +@Composable +private fun CardSection( + section: YahtzeeSection, + state: YahtzeeState, + localSeat: Int, + writable: Set, + onWrite: (YahtzeeCategory) -> Unit, +) { + YahtzeeCategory.entries.filter { it.section == section }.forEach { category -> + CardRow(state, localSeat, category, writable, onWrite) } } @@ -244,12 +394,12 @@ private fun CardRow( modifier = Modifier .fillMaxWidth() .clickable(enabled = open) { onWrite(category) } - .padding(vertical = 2.dp), + .padding(vertical = 5.dp), ) { Text( text = category.label, modifier = Modifier.weight(2f), - style = MaterialTheme.typography.bodySmall, + style = MaterialTheme.typography.bodyMedium, fontWeight = if (open) FontWeight.Bold else FontWeight.Normal, ) state.cards.forEachIndexed { seat, card -> @@ -263,7 +413,7 @@ private fun CardRow( else -> "—" }, modifier = Modifier.weight(1f), - style = MaterialTheme.typography.bodySmall, + style = MaterialTheme.typography.bodyMedium, color = if (written == null && open) WallaceRed else MaterialTheme.colorScheme.onSurface, ) } @@ -272,18 +422,18 @@ private fun CardRow( @Composable private fun TotalRow(label: String, values: List, bold: Boolean = false) { - Row(modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp)) { + Row(modifier = Modifier.fillMaxWidth().padding(vertical = 5.dp)) { Text( text = label, modifier = Modifier.weight(2f), - style = MaterialTheme.typography.bodySmall, + style = MaterialTheme.typography.bodyMedium, fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal, ) values.forEach { Text( text = "$it", modifier = Modifier.weight(1f), - style = MaterialTheme.typography.bodySmall, + style = MaterialTheme.typography.bodyMedium, fontWeight = if (bold) FontWeight.Bold else FontWeight.Normal, ) } diff --git a/app/src/test/java/org/prolibertate/games/game/CatalogTest.kt b/app/src/test/java/org/prolibertate/games/game/CatalogTest.kt index c3043ec..f5e7d74 100644 --- a/app/src/test/java/org/prolibertate/games/game/CatalogTest.kt +++ b/app/src/test/java/org/prolibertate/games/game/CatalogTest.kt @@ -106,42 +106,33 @@ class CatalogTest { } @Test - fun `every reference game in the catalogue can be played`() { - // Every game the app ships is playable. The exceptions are the games - // whose engine and screen exist but have not been verified on a real - // device yet: they are marked as previews so a production build keeps - // them out while a dev one can open them. `available = false` is what - // keeps an unverified game out of a production build while leaving it - // visible on a dev one. - assertEquals( - listOf(GameCatalog.CATAN, GameCatalog.MEOWDOKU), - GameCatalog.all.filterNot { it.available }.map { it.id }, - ) - // It is also the only difference the two channels see in a menu. - // Katan sits under Board and Meowdoku under Solitaire, so the two - // channels part ways in different sections. - val hiddenFromBoard = GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = true) - - GameCatalog.inMenu(GameMenu.BOARD, includeComingSoon = false) - assertEquals(listOf(GameCatalog.byId(GameCatalog.CATAN)!!), hiddenFromBoard) - val hiddenFromSolitaire = GameCatalog.inMenu(GameMenu.SOLITAIRE, includeComingSoon = true) - - GameCatalog.inMenu(GameMenu.SOLITAIRE, includeComingSoon = false) - assertEquals(listOf(GameCatalog.byId(GameCatalog.MEOWDOKU)!!), hiddenFromSolitaire) + fun `every game in the catalogue can be played`() { + // `available` is the release gate. Nothing is held back at the moment, + // so a production menu lists every game; a game parked behind the gate + // belongs in `devPreview`, and must say so rather than being quietly + // unavailable everywhere. + GameCatalog.all.filterNot { it.available }.forEach { game -> + assertTrue("${game.id} is unavailable but not a dev preview", game.devPreview) + } + GameMenu.entries.forEach { menu -> + val held = GameCatalog.inMenu(menu, includeComingSoon = true) - + GameCatalog.inMenu(menu, includeComingSoon = false).toSet() + held.forEach { assertTrue("${it.id} hidden from production without a preview flag", it.devPreview) } + } } @Test fun `a preview game opens on a dev build and nowhere else`() { - // Katan until its two-device play is verified; Meowdoku until its board - // and hearts have been looked at on a real screen. - val preview = GameCatalog.all.filter { it.devPreview } - assertEquals( - setOf(GameCatalog.CATAN, GameCatalog.MEOWDOKU), - preview.map { it.id }.toSet(), - ) - preview.forEach { game -> + GameCatalog.all.filter { it.devPreview }.forEach { game -> assertFalse("${game.id}: preview is for games that are not yet available", game.available) assertTrue("${game.id} should open on a dev build", game.playableIn(devBuild = true)) assertFalse("${game.id} must not open in production", game.playableIn(devBuild = false)) } + // 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. val chess = GameCatalog.byId(GameCatalog.CHESS)!! assertTrue(chess.playableIn(devBuild = true) && chess.playableIn(devBuild = false)) @@ -186,6 +177,8 @@ class CatalogTest { GameCatalog.MASTERMIND, GameCatalog.BACKGAMMON, GameCatalog.PIRATES, + GameCatalog.CATAN, + GameCatalog.MEOWDOKU, ), GameCatalog.playable.map { it.id }.toSet(), ) diff --git a/app/src/test/java/org/prolibertate/games/game/meowdoku/MeowdokuRulesTest.kt b/app/src/test/java/org/prolibertate/games/game/meowdoku/MeowdokuRulesTest.kt index 8f34d28..9521bf1 100644 --- a/app/src/test/java/org/prolibertate/games/game/meowdoku/MeowdokuRulesTest.kt +++ b/app/src/test/java/org/prolibertate/games/game/meowdoku/MeowdokuRulesTest.kt @@ -198,17 +198,37 @@ class MeowdokuRulesTest { } @Test - fun `a tapped square that is crossed over is not offered`() { + 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 wrongRow = 1 - val wrongCol = if (state.catCols[wrongRow] == 0) 1 else 0 - val marked = MeowdokuRules.applyMove(state, 0, PlaceCat(Square(wrongRow, wrongCol))) - assertThrows(IllegalArgumentException::class.java) { - MeowdokuRules.applyMove(marked, 0, PlaceCat(Square(wrongRow, wrongCol))) - } - // A pencil erases the cross and opens the tap again. - val erased = MeowdokuRules.applyMove(marked, 0, TogglePencil(Square(wrongRow, wrongCol))) - assertFalse(Square(wrongRow, wrongCol) in erased.marks) + 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 diff --git a/app/src/test/java/org/prolibertate/games/game/yahtzee/YahtzeeStatsTest.kt b/app/src/test/java/org/prolibertate/games/game/yahtzee/YahtzeeStatsTest.kt new file mode 100644 index 0000000..eedb645 --- /dev/null +++ b/app/src/test/java/org/prolibertate/games/game/yahtzee/YahtzeeStatsTest.kt @@ -0,0 +1,30 @@ +package org.prolibertate.games.game.yahtzee + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class YahtzeeStatsTest { + private fun game(total: Int, bonus: Boolean = false, yahtzees: Int = 0, won: Boolean = true) = + YahtzeeRecord(total, bonus, yahtzees, zeros = 0, players = 2, won = won) + + @Test + fun firstGameHasNothingToCompareTo() { + val c = compareToHistory(emptyList(), game(200)) + assertEquals(1, c.rank) + assertEquals(0, c.previousGames) + assertNull(c.bestBefore) + assertNull(c.averageBefore) + } + + @Test + fun ranksAgainstPreviousGames() { + val history = listOf(game(150, bonus = true, yahtzees = 1), game(250), game(200, won = false)) + val c = compareToHistory(history, game(220)) + assertEquals(2, c.rank) + assertEquals(4, c.gamesRanked) + assertEquals(250, c.bestBefore) + assertEquals(200.0, c.averageBefore!!, 0.001) + assertEquals(1, c.yahtzeesBefore) + } +} diff --git a/app/src/test/java/org/prolibertate/games/score/RecentNamesTest.kt b/app/src/test/java/org/prolibertate/games/score/RecentNamesTest.kt new file mode 100644 index 0000000..cb8d160 --- /dev/null +++ b/app/src/test/java/org/prolibertate/games/score/RecentNamesTest.kt @@ -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()) + } +} diff --git a/app/src/test/java/org/prolibertate/games/score/ScoreSheetTest.kt b/app/src/test/java/org/prolibertate/games/score/ScoreSheetTest.kt index cd6502b..1ab3414 100644 --- a/app/src/test/java/org/prolibertate/games/score/ScoreSheetTest.kt +++ b/app/src/test/java/org/prolibertate/games/score/ScoreSheetTest.kt @@ -199,6 +199,14 @@ class ScoreSheetTest { 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 fun `tally entries add up per player and can be taken back`() { val sheet = ScoreSheet.of(2, ScoringMode.TALLY) diff --git a/docs/RULES-meowdoku.md b/docs/RULES-meowdoku.md index 15531e1..571d1c2 100644 --- a/docs/RULES-meowdoku.md +++ b/docs/RULES-meowdoku.md @@ -19,22 +19,33 @@ and it sees only the colours and the rules — never the cats it was grown from. ## Playing it -**Tap a square where a cat lives.** A correct tap lands the cat; a wrong one -costs a heart and crosses the square over, because being wrong here is -information and the board keeps it for you. Finding all N cats wins; losing the -hearts ends the board with the rest still hidden. +Controls are the original's, and they carry the game's whole psychology: -The **Pencil** toggle is for the marks you make yourself. They are free, they -cost nothing to erase, and the board does not judge them. The one trap they -carry: a square crossed over is a square you have decided against, so tapping a -cat onto it is refused until the pencil erases the note. The original game -draws crosses for you on a wrong tap for the same reason — a wrong square -crossed twice is the same mistake twice — and here the same thing happens -whether the cross came from the heart or from the pencil. +- **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. 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. +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