diff --git a/CHANGELOG.md b/CHANGELOG.md index 473f481..3dae27b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,22 @@ # Changelog All notable changes to this project will be documented in this file. + +## v1.8 - 2022-01-22 + +### Added +- User can now switch between different game modes and settings without losing the old game state or streaks +- Lots of internal refactoring to how game state is persisted + +### Changed +- Profanities are now disallowed by default +- Streaks are now per game mode, and you can no longer cheat and restart the word by changing settings + - This unfortunately also means that some users will lose their current streak if daily game mode was the last selected mode. Sorry. + +### Fixed +- Animation when sixth word is correct and new game is started + + ## v1.7 - 2022-01-16 ### Added diff --git a/Cargo.lock b/Cargo.lock index 8a69d52..6420f2e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,6 +36,7 @@ dependencies = [ "libc", "num-integer", "num-traits", + "serde", "time", "wasm-bindgen", "winapi", @@ -342,7 +343,10 @@ version = "0.1.0" dependencies = [ "chrono", "getrandom", + "gloo-storage", "rand", + "serde", + "serde_json", "serde_scan", "wasm-bindgen", "web-sys", @@ -357,18 +361,18 @@ checksum = "c2e9d7eaddb227e8fbaaa71136ae0e1e913ca159b86c7da82f3e8f0044ad3a63" [[package]] name = "serde" -version = "1.0.132" +version = "1.0.133" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9875c23cf305cd1fd7eb77234cbb705f21ea6a72c637a5c6db5fe4b8e7f008" +checksum = "97565067517b60e2d1ea8b268e59ce036de907ac523ad83a0475da04e818989a" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.132" +version = "1.0.133" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc0db5cb2556c0e558887d9bbdcf6ac4471e83ff66cf696e5419024d1606276" +checksum = "ed201699328568d8d08208fdd080e3ff594e6c422e438b6705905da01005d537" dependencies = [ "proc-macro2", "quote", diff --git a/Cargo.toml b/Cargo.toml index cea3c29..1da531b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,10 +11,16 @@ serde_scan = "0.4.1" rand = "0.8.4" getrandom = { version = "0.2", features = ["js"] } wasm-bindgen = "0.2.78" +serde_json = "1.0" +gloo-storage = "0.2.0" + +[dependencies.serde] +version = "1.0" +features = ["derive"] [dependencies.chrono] version = "0.4" -features = ["wasmbind"] +features = ["wasmbind", "serde"] [dependencies.web-sys] version = "0.3" diff --git a/src/components/header.rs b/src/components/header.rs index 07cefe9..2d34223 100644 --- a/src/components/header.rs +++ b/src/components/header.rs @@ -34,7 +34,7 @@ pub fn header(props: &Props) -> Html {
{ - if props.game_mode == GameMode::DailyWord { + if let GameMode::DailyWord(_) = props.game_mode { html! {

{format!("Päivän sanuli #{}", props.daily_word_number)}

} } else if props.streak > 0 { html! {

{format!("Sanuli — Putki: {}", props.streak)}

} diff --git a/src/components/keyboard.rs b/src/components/keyboard.rs index 11f90f6..4b66f8a 100644 --- a/src/components/keyboard.rs +++ b/src/components/keyboard.rs @@ -117,7 +117,7 @@ pub fn keyboard(props: &Props) -> Html { { "ARVAA" } } - } else if props.game_mode == GameMode::DailyWord { + } else if let GameMode::DailyWord(_) = props.game_mode { let callback = props.callback.clone(); let onmousedown = Callback::from(move |e: MouseEvent| { e.prevent_default(); @@ -134,7 +134,7 @@ pub fn keyboard(props: &Props) -> Html { let callback = props.callback.clone(); let onmousedown = Callback::from(move |e: MouseEvent| { e.prevent_default(); - callback.emit(Msg::NewGame); + callback.emit(Msg::NextWord); }); html! { diff --git a/src/components/modal.rs b/src/components/modal.rs index ce51a51..3e7b033 100644 --- a/src/components/modal.rs +++ b/src/components/modal.rs @@ -1,11 +1,12 @@ use yew::prelude::*; +use chrono::{Local}; use crate::state::{GameMode, WordList, Theme}; use crate::Msg; const FORMS_LINK_TEMPLATE_ADD: &str = "https://docs.google.com/forms/d/e/1FAIpQLSfH8gs4sq-Ynn8iGOvlc99J_zOG2rJEC4m8V0kCgF_en3RHFQ/viewform?usp=pp_url&entry.461337706=Lis%C3%A4yst%C3%A4&entry.560255602="; const CHANGELOG_URL: &str = "https://github.com/Cadiac/sanuli/blob/master/CHANGELOG.md"; -const VERSION: &str = "v1.7"; +const VERSION: &str = "v1.8"; macro_rules! onmousedown { ( $cb:ident, $msg:expr ) => { @@ -86,12 +87,14 @@ pub struct MenuModalProps { pub fn menu_modal(props: &MenuModalProps) -> Html { let callback = props.callback.clone(); + let today = Local::now().naive_local().date(); + let toggle_menu = onmousedown!(callback, Msg::ToggleMenu); let change_word_length_5 = onmousedown!(callback, Msg::ChangeWordLength(5)); let change_word_length_6 = onmousedown!(callback, Msg::ChangeWordLength(6)); let change_game_mode_classic = onmousedown!(callback, Msg::ChangeGameMode(GameMode::Classic)); let change_game_mode_relay = onmousedown!(callback, Msg::ChangeGameMode(GameMode::Relay)); - let change_game_mode_daily = onmousedown!(callback, Msg::ChangeGameMode(GameMode::DailyWord)); + let change_game_mode_daily = onmousedown!(callback, Msg::ChangeGameMode(GameMode::DailyWord(today))); let change_word_list_full = onmousedown!(callback, Msg::ChangeWordList(WordList::Full)); let change_word_list_common = onmousedown!(callback, Msg::ChangeWordList(WordList::Common)); let change_allow_profanities_yes = onmousedown!(callback, Msg::ChangeAllowProfanities(true)); @@ -99,48 +102,58 @@ pub fn menu_modal(props: &MenuModalProps) -> Html { let change_theme_dark = onmousedown!(callback, Msg::ChangeTheme(Theme::Dark)); let change_theme_colorblind = onmousedown!(callback, Msg::ChangeTheme(Theme::Colorblind)); + let is_daily_word = matches!(props.game_mode, GameMode::DailyWord(_)); + html! {
{"✖"} -
- -
- - -
-
-
- -
- - -
-
-
- -
- - -
-
+ {if !is_daily_word { + html! { + <> +
+ +
+ + +
+
+
+ +
+ + +
+
+
+ +
+ + +
+
+ + } + } else { + html! {} + }}
@@ -152,7 +165,7 @@ pub fn menu_modal(props: &MenuModalProps) -> Html { onmousedown={change_game_mode_relay}> {"Sanuliketju"} - diff --git a/src/main.rs b/src/main.rs index da1e8fd..85920d4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,4 @@ +use chrono::Local; use std::collections::HashMap; use wasm_bindgen::{prelude::Closure, JsCast}; use web_sys::{window, Window}; @@ -5,6 +6,7 @@ use yew::prelude::*; mod components; mod state; +mod migration; use components::{ board::Board, @@ -12,11 +14,11 @@ use components::{ keyboard::Keyboard, modal::{HelpModal, MenuModal}, }; -use state::{GameMode, State, TileState, WordList, Theme}; +use state::{GameMode, State, Theme, TileState, WordList}; const ALLOWED_KEYS: [char; 28] = [ - 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', - 'L', 'Ö', 'Ä', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', + 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', + 'Ö', 'Ä', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', ]; pub enum Msg { @@ -24,7 +26,7 @@ pub enum Msg { Backspace, Enter, Guess, - NewGame, + NextWord, ToggleHelp, ToggleMenu, ChangeGameMode(GameMode), @@ -32,7 +34,7 @@ pub enum Msg { ChangeWordLength(usize), ChangeWordList(WordList), ChangeAllowProfanities(bool), - ChangeTheme(Theme) + ChangeTheme(Theme), } pub struct App { @@ -47,20 +49,12 @@ impl Component for App { type Properties = (); fn create(_ctx: &Context) -> Self { - let mut initial_state = Self { + Self { state: State::new(), is_help_visible: false, is_menu_visible: false, keyboard_listener: None, - }; - - if initial_state.state.rehydrate().is_err() { - // Reinitialize and just continue with defaults - initial_state.state = - State::new(); } - - initial_state } fn rendered(&mut self, ctx: &Context, first_render: bool) { @@ -111,16 +105,16 @@ impl Component for App { fn update(&mut self, ctx: &Context, msg: Self::Message) -> bool { match msg { - Msg::KeyPress(c) => self.state.push_character(c), - Msg::Backspace => self.state.pop_character(), + Msg::KeyPress(c) => self.state.game.push_character(c), + Msg::Backspace => self.state.game.pop_character(), Msg::Enter => { let link = ctx.link(); - if !self.state.is_guessing { - if self.state.game_mode == GameMode::DailyWord { + if !self.state.game.is_guessing { + if let GameMode::DailyWord(_) = self.state.game.game_mode { link.send_message(Msg::ChangePreviousGameMode); } else { - link.send_message(Msg::NewGame); + link.send_message(Msg::NextWord); } } else { link.send_message(Msg::Guess); @@ -128,8 +122,8 @@ impl Component for App { true } - Msg::Guess => self.state.submit_guess(), - Msg::NewGame => self.state.create_new_game(), + Msg::Guess => self.state.game.submit_guess(), + Msg::NextWord => self.state.game.next_word(), Msg::ToggleHelp => { self.is_help_visible = !self.is_help_visible; self.is_menu_visible = false; @@ -144,32 +138,35 @@ impl Component for App { self.state.change_word_length(new_length); self.is_menu_visible = false; self.is_help_visible = false; - self.state.create_new_game() + true } Msg::ChangeGameMode(new_mode) => { self.state.change_game_mode(new_mode); self.is_menu_visible = false; self.is_help_visible = false; - self.state.create_new_game() - } - Msg::ChangePreviousGameMode => { - self.state.change_game_mode(self.state.previous_game_mode.clone()); - self.state.create_new_game() + true } - Msg::ChangeWordList(list) => { - self.state.change_word_list(list); + Msg::ChangeWordList(new_list) => { + self.state.change_word_list(new_list); self.is_menu_visible = false; self.is_help_visible = false; - self.state.create_new_game() + true + } + Msg::ChangePreviousGameMode => { + self.state.change_previous_game_mode(); + true } Msg::ChangeAllowProfanities(is_allowed) => { - self.state.change_allow_profanities(is_allowed); + self.state + .game_manager + .borrow_mut() + .change_allow_profanities(is_allowed); self.is_menu_visible = false; self.is_help_visible = false; true - }, + } Msg::ChangeTheme(theme) => { - self.state.change_theme(theme); + self.state.game_manager.borrow_mut().change_theme(theme); true } } @@ -180,43 +177,46 @@ impl Component for App { let keyboard_state = ALLOWED_KEYS .iter() - .map(|key| (*key, self.state.keyboard_tilestate(key))) + .map(|key| (*key, self.state.game.keyboard_tilestate(key))) .collect::>(); - let word = self.state.word.iter().collect::(); + let word = self.state.game.word.iter().collect::(); - let last_guess = self.state.guesses[self.state.current_guess] + let last_guess = self.state.game.guesses[self.state.game.current_guess] .iter() .map(|(c, _)| c) .collect::(); + let game_manager = self.state.game_manager.borrow(); + let today = Local::now().naive_local().date(); + html! { -
+
} } else { diff --git a/src/migration.rs b/src/migration.rs new file mode 100644 index 0000000..a1e97fb --- /dev/null +++ b/src/migration.rs @@ -0,0 +1,182 @@ +use wasm_bindgen::JsValue; +use web_sys::{window, Window}; +use chrono::{NaiveDate}; + +use crate::state::{GameMode, Game, State, Theme, TileState, WordList, DAILY_WORD_LEN, EMPTY}; + +// Migrate the old game data to the new format, removing old data from localStorage. +// TODO: Get rid of this at some point, even if that means data loss to some players +pub fn migrate_state(state: &mut State) -> Result<(), JsValue> { + let window: Window = window().expect("window not available"); + if let Some(local_storage) = window.local_storage().expect("local storage not available") { + // Daily words + if let Some(daily_word_history_str) = local_storage.get_item("daily_word_history")? { + local_storage.remove_item("daily_word_history")?; + + if daily_word_history_str.len() != 0 { + daily_word_history_str.split(',').for_each(|date_str| { + let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d").unwrap(); + let daily_item_key = &format!("daily_word_history[{}]", date_str); + let daily_item = local_storage.get_item(daily_item_key).unwrap(); + if let Some(daily_str) = daily_item { + let _res = local_storage.remove_item(daily_item_key); + + let parts = daily_str.split('|').collect::>(); + + // AIVAN|2022-01-07|KOIRA,AVAIN,AIVAN,,,|2|true|true + // let word = parts[0]; + let previous_guesses = parts[2].split(',').map(|guess| { + guess.chars().map(|c| (c, TileState::Unknown)).collect() + }); + let current_guess = parts[3].parse::().unwrap(); + let is_guessing = parts[4].parse::().unwrap(); + let is_winner = parts[5].parse::().unwrap(); + + // If we haven't got a game in background with this date, create one + let game_id = + (GameMode::DailyWord(date), WordList::Daily, DAILY_WORD_LEN); + + if !state.background_games.contains_key(&game_id) { + let mut new_daily_game = Game::new( + game_id.0, + game_id.1, + game_id.2, + state.game_manager.clone(), + ); + + for (guess_index, guess) in previous_guesses.enumerate() { + new_daily_game.guesses[guess_index] = guess; + new_daily_game.current_guess = guess_index; + new_daily_game.calculate_current_guess(); + } + + new_daily_game.current_guess = current_guess; + new_daily_game.is_guessing = is_guessing; + new_daily_game.is_winner = is_winner; + + if !new_daily_game.is_guessing { + new_daily_game.message = "Uusi sanuli huomenna!".to_owned(); + } else { + new_daily_game.message = EMPTY.to_string() + } + + // Persist the game + let _res = new_daily_game.persist(); + + state.background_games.insert(game_id, new_daily_game); + } else { + // We... Already had the game? Don't do anything? + } + } + }); + } + } + + // Current game + if let Some(game_mode_str) = local_storage.get_item("game_mode")? { + if let Ok(game_mode) = game_mode_str.parse::() { + state.game_manager.borrow_mut().current_game_mode = game_mode; + } + local_storage.remove_item("game_mode")?; + } + + if let Some(word_list_str) = local_storage.get_item("word_list")? { + if let Ok(word_list) = word_list_str.parse::() { + if matches!( + state.game_manager.borrow().current_game_mode, + GameMode::DailyWord(_) + ) { + // Force the word list as daily word + state.game_manager.borrow_mut().current_word_list = WordList::Daily; + } else { + state.game_manager.borrow_mut().current_word_list = word_list; + } + } + local_storage.remove_item("word_list")?; + } + + if let Some(word_length_str) = local_storage.get_item("word_length")? { + if let Ok(word_length) = word_length_str.parse::() { + if matches!( + state.game_manager.borrow().current_game_mode, + GameMode::DailyWord(_) + ) { + // Force the word length for daily word + state.game_manager.borrow_mut().current_word_length = DAILY_WORD_LEN; + } else { + state.game_manager.borrow_mut().current_word_length = word_length; + } + } + local_storage.remove_item("word_length")?; + } + + if let Some(allow_profanities_str) = local_storage.get_item("allow_profanities")? { + if let Ok(allow_profanities) = allow_profanities_str.parse::() { + state.game_manager.borrow_mut().allow_profanities = allow_profanities; + } + local_storage.remove_item("allow_profanities")?; + } + + if let Some(theme_str) = local_storage.get_item("theme")? { + if let Ok(theme) = theme_str.parse::() { + state.game_manager.borrow_mut().theme = theme; + } + local_storage.remove_item("theme")?; + } + + if let Some(message_str) = local_storage.get_item("message")? { + state.game.message = message_str; + local_storage.remove_item("message")?; + } + + if let Some(max_streak_str) = local_storage.get_item("max_streak")? { + if let Ok(max_streak) = max_streak_str.parse::() { + state.game_manager.borrow_mut().max_streak = max_streak; + } + local_storage.remove_item("max_streak")?; + } + + if let Some(total_played_str) = local_storage.get_item("total_played")? { + if let Ok(total_played) = total_played_str.parse::() { + state.game_manager.borrow_mut().total_played = total_played; + } + local_storage.remove_item("total_played")?; + } + + if let Some(total_solved_str) = local_storage.get_item("total_solved")? { + if let Ok(total_solved) = total_solved_str.parse::() { + state.game_manager.borrow_mut().total_solved = total_solved; + } + local_storage.remove_item("total_solved")?; + } + } + + Ok(()) +} + +// Migrate the old game data (well, only the streak) to the new format, removing old data from localStorage. +// TODO: Get rid of this at some point, even if that means data loss to some players +pub fn migrate_game(game: &mut Game) -> Result<(), JsValue> { + let window: Window = window().expect("window not available"); + if let Some(local_storage) = window.local_storage()? { + match game.game_manager.borrow().current_game_mode { + GameMode::Classic | GameMode::Relay => { + if let Some(streak_str) = local_storage.get_item("streak")? { + if let Ok(streak) = streak_str.parse::() { + game.streak = streak; + } + } + } + _ => {} + } + + local_storage.remove_item("streak")?; + local_storage.remove_item("word")?; + local_storage.remove_item("is_guessing")?; + local_storage.remove_item("is_winner")?; + local_storage.remove_item("guesses")?; + local_storage.remove_item("current_guess")?; + } + + Ok(()) +} \ No newline at end of file diff --git a/src/state.rs b/src/state.rs index 714b5a4..a09561d 100644 --- a/src/state.rs +++ b/src/state.rs @@ -1,29 +1,36 @@ use rand::seq::SliceRandom; +use std::cell::RefCell; use std::collections::HashMap; use std::collections::HashSet; use std::fmt; use std::mem; +use std::rc::Rc; use std::str::FromStr; use chrono::{Local, NaiveDate}; -use wasm_bindgen::JsValue; -use web_sys::{window, Window}; +use gloo_storage::{errors::StorageError, LocalStorage, Storage}; +use serde::{Deserialize, Serialize}; + +use crate::migration; const FULL_WORDS: &str = include_str!("../full-words.txt"); const COMMON_WORDS: &str = include_str!("../common-words.txt"); const DAILY_WORDS: &str = include_str!("../daily-words.txt"); const PROFANITIES: &str = include_str!("../profanities.txt"); -const EMPTY: char = '\u{00a0}'; //   const SUCCESS_EMOJIS: [&str; 8] = ["🥳", "🤩", "🤗", "🎉", "😊", "😺", "😎", "👏"]; +pub const EMPTY: char = '\u{00a0}'; //   pub const DEFAULT_WORD_LENGTH: usize = 5; pub const DEFAULT_MAX_GUESSES: usize = 6; +pub const DAILY_WORD_LEN: usize = 5; + +type WordLists = HashMap<(WordList, usize), HashSet>>; -fn parse_all_words() -> HashMap<(WordList, usize), HashSet>> { - let mut words = HashMap::with_capacity(2); +fn parse_all_words() -> Rc { + let mut word_lists: HashMap<(WordList, usize), HashSet>> = HashMap::with_capacity(3); for word in FULL_WORDS.lines() { let chars = word.chars(); let word_length = chars.clone().count(); - words + word_lists .entry((WordList::Full, word_length)) .or_insert(HashSet::new()) .insert(chars.collect()); @@ -32,7 +39,7 @@ fn parse_all_words() -> HashMap<(WordList, usize), HashSet>> { for word in COMMON_WORDS.lines() { let chars = word.chars(); let word_length = chars.clone().count(); - words + word_lists .entry((WordList::Common, word_length)) .or_insert(HashSet::new()) .insert(chars.collect()); @@ -41,20 +48,27 @@ fn parse_all_words() -> HashMap<(WordList, usize), HashSet>> { for word in PROFANITIES.lines() { let chars = word.chars(); let word_length = chars.clone().count(); - words + word_lists .entry((WordList::Profanities, word_length)) .or_insert(HashSet::new()) .insert(chars.collect()); } - words + Rc::new(word_lists) } -#[derive(PartialEq, Eq, Hash, Clone, Copy)] +#[derive(PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize)] pub enum WordList { Full, Common, Profanities, + Daily, +} + +impl Default for WordList { + fn default() -> Self { + WordList::Common + } } impl FromStr for WordList { @@ -65,6 +79,7 @@ impl FromStr for WordList { "full" => Ok(WordList::Full), "common" => Ok(WordList::Common), "profanities" => Ok(WordList::Profanities), + "daily" => Ok(WordList::Daily), _ => Err(()), } } @@ -76,15 +91,22 @@ impl fmt::Display for WordList { WordList::Full => write!(f, "full"), WordList::Common => write!(f, "common"), WordList::Profanities => write!(f, "profanities"), + WordList::Daily => write!(f, "daily"), } } } -#[derive(PartialEq, Clone, Copy)] +#[derive(PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize)] pub enum GameMode { Classic, Relay, - DailyWord, + DailyWord(NaiveDate), +} + +impl Default for GameMode { + fn default() -> Self { + GameMode::Classic + } } impl FromStr for GameMode { @@ -94,7 +116,10 @@ impl FromStr for GameMode { match input { "classic" => Ok(GameMode::Classic), "relay" => Ok(GameMode::Relay), - "daily_word" => Ok(GameMode::DailyWord), + "daily_word" => { + let today = Local::now().naive_local().date(); + Ok(GameMode::DailyWord(today)) + } _ => Err(()), } } @@ -105,17 +130,23 @@ impl fmt::Display for GameMode { match self { GameMode::Classic => write!(f, "classic"), GameMode::Relay => write!(f, "relay"), - GameMode::DailyWord => write!(f, "daily_word"), + GameMode::DailyWord(_) => write!(f, "daily_word"), } } } -#[derive(PartialEq, Clone, Copy)] +#[derive(PartialEq, Clone, Copy, Serialize, Deserialize)] pub enum Theme { Dark, Colorblind, } +impl Default for Theme { + fn default() -> Self { + Theme::Dark + } +} + impl FromStr for Theme { type Err = (); @@ -137,15 +168,14 @@ impl fmt::Display for Theme { } } - -#[derive(Clone, PartialEq)] +#[derive(Clone, PartialEq, Serialize, Deserialize)] pub enum CharacterState { Correct, Absent, Unknown, } -#[derive(Clone, PartialEq)] +#[derive(Clone, PartialEq, Serialize, Deserialize)] pub enum TileState { Correct, Absent, @@ -174,7 +204,7 @@ pub struct DailyWordHistory { is_winner: bool, } -#[derive(Clone, PartialEq)] +#[derive(Clone, PartialEq, Serialize, Deserialize)] pub enum CharacterCount { AtLeast(usize), Exactly(usize), @@ -182,57 +212,356 @@ pub enum CharacterCount { #[derive(Clone, PartialEq)] pub struct State { - pub word: Vec, + pub game_manager: Rc>, + pub game: Game, + pub background_games: HashMap<(GameMode, WordList, usize), Game>, +} - pub current_word_list: WordList, - pub word_lists: HashMap<(WordList, usize), HashSet>>, - pub allow_profanities: bool, +impl State { + pub fn new() -> Self { + // Attempt to rehydrate old game manager from localStorage + if let Ok(rehydrated) = GameManager::rehydrate() { + let game_manager = Rc::new(RefCell::new(rehydrated)); + + let game = Game::new_or_rehydrate( + game_manager.borrow().current_game_mode, + game_manager.borrow().current_word_list, + game_manager.borrow().current_word_length, + game_manager.clone(), + ); - pub word_length: usize, - pub max_guesses: usize, + return Self { + game_manager, + game, + background_games: HashMap::new(), + }; + } else { + // Otherwise either create everything from scratch or recover some data from legacy storage state + let game_manager = Rc::new(RefCell::new(GameManager::new())); + let background_games = HashMap::new(); + let game = Game::new( + GameMode::Classic, + WordList::Common, + DEFAULT_WORD_LENGTH, + game_manager.clone(), + ); - pub is_guessing: bool, - pub is_winner: bool, - pub is_unknown: bool, - pub is_reset: bool, + let mut state = Self { + game_manager, + game, + background_games, + }; - pub theme: Theme, + // Try to migrate old settings and stats from localStorage to current format + // TODO: Doesn't do anything if the old state isn't present, but get rid of this at some point + let _res = migration::migrate_state(&mut state); + state.switch_active_game(); - pub daily_word_history: HashMap, + // Try to migrate old game streak from localStorage to current format, if the game mode is not daily + // TODO: Doesn't do anything if the old state isn't present, but get rid of this at some point + let _res = migration::migrate_game(&mut state.game); - pub game_mode: GameMode, - pub previous_game_mode: GameMode, + let _res = state.game_manager.borrow().persist(); + let _res = state.game.persist(); - pub message: String, + return state; + }; + } - pub known_states: Vec>, - pub discovered_counts: Vec>, + pub fn change_word_length(&mut self, new_length: usize) { + if self.game_manager.borrow().current_word_length == new_length { + return; + } - pub guesses: Vec>, - pub previous_guesses: Vec>, - pub current_guess: usize, + self.game_manager + .borrow_mut() + .change_word_length(new_length); + self.switch_active_game(); + let _res = self.game_manager.borrow_mut().persist(); + let _res = self.game.persist(); + } + + pub fn change_game_mode(&mut self, new_mode: GameMode) { + if self.game_manager.borrow().current_game_mode == new_mode { + return; + } + + if matches!( + self.game_manager.borrow().current_game_mode, + GameMode::DailyWord(_) + ) { + let previous_game = self.game_manager.borrow().previous_game.clone(); + self.game_manager + .borrow_mut() + .change_word_list(previous_game.1); + self.game_manager + .borrow_mut() + .change_word_length(previous_game.2); + } + + if matches!(new_mode, GameMode::DailyWord(_)) { + self.game_manager + .borrow_mut() + .change_word_list(WordList::Daily); + self.game_manager + .borrow_mut() + .change_word_length(DAILY_WORD_LEN); + } + + self.game_manager.borrow_mut().change_game_mode(new_mode); + self.switch_active_game(); + let _res = self.game_manager.borrow_mut().persist(); + let _res = self.game.persist(); + } + + pub fn change_word_list(&mut self, new_list: WordList) { + if self.game_manager.borrow().current_word_list == new_list { + return; + } + + self.game_manager.borrow_mut().change_word_list(new_list); + self.switch_active_game(); + let _res = self.game_manager.borrow_mut().persist(); + let _res = self.game.persist(); + } + + pub fn change_previous_game_mode(&mut self) { + let (game_mode, word_list, word_length) = self.game_manager.borrow().previous_game; + + self.game_manager.borrow_mut().change_game_mode(game_mode); + self.game_manager.borrow_mut().change_word_list(word_list); + self.game_manager + .borrow_mut() + .change_word_length(word_length); + self.switch_active_game(); + + let _res = self.game_manager.borrow_mut().persist(); + let _res = self.game.persist(); + } + + pub fn switch_active_game(&mut self) -> bool { + let next_game = ( + self.game_manager.borrow().current_game_mode, + self.game_manager.borrow().current_word_list, + self.game_manager.borrow().current_word_length, + ); + + let previous_game = ( + self.game.game_mode, + self.game.word_list, + self.game.word_length, + ); + + if next_game.0 == previous_game.0 + && next_game.1 == previous_game.1 + && next_game.2 == previous_game.2 + { + return false; + } + + self.game_manager.borrow_mut().previous_game = previous_game; + + // Restore a suspended game or create a new one + let mut game = self + .background_games + .remove(&next_game) + .unwrap_or(Game::new_or_rehydrate( + next_game.0, + next_game.1, + next_game.2, + self.game_manager.clone(), + )); + + // For playing the animation populate previous_guesses + if previous_game.2 <= next_game.2 { + game.previous_guesses = self.game.guesses.clone(); + } else { + game.previous_guesses = self + .game + .guesses + .iter() + .cloned() + .map(|guess| guess.into_iter().take(game.word_length).collect()) + .collect(); + } + + if self.game.current_guess < game.max_guesses - 1 { + game.previous_guesses.truncate(self.game.current_guess); + } + game.is_reset = true; + + self.background_games + .insert(previous_game, mem::replace(&mut self.game, game)); + + true + } +} + +#[derive(Clone, PartialEq, Default, Serialize, Deserialize)] +pub struct GameManager { + #[serde(skip)] + pub word_lists: Rc, + + pub allow_profanities: bool, + pub current_game_mode: GameMode, + pub current_word_list: WordList, + pub current_word_length: usize, + + pub previous_game: (GameMode, WordList, usize), + + pub current_max_guesses: usize, + + pub theme: Theme, - pub streak: usize, pub max_streak: usize, pub total_played: usize, pub total_solved: usize, } -impl State { +impl GameManager { pub fn new() -> Self { - let word_length = DEFAULT_WORD_LENGTH; - let max_guesses = DEFAULT_MAX_GUESSES; - let word_lists = parse_all_words(); let current_word_list = WordList::Common; - let allow_profanities = true; + let current_word_length = DEFAULT_WORD_LENGTH; + let current_max_guesses = DEFAULT_MAX_GUESSES; + let allow_profanities = false; - let word = State::get_random_word( - &word_lists, + Self { + word_lists, current_word_list, - word_length, allow_profanities, - ); + + current_max_guesses, + + current_game_mode: GameMode::Classic, + previous_game: (GameMode::Classic, WordList::Common, DEFAULT_WORD_LENGTH), + current_word_length, + + theme: Theme::Dark, + + max_streak: 0, + total_played: 0, + total_solved: 0, + } + } + + pub fn get_random_word(&self, word_list: WordList, word_length: usize) -> Vec { + let mut words = self + .word_lists + .get(&(word_list, word_length)) + .unwrap() + .iter() + .collect::>(); + + if !self.allow_profanities { + if let Some(profanities) = self + .word_lists + .get(&(WordList::Profanities, self.current_word_length)) + { + words.retain(|word| !profanities.contains(*word)); + } + } + + let chosen = words.choose(&mut rand::thread_rng()).unwrap(); + (*chosen).clone() + } + + pub fn get_daily_word_index(&self, date: NaiveDate) -> usize { + let epoch = NaiveDate::from_ymd(2022, 1, 07); // Epoch of the daily word mode, index 0 + date.signed_duration_since(epoch).num_days() as usize + } + + pub fn get_daily_word(&self, date: NaiveDate) -> Vec { + DAILY_WORDS + .lines() + .nth(self.get_daily_word_index(date)) + .unwrap() + .chars() + .collect() + } + + fn update_game_statistics(&mut self, is_winner: bool, streak: usize) { + self.total_played += 1; + + if is_winner { + self.total_solved += 1; + + if streak > self.max_streak { + self.max_streak = streak; + } + } + } + + fn change_word_length(&mut self, new_length: usize) { + self.current_word_length = new_length; + } + + fn change_game_mode(&mut self, new_mode: GameMode) { + self.current_game_mode = new_mode; + } + + fn change_word_list(&mut self, new_list: WordList) { + self.current_word_list = new_list; + } + + pub fn change_allow_profanities(&mut self, is_allowed: bool) { + self.allow_profanities = is_allowed; + let _result = self.persist(); + } + + pub fn change_theme(&mut self, theme: Theme) -> bool { + self.theme = theme; + let _result = self.persist(); + true + } + + fn persist(&self) -> Result<(), StorageError> { + LocalStorage::set("settings", self) + } + + fn rehydrate() -> Result { + let mut game_manager: GameManager = LocalStorage::get("settings")?; + game_manager.word_lists = parse_all_words(); + Ok(game_manager) + } +} + +#[derive(Clone, PartialEq, Serialize, Deserialize)] +pub struct Game { + pub game_mode: GameMode, + pub word_list: WordList, + pub word_length: usize, + pub max_guesses: usize, + + pub word: Vec, + pub guesses: Vec>, + pub current_guess: usize, + pub streak: usize, + + pub is_guessing: bool, + pub is_winner: bool, + pub is_unknown: bool, + pub is_reset: bool, + pub message: String, + + #[serde(skip)] + pub game_manager: Rc>, + #[serde(skip)] + pub known_states: Vec>, + #[serde(skip)] + pub discovered_counts: Vec>, + #[serde(skip)] + pub previous_guesses: Vec>, +} + +impl Game { + pub fn new( + game_mode: GameMode, + word_list: WordList, + word_length: usize, + game_manager: Rc>, + ) -> Self { + let max_guesses = DEFAULT_MAX_GUESSES; let guesses = std::iter::repeat(Vec::with_capacity(word_length)) .take(max_guesses) @@ -246,43 +575,124 @@ impl State { .take(max_guesses) .collect::>(); - Self { - word, - - word_lists, - current_word_list, - allow_profanities, + let word = if let GameMode::DailyWord(date) = game_mode { + game_manager.borrow().get_daily_word(date) + } else { + game_manager + .borrow() + .get_random_word(word_list, word_length) + }; + Self { + game_mode, + word_list, word_length, max_guesses, - + word, is_guessing: true, is_winner: false, is_unknown: false, is_reset: false, - - theme: Theme::Dark, - - daily_word_history: HashMap::new(), - - game_mode: GameMode::Classic, - previous_game_mode: GameMode::Classic, - message: EMPTY.to_string(), - known_states, discovered_counts, - guesses, previous_guesses: Vec::new(), current_guess: 0, + + game_manager, + streak: 0, - max_streak: 0, - total_played: 0, - total_solved: 0, } } + pub fn new_or_rehydrate( + game_mode: GameMode, + word_list: WordList, + word_length: usize, + game_manager: Rc>, + ) -> Self { + if let Ok(game) = Game::rehydrate(game_mode, word_list, word_length, game_manager.clone()) { + game + } else { + Game::new(game_mode, word_list, word_length, game_manager.clone()) + } + } + + pub fn next_word(&mut self) -> bool { + let next_word = + if let GameMode::DailyWord(date) = self.game_manager.borrow().current_game_mode { + self.game_manager.borrow().get_daily_word(date) + } else { + self.game_manager.borrow().get_random_word( + self.game_manager.borrow().current_word_list, + self.game_manager.borrow().current_word_length, + ) + }; + + let previous_word = mem::replace(&mut self.word, next_word); + + if previous_word.len() <= self.word_length { + self.previous_guesses = mem::take(&mut self.guesses); + if self.game_mode == GameMode::Relay && self.is_winner { + self.previous_guesses.truncate(self.current_guess); + } else { + self.previous_guesses.truncate(self.current_guess + 1); + } + } else { + let previous_guesses = mem::take(&mut self.guesses); + self.previous_guesses = previous_guesses + .into_iter() + .map(|guess| guess.into_iter().take(self.word_length).collect()) + .collect(); + self.previous_guesses.truncate(self.current_guess); + } + + self.guesses = Vec::with_capacity(self.max_guesses); + + self.known_states = std::iter::repeat(HashMap::new()) + .take(DEFAULT_MAX_GUESSES) + .collect::>(); + self.discovered_counts = std::iter::repeat(HashMap::new()) + .take(DEFAULT_MAX_GUESSES) + .collect::>(); + + if previous_word.len() == self.word_length + && self.is_winner + && self.game_mode == GameMode::Relay + { + let empty_guesses = std::iter::repeat(Vec::with_capacity(self.word_length)) + .take(self.max_guesses - 1) + .collect::>(); + + self.guesses.push( + previous_word + .iter() + .map(|c| (*c, TileState::Unknown)) + .collect(), + ); + self.guesses.extend(empty_guesses); + + self.current_guess = 0; + self.calculate_current_guess(); + self.current_guess = 1; + } else { + self.guesses = std::iter::repeat(Vec::with_capacity(self.word_length)) + .take(self.max_guesses) + .collect::>(); + self.current_guess = 0; + } + + self.is_guessing = true; + self.is_winner = false; + self.is_reset = true; + self.clear_message(); + + let _result = self.persist(); + + true + } + pub fn keyboard_tilestate(&self, key: &char) -> TileState { let is_correct = self.known_states[self.current_guess] .iter() @@ -390,7 +800,7 @@ impl State { } } - pub fn submit_current_guess(&mut self) { + pub fn calculate_current_guess(&mut self) { for (index, (character, _)) in self.guesses[self.current_guess].iter().enumerate() { let known = self.known_states[self.current_guess] .entry((*character, index)) @@ -478,7 +888,12 @@ impl State { } fn is_guess_real_word(&self) -> bool { - match self.word_lists.get(&(WordList::Full, self.word_length)) { + match self + .game_manager + .borrow() + .word_lists + .get(&(WordList::Full, self.word_length)) + { Some(list) => { let word: &Vec = &self.guesses[self.current_guess] .iter() @@ -510,7 +925,7 @@ impl State { fn set_game_end_message(&mut self) { if self.is_winner { - if self.game_mode == GameMode::DailyWord { + if let GameMode::DailyWord(_) = self.game_mode { self.message = format!( "Löysit päivän sanulin! {}", SUCCESS_EMOJIS.choose(&mut rand::thread_rng()).unwrap() @@ -526,41 +941,6 @@ impl State { } } - fn set_daily_word_history(&mut self, date: &NaiveDate) { - self.daily_word_history.insert( - *date, - DailyWordHistory { - word: self.word.iter().collect(), - date: *date, - guesses: self - .guesses - .iter() - .map(|guess| guess.iter().map(|(c, _)| *c).collect()) - .collect(), - current_guess: self.current_guess, - is_guessing: self.is_guessing, - is_winner: self.is_winner, - }, - ); - } - - fn set_game_statistics(&mut self) { - self.total_played += 1; - - if self.is_winner { - self.total_solved += 1; - - if self.game_mode != GameMode::DailyWord { - self.streak += 1; - if self.streak > self.max_streak { - self.max_streak = self.streak; - } - } - } else { - self.streak = 0; - } - } - pub fn submit_guess(&mut self) -> bool { if !self.is_guess_allowed() { self.message = "Liian vähän kirjaimia!".to_owned(); @@ -576,471 +956,86 @@ impl State { self.clear_message(); self.is_winner = self.is_correct_word(); - self.submit_current_guess(); + self.calculate_current_guess(); if self.is_game_ended() { self.is_guessing = false; - self.set_game_statistics(); - self.set_game_end_message(); - - let _result = self.persist_stats(); - } else { - self.current_guess += 1; - } - - if self.game_mode == GameMode::DailyWord { - let today = Local::now().naive_local().date(); - self.set_daily_word_history(&today); - - let _result = self.persist_single_daily_word(&today); - } else { - let _result = self.persist_game(); - } - - true - } - - pub fn get_random_word( - word_lists: &HashMap<(WordList, usize), HashSet>>, - current: WordList, - word_length: usize, - allow_profanities: bool, - ) -> Vec { - let mut words = word_lists - .get(&(current, word_length)) - .unwrap() - .iter() - .collect::>(); - - if !allow_profanities { - if let Some(profanities) = word_lists.get(&(WordList::Profanities, word_length)) { - words.retain(|word| !profanities.contains(*word)); - } - } - - let chosen = words.choose(&mut rand::thread_rng()).unwrap(); - (*chosen).clone() - } - - pub fn get_daily_word_index(&self) -> usize { - let epoch = NaiveDate::from_ymd(2022, 1, 07); // Epoch of the daily word mode, index 0 - Local::now() - .naive_local() - .date() - .signed_duration_since(epoch) - .num_days() as usize - } - - pub fn get_daily_word(&self) -> Vec { - DAILY_WORDS - .lines() - .nth(self.get_daily_word_index()) - .unwrap() - .chars() - .collect() - } - - pub fn create_new_game(&mut self) -> bool { - let next_word = if self.game_mode == GameMode::DailyWord { - self.get_daily_word() - } else { - State::get_random_word( - &self.word_lists, - self.current_word_list, - self.word_length, - self.allow_profanities, - ) - }; - - let previous_word = mem::replace(&mut self.word, next_word); - - if previous_word.len() <= self.word_length { - self.previous_guesses = mem::take(&mut self.guesses); - self.previous_guesses.truncate(self.current_guess); - } else { - let previous_guesses = mem::take(&mut self.guesses); - self.previous_guesses = previous_guesses - .into_iter() - .map(|guess| guess.into_iter().take(self.word_length).collect()) - .collect(); - self.previous_guesses.truncate(self.current_guess); - } - - self.guesses = Vec::with_capacity(self.max_guesses); - - self.known_states = std::iter::repeat(HashMap::new()) - .take(DEFAULT_MAX_GUESSES) - .collect::>(); - self.discovered_counts = std::iter::repeat(HashMap::new()) - .take(DEFAULT_MAX_GUESSES) - .collect::>(); - - if previous_word.len() == self.word_length - && self.is_winner - && self.game_mode == GameMode::Relay - { - let empty_guesses = std::iter::repeat(Vec::with_capacity(self.word_length)) - .take(self.max_guesses - 1) - .collect::>(); - - self.guesses.push( - previous_word - .iter() - .map(|c| (*c, TileState::Unknown)) - .collect(), - ); - self.guesses.extend(empty_guesses); - - self.current_guess = 0; - self.submit_current_guess(); - self.current_guess = 1; - } else { - self.guesses = std::iter::repeat(Vec::with_capacity(self.word_length)) - .take(self.max_guesses) - .collect::>(); - self.current_guess = 0; - } - - self.is_guessing = true; - self.is_winner = false; - self.is_reset = true; - self.clear_message(); - - if self.game_mode == GameMode::DailyWord { - let today = Local::now().naive_local().date(); - if let Some(solve) = self.daily_word_history.get(&today).cloned() { - for (guess_index, guess) in solve.guesses.iter().enumerate() { - self.guesses[guess_index] = - guess.iter().map(|c| (*c, TileState::Unknown)).collect(); - self.current_guess = guess_index; - self.submit_current_guess(); + if let GameMode::DailyWord(_) = self.game_mode { + // Do nothing? + } else { + if self.is_winner { + self.streak += 1; + } else { + self.streak = 0; } - self.is_winner = solve.is_winner; - self.is_guessing = solve.is_guessing; - self.current_guess = solve.current_guess; - } - if !self.is_guessing { - self.message = "Uusi sanuli huomenna!".to_owned(); + self.game_manager + .borrow_mut() + .update_game_statistics(self.is_winner, self.streak); } - } else { - let _result = self.persist_game(); - } - - true - } - - pub fn change_word_length(&mut self, new_length: usize) { - self.word_length = new_length; - // TODO: Store streaks for every word length separately - - if self.game_mode == GameMode::DailyWord { - self.game_mode = GameMode::Classic; - } - } - - pub fn change_game_mode(&mut self, new_mode: GameMode) { - self.previous_game_mode = std::mem::replace(&mut self.game_mode, new_mode); - self.message = EMPTY.to_string(); - let _result = self.persist_settings(); + self.set_game_end_message(); - if self.game_mode == GameMode::DailyWord { - self.word_length = 5; + let _result = self.game_manager.borrow().persist(); + } else { + self.current_guess += 1; } - } - pub fn change_word_list(&mut self, new_list: WordList) { - self.current_word_list = new_list; - self.message = EMPTY.to_string(); - let _result = self.persist_settings(); - } + let _result = self.persist(); - pub fn change_allow_profanities(&mut self, is_allowed: bool) { - self.allow_profanities = is_allowed; - let _result = self.persist_settings(); - } - - pub fn change_theme(&mut self, theme: Theme) -> bool { - self.theme = theme; - let _result = self.persist_settings(); true } - // Persisting & restoring game state - - fn persist_settings(&mut self) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - let local_storage = window.local_storage().expect("local storage not available"); - if let Some(local_storage) = local_storage { - local_storage.set_item("game_mode", &self.game_mode.to_string())?; - local_storage.set_item("word_length", format!("{}", self.word_length).as_str())?; - local_storage.set_item("word_list", format!("{}", self.current_word_list).as_str())?; - local_storage.set_item("allow_profanities", format!("{}", self.allow_profanities).as_str())?; - local_storage.set_item("theme", format!("{}", self.theme).as_str())?; - } - - Ok(()) - } - - fn persist_stats(&self) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - let local_storage = window.local_storage().expect("local storage not available"); - if let Some(local_storage) = local_storage { - local_storage.set_item("streak", &format!("{}", self.streak))?; - local_storage.set_item("max_streak", &format!("{}", self.max_streak))?; - local_storage.set_item("total_played", &format!("{}", self.total_played))?; - local_storage.set_item("total_solved", &format!("{}", self.total_solved))?; - } - - Ok(()) - } - - fn persist_game(&self) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - let local_storage = window.local_storage().expect("local storage not available"); - if let Some(local_storage) = local_storage { - local_storage.set_item("word", &self.word.iter().collect::())?; - local_storage.set_item("word_length", &format!("{}", self.word_length))?; - local_storage.set_item("current_guess", &format!("{}", self.current_guess))?; - local_storage.set_item( - "guesses", - &self - .guesses - .iter() - .map(|guess| guess.iter().map(|(c, _)| c).collect::()) - .collect::>() - .join(","), - )?; - local_storage.set_item("message", &self.message)?; - local_storage.set_item("is_guessing", format!("{}", self.is_guessing).as_str())?; - local_storage.set_item("is_winner", format!("{}", self.is_winner).as_str())?; - } - - Ok(()) - } - - fn persist_single_daily_word(&self, date: &NaiveDate) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - let local_storage = window.local_storage().expect("local storage not available"); - - if let Some(local_storage) = local_storage { - if let Some(history) = self.daily_word_history.get(date) { - local_storage.set_item( - &format!("daily_word_history[{}]", date.format("%Y-%m-%d")), - &format!( - "{}|{}|{}|{}|{}|{}", - history.word, - history.date.format("%Y-%m-%d"), - history - .guesses - .iter() - .map(|guess| guess.iter().collect::()) - .collect::>() - .join(","), - history.current_guess, - history.is_guessing, - history.is_winner - ), - )?; - } - - local_storage.set_item( - "daily_word_history", - &format!( - "{}", - &self - .daily_word_history - .keys() - .map(|date| date.format("%Y-%m-%d").to_string()) - .collect::>() - .join(",") - ), - )?; - - local_storage.set_item("total_played", &format!("{}", self.total_played))?; - local_storage.set_item("total_solved", &format!("{}", self.total_solved))?; - } - - Ok(()) - } - - fn rehydrate_daily_word(&mut self) { - self.word = self.get_daily_word(); - self.word_length = self.word.len(); - - let today = Local::now().naive_local().date(); - if let Some(solve) = self.daily_word_history.get(&today).cloned() { - for (guess_index, guess) in solve.guesses.iter().enumerate() { - self.guesses[guess_index] = - guess.iter().map(|c| (*c, TileState::Unknown)).collect(); - self.current_guess = guess_index; - self.submit_current_guess(); - } - self.is_guessing = solve.is_guessing; - self.is_winner = solve.is_winner; - self.current_guess = solve.current_guess; + pub fn persist(&self) -> Result<(), StorageError> { + let game_key = &format!( + "game|{}|{}|{}", + serde_json::to_string(&self.game_mode).unwrap(), + serde_json::to_string(&self.word_list).unwrap(), + self.word_length + ); - if !self.is_guessing { - self.message = "Uusi sanuli huomenna!".to_owned(); - } else { - self.message = EMPTY.to_string() - } - } + LocalStorage::set(game_key, self) } - fn rehydrate_game(&mut self) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - if let Some(local_storage) = window.local_storage()? { - if let Some(word_list_str) = local_storage.get_item("word_list")? { - if let Ok(word_list) = word_list_str.parse::() { - self.current_word_list = word_list; - } - } - - if let Some(word_length_str) = local_storage.get_item("word_length")? { - if let Ok(word_length) = word_length_str.parse::() { - self.word_length = word_length; - } - } - - if let Some(allow_profanities_str) = local_storage.get_item("allow_profanities")? { - if let Ok(allow_profanities) = allow_profanities_str.parse::() { - self.allow_profanities = allow_profanities; - } - } - - if let Some(theme_str) = local_storage.get_item("theme")? { - if let Ok(theme) = theme_str.parse::() { - self.theme = theme; - } - } - - if let Some(word) = local_storage.get_item("word")? { - self.word = word.chars().collect(); - } else { - local_storage.set_item("word", &self.word.iter().collect::())?; - } - - if let Some(is_guessing_str) = local_storage.get_item("is_guessing")? { - if let Ok(is_guessing) = is_guessing_str.parse::() { - self.is_guessing = is_guessing; - } - } + fn rehydrate( + game_mode: GameMode, + word_list: WordList, + word_length: usize, + game_manager: Rc>, + ) -> Result { + let game_key = &format!( + "game|{}|{}|{}", + serde_json::to_string(&game_mode).unwrap(), + serde_json::to_string(&word_list).unwrap(), + word_length + ); - if let Some(is_winner_str) = local_storage.get_item("is_winner")? { - if let Ok(is_winner) = is_winner_str.parse::() { - self.is_winner = is_winner; - } - } + let mut game: Game = LocalStorage::get(game_key)?; + game.game_manager = game_manager; - if let Some(guesses_str) = local_storage.get_item("guesses")? { - let previous_guesses = guesses_str - .split(',') - .map(|guess| guess.chars().map(|c| (c, TileState::Unknown)).collect()); + game.known_states = std::iter::repeat(HashMap::new()) + .take(game.max_guesses) + .collect::>(); - for (guess_index, guess) in previous_guesses.enumerate() { - self.guesses[guess_index] = guess; - self.current_guess = guess_index; - self.submit_current_guess(); - } - } + game.discovered_counts = std::iter::repeat(HashMap::new()) + .take(game.max_guesses) + .collect::>(); - if let Some(current_guess_str) = local_storage.get_item("current_guess")? { - if let Ok(current_guess) = current_guess_str.parse::() { - self.current_guess = current_guess; - } - } + let current_guess = game.current_guess; + // Rerrun the game to repuplate known_states and discovered_counts + for guess_index in 0..game.current_guess { + game.current_guess = guess_index; + game.calculate_current_guess(); } - Ok(()) - } - - pub fn rehydrate(&mut self) -> Result<(), JsValue> { - let window: Window = window().expect("window not available"); - if let Some(local_storage) = window.local_storage().expect("local storage not available") { - // Common state - if let Some(game_mode_str) = local_storage.get_item("game_mode")? { - if let Ok(new_mode) = game_mode_str.parse::() { - self.previous_game_mode = mem::replace(&mut self.game_mode, new_mode); - } - } - - if let Some(daily_word_history_str) = local_storage.get_item("daily_word_history")? { - if daily_word_history_str.len() != 0 { - daily_word_history_str.split(',').for_each(|date_str| { - let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d").unwrap(); - let daily_item = local_storage - .get_item(&format!("daily_word_history[{}]", date_str)) - .unwrap(); - if let Some(daily_str) = daily_item { - let parts = daily_str.split('|').collect::>(); - - // AIVAN|2022-01-07|KOIRA,AVAIN,AIVAN,,,|2|true|true - let word = parts[0]; - let guesses = parts[2] - .split(',') - .map(|guess| guess.chars().collect::>()) - .collect::>(); - let current_guess = parts[3].parse::().unwrap(); - let is_guessing = parts[4].parse::().unwrap(); - let is_winner = parts[5].parse::().unwrap(); - - let history = DailyWordHistory { - word: word.to_string(), - date, - guesses: guesses, - current_guess: current_guess, - is_guessing: is_guessing, - is_winner: is_winner, - }; - - self.daily_word_history.insert(date, history); - } - }); - } - } - - if let Some(message_str) = local_storage.get_item("message")? { - self.message = message_str; - } - - // Stats - if let Some(streak_str) = local_storage.get_item("streak")? { - if let Ok(streak) = streak_str.parse::() { - self.streak = streak; - } - } - - if let Some(max_streak_str) = local_storage.get_item("max_streak")? { - if let Ok(max_streak) = max_streak_str.parse::() { - self.max_streak = max_streak; - } - } + // Restore the current guess + game.current_guess = current_guess; - if let Some(total_played_str) = local_storage.get_item("total_played")? { - if let Ok(total_played) = total_played_str.parse::() { - self.total_played = total_played; - } - } - - if let Some(total_solved_str) = local_storage.get_item("total_solved")? { - if let Ok(total_solved) = total_solved_str.parse::() { - self.total_solved = total_solved; - } - } - - // Gamemode specific - match self.game_mode { - GameMode::DailyWord => { - self.rehydrate_daily_word(); - } - GameMode::Classic | GameMode::Relay => { - self.rehydrate_game()?; - } - } + // If the game is ended also recalculate the current guess + if !game.is_guessing { + game.calculate_current_guess(); } - Ok(()) + Ok(game) } } diff --git a/static/styles.css b/static/styles.css index 58de3b1..917ecc1 100644 --- a/static/styles.css +++ b/static/styles.css @@ -11,6 +11,7 @@ --slide-offset-3: 202.5px; --slide-offset-4: 269.5px; --slide-offset-5: 337.5px; + --slide-offset-6: 404.5px; font-family: 'Clear Sans', 'Helvetica Neue', Arial, sans-serif; } @@ -336,20 +337,24 @@ header { } } -.fade-in { - animation-name: slideInAnimation-1; - animation-iteration-count: 1; - animation-fill-mode: forwards; - animation-timing-function: ease; - animation-duration: 1s; +@keyframes slideInAnimation-6 { + 0% { + transform : translateY(var(--slide-offset-6)); + } + 100% { + transform : translateY(0px); + } } -.fade-out { - animation-name: slideOutAnimation-1; - animation-iteration-count: 1; - animation-fill-mode: forwards; - animation-timing-function: ease; - animation-duration: 1s; +@keyframes slideOutAnimation-6 { + 0% { + transform : translateY(var(--slide-offset-6)); + opacity: 1; + } + 100% { + transform : translateY(0px); + opacity: 0; + } } .slide-out { @@ -379,6 +384,11 @@ header { top: calc(-1 * var(--slide-offset-5)); animation-name: slideOutAnimation-5; } +.slide-out-6 { + top: calc(-1 * var(--slide-offset-6)); + animation-name: slideOutAnimation-6; + animation-duration: 1.2s; +} .slide-in { animation-iteration-count: 1; @@ -401,6 +411,10 @@ header { .slide-in-5 { animation-name: slideInAnimation-5; } +.slide-in-6 { + animation-name: slideInAnimation-6; + animation-duration: 1.2s; +} @media (max-width:375px) { .board-container { @@ -419,6 +433,7 @@ header { --slide-offset-3: 158.5px; --slide-offset-4: 211.5px; --slide-offset-5: 264.5px; + --slide-offset-6: 317.5px; } }