kifu/kifu-core/src/api.rs

@@ -1,6 +1,11 @@
 use crate::types::AppState;
-use crate::ui::{playing_field, PlayingFieldView};
+use crate::ui::playing_field::{playing_field, PlayingFieldView};
-use std::sync::{Arc, RwLock};
+use std::{
+    sync::{Arc, RwLock},
+    thread,
+    time::Duration,
+};
+use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 pub enum Request {
     PlayingField,

kifu/kifu-core/src/lib.rs

@@ -4,5 +4,5 @@ mod api;
 pub use api::{CoreApp, Request, Response};
 
 mod types;
-pub use types::{Color, Size};
+pub use types::Color;
 pub mod ui;

kifu/kifu-core/src/types.rs

@@ -6,12 +6,6 @@ pub enum Color {
     White,
 }
 
-#[derive(Clone, Debug)]
-pub struct Size {
-    pub width: u8,
-    pub height: u8,
-}
-
 pub(crate) struct AppState {
     game: Option<GameState>,
 }

kifu/kifu-core/src/ui/mod.rs

@@ -1,5 +1,4 @@
-mod playing_field;
+pub mod playing_field;
-pub use playing_field::{playing_field, PlayingFieldView};
 
 mod types;
-pub use types::{ChatElement, GameBoardElement, PlayerCardElement, TextFieldElement};
+pub use types::{ChatElement, PlayerCardElement};

kifu/kifu-core/src/ui/playing_field.rs

@@ -1,4 +1,4 @@
-use crate::types::{Color, Size};
+use crate::types::Color;
 use crate::ui::types;
 
 #[derive(Clone, Debug)]
@@ -16,7 +16,7 @@ pub fn playing_field() -> PlayingFieldView {
     (0..19).for_each(|_| spaces.push(Vec::new()));
 
     let board = types::GameBoardElement {
-        size: Size {
+        size: types::Size {
             width: 19,
             height: 19,
         },

kifu/kifu-core/src/ui/types.rs

@@ -1,4 +1,4 @@
-use crate::types::{Color, Size};
+use crate::types::Color;
 
 #[derive(Clone, Debug)]
 pub struct Jitter {
@@ -6,6 +6,12 @@ pub struct Jitter {
     pub y: i8,
 }
 
+#[derive(Clone, Debug)]
+pub struct Size {
+    pub width: u8,
+    pub height: u8,
+}
+
 #[derive(Clone, Debug)]
 pub struct StoneElement {
     pub color: Color,

kifu/kifu-gtk/Cargo.toml

@@ -3,9 +3,6 @@ name = "kifu-gtk"
 version = "0.1.0"
 edition = "2021"
 
-[features]
-screenplay = []
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
@@ -19,8 +16,3 @@ screenplay  = { path = "../../screenplay" }
 [[bin]]
 name = "kifu-gtk"
 path = "src/main.rs"
-
-[[bin]]
-name = "screenplay"
-path = "src/bin/screenplay.rs"
-required-features = [ "screenplay" ]

kifu/kifu-gtk/src/bin/screenplay.rs

@@ -1,10 +1,9 @@
+use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};
-use kifu_core::{
+use kifu_core::{ui::ChatElement, ui::PlayerCardElement, Color};
-    ui::{ChatElement, PlayerCardElement, PlayingFieldView},
+use kifu_gtk::ui::{Chat, PlayerCard};
-    Color,
-};
-use kifu_gtk::ui::{playing_field_view, Chat, PlayerCard, PlayingField};
 use screenplay::{Screen, Screenplay};
+use std::{cell::RefCell, rc::Rc};
 
 fn main() {
     let app = gtk::Application::builder()
@@ -36,13 +35,8 @@ fn main() {
                 .upcast::<gtk::Widget>(),
                 adjustments: vec![],
             },
-            Screen {
-                title: "PlayingField".to_owned(),
-                widget: PlayingField::new(playing_field_view()).upcast::<gtk::Widget>(),
-                adjustments: vec![],
-            },
         ];
-        Screenplay::new(&app, screens).unwrap();
+        let screenplay = Screenplay::new(&app, screens).unwrap();
     });
 
     app.run();

kifu/kifu-gtk/src/ui/goban.rs

@@ -1,30 +0,0 @@
-use glib::Object;
-use gtk::{prelude::*, subclass::prelude::*};
-
-#[derive(Default)]
-pub struct GobanPrivate;
-
-#[glib::object_subclass]
-impl ObjectSubclass for GobanPrivate {
-    const NAME: &'static str = "Goban";
-    type Type = Goban;
-    type ParentType = gtk::DrawingArea;
-}
-
-impl ObjectImpl for GobanPrivate {}
-impl WidgetImpl for GobanPrivate {}
-impl DrawingAreaImpl for GobanPrivate {}
-
-glib::wrapper! {
-    pub struct Goban(ObjectSubclass<GobanPrivate>) @extends gtk::DrawingArea, gtk::Widget;
-}
-
-impl Goban {
-    pub fn new() -> Self {
-        let s: Self = Object::builder().build();
-        s.set_width_request(1024);
-        s.set_height_request(768);
-
-        s
-    }
-}

kifu/kifu-gtk/src/ui/mod.rs

@@ -3,12 +3,3 @@ pub use player_card::PlayerCard;
 
 mod chat;
 pub use chat::Chat;
-
-mod playing_field;
-pub use playing_field::PlayingField;
-
-mod goban;
-pub use goban::Goban;
-
-#[cfg(feature = "screenplay")]
-pub use playing_field::playing_field_view;

kifu/kifu-gtk/src/ui/playing_field.rs

@@ -1,117 +0,0 @@
-use crate::ui::{Chat, Goban, PlayerCard};
-use glib::Object;
-use gtk::{prelude::*, subclass::prelude::*};
-use kifu_core::{
-    ui::{ChatElement, GameBoardElement, PlayerCardElement, PlayingFieldView, TextFieldElement},
-    Color, Size,
-};
-use std::{cell::RefCell, rc::Rc};
-
-/*
-#[derive(Clone, Debug)]
-pub struct PlayingFieldView {
-    pub board: types::GameBoardElement,
-    pub player_card_black: types::PlayerCardElement,
-    pub player_card_white: types::PlayerCardElement,
-    pub chat: types::ChatElement,
-    pub message: types::TextFieldElement,
-    pub current_player: Color,
-}
-*/
-
-#[derive(Default)]
-pub struct PlayingFieldPrivate {
-    player_card_white: Rc<RefCell<Option<PlayerCard>>>,
-    player_card_black: Rc<RefCell<Option<PlayerCard>>>,
-    chat: Rc<RefCell<Option<Chat>>>,
-}
-
-#[glib::object_subclass]
-impl ObjectSubclass for PlayingFieldPrivate {
-    const NAME: &'static str = "PlayingField";
-    type Type = PlayingField;
-    type ParentType = gtk::Grid;
-
-    fn new() -> Self {
-        Self {
-            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 WidgetImpl for PlayingFieldPrivate {}
-impl GridImpl for PlayingFieldPrivate {}
-
-glib::wrapper! {
-    pub struct PlayingField(ObjectSubclass<PlayingFieldPrivate>) @extends gtk::Grid, gtk::Widget;
-}
-
-impl PlayingField {
-    pub fn new(view: PlayingFieldView) -> PlayingField {
-        let s: Self = Object::builder().build();
-
-        let goban = Goban::new();
-        let player_card_white = PlayerCard::new(view.player_card_white);
-        let player_card_black = PlayerCard::new(view.player_card_black);
-        let chat = Chat::new(view.chat);
-
-        s.attach(&goban, 1, 1, 1, 2);
-        s.attach(&player_card_black, 2, 1, 1, 1);
-        s.attach(&player_card_white, 3, 1, 1, 1);
-        s.attach(&chat, 2, 2, 2, 1);
-
-        *s.imp().player_card_white.borrow_mut() = Some(player_card_white);
-        *s.imp().player_card_black.borrow_mut() = Some(player_card_black);
-        *s.imp().chat.borrow_mut() = Some(chat);
-
-        s
-    }
-}
-
-#[cfg(feature = "screenplay")]
-pub fn playing_field_view() -> PlayingFieldView {
-    let mut spaces = Vec::new();
-    (0..19).for_each(|_| spaces.push(Vec::new()));
-
-    let board = GameBoardElement {
-        size: Size {
-            width: 19,
-            height: 19,
-        },
-        spaces,
-    };
-
-    let player_card_black = PlayerCardElement {
-        color: Color::Black,
-        name: "Savanni".to_owned(),
-        rank: "10k".to_owned(),
-        clock: "24:53".to_owned(),
-    };
-
-    let player_card_white = PlayerCardElement {
-        color: Color::White,
-        name: "Opal".to_owned(),
-        rank: "10k".to_owned(),
-        clock: "25:00".to_owned(),
-    };
-
-    let chat = ChatElement {
-        messages: vec![
-            "[22:05] Savanni: oops".to_owned(),
-            "[22:06] Opal: you know I'll take advantage of that, right?".to_owned(),
-        ],
-    };
-    let message = TextFieldElement {};
-
-    PlayingFieldView {
-        board,
-        player_card_black,
-        player_card_white,
-        chat,
-        message,
-        current_player: Color::White,
-    }
-}