111 lines
3.8 KiB
Rust
111 lines
3.8 KiB
Rust
use crate::{
|
|
types::{AppState, Rank},
|
|
ui::{new_game, playing_field, NewGameView, PlayingFieldView},
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::sync::{Arc, RwLock};
|
|
use typeshare::typeshare;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
#[serde(tag = "type", content = "content")]
|
|
pub enum CoreRequest {
|
|
CreateGame(CreateGameRequest),
|
|
LaunchScreen,
|
|
NewGame,
|
|
PlayingField,
|
|
PlayStone(PlayStoneRequest),
|
|
StartGame,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
pub struct PlayStoneRequest {
|
|
pub column: u8,
|
|
pub row: u8,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
pub struct CreateGameRequest {
|
|
black_player: PlayerInfoRequest,
|
|
white_player: PlayerInfoRequest,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
pub enum PlayerInfoRequest {
|
|
Hotseat(HotseatPlayerRequest),
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
pub struct HotseatPlayerRequest {
|
|
name: Option<String>,
|
|
rank: Option<Rank>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
#[serde(tag = "type", content = "content")]
|
|
pub enum CoreResponse {
|
|
NewGameView(NewGameView),
|
|
PlayingFieldView(PlayingFieldView),
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct CoreApp {
|
|
state: Arc<RwLock<AppState>>,
|
|
}
|
|
|
|
impl CoreApp {
|
|
pub fn new() -> Self {
|
|
let state = Arc::new(RwLock::new(AppState::new()));
|
|
|
|
Self { state }
|
|
}
|
|
|
|
pub async fn dispatch(&self, request: CoreRequest) -> CoreResponse {
|
|
match request {
|
|
/*
|
|
CoreRequest::LaunchScreen => {
|
|
let app_state = self.state.read().unwrap();
|
|
|
|
At launch, I want to either show a list of games in progress, the current game, or the game creation screen.
|
|
- if a live game is in progress, immmediately go to that game. Such a game will be classified at game creation, so it should be persisted to the state.
|
|
- if no live games are in progress, but there are slow games in progress, show a list of the slow games and let the player choose which one to jump into.
|
|
- if no games are in progress, show only the game creation screen
|
|
- game creation menu should be present both when there are only slow games and when there are no games
|
|
- the UI returned here will always be available in other places, such as when the user is viewing a game and wants to return to this page
|
|
|
|
For the initial version, I want only to show the game creation screen. Then I will backtrack record application state so that the only decisions can be made.
|
|
}
|
|
*/
|
|
CoreRequest::CreateGame(_) => {
|
|
let app_state = self.state.write().unwrap();
|
|
let game = app_state.game.as_ref().unwrap();
|
|
CoreResponse::PlayingFieldView(playing_field(game))
|
|
}
|
|
CoreRequest::LaunchScreen => CoreResponse::NewGameView(new_game()),
|
|
CoreRequest::NewGame => CoreResponse::NewGameView(new_game()),
|
|
CoreRequest::PlayingField => {
|
|
let app_state = self.state.read().unwrap();
|
|
let game = app_state.game.as_ref().unwrap();
|
|
CoreResponse::PlayingFieldView(playing_field(game))
|
|
}
|
|
CoreRequest::PlayStone(request) => {
|
|
let mut app_state = self.state.write().unwrap();
|
|
app_state.place_stone(request);
|
|
|
|
let game = app_state.game.as_ref().unwrap();
|
|
CoreResponse::PlayingFieldView(playing_field(game))
|
|
}
|
|
CoreRequest::StartGame => {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn run(&self) {}
|
|
}
|