This is a bit tedious to achieve given that it's dependent on underlying platform internals.

• [x] Compose desktop should rely on AWT clipboard
• [ ] #28
• [x] Add toast message "Copied results to clipboard"
• [x] For Mosaic version, we could automatically put to clipboard without user action, maybe we could rely on pbcopy call system?

In this SO answer, it is suggested to use a CompositionLocalProvider to delegate the impl: https://stackoverflow.com/a/68389985/2551689

In official game, at the left of the Share button, there is a counter for the next word, we could use this place holder for our restart button and stay closed to original game design.

Given https://github.com/hannahcode/wordle#wordle-clone it appears words list is available in front end in official game and that the today's word could be inferred with something like

WORDS[Math.floor((NOW_IN_MS - GAME_EPOCH_IN_MS) / ONE_DAY_IN_MS)]

Currently, the transition from dictionary picker to loading to game screen is a bit ad hoc and might be improved thanks to a screen abstraction.

Here is what was done for another POC game.

sealed class Screen {
    object Home : Screen()
    data class Progress(val maxRank: Int) : Screen()
    data class Settings(val player: PlayerInfo) : Screen()
    data class Scores(val player: PlayerInfo) : Screen()
    object Inventory : Screen()
    data class InGame(val mode: GameRules.Mode) : Screen() {
        val rules = GameRules(mode)
    }

    data class Statistics(val player: PlayerInfo, val viewModel: GameRulesViewModel) : Screen()
}

@Composable
fun HuesApp() {
    CheapHuesComposeTheme {
        var screenState by remember { mutableStateOf<Screen>(Screen.Home) }
        val player by remember { mutableStateOf(PlayerInfo.DEFAULT_PLAYER) }

        val backToHome = { screenState = Screen.Home }

        screenState.let { screen ->
            when (screen) {
                Screen.Home -> HomeScreen(player) { screenState = it }
                is Screen.Inventory -> InventoryScreen(player, backToHome)
                is Screen.Settings -> SettingsScreen(player, backToHome)
                is Screen.Scores -> ScoresScreen(player, backToHome)
                is Screen.Progress -> ProgressionScreen(3, backToHome)
                is Screen.InGame -> {
                    val viewModel = GameRulesViewModel(player, screen.rules)
                    val status = rememberUpdatedState(viewModel.status)

                    when (status.value) {
                        GameRules.GameStatus.PLAYING -> GameScreen(viewModel, backToHome)
                        else -> EndOfGameScreen(viewModel) {
                            screenState = Screen.Statistics(player, viewModel)
                        }
                    }
                }
                is Screen.Statistics -> StatisticsScreen(
                    screen.player,
                    screen.viewModel,
                    onRestart = {
                        screen.viewModel.restart()
                        screenState = Screen.InGame(screen.viewModel.mode)
                    },
                    onQuit = backToHome
                )
            }
        }
    }
}

1. Grid animation
2. Victory message toast
3. Once toast is dismissed, show victory dialog
4. Once victory dialog is dismissed, show restart and answer placeholder

Will also fix

• #4

Instead of having as many booleans as dialogs types, given that only one of them can be displayed at once, define a (nullable or having a none case) visible dialog state.

The stats dialog should be the same for end of game or toolbar menu. The criteria to display graph is only to determine if the last played game was a victory or not.

Based on #6

• [x] Compute last streak
• [x] Compute stats
• [x] Add stats dialog (charts button added at left of settings in official app recently) (done in 2cd276e)

• [ ] Drop any words_[a-z]{2}_[\d]+.txt in app's data dir (esp. for Desktop)
• [ ] Add a button to open a file picker in DictionaryPicker (would need CompositionLocalProvider for Desktop & Android)
• [ ] Define a builtIn attribute in Dictionary
• [ ] Add special indicator (user icon vs system icon?) in dictionary list
• [ ] Handle invalid data

When transitioning from dictionary picker to loading to game to "how to play", there are several freezes.

• Should we do more work in background?
• Should we optimize recomposition for some Composable?
• ?

• [ ] Backspace should only be enabled if at least 1 character is entered
• [ ] Enter should only be enabled if entered answer matches requested word size