opatry / wordle-kt Goto Github PK

Black vs white square is expected.

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

• 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

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

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

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

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

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

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

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

Currently the how to play is displayed at each launch.

This would reduce the boilerplate and enforce sharing transition behavior.

At least with azul JDK 11.

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

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, ...

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

Maybe then we should add Enter & Backspace buttons.

• 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

• settings
• previous game results

• 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

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

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.

• 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

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)

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

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

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

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

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

Maybe using JakeWharton/flip-tables.

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

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.

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

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

• Check license is compatible

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.