+2 -2

.prettierignore

··· 1 1 frontend/dist 2 2 frontend/node_modules 3 3 frontend/package-lock.json 4 4 - backend/gen 5 5 - backend/target 4 4 + manhunt-app/gen 5 5 + manhunt-app/target 6 6 result 7 7 .prettiercache

+1 -1

Cargo.toml

··· 1 1 [workspace] 2 2 - members = ["backend", "manhunt-logic", "manhunt-signaling", "manhunt-transport"] 2 2 + members = ["manhunt-app", "manhunt-logic", "manhunt-signaling", "manhunt-transport"] 3 3 resolver = "3" 4 4 5 5 [profile.release]

+2 -2

README.md

··· 64 64 Game and lobby logic for the app 65 65 - [manhunt-transport/](https://github.com/Bwc9876/manhunt-app/tree/main/manhunt-transport): 66 66 Transport (networking) implementation for communication between apps 67 67 - - [backend/](https://github.com/Bwc9876/manhunt-app/tree/main/backend): App 67 67 + - [manhunt-app/](https://github.com/Bwc9876/manhunt-app/tree/main/manhunt-app): App 68 68 backend, Rust side of the Tauri application 69 69 - [frontend/](https://github.com/Bwc9876/manhunt-app/tree/main/frontend): App 70 70 frontend, Web side of the Tauri application ··· 83 83 - `just check-frontend`: Check for potential issues on the frontend 84 84 (only need to run if you edited the frontend) 85 85 86 86 - **Important**: When changing any type in `backend` that derives `specta::Type`, 86 86 + **Important**: When changing any type in a rust file that derives `specta::Type`, 87 87 you need to run `just export-types` to sync these type bindings to the frontend. 88 88 Otherwise the TypeScript definitions will not match the ones that the backend expects. 89 89

backend/.gitignore manhunt-app/.gitignore

backend/Cargo.toml manhunt-app/Cargo.toml

backend/build.rs manhunt-app/build.rs

backend/capabilities/default.json manhunt-app/capabilities/default.json

backend/gen/android/.editorconfig manhunt-app/gen/android/.editorconfig

backend/gen/android/.gitignore manhunt-app/gen/android/.gitignore

backend/gen/android/app/.gitignore manhunt-app/gen/android/app/.gitignore

backend/gen/android/app/build.gradle.kts manhunt-app/gen/android/app/build.gradle.kts

backend/gen/android/app/proguard-rules.pro manhunt-app/gen/android/app/proguard-rules.pro

backend/gen/android/app/src/main/AndroidManifest.xml manhunt-app/gen/android/app/src/main/AndroidManifest.xml

backend/gen/android/app/src/main/java/com/bwc9876/manhunt/app/MainActivity.kt manhunt-app/gen/android/app/src/main/java/com/bwc9876/manhunt/app/MainActivity.kt

backend/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml manhunt-app/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

backend/gen/android/app/src/main/res/drawable/ic_launcher_background.xml manhunt-app/gen/android/app/src/main/res/drawable/ic_launcher_background.xml

backend/gen/android/app/src/main/res/layout/activity_main.xml manhunt-app/gen/android/app/src/main/res/layout/activity_main.xml

backend/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher.png manhunt-app/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher.png

backend/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png manhunt-app/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png

backend/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png manhunt-app/gen/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png

backend/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher.png manhunt-app/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher.png

backend/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png manhunt-app/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png

backend/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png manhunt-app/gen/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png

backend/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png manhunt-app/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png

backend/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png manhunt-app/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png

backend/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png manhunt-app/gen/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png

backend/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png manhunt-app/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png

backend/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png manhunt-app/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png

backend/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png manhunt-app/gen/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png

backend/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png manhunt-app/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png

backend/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png manhunt-app/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png

backend/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png manhunt-app/gen/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png

backend/gen/android/app/src/main/res/values-night/themes.xml manhunt-app/gen/android/app/src/main/res/values-night/themes.xml

backend/gen/android/app/src/main/res/values/colors.xml manhunt-app/gen/android/app/src/main/res/values/colors.xml

backend/gen/android/app/src/main/res/values/strings.xml manhunt-app/gen/android/app/src/main/res/values/strings.xml

backend/gen/android/app/src/main/res/values/themes.xml manhunt-app/gen/android/app/src/main/res/values/themes.xml

backend/gen/android/app/src/main/res/xml/file_paths.xml manhunt-app/gen/android/app/src/main/res/xml/file_paths.xml

backend/gen/android/build.gradle.kts manhunt-app/gen/android/build.gradle.kts

backend/gen/android/buildSrc/build.gradle.kts manhunt-app/gen/android/buildSrc/build.gradle.kts

backend/gen/android/buildSrc/src/main/java/com/bwc9876/manhunt/app/kotlin/BuildTask.kt manhunt-app/gen/android/buildSrc/src/main/java/com/bwc9876/manhunt/app/kotlin/BuildTask.kt

backend/gen/android/buildSrc/src/main/java/com/bwc9876/manhunt/app/kotlin/RustPlugin.kt manhunt-app/gen/android/buildSrc/src/main/java/com/bwc9876/manhunt/app/kotlin/RustPlugin.kt

backend/gen/android/gradle.properties manhunt-app/gen/android/gradle.properties

backend/gen/android/gradle/wrapper/gradle-wrapper.jar manhunt-app/gen/android/gradle/wrapper/gradle-wrapper.jar

backend/gen/android/gradle/wrapper/gradle-wrapper.properties manhunt-app/gen/android/gradle/wrapper/gradle-wrapper.properties

backend/gen/android/gradlew manhunt-app/gen/android/gradlew

backend/gen/android/gradlew.bat manhunt-app/gen/android/gradlew.bat

backend/gen/android/settings.gradle manhunt-app/gen/android/settings.gradle

backend/icons/128x128.png manhunt-app/icons/128x128.png

backend/icons/128x128@2x.png manhunt-app/icons/128x128@2x.png

backend/icons/32x32.png manhunt-app/icons/32x32.png

backend/icons/Square107x107Logo.png manhunt-app/icons/Square107x107Logo.png

backend/icons/Square142x142Logo.png manhunt-app/icons/Square142x142Logo.png

backend/icons/Square150x150Logo.png manhunt-app/icons/Square150x150Logo.png

backend/icons/Square284x284Logo.png manhunt-app/icons/Square284x284Logo.png

backend/icons/Square30x30Logo.png manhunt-app/icons/Square30x30Logo.png

backend/icons/Square310x310Logo.png manhunt-app/icons/Square310x310Logo.png

backend/icons/Square44x44Logo.png manhunt-app/icons/Square44x44Logo.png

backend/icons/Square71x71Logo.png manhunt-app/icons/Square71x71Logo.png

backend/icons/Square89x89Logo.png manhunt-app/icons/Square89x89Logo.png

backend/icons/StoreLogo.png manhunt-app/icons/StoreLogo.png

backend/icons/icon.icns manhunt-app/icons/icon.icns

backend/icons/icon.ico manhunt-app/icons/icon.ico

backend/icons/icon.png manhunt-app/icons/icon.png

backend/src/export_types.rs manhunt-app/src/export_types.rs

+12 -3

backend/src/history.rs manhunt-app/src/history.rs

··· 5 5 use tauri_plugin_store::{Store, StoreExt}; 6 6 use uuid::Uuid; 7 7 8 8 - use manhunt_logic::{GameHistory, PlayerProfile}; 8 8 + use manhunt_logic::{GameHistory, GameSettings, PlayerProfile}; 9 9 10 10 use crate::UtcDT; 11 11 ··· 15 15 pub struct AppGameHistory { 16 16 history: GameHistory, 17 17 profiles: HashMap<Uuid, PlayerProfile>, 18 18 + settings: GameSettings, 18 19 } 19 20 20 21 impl AppGameHistory { 21 21 - pub fn new(history: GameHistory, profiles: HashMap<Uuid, PlayerProfile>) -> Self { 22 22 - Self { history, profiles } 22 22 + pub fn new( 23 23 + history: GameHistory, 24 24 + profiles: HashMap<Uuid, PlayerProfile>, 25 25 + settings: GameSettings, 26 26 + ) -> Self { 27 27 + Self { 28 28 + history, 29 29 + profiles, 30 30 + settings, 31 31 + } 23 32 } 24 33 25 34 fn get_store<R: Runtime>(app: &AppHandle<R>) -> Result<Arc<Store<R>>> {

-578

backend/src/lib.rs

··· 1 1 - mod history; 2 2 - mod location; 3 3 - mod profiles; 4 4 - 5 5 - use std::{collections::HashMap, marker::PhantomData, sync::Arc, time::Duration}; 6 6 - 7 7 - use anyhow::Context; 8 8 - use location::TauriLocation; 9 9 - use log::{LevelFilter, error, info, warn}; 10 10 - use manhunt_logic::{ 11 11 - Game as BaseGame, GameSettings, GameUiState, Lobby as BaseLobby, LobbyState, PlayerProfile, 12 12 - StartGameInfo, StateUpdateSender, 13 13 - }; 14 14 - use manhunt_transport::{MatchboxTransport, request_room_code, room_exists}; 15 15 - use serde::{Deserialize, Serialize}; 16 16 - use tauri::{AppHandle, Manager, State}; 17 17 - use tauri_plugin_dialog::{DialogExt, MessageDialogKind}; 18 18 - use tauri_specta::{ErrorHandlingMode, Event, collect_commands, collect_events}; 19 19 - use tokio::sync::RwLock; 20 20 - use uuid::Uuid; 21 21 - 22 22 - type UtcDT = chrono::DateTime<chrono::Utc>; 23 23 - 24 24 - /// The state of the game has changed 25 25 - #[derive(Serialize, Deserialize, Clone, Default, Debug, specta::Type, tauri_specta::Event)] 26 26 - struct GameStateUpdate; 27 27 - 28 28 - /// The state of the lobby has changed 29 29 - #[derive(Serialize, Deserialize, Clone, Default, Debug, specta::Type, tauri_specta::Event)] 30 30 - struct LobbyStateUpdate; 31 31 - 32 32 - struct TauriStateUpdateSender<E: Clone + Default + Event + Serialize>(AppHandle, PhantomData<E>); 33 33 - 34 34 - impl<E: Serialize + Clone + Default + Event> TauriStateUpdateSender<E> { 35 35 - fn new(app: &AppHandle) -> Self { 36 36 - Self(app.clone(), PhantomData) 37 37 - } 38 38 - } 39 39 - 40 40 - impl<E: Serialize + Clone + Default + Event> StateUpdateSender for TauriStateUpdateSender<E> { 41 41 - fn send_update(&self) { 42 42 - if let Err(why) = E::default().emit(&self.0) { 43 43 - error!("Error sending Game state update to UI: {why:?}"); 44 44 - } 45 45 - } 46 46 - } 47 47 - 48 48 - type Game = BaseGame<TauriLocation, MatchboxTransport, TauriStateUpdateSender<GameStateUpdate>>; 49 49 - type Lobby = BaseLobby<MatchboxTransport, TauriStateUpdateSender<LobbyStateUpdate>>; 50 50 - 51 51 - enum AppState { 52 52 - Setup, 53 53 - Menu(PlayerProfile), 54 54 - Lobby(Arc<Lobby>), 55 55 - Game(Arc<Game>, HashMap<Uuid, PlayerProfile>), 56 56 - Replay(AppGameHistory), 57 57 - } 58 58 - 59 59 - #[derive(Serialize, Deserialize, specta::Type, Debug, Clone, Eq, PartialEq)] 60 60 - enum AppScreen { 61 61 - Setup, 62 62 - Menu, 63 63 - Lobby, 64 64 - Game, 65 65 - Replay, 66 66 - } 67 67 - 68 68 - type AppStateHandle = RwLock<AppState>; 69 69 - 70 70 - const GAME_TICK_RATE: Duration = Duration::from_secs(1); 71 71 - 72 72 - /// The app is changing screens, contains the screen it's switching to 73 73 - #[derive(Serialize, Deserialize, Clone, Debug, specta::Type, tauri_specta::Event)] 74 74 - struct ChangeScreen(AppScreen); 75 75 - 76 76 - fn error_dialog(app: &AppHandle, msg: &str) { 77 77 - app.dialog() 78 78 - .message(msg) 79 79 - .kind(MessageDialogKind::Error) 80 80 - .show(|_| {}); 81 81 - } 82 82 - 83 83 - impl AppState { 84 84 - pub async fn start_game(&mut self, app: AppHandle, start: StartGameInfo) { 85 85 - if let AppState::Lobby(lobby) = self { 86 86 - let transport = lobby.clone_transport(); 87 87 - let profiles = lobby.clone_profiles().await; 88 88 - let location = TauriLocation::new(app.clone()); 89 89 - let state_updates = TauriStateUpdateSender::new(&app); 90 90 - let game = Arc::new(Game::new( 91 91 - GAME_TICK_RATE, 92 92 - start, 93 93 - transport, 94 94 - location, 95 95 - state_updates, 96 96 - )); 97 97 - *self = AppState::Game(game.clone(), profiles.clone()); 98 98 - Self::game_loop(app.clone(), game, profiles); 99 99 - Self::emit_screen_change(&app, AppScreen::Game); 100 100 - } 101 101 - } 102 102 - 103 103 - fn game_loop(app: AppHandle, game: Arc<Game>, profiles: HashMap<Uuid, PlayerProfile>) { 104 104 - tokio::spawn(async move { 105 105 - let res = game.main_loop().await; 106 106 - let state_handle = app.state::<AppStateHandle>(); 107 107 - let mut state = state_handle.write().await; 108 108 - match res { 109 109 - Ok(Some(history)) => { 110 110 - let history = AppGameHistory::new(history, profiles); 111 111 - if let Err(why) = history.save_history(&app) { 112 112 - error!("Failed to save game history: {why:?}"); 113 113 - error_dialog(&app, "Failed to save the history of this game"); 114 114 - } 115 115 - state.quit_to_menu(app.clone()).await; 116 116 - } 117 117 - Ok(None) => { 118 118 - info!("User quit game"); 119 119 - } 120 120 - Err(why) => { 121 121 - error!("Game Error: {why:?}"); 122 122 - app.dialog() 123 123 - .message(format!("Connection Error: {why}")) 124 124 - .kind(MessageDialogKind::Error) 125 125 - .show(|_| {}); 126 126 - state.quit_to_menu(app.clone()).await; 127 127 - } 128 128 - } 129 129 - }); 130 130 - } 131 131 - 132 132 - pub fn get_menu(&self) -> Result<&PlayerProfile> { 133 133 - match self { 134 134 - AppState::Menu(player_profile) => Ok(player_profile), 135 135 - _ => Err("Not on menu screen".to_string()), 136 136 - } 137 137 - } 138 138 - 139 139 - pub fn get_menu_mut(&mut self) -> Result<&mut PlayerProfile> { 140 140 - match self { 141 141 - AppState::Menu(player_profile) => Ok(player_profile), 142 142 - _ => Err("Not on menu screen".to_string()), 143 143 - } 144 144 - } 145 145 - 146 146 - pub fn get_lobby(&self) -> Result<Arc<Lobby>> { 147 147 - if let AppState::Lobby(lobby) = self { 148 148 - Ok(lobby.clone()) 149 149 - } else { 150 150 - Err("Not on lobby screen".to_string()) 151 151 - } 152 152 - } 153 153 - 154 154 - pub fn get_game(&self) -> Result<Arc<Game>> { 155 155 - if let AppState::Game(game, _) = self { 156 156 - Ok(game.clone()) 157 157 - } else { 158 158 - Err("Not on game screen".to_string()) 159 159 - } 160 160 - } 161 161 - 162 162 - pub fn get_profiles(&self) -> Result<&HashMap<Uuid, PlayerProfile>> { 163 163 - if let AppState::Game(_, profiles) = self { 164 164 - Ok(profiles) 165 165 - } else { 166 166 - Err("Not on game screen".to_string()) 167 167 - } 168 168 - } 169 169 - 170 170 - pub fn get_replay(&self) -> Result<AppGameHistory> { 171 171 - if let AppState::Replay(history) = self { 172 172 - Ok(history.clone()) 173 173 - } else { 174 174 - Err("Not on replay screen".to_string()) 175 175 - } 176 176 - } 177 177 - 178 178 - fn emit_screen_change(app: &AppHandle, screen: AppScreen) { 179 179 - if let Err(why) = ChangeScreen(screen).emit(app) { 180 180 - warn!("Error emitting screen change: {why:?}"); 181 181 - } 182 182 - } 183 183 - 184 184 - pub fn complete_setup(&mut self, app: &AppHandle, profile: PlayerProfile) -> Result { 185 185 - if let AppState::Setup = self { 186 186 - write_profile_to_store(app, profile.clone()); 187 187 - *self = AppState::Menu(profile); 188 188 - Self::emit_screen_change(app, AppScreen::Menu); 189 189 - Ok(()) 190 190 - } else { 191 191 - Err("Must be on the Setup screen".to_string()) 192 192 - } 193 193 - } 194 194 - 195 195 - pub fn replay_game(&mut self, app: &AppHandle, id: UtcDT) -> Result { 196 196 - if let AppState::Menu(_) = self { 197 197 - let history = AppGameHistory::get_history(app, id) 198 198 - .context("Failed to read history") 199 199 - .map_err(|e| e.to_string())?; 200 200 - *self = AppState::Replay(history); 201 201 - Self::emit_screen_change(app, AppScreen::Replay); 202 202 - Ok(()) 203 203 - } else { 204 204 - Err("Not on menu screen".to_string()) 205 205 - } 206 206 - } 207 207 - 208 208 - fn lobby_loop(app: AppHandle, lobby: Arc<Lobby>) { 209 209 - tokio::spawn(async move { 210 210 - let res = lobby.main_loop().await; 211 211 - let app_game = app.clone(); 212 212 - let state_handle = app.state::<AppStateHandle>(); 213 213 - let mut state = state_handle.write().await; 214 214 - match res { 215 215 - Ok(Some(start)) => { 216 216 - info!("Starting Game"); 217 217 - state.start_game(app_game, start).await; 218 218 - } 219 219 - Ok(None) => { 220 220 - info!("User quit lobby"); 221 221 - } 222 222 - Err(why) => { 223 223 - error!("Lobby Error: {why}"); 224 224 - error_dialog(&app_game, &format!("Error joining the lobby: {why}")); 225 225 - state.quit_to_menu(app_game).await; 226 226 - } 227 227 - } 228 228 - }); 229 229 - } 230 230 - 231 231 - pub async fn start_lobby( 232 232 - &mut self, 233 233 - join_code: Option<String>, 234 234 - app: AppHandle, 235 235 - settings: GameSettings, 236 236 - ) { 237 237 - if let AppState::Menu(profile) = self { 238 238 - let host = join_code.is_none(); 239 239 - let room_code = if let Some(code) = join_code { 240 240 - code.to_ascii_uppercase() 241 241 - } else { 242 242 - match request_room_code().await { 243 243 - Ok(code) => code, 244 244 - Err(why) => { 245 245 - error_dialog(&app, &format!("Couldn't create a lobby\n\n{why:?}")); 246 246 - return; 247 247 - } 248 248 - } 249 249 - }; 250 250 - let state_updates = TauriStateUpdateSender::<LobbyStateUpdate>::new(&app); 251 251 - let lobby = 252 252 - Lobby::new(&room_code, host, profile.clone(), settings, state_updates).await; 253 253 - match lobby { 254 254 - Ok(lobby) => { 255 255 - *self = AppState::Lobby(lobby.clone()); 256 256 - Self::lobby_loop(app.clone(), lobby); 257 257 - Self::emit_screen_change(&app, AppScreen::Lobby); 258 258 - } 259 259 - Err(why) => { 260 260 - error_dialog( 261 261 - &app, 262 262 - &format!("Couldn't connect you to the lobby\n\n{why:?}"), 263 263 - ); 264 264 - } 265 265 - } 266 266 - } 267 267 - } 268 268 - 269 269 - pub async fn quit_to_menu(&mut self, app: AppHandle) { 270 270 - let profile = match self { 271 271 - AppState::Setup => None, 272 272 - AppState::Menu(_) => { 273 273 - warn!("Already on menu!"); 274 274 - return; 275 275 - } 276 276 - AppState::Lobby(lobby) => { 277 277 - lobby.quit_lobby().await; 278 278 - read_profile_from_store(&app) 279 279 - } 280 280 - AppState::Game(game, _) => { 281 281 - game.quit_game().await; 282 282 - read_profile_from_store(&app) 283 283 - } 284 284 - AppState::Replay(_) => read_profile_from_store(&app), 285 285 - }; 286 286 - let screen = if let Some(profile) = profile { 287 287 - *self = AppState::Menu(profile); 288 288 - AppScreen::Menu 289 289 - } else { 290 290 - *self = AppState::Setup; 291 291 - AppScreen::Setup 292 292 - }; 293 293 - 294 294 - Self::emit_screen_change(&app, screen); 295 295 - } 296 296 - } 297 297 - 298 298 - use std::result::Result as StdResult; 299 299 - 300 300 - use crate::{ 301 301 - history::AppGameHistory, 302 302 - profiles::{read_profile_from_store, write_profile_to_store}, 303 303 - }; 304 304 - 305 305 - type Result<T = (), E = String> = StdResult<T, E>; 306 306 - 307 307 - // == GENERAL / FLOW COMMANDS == 308 308 - 309 309 - #[tauri::command] 310 310 - #[specta::specta] 311 311 - /// Get the screen the app should currently be on, returns [AppScreen] 312 312 - async fn get_current_screen(state: State<'_, AppStateHandle>) -> Result<AppScreen> { 313 313 - let state = state.read().await; 314 314 - Ok(match &*state { 315 315 - AppState::Setup => AppScreen::Setup, 316 316 - AppState::Menu(_player_profile) => AppScreen::Menu, 317 317 - AppState::Lobby(_lobby) => AppScreen::Lobby, 318 318 - AppState::Game(_game, _profiles) => AppScreen::Game, 319 319 - AppState::Replay(_) => AppScreen::Replay, 320 320 - }) 321 321 - } 322 322 - 323 323 - #[tauri::command] 324 324 - #[specta::specta] 325 325 - /// Quit a running game or leave a lobby 326 326 - async fn quit_to_menu(app: AppHandle, state: State<'_, AppStateHandle>) -> Result { 327 327 - let mut state = state.write().await; 328 328 - state.quit_to_menu(app).await; 329 329 - Ok(()) 330 330 - } 331 331 - 332 332 - // == AppState::Setup COMMANDS 333 333 - 334 334 - #[tauri::command] 335 335 - #[specta::specta] 336 336 - /// (Screen: Setup) Complete user setup and go to the menu screen 337 337 - async fn complete_setup( 338 338 - profile: PlayerProfile, 339 339 - app: AppHandle, 340 340 - state: State<'_, AppStateHandle>, 341 341 - ) -> Result { 342 342 - state.write().await.complete_setup(&app, profile) 343 343 - } 344 344 - 345 345 - // == AppState::Menu COMMANDS == 346 346 - 347 347 - #[tauri::command] 348 348 - #[specta::specta] 349 349 - /// (Screen: Menu) Get the user's player profile 350 350 - async fn get_profile(state: State<'_, AppStateHandle>) -> Result<PlayerProfile> { 351 351 - let state = state.read().await; 352 352 - let profile = state.get_menu()?; 353 353 - Ok(profile.clone()) 354 354 - } 355 355 - 356 356 - #[tauri::command] 357 357 - #[specta::specta] 358 358 - /// (Screen: Menu) Get a list of all previously played games, returns of list of DateTimes that represent when 359 359 - /// each game started, use this as a key 360 360 - fn list_game_histories(app: AppHandle) -> Result<Vec<UtcDT>> { 361 361 - AppGameHistory::ls_histories(&app) 362 362 - .map_err(|err| err.context("Failed to get game histories").to_string()) 363 363 - } 364 364 - 365 365 - #[tauri::command] 366 366 - #[specta::specta] 367 367 - /// (Screen: Menu) Go to the game replay screen to replay the game history specified by id 368 368 - async fn replay_game(id: UtcDT, app: AppHandle, state: State<'_, AppStateHandle>) -> Result { 369 369 - state.write().await.replay_game(&app, id) 370 370 - } 371 371 - 372 372 - #[tauri::command] 373 373 - #[specta::specta] 374 374 - /// (Screen: Menu) Check if a room code is valid to join, use this before starting a game 375 375 - /// for faster error checking. 376 376 - async fn check_room_code(code: &str) -> Result<bool> { 377 377 - room_exists(code).await.map_err(|err| err.to_string()) 378 378 - } 379 379 - 380 380 - #[tauri::command] 381 381 - #[specta::specta] 382 382 - /// (Screen: Menu) Update the player's profile and persist it 383 383 - async fn update_profile( 384 384 - new_profile: PlayerProfile, 385 385 - app: AppHandle, 386 386 - state: State<'_, AppStateHandle>, 387 387 - ) -> Result { 388 388 - write_profile_to_store(&app, new_profile.clone()); 389 389 - let mut state = state.write().await; 390 390 - let profile = state.get_menu_mut()?; 391 391 - *profile = new_profile; 392 392 - Ok(()) 393 393 - } 394 394 - 395 395 - #[tauri::command] 396 396 - #[specta::specta] 397 397 - /// (Screen: Menu) Start/Join a new lobby, set `join_code` to `null` to be host, 398 398 - /// set it to a join code to be a client. This triggers a screen change to [AppScreen::Lobby] 399 399 - async fn start_lobby( 400 400 - app: AppHandle, 401 401 - join_code: Option<String>, 402 402 - settings: GameSettings, 403 403 - state: State<'_, AppStateHandle>, 404 404 - ) -> Result { 405 405 - let mut state = state.write().await; 406 406 - state.start_lobby(join_code, app, settings).await; 407 407 - Ok(()) 408 408 - } 409 409 - 410 410 - // AppState::Lobby COMMANDS 411 411 - 412 412 - #[tauri::command] 413 413 - #[specta::specta] 414 414 - /// (Screen: Lobby) Get the current state of the lobby, call after receiving an update event 415 415 - async fn get_lobby_state(state: State<'_, AppStateHandle>) -> Result<LobbyState> { 416 416 - let lobby = state.read().await.get_lobby()?; 417 417 - Ok(lobby.clone_state().await) 418 418 - } 419 419 - 420 420 - #[tauri::command] 421 421 - #[specta::specta] 422 422 - /// (Screen: Lobby) Switch teams between seekers and hiders, returns the new [LobbyState] 423 423 - async fn switch_teams(seeker: bool, state: State<'_, AppStateHandle>) -> Result { 424 424 - let lobby = state.read().await.get_lobby()?; 425 425 - lobby.switch_teams(seeker).await; 426 426 - Ok(()) 427 427 - } 428 428 - 429 429 - #[tauri::command] 430 430 - #[specta::specta] 431 431 - /// (Screen: Lobby) HOST ONLY: Push new settings to everyone, does nothing on clients. Returns the 432 432 - /// new lobby state 433 433 - async fn host_update_settings(settings: GameSettings, state: State<'_, AppStateHandle>) -> Result { 434 434 - let lobby = state.read().await.get_lobby()?; 435 435 - lobby.update_settings(settings).await; 436 436 - Ok(()) 437 437 - } 438 438 - 439 439 - #[tauri::command] 440 440 - #[specta::specta] 441 441 - /// (Screen: Lobby) HOST ONLY: Start the game, stops anyone else from joining and switched screen 442 442 - /// to AppScreen::Game. 443 443 - async fn host_start_game(state: State<'_, AppStateHandle>) -> Result { 444 444 - state.read().await.get_lobby()?.start_game().await; 445 445 - Ok(()) 446 446 - } 447 447 - 448 448 - // AppScreen::Game COMMANDS 449 449 - 450 450 - #[tauri::command] 451 451 - #[specta::specta] 452 452 - /// (Screen: Game) Get all player profiles with display names and profile pictures for this game. 453 453 - /// This value will never change and is fairly expensive to clone, so please minimize calls to 454 454 - /// this command. 455 455 - async fn get_profiles(state: State<'_, AppStateHandle>) -> Result<HashMap<Uuid, PlayerProfile>> { 456 456 - state.read().await.get_profiles().cloned() 457 457 - } 458 458 - 459 459 - #[tauri::command] 460 460 - #[specta::specta] 461 461 - /// (Screen: Game) Get the current settings for this game. 462 462 - async fn get_game_settings(state: State<'_, AppStateHandle>) -> Result<GameSettings> { 463 463 - Ok(state.read().await.get_game()?.clone_settings().await) 464 464 - } 465 465 - 466 466 - #[tauri::command] 467 467 - #[specta::specta] 468 468 - /// (Screen: Game) Get the current state of the game. 469 469 - async fn get_game_state(state: State<'_, AppStateHandle>) -> Result<GameUiState> { 470 470 - Ok(state.read().await.get_game()?.get_ui_state().await) 471 471 - } 472 472 - 473 473 - #[tauri::command] 474 474 - #[specta::specta] 475 475 - /// (Screen: Game) Mark this player as caught, this player will become a seeker. Returns the new game state 476 476 - async fn mark_caught(state: State<'_, AppStateHandle>) -> Result { 477 477 - let game = state.read().await.get_game()?; 478 478 - game.mark_caught().await; 479 479 - Ok(()) 480 480 - } 481 481 - 482 482 - #[tauri::command] 483 483 - #[specta::specta] 484 484 - /// (Screen: Game) Grab a powerup on the map, this should be called when the user is *in range* of 485 485 - /// the powerup. Returns the new game state after rolling for the powerup 486 486 - async fn grab_powerup(state: State<'_, AppStateHandle>) -> Result { 487 487 - let game = state.read().await.get_game()?; 488 488 - game.get_powerup().await; 489 489 - Ok(()) 490 490 - } 491 491 - 492 492 - #[tauri::command] 493 493 - #[specta::specta] 494 494 - /// (Screen: Game) Use the currently held powerup in the player's held_powerup. Does nothing if the 495 495 - /// player has none. Returns the updated game state 496 496 - async fn activate_powerup(state: State<'_, AppStateHandle>) -> Result { 497 497 - let game = state.read().await.get_game()?; 498 498 - game.use_powerup().await; 499 499 - Ok(()) 500 500 - } 501 501 - 502 502 - // AppState::Replay COMMANDS 503 503 - 504 504 - #[tauri::command] 505 505 - #[specta::specta] 506 506 - /// (Screen: Replay) Get the game history that's currently being replayed. Try to limit calls to 507 507 - /// this 508 508 - async fn get_current_replay_history(state: State<'_, AppStateHandle>) -> Result<AppGameHistory> { 509 509 - state.read().await.get_replay() 510 510 - } 511 511 - 512 512 - pub fn mk_specta() -> tauri_specta::Builder { 513 513 - tauri_specta::Builder::<tauri::Wry>::new() 514 514 - .error_handling(ErrorHandlingMode::Throw) 515 515 - .commands(collect_commands![ 516 516 - start_lobby, 517 517 - get_profile, 518 518 - quit_to_menu, 519 519 - get_current_screen, 520 520 - update_profile, 521 521 - get_lobby_state, 522 522 - host_update_settings, 523 523 - switch_teams, 524 524 - host_start_game, 525 525 - mark_caught, 526 526 - grab_powerup, 527 527 - activate_powerup, 528 528 - check_room_code, 529 529 - get_profiles, 530 530 - replay_game, 531 531 - list_game_histories, 532 532 - get_current_replay_history, 533 533 - get_game_settings, 534 534 - get_game_state, 535 535 - complete_setup, 536 536 - ]) 537 537 - .events(collect_events![ 538 538 - ChangeScreen, 539 539 - GameStateUpdate, 540 540 - LobbyStateUpdate 541 541 - ]) 542 542 - } 543 543 - 544 544 - #[cfg_attr(mobile, tauri::mobile_entry_point)] 545 545 - pub fn run() { 546 546 - let state = RwLock::new(AppState::Setup); 547 547 - 548 548 - let builder = mk_specta(); 549 549 - 550 550 - tauri::Builder::default() 551 551 - .plugin(tauri_plugin_dialog::init()) 552 552 - .plugin(tauri_plugin_notification::init()) 553 553 - .plugin( 554 554 - tauri_plugin_log::Builder::new() 555 555 - .level(LevelFilter::Debug) 556 556 - .build(), 557 557 - ) 558 558 - .plugin(tauri_plugin_opener::init()) 559 559 - .plugin(tauri_plugin_geolocation::init()) 560 560 - .plugin(tauri_plugin_store::Builder::default().build()) 561 561 - .invoke_handler(builder.invoke_handler()) 562 562 - .manage(state) 563 563 - .setup(move |app| { 564 564 - builder.mount_events(app); 565 565 - 566 566 - let handle = app.handle().clone(); 567 567 - tauri::async_runtime::spawn(async move { 568 568 - if let Some(profile) = read_profile_from_store(&handle) { 569 569 - let state_handle = handle.state::<AppStateHandle>(); 570 570 - let mut state = state_handle.write().await; 571 571 - *state = AppState::Menu(profile); 572 572 - } 573 573 - }); 574 574 - Ok(()) 575 575 - }) 576 576 - .run(tauri::generate_context!()) 577 577 - .expect("error while running tauri application"); 578 578 - }

backend/src/location.rs manhunt-app/src/location.rs

backend/src/main.rs manhunt-app/src/main.rs

backend/src/profiles.rs manhunt-app/src/profiles.rs

backend/tauri.conf.json manhunt-app/tauri.conf.json

+1

frontend/src/bindings.ts

··· 156 156 export type AppGameHistory = { 157 157 history: GameHistory; 158 158 profiles: Partial<{ [key in string]: PlayerProfile }>; 159 159 + settings: GameSettings; 159 160 }; 160 161 export type AppScreen = "Setup" | "Menu" | "Lobby" | "Game" | "Replay"; 161 162 /**

+2 -3

justfile

··· 37 37 npm run lint 38 38 39 39 # Export types from the backend to TypeScript bindings 40 40 - [working-directory('backend')] 41 40 export-types: 42 42 - cargo run --bin export-types ../frontend/src/bindings.ts 43 43 - prettier --write ../frontend/src/bindings.ts --config ../.prettierrc.yaml 41 41 + cargo run --bin export-types frontend/src/bindings.ts 42 42 + prettier --write frontend/src/bindings.ts --config .prettierrc.yaml 44 43 45 44 # Start the signaling server on localhost:3536 46 45 [working-directory('manhunt-signaling')]

+297

manhunt-app/src/lib.rs

··· 1 1 + mod history; 2 2 + mod location; 3 3 + mod profiles; 4 4 + mod state; 5 5 + 6 6 + use std::collections::HashMap; 7 7 + 8 8 + use log::LevelFilter; 9 9 + use manhunt_logic::{GameSettings, GameUiState, LobbyState, PlayerProfile, UtcDT}; 10 10 + use manhunt_transport::room_exists; 11 11 + use tauri::{AppHandle, Manager, State}; 12 12 + use tauri_specta::{ErrorHandlingMode, collect_commands, collect_events}; 13 13 + use tokio::sync::RwLock; 14 14 + use uuid::Uuid; 15 15 + 16 16 + use std::result::Result as StdResult; 17 17 + 18 18 + use crate::{ 19 19 + history::AppGameHistory, 20 20 + profiles::{read_profile_from_store, write_profile_to_store}, 21 21 + state::{AppScreen, AppState, AppStateHandle, ChangeScreen, GameStateUpdate, LobbyStateUpdate}, 22 22 + }; 23 23 + 24 24 + type Result<T = (), E = String> = StdResult<T, E>; 25 25 + 26 26 + // == GENERAL / FLOW COMMANDS == 27 27 + 28 28 + #[tauri::command] 29 29 + #[specta::specta] 30 30 + /// Get the screen the app should currently be on, returns [AppScreen] 31 31 + async fn get_current_screen(state: State<'_, AppStateHandle>) -> Result<AppScreen> { 32 32 + let state = state.read().await; 33 33 + Ok(match &*state { 34 34 + AppState::Setup => AppScreen::Setup, 35 35 + AppState::Menu(_player_profile) => AppScreen::Menu, 36 36 + AppState::Lobby(_lobby) => AppScreen::Lobby, 37 37 + AppState::Game(_game, _profiles) => AppScreen::Game, 38 38 + AppState::Replay(_) => AppScreen::Replay, 39 39 + }) 40 40 + } 41 41 + 42 42 + #[tauri::command] 43 43 + #[specta::specta] 44 44 + /// Quit a running game or leave a lobby 45 45 + async fn quit_to_menu(app: AppHandle, state: State<'_, AppStateHandle>) -> Result { 46 46 + let mut state = state.write().await; 47 47 + state.quit_to_menu(app).await; 48 48 + Ok(()) 49 49 + } 50 50 + 51 51 + // == AppState::Setup COMMANDS 52 52 + 53 53 + #[tauri::command] 54 54 + #[specta::specta] 55 55 + /// (Screen: Setup) Complete user setup and go to the menu screen 56 56 + async fn complete_setup( 57 57 + profile: PlayerProfile, 58 58 + app: AppHandle, 59 59 + state: State<'_, AppStateHandle>, 60 60 + ) -> Result { 61 61 + state.write().await.complete_setup(&app, profile) 62 62 + } 63 63 + 64 64 + // == AppState::Menu COMMANDS == 65 65 + 66 66 + #[tauri::command] 67 67 + #[specta::specta] 68 68 + /// (Screen: Menu) Get the user's player profile 69 69 + async fn get_profile(state: State<'_, AppStateHandle>) -> Result<PlayerProfile> { 70 70 + let state = state.read().await; 71 71 + let profile = state.get_menu()?; 72 72 + Ok(profile.clone()) 73 73 + } 74 74 + 75 75 + #[tauri::command] 76 76 + #[specta::specta] 77 77 + /// (Screen: Menu) Get a list of all previously played games, returns of list of DateTimes that represent when 78 78 + /// each game started, use this as a key 79 79 + fn list_game_histories(app: AppHandle) -> Result<Vec<UtcDT>> { 80 80 + AppGameHistory::ls_histories(&app) 81 81 + .map_err(|err| err.context("Failed to get game histories").to_string()) 82 82 + } 83 83 + 84 84 + #[tauri::command] 85 85 + #[specta::specta] 86 86 + /// (Screen: Menu) Go to the game replay screen to replay the game history specified by id 87 87 + async fn replay_game(id: UtcDT, app: AppHandle, state: State<'_, AppStateHandle>) -> Result { 88 88 + state.write().await.replay_game(&app, id) 89 89 + } 90 90 + 91 91 + #[tauri::command] 92 92 + #[specta::specta] 93 93 + /// (Screen: Menu) Check if a room code is valid to join, use this before starting a game 94 94 + /// for faster error checking. 95 95 + async fn check_room_code(code: &str) -> Result<bool> { 96 96 + room_exists(code).await.map_err(|err| err.to_string()) 97 97 + } 98 98 + 99 99 + #[tauri::command] 100 100 + #[specta::specta] 101 101 + /// (Screen: Menu) Update the player's profile and persist it 102 102 + async fn update_profile( 103 103 + new_profile: PlayerProfile, 104 104 + app: AppHandle, 105 105 + state: State<'_, AppStateHandle>, 106 106 + ) -> Result { 107 107 + write_profile_to_store(&app, new_profile.clone()); 108 108 + let mut state = state.write().await; 109 109 + let profile = state.get_menu_mut()?; 110 110 + *profile = new_profile; 111 111 + Ok(()) 112 112 + } 113 113 + 114 114 + #[tauri::command] 115 115 + #[specta::specta] 116 116 + /// (Screen: Menu) Start/Join a new lobby, set `join_code` to `null` to be host, 117 117 + /// set it to a join code to be a client. This triggers a screen change to [AppScreen::Lobby] 118 118 + async fn start_lobby( 119 119 + app: AppHandle, 120 120 + join_code: Option<String>, 121 121 + settings: GameSettings, 122 122 + state: State<'_, AppStateHandle>, 123 123 + ) -> Result { 124 124 + let mut state = state.write().await; 125 125 + state.start_lobby(join_code, app, settings).await; 126 126 + Ok(()) 127 127 + } 128 128 + 129 129 + // AppState::Lobby COMMANDS 130 130 + 131 131 + #[tauri::command] 132 132 + #[specta::specta] 133 133 + /// (Screen: Lobby) Get the current state of the lobby, call after receiving an update event 134 134 + async fn get_lobby_state(state: State<'_, AppStateHandle>) -> Result<LobbyState> { 135 135 + let lobby = state.read().await.get_lobby()?; 136 136 + Ok(lobby.clone_state().await) 137 137 + } 138 138 + 139 139 + #[tauri::command] 140 140 + #[specta::specta] 141 141 + /// (Screen: Lobby) Switch teams between seekers and hiders, returns the new [LobbyState] 142 142 + async fn switch_teams(seeker: bool, state: State<'_, AppStateHandle>) -> Result { 143 143 + let lobby = state.read().await.get_lobby()?; 144 144 + lobby.switch_teams(seeker).await; 145 145 + Ok(()) 146 146 + } 147 147 + 148 148 + #[tauri::command] 149 149 + #[specta::specta] 150 150 + /// (Screen: Lobby) HOST ONLY: Push new settings to everyone, does nothing on clients. Returns the 151 151 + /// new lobby state 152 152 + async fn host_update_settings(settings: GameSettings, state: State<'_, AppStateHandle>) -> Result { 153 153 + let lobby = state.read().await.get_lobby()?; 154 154 + lobby.update_settings(settings).await; 155 155 + Ok(()) 156 156 + } 157 157 + 158 158 + #[tauri::command] 159 159 + #[specta::specta] 160 160 + /// (Screen: Lobby) HOST ONLY: Start the game, stops anyone else from joining and switched screen 161 161 + /// to AppScreen::Game. 162 162 + async fn host_start_game(state: State<'_, AppStateHandle>) -> Result { 163 163 + state.read().await.get_lobby()?.start_game().await; 164 164 + Ok(()) 165 165 + } 166 166 + 167 167 + // AppScreen::Game COMMANDS 168 168 + 169 169 + #[tauri::command] 170 170 + #[specta::specta] 171 171 + /// (Screen: Game) Get all player profiles with display names and profile pictures for this game. 172 172 + /// This value will never change and is fairly expensive to clone, so please minimize calls to 173 173 + /// this command. 174 174 + async fn get_profiles(state: State<'_, AppStateHandle>) -> Result<HashMap<Uuid, PlayerProfile>> { 175 175 + state.read().await.get_profiles().cloned() 176 176 + } 177 177 + 178 178 + #[tauri::command] 179 179 + #[specta::specta] 180 180 + /// (Screen: Game) Get the current settings for this game. 181 181 + async fn get_game_settings(state: State<'_, AppStateHandle>) -> Result<GameSettings> { 182 182 + Ok(state.read().await.get_game()?.clone_settings().await) 183 183 + } 184 184 + 185 185 + #[tauri::command] 186 186 + #[specta::specta] 187 187 + /// (Screen: Game) Get the current state of the game. 188 188 + async fn get_game_state(state: State<'_, AppStateHandle>) -> Result<GameUiState> { 189 189 + Ok(state.read().await.get_game()?.get_ui_state().await) 190 190 + } 191 191 + 192 192 + #[tauri::command] 193 193 + #[specta::specta] 194 194 + /// (Screen: Game) Mark this player as caught, this player will become a seeker. Returns the new game state 195 195 + async fn mark_caught(state: State<'_, AppStateHandle>) -> Result { 196 196 + let game = state.read().await.get_game()?; 197 197 + game.mark_caught().await; 198 198 + Ok(()) 199 199 + } 200 200 + 201 201 + #[tauri::command] 202 202 + #[specta::specta] 203 203 + /// (Screen: Game) Grab a powerup on the map, this should be called when the user is *in range* of 204 204 + /// the powerup. Returns the new game state after rolling for the powerup 205 205 + async fn grab_powerup(state: State<'_, AppStateHandle>) -> Result { 206 206 + let game = state.read().await.get_game()?; 207 207 + game.get_powerup().await; 208 208 + Ok(()) 209 209 + } 210 210 + 211 211 + #[tauri::command] 212 212 + #[specta::specta] 213 213 + /// (Screen: Game) Use the currently held powerup in the player's held_powerup. Does nothing if the 214 214 + /// player has none. Returns the updated game state 215 215 + async fn activate_powerup(state: State<'_, AppStateHandle>) -> Result { 216 216 + let game = state.read().await.get_game()?; 217 217 + game.use_powerup().await; 218 218 + Ok(()) 219 219 + } 220 220 + 221 221 + // AppState::Replay COMMANDS 222 222 + 223 223 + #[tauri::command] 224 224 + #[specta::specta] 225 225 + /// (Screen: Replay) Get the game history that's currently being replayed. Try to limit calls to 226 226 + /// this 227 227 + async fn get_current_replay_history(state: State<'_, AppStateHandle>) -> Result<AppGameHistory> { 228 228 + state.read().await.get_replay() 229 229 + } 230 230 + 231 231 + pub fn mk_specta() -> tauri_specta::Builder { 232 232 + tauri_specta::Builder::<tauri::Wry>::new() 233 233 + .error_handling(ErrorHandlingMode::Throw) 234 234 + .commands(collect_commands![ 235 235 + start_lobby, 236 236 + get_profile, 237 237 + quit_to_menu, 238 238 + get_current_screen, 239 239 + update_profile, 240 240 + get_lobby_state, 241 241 + host_update_settings, 242 242 + switch_teams, 243 243 + host_start_game, 244 244 + mark_caught, 245 245 + grab_powerup, 246 246 + activate_powerup, 247 247 + check_room_code, 248 248 + get_profiles, 249 249 + replay_game, 250 250 + list_game_histories, 251 251 + get_current_replay_history, 252 252 + get_game_settings, 253 253 + get_game_state, 254 254 + complete_setup, 255 255 + ]) 256 256 + .events(collect_events![ 257 257 + ChangeScreen, 258 258 + GameStateUpdate, 259 259 + LobbyStateUpdate 260 260 + ]) 261 261 + } 262 262 + 263 263 + #[cfg_attr(mobile, tauri::mobile_entry_point)] 264 264 + pub fn run() { 265 265 + let state = RwLock::new(AppState::Setup); 266 266 + 267 267 + let builder = mk_specta(); 268 268 + 269 269 + tauri::Builder::default() 270 270 + .plugin(tauri_plugin_dialog::init()) 271 271 + .plugin(tauri_plugin_notification::init()) 272 272 + .plugin( 273 273 + tauri_plugin_log::Builder::new() 274 274 + .level(LevelFilter::Debug) 275 275 + .build(), 276 276 + ) 277 277 + .plugin(tauri_plugin_opener::init()) 278 278 + .plugin(tauri_plugin_geolocation::init()) 279 279 + .plugin(tauri_plugin_store::Builder::default().build()) 280 280 + .invoke_handler(builder.invoke_handler()) 281 281 + .manage(state) 282 282 + .setup(move |app| { 283 283 + builder.mount_events(app); 284 284 + 285 285 + let handle = app.handle().clone(); 286 286 + tauri::async_runtime::spawn(async move { 287 287 + if let Some(profile) = read_profile_from_store(&handle) { 288 288 + let state_handle = handle.state::<AppStateHandle>(); 289 289 + let mut state = state_handle.write().await; 290 290 + *state = AppState::Menu(profile); 291 291 + } 292 292 + }); 293 293 + Ok(()) 294 294 + }) 295 295 + .run(tauri::generate_context!()) 296 296 + .expect("error while running tauri application"); 297 297 + }

+300

manhunt-app/src/state.rs

··· 1 1 + use std::{collections::HashMap, marker::PhantomData, sync::Arc, time::Duration}; 2 2 + 3 3 + use anyhow::Context; 4 4 + use log::{error, info, warn}; 5 5 + use manhunt_logic::{ 6 6 + Game as BaseGame, GameSettings, Lobby as BaseLobby, PlayerProfile, StartGameInfo, 7 7 + StateUpdateSender, UtcDT, 8 8 + }; 9 9 + use manhunt_transport::{MatchboxTransport, request_room_code}; 10 10 + use serde::{Deserialize, Serialize}; 11 11 + use tauri::{AppHandle, Manager}; 12 12 + use tauri_plugin_dialog::{DialogExt, MessageDialogKind}; 13 13 + use tauri_specta::Event; 14 14 + use tokio::sync::RwLock; 15 15 + use uuid::Uuid; 16 16 + 17 17 + use crate::{ 18 18 + Result, 19 19 + history::AppGameHistory, 20 20 + location::TauriLocation, 21 21 + profiles::{read_profile_from_store, write_profile_to_store}, 22 22 + }; 23 23 + 24 24 + /// The state of the game has changed 25 25 + #[derive(Serialize, Deserialize, Clone, Default, Debug, specta::Type, tauri_specta::Event)] 26 26 + pub struct GameStateUpdate; 27 27 + 28 28 + /// The state of the lobby has changed 29 29 + #[derive(Serialize, Deserialize, Clone, Default, Debug, specta::Type, tauri_specta::Event)] 30 30 + pub struct LobbyStateUpdate; 31 31 + 32 32 + pub struct TauriStateUpdateSender<E: Clone + Default + Event + Serialize>( 33 33 + AppHandle, 34 34 + PhantomData<E>, 35 35 + ); 36 36 + 37 37 + impl<E: Serialize + Clone + Default + Event> TauriStateUpdateSender<E> { 38 38 + fn new(app: &AppHandle) -> Self { 39 39 + Self(app.clone(), PhantomData) 40 40 + } 41 41 + } 42 42 + 43 43 + impl<E: Serialize + Clone + Default + Event> StateUpdateSender for TauriStateUpdateSender<E> { 44 44 + fn send_update(&self) { 45 45 + if let Err(why) = E::default().emit(&self.0) { 46 46 + error!("Error sending Game state update to UI: {why:?}"); 47 47 + } 48 48 + } 49 49 + } 50 50 + 51 51 + type Game = BaseGame<TauriLocation, MatchboxTransport, TauriStateUpdateSender<GameStateUpdate>>; 52 52 + type Lobby = BaseLobby<MatchboxTransport, TauriStateUpdateSender<LobbyStateUpdate>>; 53 53 + 54 54 + pub enum AppState { 55 55 + Setup, 56 56 + Menu(PlayerProfile), 57 57 + Lobby(Arc<Lobby>), 58 58 + Game(Arc<Game>, HashMap<Uuid, PlayerProfile>), 59 59 + Replay(AppGameHistory), 60 60 + } 61 61 + 62 62 + #[derive(Serialize, Deserialize, specta::Type, Debug, Clone, Eq, PartialEq)] 63 63 + pub enum AppScreen { 64 64 + Setup, 65 65 + Menu, 66 66 + Lobby, 67 67 + Game, 68 68 + Replay, 69 69 + } 70 70 + 71 71 + pub type AppStateHandle = RwLock<AppState>; 72 72 + 73 73 + const GAME_TICK_RATE: Duration = Duration::from_secs(1); 74 74 + 75 75 + /// The app is changing screens, contains the screen it's switching to 76 76 + #[derive(Serialize, Deserialize, Clone, Debug, specta::Type, tauri_specta::Event)] 77 77 + pub struct ChangeScreen(AppScreen); 78 78 + 79 79 + fn error_dialog(app: &AppHandle, msg: &str) { 80 80 + app.dialog() 81 81 + .message(msg) 82 82 + .kind(MessageDialogKind::Error) 83 83 + .show(|_| {}); 84 84 + } 85 85 + 86 86 + impl AppState { 87 87 + pub async fn start_game(&mut self, app: AppHandle, start: StartGameInfo) { 88 88 + if let AppState::Lobby(lobby) = self { 89 89 + let transport = lobby.clone_transport(); 90 90 + let profiles = lobby.clone_profiles().await; 91 91 + let location = TauriLocation::new(app.clone()); 92 92 + let state_updates = TauriStateUpdateSender::new(&app); 93 93 + let game = Arc::new(Game::new( 94 94 + GAME_TICK_RATE, 95 95 + start, 96 96 + transport, 97 97 + location, 98 98 + state_updates, 99 99 + )); 100 100 + *self = AppState::Game(game.clone(), profiles.clone()); 101 101 + Self::game_loop(app.clone(), game, profiles); 102 102 + Self::emit_screen_change(&app, AppScreen::Game); 103 103 + } 104 104 + } 105 105 + 106 106 + fn game_loop(app: AppHandle, game: Arc<Game>, profiles: HashMap<Uuid, PlayerProfile>) { 107 107 + tokio::spawn(async move { 108 108 + let res = game.main_loop().await; 109 109 + let state_handle = app.state::<AppStateHandle>(); 110 110 + let mut state = state_handle.write().await; 111 111 + match res { 112 112 + Ok(Some(history)) => { 113 113 + let history = 114 114 + AppGameHistory::new(history, profiles, game.clone_settings().await); 115 115 + if let Err(why) = history.save_history(&app) { 116 116 + error!("Failed to save game history: {why:?}"); 117 117 + error_dialog(&app, "Failed to save the history of this game"); 118 118 + } 119 119 + state.quit_to_menu(app.clone()).await; 120 120 + } 121 121 + Ok(None) => { 122 122 + info!("User quit game"); 123 123 + } 124 124 + Err(why) => { 125 125 + error!("Game Error: {why:?}"); 126 126 + app.dialog() 127 127 + .message(format!("Connection Error: {why}")) 128 128 + .kind(MessageDialogKind::Error) 129 129 + .show(|_| {}); 130 130 + state.quit_to_menu(app.clone()).await; 131 131 + } 132 132 + } 133 133 + }); 134 134 + } 135 135 + 136 136 + pub fn get_menu(&self) -> Result<&PlayerProfile> { 137 137 + match self { 138 138 + AppState::Menu(player_profile) => Ok(player_profile), 139 139 + _ => Err("Not on menu screen".to_string()), 140 140 + } 141 141 + } 142 142 + 143 143 + pub fn get_menu_mut(&mut self) -> Result<&mut PlayerProfile> { 144 144 + match self { 145 145 + AppState::Menu(player_profile) => Ok(player_profile), 146 146 + _ => Err("Not on menu screen".to_string()), 147 147 + } 148 148 + } 149 149 + 150 150 + pub fn get_lobby(&self) -> Result<Arc<Lobby>> { 151 151 + if let AppState::Lobby(lobby) = self { 152 152 + Ok(lobby.clone()) 153 153 + } else { 154 154 + Err("Not on lobby screen".to_string()) 155 155 + } 156 156 + } 157 157 + 158 158 + pub fn get_game(&self) -> Result<Arc<Game>> { 159 159 + if let AppState::Game(game, _) = self { 160 160 + Ok(game.clone()) 161 161 + } else { 162 162 + Err("Not on game screen".to_string()) 163 163 + } 164 164 + } 165 165 + 166 166 + pub fn get_profiles(&self) -> Result<&HashMap<Uuid, PlayerProfile>> { 167 167 + if let AppState::Game(_, profiles) = self { 168 168 + Ok(profiles) 169 169 + } else { 170 170 + Err("Not on game screen".to_string()) 171 171 + } 172 172 + } 173 173 + 174 174 + pub fn get_replay(&self) -> Result<AppGameHistory> { 175 175 + if let AppState::Replay(history) = self { 176 176 + Ok(history.clone()) 177 177 + } else { 178 178 + Err("Not on replay screen".to_string()) 179 179 + } 180 180 + } 181 181 + 182 182 + fn emit_screen_change(app: &AppHandle, screen: AppScreen) { 183 183 + if let Err(why) = ChangeScreen(screen).emit(app) { 184 184 + warn!("Error emitting screen change: {why:?}"); 185 185 + } 186 186 + } 187 187 + 188 188 + pub fn complete_setup(&mut self, app: &AppHandle, profile: PlayerProfile) -> Result { 189 189 + if let AppState::Setup = self { 190 190 + write_profile_to_store(app, profile.clone()); 191 191 + *self = AppState::Menu(profile); 192 192 + Self::emit_screen_change(app, AppScreen::Menu); 193 193 + Ok(()) 194 194 + } else { 195 195 + Err("Must be on the Setup screen".to_string()) 196 196 + } 197 197 + } 198 198 + 199 199 + pub fn replay_game(&mut self, app: &AppHandle, id: UtcDT) -> Result { 200 200 + if let AppState::Menu(_) = self { 201 201 + let history = AppGameHistory::get_history(app, id) 202 202 + .context("Failed to read history") 203 203 + .map_err(|e| e.to_string())?; 204 204 + *self = AppState::Replay(history); 205 205 + Self::emit_screen_change(app, AppScreen::Replay); 206 206 + Ok(()) 207 207 + } else { 208 208 + Err("Not on menu screen".to_string()) 209 209 + } 210 210 + } 211 211 + 212 212 + fn lobby_loop(app: AppHandle, lobby: Arc<Lobby>) { 213 213 + tokio::spawn(async move { 214 214 + let res = lobby.main_loop().await; 215 215 + let app_game = app.clone(); 216 216 + let state_handle = app.state::<AppStateHandle>(); 217 217 + let mut state = state_handle.write().await; 218 218 + match res { 219 219 + Ok(Some(start)) => { 220 220 + info!("Starting Game"); 221 221 + state.start_game(app_game, start).await; 222 222 + } 223 223 + Ok(None) => { 224 224 + info!("User quit lobby"); 225 225 + } 226 226 + Err(why) => { 227 227 + error!("Lobby Error: {why}"); 228 228 + error_dialog(&app_game, &format!("Error joining the lobby: {why}")); 229 229 + state.quit_to_menu(app_game).await; 230 230 + } 231 231 + } 232 232 + }); 233 233 + } 234 234 + 235 235 + pub async fn start_lobby( 236 236 + &mut self, 237 237 + join_code: Option<String>, 238 238 + app: AppHandle, 239 239 + settings: GameSettings, 240 240 + ) { 241 241 + if let AppState::Menu(profile) = self { 242 242 + let host = join_code.is_none(); 243 243 + let room_code = if let Some(code) = join_code { 244 244 + code.to_ascii_uppercase() 245 245 + } else { 246 246 + match request_room_code().await { 247 247 + Ok(code) => code, 248 248 + Err(why) => { 249 249 + error_dialog(&app, &format!("Couldn't create a lobby\n\n{why:?}")); 250 250 + return; 251 251 + } 252 252 + } 253 253 + }; 254 254 + let state_updates = TauriStateUpdateSender::<LobbyStateUpdate>::new(&app); 255 255 + let lobby = 256 256 + Lobby::new(&room_code, host, profile.clone(), settings, state_updates).await; 257 257 + match lobby { 258 258 + Ok(lobby) => { 259 259 + *self = AppState::Lobby(lobby.clone()); 260 260 + Self::lobby_loop(app.clone(), lobby); 261 261 + Self::emit_screen_change(&app, AppScreen::Lobby); 262 262 + } 263 263 + Err(why) => { 264 264 + error_dialog( 265 265 + &app, 266 266 + &format!("Couldn't connect you to the lobby\n\n{why:?}"), 267 267 + ); 268 268 + } 269 269 + } 270 270 + } 271 271 + } 272 272 + 273 273 + pub async fn quit_to_menu(&mut self, app: AppHandle) { 274 274 + let profile = match self { 275 275 + AppState::Setup => None, 276 276 + AppState::Menu(_) => { 277 277 + warn!("Already on menu!"); 278 278 + return; 279 279 + } 280 280 + AppState::Lobby(lobby) => { 281 281 + lobby.quit_lobby().await; 282 282 + read_profile_from_store(&app) 283 283 + } 284 284 + AppState::Game(game, _) => { 285 285 + game.quit_game().await; 286 286 + read_profile_from_store(&app) 287 287 + } 288 288 + AppState::Replay(_) => read_profile_from_store(&app), 289 289 + }; 290 290 + let screen = if let Some(profile) = profile { 291 291 + *self = AppState::Menu(profile); 292 292 + AppScreen::Menu 293 293 + } else { 294 294 + *self = AppState::Setup; 295 295 + AppScreen::Setup 296 296 + }; 297 297 + 298 298 + Self::emit_screen_change(&app, screen); 299 299 + } 300 300 + }

+1 -1

manhunt-logic/src/lib.rs

··· 10 10 mod tests; 11 11 mod transport; 12 12 13 13 - pub use game::{Game, StateUpdateSender}; 13 13 + pub use game::{Game, StateUpdateSender, UtcDT}; 14 14 pub use game_events::GameEvent; 15 15 pub use game_state::{GameHistory, GameUiState}; 16 16 pub use lobby::{Lobby, LobbyMessage, LobbyState, StartGameInfo};

+1 -1

nix/packages/manhunt-signaling.nix

··· 9 9 toSource { 10 10 root = ../../.; 11 11 fileset = unions [ 12 12 - ../../backend 12 12 + ../../manhunt-app 13 13 ../../manhunt-logic 14 14 ../../manhunt-transport 15 15 ../../manhunt-signaling

+6 -7

nix/packages/manhunt.nix

··· 11 11 copyDesktopItems, 12 12 rustPlatform, 13 13 manhunt-frontend, 14 14 - cargo-nextest, 15 14 }: 16 15 rustPlatform.buildRustPackage { 17 16 pname = "manhunt"; ··· 20 19 toSource { 21 20 root = ../../.; 22 21 fileset = unions [ 23 23 - ../../backend 22 22 + ../../manhunt-app 24 23 ../../manhunt-logic 25 24 ../../manhunt-transport 26 25 ../../manhunt-signaling ··· 29 28 ]; 30 29 }; 31 30 cargoLock.lockFile = ../../Cargo.lock; 32 32 - buildAndTestSubdir = "backend"; 31 31 + buildAndTestSubdir = "manhunt-app"; 33 32 buildFeatures = [ 34 33 "tauri/custom-protocol" 35 34 ]; ··· 50 49 ]; 51 50 52 51 postPatch = '' 53 53 - substituteInPlace backend/tauri.conf.json \ 52 52 + substituteInPlace manhunt-app/tauri.conf.json \ 54 53 --replace-fail '"frontendDist": "../frontend/dist"' '"frontendDist": "${manhunt-frontend}"' 55 54 ''; 56 55 ··· 59 58 cargoTestFlags = "-p manhunt-logic -p manhunt-transport -p manhunt-app"; 60 59 61 60 postInstall = '' 62 62 - install -DT backend/icons/128x128@2x.png $out/share/icons/hicolor/256x256@2/apps/manhunt.png 63 63 - install -DT backend/icons/128x128.png $out/share/icons/hicolor/128x128/apps/manhunt.png 64 64 - install -DT backend/icons/32x32.png $out/share/icons/hicolor/32x32/apps/manhunt.png 61 61 + install -DT manhunt-app/icons/128x128@2x.png $out/share/icons/hicolor/256x256@2/apps/manhunt.png 62 62 + install -DT manhunt-app/icons/128x128.png $out/share/icons/hicolor/128x128/apps/manhunt.png 63 63 + install -DT manhunt-app/icons/32x32.png $out/share/icons/hicolor/32x32/apps/manhunt.png 65 64 ''; 66 65 67 66 meta = with lib; {