Place a stone onto the drawing area #38

Merged
savanni merged 7 commits from feature/place-stone into main 2023-04-07 12:14:04 +00:00
8 changed files with 211 additions and 75 deletions
Showing only changes of commit 8df649d6cd - Show all commits

View File

@ -2,11 +2,19 @@ use crate::types::AppState;
use crate::ui::{playing_field, PlayingFieldView}; use crate::ui::{playing_field, PlayingFieldView};
use std::sync::{Arc, RwLock}; use std::sync::{Arc, RwLock};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Request { pub enum Request {
PlayingField, PlayingField,
PlayStoneRequest(PlayStoneRequest),
} }
#[derive(Debug)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PlayStoneRequest {
pub column: u8,
pub row: u8,
}
#[derive(Clone, Debug)]
pub enum Response { pub enum Response {
PlayingFieldView(PlayingFieldView), PlayingFieldView(PlayingFieldView),
} }
@ -25,7 +33,18 @@ impl CoreApp {
pub async fn dispatch(&self, request: Request) -> Response { pub async fn dispatch(&self, request: Request) -> Response {
match request { match request {
Request::PlayingField => Response::PlayingFieldView(playing_field()), Request::PlayingField => {
let app_state = self.state.read().unwrap();
let game = app_state.game.as_ref().unwrap();
Response::PlayingFieldView(playing_field(game))
}
Request::PlayStoneRequest(request) => {
let mut app_state = self.state.write().unwrap();
app_state.place_stone(request);
let game = app_state.game.as_ref().unwrap();
Response::PlayingFieldView(playing_field(game))
}
} }
} }

View File

@ -1,3 +1,4 @@
use crate::api::PlayStoneRequest;
use std::time::Duration; use std::time::Duration;
#[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@ -21,13 +22,24 @@ impl Default for Size {
} }
} }
pub(crate) struct AppState { pub struct AppState {
game: Option<GameState>, pub game: Option<GameState>,
} }
impl AppState { impl AppState {
pub fn new() -> Self { pub fn new() -> Self {
Self { game: None } Self {
game: Some(GameState::new()),
}
}
pub fn place_stone(&mut self, req: PlayStoneRequest) {
match self.game {
Some(ref mut game) => {
game.place_stone(req.column, req.row);
}
None => {}
}
} }
} }
@ -55,18 +67,82 @@ impl From<Rank> for String {
} }
} }
struct Player { pub struct Player {
name: String, name: String,
rank: Rank, rank: Rank,
} }
pub(crate) struct GameState { pub struct GameState {
goban: Vec<Vec<Color>>, pub board: Board,
conversation: Vec<String>, pub conversation: Vec<String>,
pub current_player: Color,
white_player: Player, pub white_player: Player,
black_player: Player, pub black_player: Player,
white_clock: Duration, pub white_clock: Duration,
black_clock: Duration, pub black_clock: Duration,
}
impl GameState {
fn new() -> GameState {
GameState {
board: Board::new(),
conversation: vec![],
current_player: Color::Black,
white_player: Player {
name: "Savanni".to_owned(),
rank: Rank::Kyu(10),
},
black_player: Player {
name: "Opal".to_owned(),
rank: Rank::Kyu(10),
},
white_clock: Duration::from_secs(600),
black_clock: Duration::from_secs(600),
}
}
fn place_stone(&mut self, column: u8, row: u8) {
self.board.place_stone(column, row, self.current_player);
match self.current_player {
Color::White => self.current_player = Color::Black,
Color::Black => self.current_player = Color::White,
}
}
}
pub struct Board {
pub size: Size,
pub spaces: Vec<Option<Color>>,
}
impl Board {
fn new() -> Self {
let mut spaces = Vec::new();
for _ in 0..19 * 19 {
spaces.push(None);
}
Self {
size: Size {
width: 19,
height: 19,
},
spaces,
}
}
pub fn place_stone(&mut self, column: u8, row: u8, stone: Color) {
let addr = self.addr(column, row);
self.spaces[addr] = Some(stone);
}
pub fn stone(&self, column: u8, row: u8) -> Option<Color> {
let addr = self.addr(column, row);
self.spaces[addr]
}
fn addr(&self, column: u8, row: u8) -> usize {
((row as usize) * (self.size.width as usize) + (column as usize)) as usize
}
} }

View File

@ -1,5 +1,5 @@
use crate::types::{Color, Size}; use crate::types::{Color, Size};
use crate::ui::types; use crate::{types::GameState, ui::types};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct PlayingFieldView { pub struct PlayingFieldView {
@ -11,8 +11,8 @@ pub struct PlayingFieldView {
pub current_player: Color, pub current_player: Color,
} }
pub fn playing_field() -> PlayingFieldView { pub fn playing_field(game: &GameState) -> PlayingFieldView {
let board = types::BoardElement::default(); let board = types::BoardElement::from(&game.board);
let player_card_black = types::PlayerCardElement { let player_card_black = types::PlayerCardElement {
color: Color::Black, color: Color::Black,
@ -42,6 +42,6 @@ pub fn playing_field() -> PlayingFieldView {
player_card_white, player_card_white,
chat, chat,
message, message,
current_player: Color::White, current_player: game.current_player,
} }
} }

View File

@ -1,4 +1,8 @@
use crate::types::{Color, Size}; use crate::types::{Color, Size};
use crate::{
api::{PlayStoneRequest, Request},
types::Board,
};
#[derive(Clone, Copy, Debug, PartialEq)] #[derive(Clone, Copy, Debug, PartialEq)]
pub struct Jitter { pub struct Jitter {
@ -21,16 +25,10 @@ impl StoneElement {
} }
} }
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PlayStoneRequest {
col: u8,
row: u8,
}
#[derive(Clone, Copy, Debug, PartialEq)] #[derive(Clone, Copy, Debug, PartialEq)]
pub enum IntersectionElement { pub enum IntersectionElement {
Unplayable, Unplayable,
Empty(PlayStoneRequest), Empty(Request),
Filled(StoneElement), Filled(StoneElement),
} }
@ -45,7 +43,12 @@ impl BoardElement {
let spaces: Vec<IntersectionElement> = (0..size.height) let spaces: Vec<IntersectionElement> = (0..size.height)
.map(|row| { .map(|row| {
(0..size.width) (0..size.width)
.map(|col| IntersectionElement::Empty(PlayStoneRequest { col, row })) .map(|column| {
IntersectionElement::Empty(Request::PlayStoneRequest(PlayStoneRequest {
column,
row,
}))
})
.collect::<Vec<IntersectionElement>>() .collect::<Vec<IntersectionElement>>()
}) })
.collect::<Vec<Vec<IntersectionElement>>>() .collect::<Vec<Vec<IntersectionElement>>>()
@ -53,17 +56,38 @@ impl BoardElement {
Self { size, spaces } Self { size, spaces }
} }
pub fn stone_mut<'a>(&'a mut self, row: u8, col: u8) -> &'a mut IntersectionElement { pub fn stone(&self, column: u8, row: u8) -> IntersectionElement {
let addr = self.addr(row, col); let addr = self.addr(column, row);
&mut self.spaces[addr] self.spaces[addr]
} }
pub fn stone(&self, row: u8, col: u8) -> IntersectionElement { fn addr(&self, column: u8, row: u8) -> usize {
self.spaces[self.addr(row, col)].clone() ((row as usize) * (self.size.width as usize) + (column as usize)) as usize
} }
}
fn addr(&self, row: u8, col: u8) -> usize { impl From<&Board> for BoardElement {
((row as usize) * (self.size.width as usize) + (col as usize)) as usize fn from(board: &Board) -> Self {
let spaces: Vec<IntersectionElement> = (0..board.size.height)
.map(|row| {
(0..board.size.width)
.map(|column| match board.stone(column, row) {
Some(color) => IntersectionElement::Filled(StoneElement {
jitter: Jitter { x: 0, y: 0 },
color,
}),
None => IntersectionElement::Empty(Request::PlayStoneRequest(
PlayStoneRequest { column, row },
)),
})
.collect::<Vec<IntersectionElement>>()
})
.collect::<Vec<Vec<IntersectionElement>>>()
.concat();
Self {
size: board.size,
spaces,
}
} }
} }

View File

@ -1 +1,21 @@
pub mod ui; pub mod ui;
use kifu_core::{CoreApp, Request, Response};
use std::sync::Arc;
use tokio::runtime::Runtime;
#[derive(Clone)]
pub struct CoreApi {
pub gtk_tx: gtk::glib::Sender<Response>,
pub rt: Arc<Runtime>,
pub core: CoreApp,
}
impl CoreApi {
pub fn dispatch(&self, request: Request) {
self.rt.spawn({
let gtk_tx = self.gtk_tx.clone();
let core = self.core.clone();
async move { gtk_tx.send(core.dispatch(request).await) }
});
}
}

View File

@ -1,7 +1,7 @@
use gio::resources_lookup_data; use gio::resources_lookup_data;
use gtk::prelude::*; use gtk::prelude::*;
use kifu_core::{CoreApp, Request, Response}; use kifu_core::{CoreApp, Request, Response};
use kifu_gtk::ui::PlayingField; use kifu_gtk::{ui::PlayingField, CoreApi};
use std::{ use std::{
sync::{Arc, Mutex}, sync::{Arc, Mutex},
time::Duration, time::Duration,
@ -11,23 +11,6 @@ use tokio::{
sync::mpsc::{Receiver, Sender}, sync::mpsc::{Receiver, Sender},
}; };
#[derive(Clone)]
pub struct CoreApi {
gtk_tx: gtk::glib::Sender<Response>,
rt: Arc<Runtime>,
core: CoreApp,
}
impl CoreApi {
pub fn dispatch(&self, request: Request) {
self.rt.spawn({
let gtk_tx = self.gtk_tx.clone();
let core = self.core.clone();
async move { gtk_tx.send(core.dispatch(request).await) }
});
}
}
fn main() { fn main() {
gio::resources_register_include!("com.luminescent-dreams.kifu-gtk.gresource") gio::resources_register_include!("com.luminescent-dreams.kifu-gtk.gresource")
.expect("Failed to register resources"); .expect("Failed to register resources");
@ -67,15 +50,18 @@ fn main() {
let window = gtk::ApplicationWindow::new(app); let window = gtk::ApplicationWindow::new(app);
window.present(); window.present();
gtk_rx.attach(None, move |message| { gtk_rx.attach(None, {
println!("message: {:?}", message); let api = api.clone();
match message { move |message| {
Response::PlayingFieldView(view) => { match message {
let playing_field = PlayingField::new(view); Response::PlayingFieldView(view) => {
window.set_child(Some(&playing_field)); let api = api.clone();
let playing_field = PlayingField::new(api, view);
window.set_child(Some(&playing_field));
}
} }
Continue(true)
} }
Continue(true)
}); });
api.dispatch(Request::PlayingField); api.dispatch(Request::PlayingField);

View File

@ -1,3 +1,4 @@
use crate::CoreApi;
use gio::resources_lookup_data; use gio::resources_lookup_data;
use glib::Object; use glib::Object;
use gtk::{ use gtk::{
@ -27,6 +28,8 @@ pub struct BoardPrivate {
current_player: Rc<RefCell<Color>>, current_player: Rc<RefCell<Color>>,
board: Rc<RefCell<BoardElement>>, board: Rc<RefCell<BoardElement>>,
cursor_location: Rc<RefCell<Addr>>, cursor_location: Rc<RefCell<Addr>>,
api: Rc<RefCell<Option<CoreApi>>>,
} }
#[glib::object_subclass] #[glib::object_subclass]
@ -41,6 +44,7 @@ impl ObjectSubclass for BoardPrivate {
current_player: Rc::new(RefCell::new(Color::Black)), current_player: Rc::new(RefCell::new(Color::Black)),
board: Default::default(), board: Default::default(),
cursor_location: Default::default(), cursor_location: Default::default(),
api: Default::default(),
} }
} }
} }
@ -169,12 +173,17 @@ impl ObjectImpl for BoardPrivate {
{ {
let board = self.board.clone(); let board = self.board.clone();
let cursor = self.cursor_location.clone(); let cursor = self.cursor_location.clone();
let api = self.api.clone();
gesture.connect_released(move |_, _, _, _| { gesture.connect_released(move |_, _, _, _| {
let board = board.borrow(); let board = board.borrow();
let cursor = cursor.borrow(); let cursor = cursor.borrow();
match board.stone(cursor.row, cursor.column) { match board.stone(cursor.row, cursor.column) {
IntersectionElement::Empty(request) => { IntersectionElement::Empty(request) => {
println!("need to send request: {:?}", request) println!("need to send request: {:?}", request);
api.borrow()
.as_ref()
.expect("API must exist")
.dispatch(request);
} }
_ => {} _ => {}
} }
@ -193,9 +202,12 @@ glib::wrapper! {
} }
impl Board { impl Board {
pub fn new() -> Self { pub fn new(api: CoreApi) -> Self {
let s: Self = Object::builder().build(); let s: Self = Object::builder().build();
*s.imp().api.borrow_mut() = Some(api);
s.attach(&s.imp().drawing_area, 1, 1, 1, 1); s.attach(&s.imp().drawing_area, 1, 1, 1, 1);
s s
} }

View File

@ -1,4 +1,5 @@
use crate::ui::{Board, Chat, PlayerCard}; use crate::ui::{Board, Chat, PlayerCard};
use crate::CoreApi;
use glib::Object; use glib::Object;
use gtk::{prelude::*, subclass::prelude::*}; use gtk::{prelude::*, subclass::prelude::*};
use kifu_core::{ use kifu_core::{
@ -23,7 +24,7 @@ pub struct PlayingFieldView {
*/ */
pub struct PlayingFieldPrivate { pub struct PlayingFieldPrivate {
goban: Board, board: Rc<RefCell<Option<Board>>>,
player_card_white: Rc<RefCell<Option<PlayerCard>>>, player_card_white: Rc<RefCell<Option<PlayerCard>>>,
player_card_black: Rc<RefCell<Option<PlayerCard>>>, player_card_black: Rc<RefCell<Option<PlayerCard>>>,
chat: Rc<RefCell<Option<Chat>>>, chat: Rc<RefCell<Option<Chat>>>,
@ -32,7 +33,7 @@ pub struct PlayingFieldPrivate {
impl Default for PlayingFieldPrivate { impl Default for PlayingFieldPrivate {
fn default() -> Self { fn default() -> Self {
Self { Self {
goban: Board::new(), board: Default::default(),
player_card_white: Rc::new(RefCell::new(None)), player_card_white: Rc::new(RefCell::new(None)),
player_card_black: Rc::new(RefCell::new(None)), player_card_black: Rc::new(RefCell::new(None)),
chat: Rc::new(RefCell::new(None)), chat: Rc::new(RefCell::new(None)),
@ -45,15 +46,6 @@ impl ObjectSubclass for PlayingFieldPrivate {
const NAME: &'static str = "PlayingField"; const NAME: &'static str = "PlayingField";
type Type = PlayingField; type Type = PlayingField;
type ParentType = gtk::Grid; type ParentType = gtk::Grid;
fn new() -> Self {
Self {
goban: Board::new(),
player_card_white: Rc::new(RefCell::new(None)),
player_card_black: Rc::new(RefCell::new(None)),
chat: Rc::new(RefCell::new(None)),
}
}
} }
impl ObjectImpl for PlayingFieldPrivate {} impl ObjectImpl for PlayingFieldPrivate {}
@ -65,16 +57,19 @@ glib::wrapper! {
} }
impl PlayingField { impl PlayingField {
pub fn new(view: PlayingFieldView) -> PlayingField { pub fn new(api: CoreApi, view: PlayingFieldView) -> PlayingField {
let s: Self = Object::builder().build(); let s: Self = Object::builder().build();
let player_card_white = PlayerCard::new(view.player_card_white); let player_card_white = PlayerCard::new(view.player_card_white);
let player_card_black = PlayerCard::new(view.player_card_black); let player_card_black = PlayerCard::new(view.player_card_black);
let chat = Chat::new(view.chat); let chat = Chat::new(view.chat);
s.imp().goban.set_board(view.board); *s.imp().board.borrow_mut() = Some(Board::new(api));
s.imp()
s.attach(&s.imp().goban, 1, 1, 1, 2); .board
.borrow()
.as_ref()
.map(|board| s.attach(board, 1, 1, 1, 2));
s.attach(&player_card_black, 2, 1, 1, 1); s.attach(&player_card_black, 2, 1, 1, 1);
s.attach(&player_card_white, 3, 1, 1, 1); s.attach(&player_card_white, 3, 1, 1, 1);
s.attach(&chat, 2, 2, 2, 1); s.attach(&chat, 2, 2, 2, 1);
@ -82,7 +77,11 @@ impl PlayingField {
*s.imp().player_card_white.borrow_mut() = Some(player_card_white); *s.imp().player_card_white.borrow_mut() = Some(player_card_white);
*s.imp().player_card_black.borrow_mut() = Some(player_card_black); *s.imp().player_card_black.borrow_mut() = Some(player_card_black);
*s.imp().chat.borrow_mut() = Some(chat); *s.imp().chat.borrow_mut() = Some(chat);
s.imp().goban.set_current_player(view.current_player);
s.imp().board.borrow().as_ref().map(|board| {
board.set_board(view.board);
board.set_current_player(view.current_player);
});
s s
} }