• Allow resizing window
• Restrict to min size (500x700?)
• Adjust components to make them more responsive (especially Alphabet & WordleGrid)
• Adjust dialog & panel to take current window width into account for their max size

• individual letter state update (incl. in How to play screen)
• victory "wave dance"
• error vibration

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.

See https://ftp.gnu.org/gnu/aspell/dict/0index.html

• Check license is compatible

In WordleViewModel, when (re)starting a new game, chosen word should be compared to stored ones in WordleRepository.

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

Maybe then we should add Enter & Backspace buttons.

• Smart user default (device locale + 5 letters).
• persistence
• initial choice at first launch
• option on settings
• add source dictionary buckets in records to avoid melding results for different setup

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?
• ?

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)]

Ideally sharing as much code as possible.
Keeping strings hardcoded inline the code should help but not sure about image assets.

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
                )
            }
        }
    }
}

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.

Either find a way to make the active row a full text field properly displaying characters or define it as focusable/focused but invisible /hidden.

At each input pushing word to view model would automatically update grid.

This would allow writing accented characters (out any diacritic) for french, Spanish, ...

• We should honor system's dark mode choice.
• Status bar & navigation bar should follow the theme chosen is app settings.

• Either separate workflows for each target or restrict to only release builds?
• Should we sign APK?
• Should we archive (signed) APK?

• 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

• add solver
• add a auto solve button in Compose version
• determine if a hint couldn't be provided by a way or another

Check dlew/wordle-solver for details.

Black vs white square is expected.

Based on #6

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

We could either display it on left of the grid or below.

• need to press enter twice to update screen
• replace println game instructions with Text() Composable
• determine if Mosaic provides the equivalent of EditText() to replace readLine()
• #17

• word too short toast
• word not in user dictionary toast
• animation (see #2)

• settings
• previous game results

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

• hard mode in WordleRules
• plug hard mode in settings
• check original game user feedback when invalid input is entered

Currently the how to play is displayed at each launch.

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

• Compose desktop should rely on AWT clipboard
• #28
• Add toast message "Copied results to clipboard"
• 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

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.

1. Genius
2. Magnificent
3. Impressive
4. Splendid
5. Great
6. Nice

This would reduce the boilerplate and enforce sharing transition behavior.

Maybe using JakeWharton/flip-tables.

Currently, there is too much logic achieved at UI layer level.

• toast dismiss period
• delay stats dialog appearance until all animated toasts are dismissed
• delay restart button appearance until all animated toasts are dismissed
• determine if actions should be enabled

At least with azul JDK 11.

Clipboard works around of the box thanks to #17 and LocalClipboardManager, but having a real share intent on Android would be even better.