remove old

src/game/hand.rs

@@ -46,6 +46,7 @@ pub(crate) fn shuffle_deal(
     // commands.get_entity(*wall_ent)?.replace_children(&walltiles);
 
     for player_ent in players {
+        debug!("deal to player_ent {player_ent:?}");
         let handtiles = walltiles.split_off(walltiles.len() - 13);
         // commands.get_entity(*wall_ent)?.remove_children(&handtiles);
 
@@ -56,7 +57,6 @@ pub(crate) fn shuffle_deal(
             .get_entity(player_ent)?
             .replace_children(&[hand_ent]);
 
-        debug!("dealt to player_ent {player_ent:?}");
     }
 
     commands.get_entity(*wall_ent)?.replace_children(&walltiles);

src/game/round.rs

@@ -45,7 +45,7 @@ impl Default for MatchSettings {
     }
 }
 
-#[derive(Component, Clone, Copy, FromRepr, EnumCount)]
+#[derive(Component, Clone, Copy, FromRepr, EnumCount, PartialEq)]
 pub enum Wind {
     Ton,
     Nan,
@@ -53,6 +53,12 @@ pub enum Wind {
     Pei,
 }
 
+pub enum WindRelation {
+    Shimocha,
+    Toimen,
+    Kamicha,
+}
+
 impl EnumNextCycle for Wind {
     fn next(&self) -> Self {
         if (*self as usize + 1) >= Self::COUNT {
@@ -63,6 +69,18 @@ impl EnumNextCycle for Wind {
     }
 }
 
+impl Wind {
+    pub fn relate(&self, other: &Self) -> WindRelation {
+        if self.next() == *other {
+            WindRelation::Shimocha
+        } else if other.next() == *self {
+            WindRelation::Kamicha
+        } else {
+            WindRelation::Toimen
+        }
+    }
+}
+
 #[derive(Resource)]
 pub(crate) struct CurrentPlayer(pub Entity);
 
@@ -97,7 +115,7 @@ pub(crate) fn tsumo(
     curr_turnstate: Res<State<TurnState>>,
     mut next_turnstate: ResMut<NextState<TurnState>>,
 ) {
-    trace!("tsumo for: {:?}", curr_player.0);
+    debug!("tsumo for: {:?}", curr_player.0);
 
     let drawn = walltiles.last().unwrap();
     commands.entity(*wall_ent).remove_child(*drawn);

src/main.rs

@@ -41,7 +41,8 @@ fn main() {
             tui_logger::init_logger(tui_logger::LevelFilter::Trace).unwrap();
             tui_logger::set_env_filter_from_string(FILTERSTRING);
 
-            app.add_plugins(tui::RiichiTui)
+            // app.add_plugins(tui::RiichiTui)
+            app.add_plugins(tui::TuiPlugin)
         }
     };
 

src/tui.rs

@@ -0,0 +1,89 @@
+use std::time::Duration;
+
+use bevy::{app::ScheduleRunnerPlugin, prelude::*, state::app::StatesPlugin};
+use bevy_ratatui::RatatuiPlugins;
+use jong::game::GameState;
+use tui_logger::TuiWidgetState;
+
+use crate::tui::states::ConsoleWidget;
+
+mod input;
+mod layout;
+mod render;
+
+#[derive(Default)]
+pub struct TuiPlugin;
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq, SystemSet)]
+pub enum TuiSet {
+    Input,
+    Layout,
+    Render,
+}
+
+impl Plugin for TuiPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            MinimalPlugins.set(ScheduleRunnerPlugin::run_loop(Duration::from_secs_f32(
+                1. / 60.,
+            ))),
+            RatatuiPlugins {
+                // enable_kitty_protocol: todo!(),
+                enable_mouse_capture: true,
+                enable_input_forwarding: true,
+                ..Default::default()
+            },
+        ))
+        .add_plugins(StatesPlugin)
+        .init_resource::<layout::Overlays>()
+        .insert_resource(ConsoleWidget {
+            state: TuiWidgetState::new(),
+            open: true,
+        })
+        .init_state::<states::TuiState>()
+        .configure_sets(
+            Update,
+            (TuiSet::Input, TuiSet::Layout, TuiSet::Render).chain(),
+        )
+        .add_systems(
+            Update,
+            (input::keyboard, input::mouse).in_set(TuiSet::Input),
+        )
+        .add_systems(Update, layout::layout.in_set(TuiSet::Layout))
+        .add_systems(
+            Update,
+            (
+                render::render_hands.run_if(in_state(GameState::Play)),
+                render::render,
+            )
+                .chain()
+                .in_set(TuiSet::Render),
+        );
+    }
+}
+
+mod states {
+    use bevy::prelude::*;
+    use tui_logger::TuiWidgetState;
+
+    #[derive(Resource)]
+    pub(crate) struct ConsoleWidget {
+        pub(crate) state: TuiWidgetState,
+        pub(crate) open: bool,
+    }
+
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, States, Default)]
+    pub(crate) enum TuiState {
+        #[default]
+        MainMenu,
+        InGame,
+    }
+
+    // #[derive(SubStates, Default, Clone, Copy, PartialEq, Eq, Hash, Debug)]
+    // #[source(TuiState = TuiState::MainMenu)]
+    // pub(crate) enum ZenState {
+    //     #[default]
+    //     Menu,
+    //     Zen,
+    // }
+}

src/tui/console.rs

@@ -1,34 +0,0 @@
-use bevy::prelude::*;
-use ratatui::widgets::{Block, Clear};
-use tui_logger::TuiLoggerWidget;
-
-use crate::tui::render::WidgetStack;
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default, States)]
-pub(crate) enum ConsoleState {
-    #[default]
-    Closed,
-    Open,
-}
-
-impl std::ops::Not for ConsoleState {
-    type Output = Self;
-
-    fn not(self) -> Self::Output {
-        match self {
-            ConsoleState::Open => ConsoleState::Closed,
-            ConsoleState::Closed => ConsoleState::Open,
-        }
-    }
-}
-
-pub(crate) fn draw_console(mut widgets: ResMut<WidgetStack>) {
-    widgets.0.push(Box::new(|frame| {
-        let block = Block::bordered().title("console");
-        frame.render_widget(Clear, frame.area());
-        frame.render_widget(
-            TuiLoggerWidget::default().block(block),
-            frame.area(), /* .inner(Margin { horizontal: 8, vertical: 8 }) */
-        );
-    }));
-}

src/tui/input.rs

@@ -0,0 +1,149 @@
+pub(crate) use keyboard::keyboard;
+pub(crate) use mouse::mouse;
+
+pub(crate) mod keyboard {
+    use bevy::prelude::*;
+    use bevy_ratatui::event::KeyMessage;
+    use ratatui::crossterm::event::KeyCode;
+    use tui_logger::TuiWidgetEvent;
+
+    use jong::game::GameState;
+
+    use crate::tui::layout::Overlays;
+    use crate::tui::states::ConsoleWidget;
+    use crate::tui::states::TuiState;
+
+    pub(crate) fn keyboard(
+        mut messages: MessageReader<KeyMessage>,
+        mut overlays: ResMut<Overlays>,
+        mut consolewidget: ResMut<ConsoleWidget>,
+        mut exit: MessageWriter<AppExit>,
+
+        curr_gamestate: Res<State<GameState>>,
+        curr_tuistate: Res<State<TuiState>>,
+
+        mut next_gamestate: ResMut<NextState<GameState>>,
+        mut next_tuistate: ResMut<NextState<TuiState>>,
+    ) {
+        'message: for message in messages.read() {
+            let key = message.code;
+            if consolewidget.handle_keyboard(key) {
+                continue 'message;
+            }
+            for overlay in overlays.stack.iter().rev() {
+                let consumed = match overlay {
+                    _ => false,
+                };
+                if consumed {
+                    continue 'message;
+                }
+            }
+
+            match curr_tuistate.get() {
+                TuiState::MainMenu => match key {
+                    KeyCode::Char('p') => {
+                        next_tuistate.set(TuiState::InGame);
+                        next_gamestate.set(GameState::Setup);
+                    }
+                    KeyCode::Char('z') => {
+                        // if let Some(ref curr_zenstate) = curr_zenstate {
+                        //     match curr_zenstate.get() {
+                        //         ZenState::Menu => next_zenstate.set(ZenState::Zen),
+                        //         ZenState::Zen => next_zenstate.set(ZenState::Menu),
+                        //     }
+                        // }
+                    }
+                    KeyCode::Char('q') => {
+                        exit.write_default();
+                    }
+                    _ => {}
+                },
+                TuiState::InGame => todo!(),
+            }
+        }
+    }
+
+    impl ConsoleWidget {
+        pub(crate) fn handle_keyboard(&mut self, key: KeyCode) -> bool {
+            if key == KeyCode::Char('`') {
+                self.open = !self.open;
+                return true;
+            }
+            if self.open {
+                match key {
+                    KeyCode::Up => self.state.transition(TuiWidgetEvent::UpKey),
+                    KeyCode::Down => self.state.transition(TuiWidgetEvent::DownKey),
+                    // KeyCode::Home => self.state.transition(TuiWidgetEvent::),
+                    // KeyCode::End => self.state.transition(TuiWidgetEvent::),
+                    KeyCode::PageUp => self.state.transition(TuiWidgetEvent::PrevPageKey),
+                    KeyCode::PageDown => self.state.transition(TuiWidgetEvent::NextPageKey),
+                    KeyCode::Esc => {
+                        self.open = false;
+                        return true;
+                    }
+                    _ => return false,
+                }
+            }
+            self.open
+        }
+    }
+}
+
+pub(crate) mod mouse {
+    use bevy::prelude::*;
+    use bevy_ratatui::event::MouseMessage;
+    use ratatui::layout::Position;
+
+    use crate::tui::render::{Hovered, PickRegion};
+
+    pub(crate) fn mouse(
+        mut commands: Commands,
+        mut messages: MessageReader<MouseMessage>,
+        entities: Query<(Entity, &PickRegion)>,
+        hovered: Query<(Entity, &PickRegion), With<Hovered>>,
+    ) -> Result {
+        for message in messages.read() {
+            let event = message.0;
+            // let term_size = context.size().unwrap();
+            let position = Position::new(event.column, event.row);
+            match event.kind {
+                ratatui::crossterm::event::MouseEventKind::Down(mouse_button) => match mouse_button
+                {
+                    ratatui::crossterm::event::MouseButton::Left => {
+                        for (_entity, _region) in &entities {}
+                    }
+                    // ratatui::crossterm::event::MouseButton::Right => todo!(),
+                    // ratatui::crossterm::event::MouseButton::Middle => todo!(),
+                    _ => {}
+                },
+                // ratatui::crossterm::event::MouseEventKind::Up(mouse_button) => todo!(),
+                // ratatui::crossterm::event::MouseEventKind::Drag(mouse_button) => todo!(),
+                ratatui::crossterm::event::MouseEventKind::Moved => {
+                    for (entity, region) in &hovered {
+                        if !region.area.contains(position) {
+                            commands.get_entity(entity)?.remove::<Hovered>();
+                        }
+                    }
+                    for (entity, region) in &entities {
+                        // debug!(
+                        //     "{:?}, {position:?}",
+                        //     // region.area.positions().collect::<Vec<_>>()
+                        //     region.area
+                        // );
+                        if region.area.contains(position) {
+                            commands.get_entity(entity)?.insert(Hovered);
+                            // trace!("{entity:?} hovered!")
+                        }
+                    }
+                }
+                // ratatui::crossterm::event::MouseEventKind::ScrollDown => todo!(),
+                // ratatui::crossterm::event::MouseEventKind::ScrollUp => todo!(),
+                // ratatui::crossterm::event::MouseEventKind::ScrollLeft => todo!(),
+                // ratatui::crossterm::event::MouseEventKind::ScrollRight => todo!(),
+                _ => {}
+            }
+        }
+
+        Ok(())
+    }
+}

src/tui/input/keyboard.rs

@@ -1,91 +0,0 @@
-use bevy::prelude::*;
-use bevy_ratatui::crossterm::event::KeyCode;
-use bevy_ratatui::event::KeyMessage;
-
-use jong::game::GameState;
-
-use crate::tui::{TuiState, ZenState, console::ConsoleState};
-
-// TODO change this to handle console open request, esc for menu, etc, then
-// route other messages to other systems
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn input_system(
-    mut messages: MessageReader<KeyMessage>,
-
-    curr_tuistate: Res<State<TuiState>>,
-    curr_consolestate: Res<State<ConsoleState>>,
-    curr_gamestate: Res<State<GameState>>,
-    curr_zenstate: Option<Res<State<ZenState>>>,
-
-    mut next_tuistate: ResMut<NextState<TuiState>>,
-    mut next_consolestate: ResMut<NextState<ConsoleState>>,
-    mut next_gamestate: ResMut<NextState<GameState>>,
-    mut next_zenstate: ResMut<NextState<ZenState>>,
-
-    mut exit: MessageWriter<AppExit>,
-) {
-    let (ts, cs, gs) = (
-        curr_tuistate.get(),
-        curr_consolestate.get(),
-        curr_gamestate.get(),
-    );
-
-    for message in messages.read() {
-        if let KeyCode::Char('`') = message.code {
-            next_consolestate.set(!*curr_consolestate.get());
-            continue;
-        }
-
-        if *cs == ConsoleState::Open {
-            let mut passthrough = false;
-            match message.code {
-                KeyCode::Up => todo!(),
-                KeyCode::Down => todo!(),
-                KeyCode::Home => todo!(),
-                KeyCode::End => todo!(),
-                KeyCode::PageUp => todo!(),
-                KeyCode::PageDown => todo!(),
-                KeyCode::Esc => next_consolestate.set(ConsoleState::Closed),
-                _ => passthrough = true,
-            }
-            if !passthrough {
-                continue;
-            }
-        }
-
-        match ts {
-            TuiState::MainMenu => match message.code {
-                KeyCode::Char('p') => {
-                    next_tuistate.set(TuiState::InGame);
-                    next_gamestate.set(GameState::Setup);
-                }
-                KeyCode::Char('z') => {
-                    if let Some(ref curr_zenstate) = curr_zenstate {
-                        match curr_zenstate.get() {
-                            ZenState::Menu => next_zenstate.set(ZenState::Zen),
-                            ZenState::Zen => next_zenstate.set(ZenState::Menu),
-                        }
-                    }
-                }
-                KeyCode::Char('q') => {
-                    exit.write_default();
-                }
-                _ => {}
-            },
-            TuiState::InGame => match gs {
-                GameState::Setup => match message.code {
-                    _ => {}
-                },
-                GameState::Play => match message.code {
-                    KeyCode::Char('q') => {
-                        exit.write_default();
-                    }
-                    _ => {}
-                },
-                _ => todo!(),
-                _ => unreachable!("TuiState::InGame but GameState invalid"),
-            },
-        }
-    }
-}

src/tui/input/mod.rs

@@ -1,2 +0,0 @@
-pub(crate) mod keyboard;
-pub(crate) mod mouse;

src/tui/input/mouse.rs

@@ -1,65 +0,0 @@
-use bevy::prelude::*;
-use bevy_ratatui::{RatatuiContext, event::MouseMessage};
-use ratatui::layout::Position;
-
-use crate::tui::render::Hovered;
-
-#[derive(Component)]
-pub(crate) struct PickRegion {
-    pub(crate) area: ratatui::prelude::Rect,
-}
-
-// enum PickEvent {
-//     Click { col: u16, row: u16 },
-//     Hover { col: u16, row: u16 },
-// }
-
-pub(crate) fn input_system(
-    mut commands: Commands,
-    mut messages: MessageReader<MouseMessage>,
-    _context: Res<RatatuiContext>,
-    entities: Query<(Entity, &PickRegion)>,
-    hovered: Query<(Entity, &PickRegion), With<Hovered>>,
-) -> Result {
-    for message in messages.read() {
-        let event = message.0;
-        // let term_size = context.size().unwrap();
-        let position = Position::new(event.column, event.row);
-        match event.kind {
-            ratatui::crossterm::event::MouseEventKind::Down(mouse_button) => match mouse_button {
-                ratatui::crossterm::event::MouseButton::Left => {
-                    for (_entity, _region) in &entities {}
-                }
-                // ratatui::crossterm::event::MouseButton::Right => todo!(),
-                // ratatui::crossterm::event::MouseButton::Middle => todo!(),
-                _ => {}
-            },
-            // ratatui::crossterm::event::MouseEventKind::Up(mouse_button) => todo!(),
-            // ratatui::crossterm::event::MouseEventKind::Drag(mouse_button) => todo!(),
-            ratatui::crossterm::event::MouseEventKind::Moved => {
-                for (entity, region) in &hovered {
-                    if !region.area.contains(position) {
-                        commands.get_entity(entity)?.remove::<Hovered>();
-                    }
-                }
-                for (entity, region) in &entities {
-                    // debug!(
-                    //     "{:?}, {position:?}",
-                    //     region.area.positions().collect::<Vec<_>>()
-                    // );
-                    if region.area.contains(position) {
-                        commands.get_entity(entity)?.insert(Hovered);
-                        // trace!("{entity:?} hovered!")
-                    }
-                }
-            }
-            // ratatui::crossterm::event::MouseEventKind::ScrollDown => todo!(),
-            // ratatui::crossterm::event::MouseEventKind::ScrollUp => todo!(),
-            // ratatui::crossterm::event::MouseEventKind::ScrollLeft => todo!(),
-            // ratatui::crossterm::event::MouseEventKind::ScrollRight => todo!(),
-            _ => {}
-        }
-    }
-
-    Ok(())
-}

src/tui/layout.rs

@@ -0,0 +1,82 @@
+use bevy::prelude::*;
+use bevy_ratatui::RatatuiContext;
+use ratatui::{
+    layout::{Constraint, Layout, Margin},
+    prelude::Rect,
+};
+
+#[derive(Resource, Default)]
+pub(crate) struct Overlays {
+    pub(crate) stack: Vec<Overlay>,
+}
+
+pub(crate) enum Overlay {}
+
+#[derive(Resource, Clone, Copy)]
+pub(crate) struct HandLayouts {
+    pub(crate) left_pond: Rect,
+    pub(crate) cross_pond: Rect,
+    pub(crate) right_pond: Rect,
+    pub(crate) this_pond: Rect,
+    pub(crate) left_hand: Rect,
+    pub(crate) cross_hand: Rect,
+    pub(crate) right_hand: Rect,
+    pub(crate) this_hand: Rect,
+}
+
+pub(crate) enum LayoutError {
+    TerminalTooSmall,
+}
+
+pub(crate) fn layout(mut commands: Commands, mut tui: ResMut<RatatuiContext>) -> Result {
+    tui.autoresize()?;
+    let frame = tui.get_frame();
+    let term_area = frame.area();
+
+    let tiles = tiles_areas(term_area);
+    commands.insert_resource(tiles);
+
+    Ok(())
+}
+
+// TODO make fallible to warn area too small
+fn tiles_areas(term_area: Rect) -> HandLayouts {
+    let constraints = [Constraint::Fill(3), Constraint::Fill(18)];
+    let horizontal_slicer_right = Layout::horizontal(constraints);
+    let vertical_slicer_bottom = Layout::vertical(constraints);
+    let horizontal_slicer_left = Layout::horizontal(constraints.iter().rev());
+    let vertical_slicer_top = Layout::vertical(constraints.iter().rev());
+    let [left_hand, this_hand] = horizontal_slicer_right.areas::<2>(term_area);
+    let [_, left_hand] = vertical_slicer_bottom.areas::<2>(left_hand);
+    let [_, this_hand] = vertical_slicer_top.areas::<2>(this_hand);
+    let [cross_hand, right_hand] = horizontal_slicer_left.areas::<2>(term_area);
+    let [right_hand, _] = vertical_slicer_top.areas::<2>(right_hand);
+    let [cross_hand, _] = vertical_slicer_bottom.areas::<2>(cross_hand);
+
+    let margin = Margin::new(
+        (left_hand.width + right_hand.width) / 2,
+        (cross_hand.height + this_hand.height) / 2,
+    );
+    let pond_area = term_area.inner(margin);
+    let all_pond = Layout::horizontal([Constraint::Fill(1); 3]);
+    let cross_pond =
+        Layout::vertical([Constraint::Fill(1), Constraint::Max(1), Constraint::Fill(1)]);
+    let [mut left_pond, center, mut right_pond] = all_pond.areas::<3>(pond_area);
+    let [cross_pond, _compass, this_pond] = cross_pond.areas::<3>(center);
+    // let shift = left_pond.height - cross_pond.height;
+    left_pond.height = cross_pond.height;
+    left_pond.y += cross_pond.height / 2;
+    right_pond.height = cross_pond.height;
+    right_pond.y += cross_pond.height / 2;
+
+    HandLayouts {
+        left_pond,
+        cross_pond,
+        right_pond,
+        this_pond,
+        left_hand,
+        cross_hand,
+        right_hand,
+        this_hand,
+    }
+}

src/tui/mod.rs

@@ -1,95 +0,0 @@
-use std::time::Duration;
-
-use bevy::{app::ScheduleRunnerPlugin, prelude::*, state::app::StatesPlugin};
-use bevy_ratatui::RatatuiPlugins;
-
-use jong::game::GameState;
-
-use crate::tui::render::{WidgetStack, menu::Splash};
-// use jong::game::wall::InWall;
-
-
-mod console;
-mod render;
-mod input;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, States, Default)]
-pub(crate) enum TuiState {
-    #[default]
-    MainMenu,
-    InGame,
-}
-
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-struct InGame;
-
-impl ComputedStates for InGame {
-    type SourceStates = TuiState;
-
-    fn compute(sources: Self::SourceStates) -> Option<Self> {
-        match sources {
-            TuiState::InGame => Some(Self),
-            _ => None,
-        }
-    }
-}
-
-#[derive(SubStates, Default, Clone, Copy, PartialEq, Eq, Hash, Debug,)]
-#[source(TuiState = TuiState::MainMenu)]
-pub(crate) enum ZenState {
-    #[default]
-    Menu,
-    Zen,
-}
-
-#[derive(Default)]
-pub struct RiichiTui;
-impl Plugin for RiichiTui {
-    fn build(&self, app: &mut App) {
-        app.add_plugins((
-            MinimalPlugins.set(ScheduleRunnerPlugin::run_loop(Duration::from_secs_f32(
-                1. / 60.,
-            ))),
-            RatatuiPlugins {
-                // enable_kitty_protocol: todo!(),
-                enable_mouse_capture: true,
-                enable_input_forwarding: true,
-                ..Default::default()
-            },
-        ))
-        .add_plugins(StatesPlugin)
-
-        // general setup
-        .init_state::<TuiState>()
-        .add_computed_state::<InGame>()
-        .init_resource::<WidgetStack>()
-        .add_sub_state::<ZenState>()
-        .init_resource::<Splash>()
-        .init_state::<console::ConsoleState>()
-        .add_systems(PostUpdate, console::draw_console.run_if(in_state(console::ConsoleState::Open)))
-
-        // input
-        .add_systems(PreUpdate, input::keyboard::input_system)
-        .add_systems(PreUpdate, input::mouse::input_system)
-
-        // main menu
-        .add_systems(PostStartup, render::menu::init_splash)
-        .insert_resource(Time::<Fixed>::from_seconds(1.0))
-        .add_systems(FixedUpdate, render::menu::render_splash.run_if(in_state(TuiState::MainMenu)))
-        .add_systems(Update, render::menu::draw_splash.run_if(in_state(TuiState::MainMenu)))
-        .add_systems(Update, render::menu::draw_mainmenu.after(render::menu::draw_splash).run_if(in_state(TuiState::MainMenu).and(in_state(ZenState::Menu))))
-
-        // gaming
-        .init_resource::<render::hand::RenderedHand>()
-        .add_systems(Update, render::hand::render_hands.run_if(in_state(InGame).and(in_state(GameState::Play))))
-        .add_systems(Update, render::ingame::draw_ingame.run_if(in_state(InGame)))
-
-        // render
-        .add_systems(Last, render::draw_system.run_if(not(in_state(InGame))))
-        
-        // semicolon stopper
-        ;
-    }
-}
-
-

src/tui/render.rs

@@ -0,0 +1,205 @@
+use std::io::Write as _;
+use std::ops::Sub;
+
+use bevy::platform::collections::HashSet;
+use bevy::prelude::*;
+use bevy_ratatui::RatatuiContext;
+use ratatui::layout::{Constraint, Flex, Layout, Offset, Rect, Size};
+use ratatui::style::{Modifier, Style, Stylize};
+use ratatui::widgets::{Block, Borders, Clear, Paragraph};
+
+use jong::game::hand::{DrawnTile, Hand};
+use jong::game::player::{MainPlayer, Player};
+use jong::game::round::Wind;
+use jong::tile::Tile;
+
+use crate::tui::layout::*;
+use crate::tui::states::ConsoleWidget;
+
+#[derive(Component)]
+pub(crate) struct Hovered;
+
+#[derive(Component)]
+pub(crate) struct PickRegion {
+    pub(crate) area: Rect,
+}
+
+fn render_tile(tile: &Tile, hovered: bool) -> (Paragraph<'_>) {
+    let block = ratatui::widgets::Block::bordered();
+    let mut widget = Paragraph::new(match &tile.suit {
+        jong::tile::Suit::Pin(rank) => format!("{}\np", rank.0),
+        jong::tile::Suit::Sou(rank) => format!("{}\ns", rank.0),
+        jong::tile::Suit::Man(rank) => format!("{}\nm", rank.0),
+        jong::tile::Suit::Wind(wind) => (match wind {
+            jong::tile::Wind::Ton => "e\nw",
+            jong::tile::Wind::Nan => "s\nw",
+            jong::tile::Wind::Shaa => "w\nw",
+            jong::tile::Wind::Pei => "n\nw",
+        })
+        .into(),
+        jong::tile::Suit::Dragon(dragon) => (match dragon {
+            jong::tile::Dragon::Haku => "w\nd",
+            jong::tile::Dragon::Hatsu => "g\nd",
+            jong::tile::Dragon::Chun => "r\nd",
+        })
+        .into(),
+    })
+    .block(block)
+    .centered();
+
+    if hovered {
+        widget = widget.add_modifier(Modifier::BOLD);
+    }
+
+    widget
+}
+
+fn debug_blocks(layouts: HandLayouts, frame: &mut ratatui::Frame<'_>) {
+    let debug_block = Block::new().borders(Borders::ALL);
+    frame.render_widget(debug_block.clone(), layouts.this_hand);
+    frame.render_widget(debug_block.clone(), layouts.left_hand);
+    frame.render_widget(debug_block.clone(), layouts.cross_hand);
+    frame.render_widget(debug_block.clone(), layouts.right_hand);
+    frame.render_widget(debug_block.clone(), layouts.this_pond);
+    frame.render_widget(debug_block.clone(), layouts.left_pond);
+    frame.render_widget(debug_block.clone(), layouts.cross_pond);
+    frame.render_widget(debug_block.clone(), layouts.right_pond);
+}
+
+pub(crate) fn render(
+    mut tui: ResMut<RatatuiContext>,
+    layouts: Res<HandLayouts>,
+    overlays: Res<Overlays>,
+    consolewidget: Res<ConsoleWidget>,
+) -> Result {
+    let mut frame = tui.get_frame();
+
+    for overlay in overlays.stack.iter() {
+        match overlay {
+            _ => {}
+        }
+    }
+
+    if consolewidget.open {
+        let block = Block::bordered().title("console [press esc to close]");
+        frame.render_widget(Clear, frame.area());
+        frame.render_widget(
+            tui_logger::TuiLoggerWidget::default()
+                .block(block)
+                .state(&consolewidget.state),
+            frame.area(), /* .inner(Margin { horizontal: 8, vertical: 8 }) */
+        );
+    }
+
+    tui.hide_cursor()?;
+    tui.flush()?;
+    tui.swap_buffers();
+    tui.backend_mut().flush()?;
+    Ok(())
+}
+
+pub(crate) fn render_hands(
+    mut commands: Commands,
+    mut tui: ResMut<RatatuiContext>,
+    hovered: Query<Entity, With<Hovered>>,
+    layouts: Res<HandLayouts>,
+    mainplayer: Single<(&Player, &Wind), With<MainPlayer>>,
+    players: Populated<(&Player, /* &Wind, */ &Children)>,
+    hands: Populated<&Children, (With<Hand>, Without<Player>)>,
+    tiles: Populated<&Tile>,
+    drawn_tile: Option<Single<(&Player, &DrawnTile, Entity)>>,
+) -> Result {
+    let mut frame = tui.get_frame();
+    debug_blocks(*layouts, &mut frame);
+
+    for (player, /* wind, */ hand_ent) in players {
+        let hand = hand_ent.iter().next().unwrap();
+        let hand: Vec<_> = hands
+            .get(hand)?
+            .iter()
+            .map(|entity| -> Result<_> {
+                let tile = tiles.get(entity)?;
+                // let paragraph = render_tile(tile,);
+                let hovered = hovered.contains(entity);
+                let widget = render_tile(tile, hovered);
+                Ok((entity, widget, hovered))
+            })
+            .collect::<Result<_>>()?;
+
+        if player == mainplayer.0 {
+            // split main box into thirds
+            let mut this_hand = layouts.this_hand;
+            let this_drawer = drawn_tile.as_ref().is_some_and(|dt| dt.0 == player);
+            let tile_drawn = if this_drawer { 7 } else { 0 };
+            let hand_draw_meld = Layout::horizontal([
+                Constraint::Max(hand.len() as u16 * 5),
+                Constraint::Max(tile_drawn),
+                Constraint::Fill(1),
+            ])
+            .flex(Flex::SpaceBetween);
+            this_hand = this_hand.offset(Offset {
+                x: 0,
+                y: this_hand.height.abs_diff(5) as i32 + 1,
+            });
+            this_hand = this_hand.resize(Size {
+                width: this_hand.width,
+                height: 4,
+            });
+            let [hand_area, drawn_area, meld_area] = hand_draw_meld.areas::<3>(this_hand);
+
+            // split hand area into tile areas
+            let mut constraints = vec![Constraint::Max(5); hand.len()];
+            constraints.push(Constraint::Fill(1));
+            let layout = Layout::horizontal(constraints).flex(Flex::Start);
+            let tile_areas = layout.split(hand_area);
+
+            for ((entity, widget, hovered), mut area) in
+                hand.into_iter().zip(tile_areas.iter().copied())
+            {
+                if hovered {
+                    area = area.offset(Offset { x: 0, y: -1 });
+                    let mut hitbox = area.as_size();
+                    hitbox.height += 1;
+                    commands.entity(entity).insert(PickRegion {
+                        area: area.resize(hitbox),
+                    });
+                } else {
+                    commands.entity(entity).insert(PickRegion { area });
+                }
+                frame.render_widget(widget, area);
+            }
+
+            // tsumo tile
+            if this_drawer {
+                let (_, tile, entity) = **drawn_tile.as_ref().unwrap();
+                let mut area = drawn_area.resize(Size {
+                    width: 5,
+                    height: 4,
+                });
+                area = area.offset(Offset { x: 2, y: 0 });
+                let hovered = hovered.contains(entity);
+                let widget = render_tile(tiles.get(tile.0)?, hovered);
+                if hovered {
+                    area = area.offset(Offset { x: 0, y: -1 });
+                    let mut hitbox = area.as_size();
+                    hitbox.height += 1;
+                    commands.entity(entity).insert(PickRegion {
+                        area: area.resize(hitbox),
+                    });
+                } else {
+                    commands.entity(entity).insert(PickRegion { area });
+                }
+                frame.render_widget(widget, area);
+            }
+            // TODO draw melds
+        } else {
+            // match mainplayer.1.relate(wind) {
+            //     jong::game::round::WindRelation::Shimocha => todo!(),
+            //     jong::game::round::WindRelation::Toimen => todo!(),
+            //     jong::game::round::WindRelation::Kamicha => todo!(),
+            // }
+        }
+    }
+
+    Ok(())
+}

src/tui/render/hand.rs

@@ -1,45 +0,0 @@
-use bevy::{platform::collections::HashMap, prelude::*};
-
-use jong::{
-    game::{hand::Hand, player::Player},
-    tile::Tile,
-};
-
-use crate::tui::render::tile::{self, RenderedTile};
-
-#[derive(Resource, Default)]
-pub(crate) struct RenderedHand(pub(crate) HashMap<Entity, Vec<Entity>>);
-
-#[allow(clippy::type_complexity)]
-pub(crate) fn render_hands(
-    mut commands: Commands,
-    mut rendered_hand: ResMut<RenderedHand>,
-    tiles: Populated<&Tile>,
-    player_hands: Populated<(Entity, &Children), (With<Player>, Changed<Hand>)>,
-    hands: Populated<&Children, (Changed<Hand>, Without<Player>)>,
-) -> Result {
-    let mut rendered = HashMap::new();
-
-    for (player_ent, hand) in player_hands {
-        let hand = hand.iter().next().unwrap();
-        let tiles = hands
-            .get(hand)?
-            .iter()
-            .map(|it| {
-                tiles
-                    .get(it)
-                    // .inspect(|t| debug!("{t:?}"))
-                    .map(tile::draw_tile)
-                    .map(|p| commands.spawn(RenderedTile(p)).id())
-                    // .inspect(|e| debug!("{e:?}"))
-                    .unwrap()
-            })
-            .collect();
-        rendered.insert(player_ent, tiles);
-    }
-
-    rendered_hand.0 = rendered;
-
-    trace!("render_hands");
-    Ok(())
-}

src/tui/render/ingame.rs

@@ -1,136 +0,0 @@
-use bevy::prelude::*;
-use bevy_ratatui::RatatuiContext;
-use jong::game::hand::DrawnTile;
-use jong::game::player::{MainPlayer, Player};
-use jong::tile::Tile;
-use ratatui::widgets::{Block, Borders};
-
-use crate::tui::render::tile::draw_tile;
-use crate::tui::{
-    input::mouse::PickRegion,
-    render::{Hovered, hand, tile::RenderedTile},
-};
-
-pub(crate) fn draw_ingame(
-    mut commands: Commands,
-    mut tui_ctx: ResMut<RatatuiContext>,
-    tiles: Query<&Tile>,
-    hovered_entity: Query<Entity, With<Hovered>>,
-    main_player: Single<Entity, (With<Player>, With<MainPlayer>)>,
-    rendered_tiles: Populated<&RenderedTile>,
-    rendered_hand: Res<hand::RenderedHand>,
-    drawn_tile: Option<Single<&DrawnTile, With<MainPlayer>>>,
-) -> Result {
-    use ratatui::layout::Flex;
-    use ratatui::prelude::*;
-
-    tui_ctx.draw(|frame| {
-        // debug!("{}", frame.area());
-
-        let term_area = frame.area();
-
-        // TODO this is gross
-        let constraints = [Constraint::Fill(3), Constraint::Fill(18)];
-        let horizontal_slicer_right = Layout::horizontal(constraints);
-        let vertical_slicer_bottom = Layout::vertical(constraints);
-        let horizontal_slicer_left = Layout::horizontal(constraints.iter().rev());
-        let vertical_slicer_top = Layout::vertical(constraints.iter().rev());
-        let [left_hand, this_hand] = horizontal_slicer_right.areas::<2>(term_area);
-        let [_, left_hand] = vertical_slicer_bottom.areas::<2>(left_hand);
-        let [_, mut this_hand] = vertical_slicer_top.areas::<2>(this_hand);
-        let [cross_hand, right_hand] = horizontal_slicer_left.areas::<2>(term_area);
-        let [right_hand, _] = vertical_slicer_top.areas::<2>(right_hand);
-        let [cross_hand, _] = vertical_slicer_bottom.areas::<2>(cross_hand);
-
-        let margin = Margin::new(
-            (left_hand.width + right_hand.width) / 2,
-            (cross_hand.height + this_hand.height) / 2,
-        );
-        let pond_area = term_area.inner(margin);
-        let all_pond = Layout::horizontal([Constraint::Fill(1); 3]);
-        let cross_pond =
-            Layout::vertical([Constraint::Fill(1), Constraint::Max(1), Constraint::Fill(1)]);
-        let [mut left_pond, center, mut right_pond] = all_pond.areas::<3>(pond_area);
-        let [cross_pond, _compass, this_pond] = cross_pond.areas::<3>(center);
-        // let shift = left_pond.height - cross_pond.height;
-        left_pond.height = cross_pond.height;
-        left_pond.y += cross_pond.height / 2;
-        right_pond.height = cross_pond.height;
-        right_pond.y += cross_pond.height / 2;
-
-        let debug_block = Block::new().borders(Borders::ALL);
-        frame.render_widget(debug_block.clone(), this_hand);
-        frame.render_widget(debug_block.clone(), left_hand);
-        frame.render_widget(debug_block.clone(), cross_hand);
-        frame.render_widget(debug_block.clone(), right_hand);
-        frame.render_widget(debug_block.clone(), this_pond);
-        frame.render_widget(debug_block.clone(), left_pond);
-        frame.render_widget(debug_block.clone(), cross_pond);
-        frame.render_widget(debug_block.clone(), right_pond);
-
-        // TODO attempt to merge blocks on smol term?
-        if let Some(hand) = rendered_hand.0.get(&*main_player) {
-            let hand_area_layout = Layout::horizontal([
-                Constraint::Max(hand.len() as u16 * 5),
-                Constraint::Max(if drawn_tile.is_some() { 7 } else { 0 }),
-                Constraint::Fill(1),
-            ])
-            .flex(Flex::SpaceBetween);
-            let this_clamped = this_hand.height.abs_diff(5);
-            if let Some(_val) = this_hand.height.checked_sub(this_clamped) {
-                this_hand.height = 4
-            } else {
-                // FIXME show error
-                panic!("terminal too small!");
-            }
-            this_hand.y += this_clamped + 1;
-            let [this_hand, mut this_drawn, _this_meld] = hand_area_layout.areas::<3>(this_hand);
-
-            // this_hand
-            let mut constraints = vec![Constraint::Max(5); hand.len()];
-            constraints.push(Constraint::Fill(1));
-            let layout = Layout::horizontal(constraints).flex(Flex::Start);
-            let hand_areas = layout.split(this_hand);
-            for (tile, mut tile_area) in hand.iter().zip(hand_areas.iter().cloned()) {
-                // tile_area.height = 4;
-                let mut widget = rendered_tiles.get(*tile).unwrap().0.clone();
-                if hovered_entity.contains(*tile) {
-                    widget = widget.add_modifier(Modifier::BOLD);
-                    if let Some(val) = tile_area.y.checked_sub(1) {
-                        tile_area.y = val
-                    } else {
-                        // FIXME show error
-                        panic!("terminal too small!");
-                    }
-                }
-                commands
-                    .entity(*tile)
-                    .insert(PickRegion { area: tile_area });
-                frame.render_widget(widget, tile_area);
-            }
-
-            // this_drawn
-            if let Some(tile) = drawn_tile {
-                // this_drawn.height = 4;
-                this_drawn.width = 5;
-                this_drawn.x += 2;
-                let mut widget = draw_tile(tiles.get(tile.0).unwrap());
-                if hovered_entity.contains(tile.0) {
-                    widget = widget.add_modifier(Modifier::BOLD);
-                    if let Some(val) = this_drawn.y.checked_sub(1) {
-                        this_drawn.y = val
-                    } else {
-                        // FIXME show error
-                        panic!("terminal too small!");
-                    }
-                }
-                commands
-                    .entity(tile.0)
-                    .insert(PickRegion { area: this_drawn });
-                frame.render_widget(widget, this_drawn);
-            }
-        }
-    })?;
-
-    Ok(())
-}

src/tui/render/menu.rs

@@ -1,96 +0,0 @@
-use bevy::prelude::*;
-use bevy_ratatui::RatatuiContext;
-use rand::rng;
-use rand::seq::SliceRandom;
-use ratatui::layout::Constraint;
-use ratatui::layout::Flex;
-use ratatui::layout::Layout;
-use ratatui::layout::Margin;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::{Block, Clear};
-
-use jong::tile::Tile;
-
-use crate::tui::render::WidgetStack;
-use crate::tui::render::tile;
-
-const MAINMENU_OPTIONS: [&str; 2] = [
-    " ██╗██████╗ ██╗ ██╗      █████╗ ██╗   ██╗██╗
-██╔╝██╔══██╗╚██╗██║     ██╔══██╗╚██╗ ██╔╝██║
-██║ ██████╔╝ ██║██║     ███████║ ╚████╔╝ ██║
-██║ ██╔═══╝  ██║██║     ██╔══██║  ╚██╔╝  ╚═╝
-╚██╗██║     ██╔╝███████╗██║  ██║   ██║   ██╗
- ╚═╝╚═╝     ╚═╝ ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝
-",
-    " ██╗ ██████╗ ██╗ ██╗   ██╗██╗████████╗    ██╗
-██╔╝██╔═══██╗╚██╗██║   ██║██║╚══██╔══╝██╗██╔╝
-██║ ██║   ██║ ██║██║   ██║██║   ██║   ╚═╝██║ 
-██║ ██║▄▄ ██║ ██║██║   ██║██║   ██║   ██╗██║ 
-╚██╗╚██████╔╝██╔╝╚██████╔╝██║   ██║   ╚═╝╚██╗
- ╚═╝ ╚══▀▀═╝ ╚═╝  ╚═════╝ ╚═╝   ╚═╝       ╚═╝
-",
-];
-
-pub(crate) fn draw_mainmenu(mut widgets: ResMut<WidgetStack>) {
-    let options = MAINMENU_OPTIONS;
-    let layout =
-        Layout::vertical(vec![Constraint::Fill(1); options.len()]).flex(Flex::SpaceBetween);
-    let block = Block::bordered();
-
-    widgets.0.push(Box::new(move |frame| {
-        let area = frame
-            .area()
-            .centered(Constraint::Max(55), Constraint::Max(19));
-        frame.render_widget(Clear, area);
-        frame.render_widget(block, area);
-        let areas = layout.split(area.centered(Constraint::Max(45), Constraint::Max(14)));
-        for (opt, area) in options.into_iter().zip(areas.iter()) {
-            let para = Paragraph::new(opt);
-            frame.render_widget(para, *area)
-        }
-    }));
-}
-
-#[derive(Resource, Default)]
-pub(crate) struct Splash(pub Vec<Paragraph<'static>>);
-
-pub(crate) fn init_splash(mut commands: Commands, tiles: Populated<&Tile>) {
-    let tiles: Vec<_> = tiles
-        .iter()
-        .copied()
-        .map(|tile| tile::draw_tile(&tile))
-        .collect();
-
-    commands.insert_resource(Splash(tiles));
-    trace!("init_splash")
-}
-
-pub(crate) fn render_splash(mut splash: ResMut<Splash>) {
-    let mut rng = rng();
-    splash.0.shuffle(&mut rng);
-}
-
-pub(crate) fn draw_splash(mut widgets: ResMut<WidgetStack>, splash: Res<Splash>) {
-    let tiles: Vec<_> = splash.0.clone();
-    widgets.0.push(Box::new(move |frame| {
-        let area = frame.area().outer(Margin {
-            horizontal: 1,
-            vertical: 1,
-        });
-        let layout = Layout::horizontal(vec![Constraint::Length(5); (area.width / 5) as usize]);
-        let areas = layout.split(area);
-        let mut tile_chunks = tiles.chunks(areas.len()).cycle();
-        for area in areas.iter() {
-            let layout = Layout::vertical(vec![Constraint::Length(4); (area.height / 4) as usize]);
-            let areas = layout.split(*area);
-            // let tiles: Vec<_> = tile_it
-            //     .by_ref()
-            //     .take((area.height / 4 + 1) as usize)
-            //     .map(|t| tile::draw_tile(&t))
-            //     .collect();
-            for (tile, area) in tile_chunks.next().unwrap().iter().zip(areas.iter()) {
-                frame.render_widget(tile, *area);
-            }
-        }
-    }));
-}

src/tui/render/mod.rs

@@ -1,26 +0,0 @@
-use bevy::prelude::*;
-use bevy_ratatui::RatatuiContext;
-use ratatui::Frame;
-
-pub(crate) mod hand;
-pub(crate) mod ingame;
-pub(crate) mod menu;
-pub(crate) mod tile;
-
-#[derive(Resource, Default)]
-pub(crate) struct WidgetStack(pub(crate) Vec<Box<dyn FnOnce(&mut Frame) + Send + Sync>>);
-
-#[derive(Component)]
-pub(crate) struct Hovered;
-
-pub(crate) fn draw_system(
-    mut tui_ctx: ResMut<RatatuiContext>,
-    mut widgetstack: ResMut<WidgetStack>,
-) -> Result {
-    tui_ctx.draw(|frame| {
-        for widget in widgetstack.0.drain(..) {
-            widget(frame)
-        }
-    })?;
-    Ok(())
-}

src/tui/render/tile.rs

@@ -1,34 +0,0 @@
-use bevy::prelude::*;
-use ratatui::widgets::Paragraph;
-
-use jong::tile::Tile;
-
-#[derive(Component)]
-pub(crate) struct RenderedTile(pub(crate) Paragraph<'static>);
-
-pub(crate) fn draw_tile(tile: &Tile) -> Paragraph<'static> {
-    
-
-    let block = ratatui::widgets::Block::bordered();
-
-    Paragraph::new(match &tile.suit {
-        jong::tile::Suit::Pin(rank) => format!("{}\np", rank.0),
-        jong::tile::Suit::Sou(rank) => format!("{}\ns", rank.0),
-        jong::tile::Suit::Man(rank) => format!("{}\nm", rank.0),
-        jong::tile::Suit::Wind(wind) => (match wind {
-            jong::tile::Wind::Ton => "e\nw",
-            jong::tile::Wind::Nan => "s\nw",
-            jong::tile::Wind::Shaa => "w\nw",
-            jong::tile::Wind::Pei => "n\nw",
-        })
-        .into(),
-        jong::tile::Suit::Dragon(dragon) => (match dragon {
-            jong::tile::Dragon::Haku => "w\nd",
-            jong::tile::Dragon::Hatsu => "g\nd",
-            jong::tile::Dragon::Chun => "r\nd",
-        })
-        .into(),
-    })
-    .block(block)
-    .centered()
-}