render drawn, discard drawn

src/game.rs

@@ -47,6 +47,7 @@ impl Plugin for Riichi {
             .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, round::debug_discard.run_if(in_state(TurnState::Discard)))
             .add_systems(Update, round::ron_chi_pon_kan.run_if(in_state(TurnState::RonChiiPonKan)))
             .add_systems(OnEnter(TurnState::End), round::end)
             // .add_systems(Update, systems)

src/game/round.rs

@@ -155,31 +155,30 @@ pub(crate) fn discard(
 
     curr_player: Single<Entity, With<CurrentPlayer>>,
     players: Query<&Children, With<Player>>,
-    mut hands: Query<(&Children, Entity, &mut Hand), (With<Hand>, Without<Player>)>,
+    mut hands: Query<(&Children, Entity), (With<Hand>, Without<Player>)>,
     drawn: Single<Entity, With<Drawn>>,
 
     curr_turnstate: Res<State<TurnState>>,
     mut next_turnstate: ResMut<NextState<TurnState>>,
 ) -> Result {
     // trace!("discard");
-    let curr_hand = hands.get_mut(players.get(*curr_player)?.iter().next().unwrap())?;
+    let (handtiles, hand) = hands.get_mut(players.get(*curr_player)?.iter().next().unwrap())?;
 
     let mut done = false;
     while let Some(message) = reader.read().next() {
         if let GameMessage::Discarded(discarded) = message {
+            debug!("discarded: {discarded:?}");
             if *discarded == *drawn {
-            } else if curr_hand.0.contains(discarded) {
+            } else if handtiles.contains(discarded) {
                 commands
-                    .entity(curr_hand.1)
+                    .entity(hand)
                     .remove_child(*discarded)
                     .add_child(*drawn);
             } else {
                 panic!("current hand nor drawn tile contains discarded tile")
             }
-            commands
-                .entity(*discarded)
-                .remove::<Drawn>()
-                .insert(Discarded);
+            commands.entity(*drawn).remove::<Drawn>();
+            commands.entity(*discarded).insert(Discarded);
 
             done = true;
             break;

src/tui.rs

@@ -1,13 +1,12 @@
 use std::time::Duration;
 
-use bevy::{app::ScheduleRunnerPlugin, prelude::*, state::app::StatesPlugin, time::TimePlugin};
+use bevy::{app::ScheduleRunnerPlugin, prelude::*, state::app::StatesPlugin};
 use bevy_ratatui::RatatuiPlugins;
 use jong::game::{
     GameMessage, GameState,
     hand::{Drawn, Hand},
     player::{CurrentPlayer, Player},
 };
-use tracing::instrument;
 use tui_logger::TuiWidgetState;
 
 use crate::tui::{input::ConfirmSelect, states::ConsoleWidget};

src/tui/render.rs

@@ -94,6 +94,7 @@ pub(crate) fn render(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments, clippy::type_complexity)]
 pub(crate) fn render_hands(
     mut commands: Commands,
     mut tui: ResMut<RatatuiContext>,
@@ -102,18 +103,21 @@ pub(crate) fn render_hands(
     layouts: Res<HandLayouts>,
 
     tiles: Query<&Tile>,
-    main_player: Single<(&Player, &Wind), With<MainPlayer>>,
+    main_player: Single<(&Player, Entity, &Wind), With<MainPlayer>>,
     curr_player: Single<Entity, With<CurrentPlayer>>,
-    players: Query<(&Player, &Children)>,
+    players: Query<(&Player, Entity, &Children)>,
     hands: Query<(&Children, Entity), (With<Hand>, Without<Player>)>,
-    drawn_tile: Option<Single<(&Player, Entity), With<Drawn>>>,
+    drawn_tile: Single<Entity, With<Drawn>>,
 ) -> Result {
     let mut frame = tui.get_frame();
     debug_blocks(*layouts, &mut frame);
 
     for (hand, hand_ent) in hands {
         // debug!("{hand:?}");
-        let (player, _) = players.iter().find(|(_, c)| c.contains(&hand_ent)).unwrap();
+        let (player, player_ent, _) = players
+            .iter()
+            .find(|(_, e, c)| c.contains(&hand_ent))
+            .unwrap();
         let hand: Vec<_> = hand
             .iter()
             .map(|entity| -> Result<_> {
@@ -128,7 +132,8 @@ pub(crate) fn render_hands(
         if player == main_player.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 this_drawer = drawn_tile..is_some_and(|dt| dt.0 == player);
+            let this_drawer = player_ent == *curr_player;
             let tile_drawn = if this_drawer { 7 } else { 0 };
             let hand_draw_meld = Layout::horizontal([
                 Constraint::Max(hand.len() as u16 * 5),
@@ -170,23 +175,23 @@ pub(crate) fn render_hands(
 
             // tsumo tile
             if this_drawer {
-                let (_, entity) = **drawn_tile.as_ref().unwrap();
+                // trace!("this_drawer");
                 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(entity)?, hovered);
+                let hovered = hovered.contains(*drawn_tile);
+                let widget = render_tile(tiles.get(*drawn_tile)?, 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 {
+                    commands.entity(*drawn_tile).insert(PickRegion {
                         area: area.resize(hitbox),
                     });
                 } else {
-                    commands.entity(entity).insert(PickRegion { area });
+                    commands.entity(*drawn_tile).insert(PickRegion { area });
                 }
                 frame.render_widget(widget, area);
             }