discard a tile

src/game.rs

@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{ecs::query::QueryData, prelude::*};
 
 use crate::{
     game::{
@@ -24,6 +24,11 @@ pub enum GameState {
     Play,
 }
 
+#[derive(Message)]
+pub enum GameMessage {
+    Discarded(Entity),
+}
+
 pub struct Riichi;
 impl Plugin for Riichi {
     fn build(&self, app: &mut App) {
@@ -33,29 +38,27 @@ impl Plugin for Riichi {
             .add_sub_state::<TurnState>()
             .init_resource::<round::MatchSettings>()
             .init_resource::<round::Compass>()
+            .add_message::<GameMessage>()
             .add_systems(Startup, tile::init_tiles)
             .add_systems(OnEnter(GameState::Setup), setup)
             .add_systems(OnEnter(GameState::Deal), hand::shuffle_deal)
             .add_systems(Update, hand::sort_hands.run_if(in_state(GameState::Play)))
-            // .add_systems(Update, turn_manager.run_if(in_state(GameState::Play)))
             .add_systems(OnEnter(TurnState::Tsumo), round::tsumo)
+            .add_systems(OnEnter(TurnState::Menzen), round::menzen)
+            .add_systems(Update, round::riichi_kan.run_if(in_state(TurnState::RiichiKan)))
+            .add_systems(Update, round::discard.run_if(in_state(TurnState::Discard)))
+            // .add_systems(Update, systems)
             // semicolon stopper
             ;
     }
 }
 
-// struct TurnEvent {
-//     pub next: Option<Entity>,
-//     pub prev: Option<Entity>,
-// }
-
-// fn turn_manager() {}
-
 pub(crate) fn setup(
     mut commands: Commands,
     matchsettings: Res<round::MatchSettings>,
     // mut compass: ResMut<Compass>
     // tiles: Query<Entity, With<Tile>>,
+    curr_gamestate: Res<State<GameState>>,
     mut next_gamestate: ResMut<NextState<GameState>>,
 ) {
     for i in 1..=matchsettings.player_count {

src/game/hand.rs

@@ -8,7 +8,7 @@ use crate::{
 #[derive(Component)]
 pub struct Hand;
 
-#[derive(Component)]
+#[derive(Component, Debug)]
 pub struct DrawnTile(pub Entity);
 
 // #[derive(Component, Default)]
@@ -36,7 +36,7 @@ pub(crate) fn shuffle_deal(
     players: Populated<Entity, With<Player>>,
     wall_ent: Single<Entity, With<Wall>>,
     mut next_gamestate: ResMut<NextState<GameState>>,
-) -> Result {
+) {
     use rand::seq::SliceRandom;
 
     let mut rng = rand::rng();
@@ -53,14 +53,10 @@ pub(crate) fn shuffle_deal(
         let hand_ent = commands.spawn(Hand).add_children(&handtiles).id();
         debug!("hand_ent: {hand_ent:?}");
 
-        commands
+        commands.entity(player_ent).replace_children(&[hand_ent]);
-            .get_entity(player_ent)?
-            .replace_children(&[hand_ent]);
-
     }
 
-    commands.get_entity(*wall_ent)?.replace_children(&walltiles);
+    commands.entity(*wall_ent).replace_children(&walltiles);
 
     next_gamestate.set(GameState::Play);
-    Ok(())
 }

src/game/round.rs

@@ -3,9 +3,23 @@ use strum::{EnumCount, FromRepr};
 
 use crate::{
     EnumNextCycle,
-    game::{GameState, hand::DrawnTile, wall::Wall},
+    game::{
+        GameMessage, GameState,
+        hand::{DrawnTile, Hand},
+        player::Player,
+        wall::Wall,
+    },
 };
 
+#[derive(Resource)]
+pub struct CurrentPlayer(pub Entity);
+
+#[derive(Resource)]
+pub(crate) struct MatchSettings {
+    pub(crate) starting_points: isize,
+    pub(crate) player_count: u8,
+}
+
 #[derive(Component)]
 pub(crate) struct Dice(u8, u8);
 
@@ -18,33 +32,6 @@ pub(crate) struct Compass {
     pub(crate) honba: usize,
 }
 
-impl Default for Compass {
-    fn default() -> Self {
-        Self {
-            prevalent_wind: Wind::Ton,
-            round: 1,
-            dealer_wind: Wind::Ton,
-            riichi: 0,
-            honba: 0,
-        }
-    }
-}
-
-#[derive(Resource)]
-pub(crate) struct MatchSettings {
-    pub(crate) starting_points: isize,
-    pub(crate) player_count: u8,
-}
-
-impl Default for MatchSettings {
-    fn default() -> Self {
-        Self {
-            starting_points: 25000,
-            player_count: 4,
-        }
-    }
-}
-
 #[derive(Component, Clone, Copy, FromRepr, EnumCount, PartialEq)]
 pub enum Wind {
     Ton,
@@ -59,6 +46,42 @@ pub enum WindRelation {
     Kamicha,
 }
 
+#[derive(SubStates, Default, Clone, Copy, PartialEq, Eq, Hash, Debug, FromRepr, EnumCount)]
+#[source(GameState = GameState::Play)]
+pub(crate) enum TurnState {
+    #[default]
+    Tsumo,
+    Menzen,
+    RiichiKan,
+    Discard,
+    RonChiiPonKan,
+    End,
+}
+
+#[derive(EntityEvent)]
+pub struct Discard(pub Entity);
+
+impl Default for MatchSettings {
+    fn default() -> Self {
+        Self {
+            starting_points: 25000,
+            player_count: 4,
+        }
+    }
+}
+
+impl Default for Compass {
+    fn default() -> Self {
+        Self {
+            prevalent_wind: Wind::Ton,
+            round: 1,
+            dealer_wind: Wind::Ton,
+            riichi: 0,
+            honba: 0,
+        }
+    }
+}
+
 impl EnumNextCycle for Wind {
     fn next(&self) -> Self {
         if (*self as usize + 1) >= Self::COUNT {
@@ -81,21 +104,6 @@ impl Wind {
     }
 }
 
-#[derive(Resource)]
-pub(crate) struct CurrentPlayer(pub Entity);
-
-#[derive(SubStates, Default, Clone, Copy, PartialEq, Eq, Hash, Debug, FromRepr, EnumCount)]
-#[source(GameState = GameState::Play)]
-pub(crate) enum TurnState {
-    #[default]
-    Tsumo,
-    Menzen,
-    RiichiKan,
-    Discard,
-    RonChiiPonKan,
-    End,
-}
-
 impl EnumNextCycle for TurnState {
     fn next(&self) -> Self {
         if (*self as usize + 1) >= Self::COUNT {
@@ -125,3 +133,44 @@ pub(crate) fn tsumo(
 
     next_turnstate.set(curr_turnstate.next());
 }
+
+pub(crate) fn menzen(
+    curr_turnstate: Res<State<TurnState>>,
+    mut next_turnstate: ResMut<NextState<TurnState>>,
+) {
+    next_turnstate.set(curr_turnstate.next());
+}
+
+pub(crate) fn riichi_kan(
+    curr_turnstate: Res<State<TurnState>>,
+    mut next_turnstate: ResMut<NextState<TurnState>>,
+) {
+    next_turnstate.set(curr_turnstate.next());
+}
+
+pub(crate) fn discard(
+    mut reader: MessageReader<GameMessage>,
+
+    currplayer: Res<CurrentPlayer>,
+    drawntile: Single<Entity, With<DrawnTile>>,
+    player_hands: Populated<(&Player, &Children), With<Hand>>,
+    hands: Populated<&Children, (With<Hand>, Without<Player>)>,
+
+    curr_turnstate: Res<State<TurnState>>,
+    mut next_turnstate: ResMut<NextState<TurnState>>,
+) {
+    let curr = currplayer.0;
+    let hand_ent = player_hands.get(curr).unwrap().1.iter().next().unwrap();
+    let hand = hands.get(hand_ent).unwrap();
+
+    while let Some(message) = reader.read().next() {
+        if let GameMessage::Discarded(entity) = message {
+            if *entity == *drawntile {
+            } else if hand.contains(entity) {
+            } else {
+                panic!("discarded illegal player tile?")
+            }
+            break;
+        }
+    }
+}

src/lib.rs

@@ -1,4 +1,4 @@
-#![feature(stmt_expr_attributes)]
+#![feature(stmt_expr_attributes, iter_array_chunks)]
 
 pub mod game;
 pub mod tile;

src/tile.rs

@@ -1,4 +1,4 @@
-use bevy::{ecs::entity::MapEntities, prelude::*};
+use bevy::prelude::*;
 use strum::FromRepr;
 
 #[derive(Component, Debug, Clone, Copy)]

src/tui.rs

@@ -2,10 +2,15 @@ use std::time::Duration;
 
 use bevy::{app::ScheduleRunnerPlugin, prelude::*, state::app::StatesPlugin};
 use bevy_ratatui::RatatuiPlugins;
-use jong::game::GameState;
+use jong::game::{
+    GameMessage, GameState,
+    hand::{DrawnTile, Hand},
+    player::{MainPlayer, Player},
+    round::{CurrentPlayer, Discard},
+};
 use tui_logger::TuiWidgetState;
 
-use crate::tui::states::ConsoleWidget;
+use crate::tui::{input::ConfirmSelect, states::ConsoleWidget};
 
 mod input;
 mod layout;
@@ -45,11 +50,13 @@ impl Plugin for TuiPlugin {
             Update,
             (TuiSet::Input, TuiSet::Layout, TuiSet::Render).chain(),
         )
+        .add_message::<ConfirmSelect>()
         .add_systems(
             Update,
             (input::keyboard, input::mouse).in_set(TuiSet::Input),
         )
         .add_systems(Update, layout::layout.in_set(TuiSet::Layout))
+        .add_systems(Update, discard_tile.run_if(in_state(GameState::Play)))
         .add_systems(
             Update,
             (
@@ -62,6 +69,25 @@ impl Plugin for TuiPlugin {
     }
 }
 
+fn discard_tile(
+    mut writer: MessageWriter<GameMessage>,
+    mut selected: MessageReader<ConfirmSelect>,
+    drawntile: Single<Entity, With<DrawnTile>>,
+    currplayer: Res<CurrentPlayer>,
+    player_hands: Populated<(&Player, &Children), With<Hand>>,
+    hands: Populated<&Children, (With<Hand>, Without<Player>)>,
+) {
+    let curr = currplayer.0;
+    let hand_ent = player_hands.get(curr).unwrap().1.iter().next().unwrap();
+    let hand = hands.get(hand_ent).unwrap();
+
+    while let Some(message) = selected.read().next()
+        && (message.0 == *drawntile || hand.contains(&message.0))
+    {
+        writer.write(GameMessage::Discarded(message.0));
+    }
+}
+
 mod states {
     use bevy::prelude::*;
     use tui_logger::TuiWidgetState;

src/tui/input.rs

@@ -1,149 +1,16 @@
+use bevy::prelude::*;
+
 pub(crate) use keyboard::keyboard;
 pub(crate) use mouse::mouse;
 
-pub(crate) mod keyboard {
+pub(crate) mod keyboard;
-    use bevy::prelude::*;
+pub(crate) mod mouse;
-    use bevy_ratatui::event::KeyMessage;
-    use ratatui::crossterm::event::KeyCode;
-    use tui_logger::TuiWidgetEvent;
 
-    use jong::game::GameState;
+#[derive(Component)]
+pub(crate) struct Hovered;
 
-    use crate::tui::layout::Overlays;
+#[derive(Component)]
-    use crate::tui::states::ConsoleWidget;
+pub(crate) struct StartSelect;
-    use crate::tui::states::TuiState;
 
-    pub(crate) fn keyboard(
+#[derive(Message)]
-        mut messages: MessageReader<KeyMessage>,
+pub(crate) struct ConfirmSelect(pub(crate) Entity);
-        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

@@ -0,0 +1,85 @@
+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 => debug!("unhandled keyboard event"),
+        }
+    }
+}
+
+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
+    }
+}

src/tui/input/mouse.rs

@@ -0,0 +1,81 @@
+use bevy::prelude::*;
+use bevy_ratatui::event::MouseMessage;
+use ratatui::layout::Position;
+
+use crate::tui::{
+    input::{ConfirmSelect, Hovered, StartSelect},
+    render::PickRegion,
+};
+
+pub(crate) fn mouse(
+    mut commands: Commands,
+    mut mouse_reader: MessageReader<MouseMessage>,
+    mut event_writer: MessageWriter<ConfirmSelect>,
+    entities: Query<(Entity, &PickRegion)>,
+    hovered: Query<(Entity, &PickRegion), With<Hovered>>,
+    startselected: Query<(Entity, &PickRegion), With<StartSelect>>,
+) {
+    for message in mouse_reader.read() {
+        let event = message.0;
+        // let term_size = context.size().unwrap();
+        let position = Position::new(event.column, event.row);
+        match event.kind {
+            #[allow(clippy::single_match)]
+            ratatui::crossterm::event::MouseEventKind::Down(mouse_button) => match mouse_button {
+                ratatui::crossterm::event::MouseButton::Left => {
+                    for (entity, region) in &entities {
+                        if region.area.contains(position) {
+                            commands.entity(entity).insert(StartSelect);
+                        }
+                    }
+                }
+
+                // ratatui::crossterm::event::MouseButton::Right => debug!("unhandled mouse event"),
+                // ratatui::crossterm::event::MouseButton::Middle => debug!("unhandled mouse event"),
+                _ => {}
+            },
+            ratatui::crossterm::event::MouseEventKind::Moved => {
+                for (entity, region) in &hovered {
+                    if !region.area.contains(position) {
+                        commands.entity(entity).remove::<Hovered>();
+                    }
+                }
+                for (entity, region) in &entities {
+                    if region.area.contains(position) {
+                        commands.entity(entity).insert(Hovered);
+                    }
+                }
+            }
+            ratatui::crossterm::event::MouseEventKind::Up(mouse_button) => match mouse_button {
+                ratatui::crossterm::event::MouseButton::Left => {
+                    for (entity, region) in &startselected {
+                        if region.area.contains(position) {
+                            commands.entity(entity).remove::<StartSelect>();
+                            event_writer.write(ConfirmSelect(entity));
+                        }
+                    }
+                }
+                ratatui::crossterm::event::MouseButton::Right => {
+                    for (entity, _) in &startselected {
+                        commands.entity(entity).remove::<StartSelect>();
+                    }
+                }
+                // ratatui::crossterm::event::MouseButton::Middle => debug!("unhandled mouse event"),
+                _ => {}
+            },
+            ratatui::crossterm::event::MouseEventKind::Drag(mouse_button) => {
+                debug!("unhandled mouse event")
+            }
+            ratatui::crossterm::event::MouseEventKind::ScrollDown => {
+                debug!("unhandled mouse event")
+            }
+            ratatui::crossterm::event::MouseEventKind::ScrollUp => debug!("unhandled mouse event"),
+            ratatui::crossterm::event::MouseEventKind::ScrollLeft => {
+                debug!("unhandled mouse event")
+            }
+            ratatui::crossterm::event::MouseEventKind::ScrollRight => {
+                debug!("unhandled mouse event")
+            }
+        }
+    }
+}

src/tui/render.rs

@@ -13,12 +13,10 @@ use jong::game::player::{MainPlayer, Player};
 use jong::game::round::Wind;
 use jong::tile::Tile;
 
+use crate::tui::input::Hovered;
 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,