From e990957ac067567c72f37def0297834f960b90b6 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 16:52:46 +0100
Subject: [PATCH 1/6] fix: Update toggle TileState debug bind to Shift + LMB
 instead of only LMB

---
 README.md                 |  2 +-
 src/features/input/mod.rs | 71 +++++++++++++++++++++++++++++++--------
 2 files changed, 58 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 73f0c50..f69b5e6 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ cargo run
 ### Hidden binds (Only available in the debug build)
 
 - `Shift + Enter`: Duration of the current phase is set to 3 seconds.
-- `Left Mouse Button` on Tile: Rotate tile state.
+- `Shift + Left Mouse Button` on Tile: Toggle tile state.
 - `Shift + Arrow Up`: Add one berry to your inventory
 - `Shift + Arrow Down`: Remove one berry from your inventory
 
diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 56d80ee..72fe940 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -21,6 +21,9 @@ impl Plugin for InputPlugin {
             interact_click.run_if(in_state(AppState::GameScreen)),
         );
 
+        #[cfg(debug_assertions)]
+        app.add_systems(Update, debug_click.run_if(in_state(AppState::GameScreen)));
+
         app.add_message::<PhaseTimerPauseMessage>();
         app.add_systems(
             Update,
@@ -74,14 +77,12 @@ fn move_click(
 fn interact_click(
     mut interact_messages: MessageWriter<InteractStartMessage>,
     mouse_btn: Res<ButtonInput<MouseButton>>,
+    keys: Res<ButtonInput<KeyCode>>,
     window: Single<&Window, With<PrimaryWindow>>,
     camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
     config: Res<GameConfig>,
     phase: Res<CurrentPhase>,
     ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
-    // for debug
-    grid: ResMut<Grid>,
-    tile_query: Query<&mut TileState>,
 ) {
     match phase.0 {
         Phase::Focus { .. } => return,
@@ -89,6 +90,9 @@ fn interact_click(
     }
 
     if mouse_btn.just_pressed(MouseButton::Left) {
+        if keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight) {
+            return;
+        }
         let (cam, cam_transform) = *camera;
 
         let Some(cursor_pos) = window.cursor_position() else {
@@ -108,19 +112,58 @@ fn interact_click(
 
         println!("Interact Click: ({}, {})", x, y);
         interact_messages.write(InteractStartMessage { x, y });
+    }
+}
 
-        if cfg!(debug_assertions) {
-            grid.map_tile_state(
-                (x, y),
-                |state| match state {
-                    TileState::Unclaimed => TileState::Empty,
-                    TileState::Empty => TileState::Occupied,
-                    TileState::Occupied => TileState::Unclaimed,
-                },
-                tile_query,
-            )
-            .unwrap_or_else(|_| ());
+fn debug_click(
+    mouse_btn: Res<ButtonInput<MouseButton>>,
+    keys: Res<ButtonInput<KeyCode>>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
+    config: Res<GameConfig>,
+    phase: Res<CurrentPhase>,
+    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
+    grid: Res<Grid>,
+    tile_query: Query<&mut TileState>,
+) {
+    match phase.0 {
+        Phase::Focus { .. } => return,
+        _ => {}
+    }
+
+    if mouse_btn.just_pressed(MouseButton::Left) {
+        if !keys.pressed(KeyCode::ShiftLeft) && !keys.pressed(KeyCode::ShiftRight) {
+            return;
         }
+
+        let (cam, cam_transform) = *camera;
+
+        let Some(cursor_pos) = window.cursor_position() else {
+            return;
+        };
+        if ui_blocks(window, cursor_pos, ui_query) {
+            return;
+        }
+        let Ok(world_pos) = cam.viewport_to_world(cam_transform, cursor_pos) else {
+            return;
+        };
+        let Ok((x, y)) =
+            world_to_grid_coords(world_pos.origin, config.grid_width, config.grid_height)
+        else {
+            return;
+        };
+
+        println!("Debug Toggle Click: ({}, {})", x, y);
+        grid.map_tile_state(
+            (x, y),
+            |state| match state {
+                TileState::Unclaimed => TileState::Empty,
+                TileState::Empty => TileState::Occupied,
+                TileState::Occupied => TileState::Unclaimed,
+            },
+            tile_query,
+        )
+        .unwrap_or_else(|_| ());
     }
 }
 

From e840e9a78b4c60fb498ad603927cdc2005c383b7 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 16:59:33 +0100
Subject: [PATCH 2/6] refactor: Move mouse click to grid position logic into
 utils.rs

---
 src/features/input/mod.rs   | 49 +++++--------------------------------
 src/features/input/utils.rs | 28 +++++++++++++++++++++
 2 files changed, 34 insertions(+), 43 deletions(-)
 create mode 100644 src/features/input/utils.rs

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 72fe940..449c7f0 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -1,4 +1,5 @@
 use crate::features::{
+    input::utils::mouse_to_grid,
     phase::messages::{NextPhaseMessage, PhaseTimerPauseMessage},
     pom::messages::InvalidMoveMessage,
     shop::ui::open_shop,
@@ -7,6 +8,8 @@ use crate::prelude::*;
 use bevy::input::mouse::MouseButton;
 use bevy::window::PrimaryWindow;
 
+pub mod utils;
+
 pub struct InputPlugin;
 
 impl Plugin for InputPlugin {
@@ -52,20 +55,7 @@ fn move_click(
     }
 
     if mouse_btn.just_pressed(MouseButton::Right) {
-        let (cam, cam_transform) = *camera;
-
-        let Some(cursor_pos) = window.cursor_position() else {
-            return;
-        };
-        if ui_blocks(window, cursor_pos, ui_query) {
-            return;
-        }
-        let Ok(world_pos) = cam.viewport_to_world(cam_transform, cursor_pos) else {
-            return;
-        };
-        let Ok((x, y)) =
-            world_to_grid_coords(world_pos.origin, config.grid_width, config.grid_height)
-        else {
+        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
             return;
         };
 
@@ -93,20 +83,7 @@ fn interact_click(
         if keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight) {
             return;
         }
-        let (cam, cam_transform) = *camera;
-
-        let Some(cursor_pos) = window.cursor_position() else {
-            return;
-        };
-        if ui_blocks(window, cursor_pos, ui_query) {
-            return;
-        }
-        let Ok(world_pos) = cam.viewport_to_world(cam_transform, cursor_pos) else {
-            return;
-        };
-        let Ok((x, y)) =
-            world_to_grid_coords(world_pos.origin, config.grid_width, config.grid_height)
-        else {
+        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
             return;
         };
 
@@ -135,21 +112,7 @@ fn debug_click(
         if !keys.pressed(KeyCode::ShiftLeft) && !keys.pressed(KeyCode::ShiftRight) {
             return;
         }
-
-        let (cam, cam_transform) = *camera;
-
-        let Some(cursor_pos) = window.cursor_position() else {
-            return;
-        };
-        if ui_blocks(window, cursor_pos, ui_query) {
-            return;
-        }
-        let Ok(world_pos) = cam.viewport_to_world(cam_transform, cursor_pos) else {
-            return;
-        };
-        let Ok((x, y)) =
-            world_to_grid_coords(world_pos.origin, config.grid_width, config.grid_height)
-        else {
+        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
             return;
         };
 
diff --git a/src/features/input/utils.rs b/src/features/input/utils.rs
new file mode 100644
index 0000000..7f38b6e
--- /dev/null
+++ b/src/features/input/utils.rs
@@ -0,0 +1,28 @@
+use crate::prelude::*;
+use bevy::window::PrimaryWindow;
+
+pub fn mouse_to_grid(
+    window: Single<&Window, With<PrimaryWindow>>,
+    camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
+    config: Res<GameConfig>,
+    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
+) -> Option<(u32, u32)> {
+    let (cam, cam_transform) = *camera;
+
+    let Some(cursor_pos) = window.cursor_position() else {
+        return None;
+    };
+    if ui_blocks(window, cursor_pos, ui_query) {
+        return None;
+    }
+    let Ok(world_pos) = cam.viewport_to_world(cam_transform, cursor_pos) else {
+        return None;
+    };
+    let Ok(grid_pos) =
+        world_to_grid_coords(world_pos.origin, config.grid_width, config.grid_height)
+    else {
+        return None;
+    };
+
+    Some(grid_pos)
+}

From 15ea976442a572683dbf1d7e5405818887fd6d4c Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 17:05:51 +0100
Subject: [PATCH 3/6] feat: Implement interact click logic (#25)

---
 src/features/pom/components.rs |   5 ++
 src/features/pom/mod.rs        | 102 +++++++++++++++++++++++++++++++--
 2 files changed, 103 insertions(+), 4 deletions(-)

diff --git a/src/features/pom/components.rs b/src/features/pom/components.rs
index 7cf4043..089438a 100644
--- a/src/features/pom/components.rs
+++ b/src/features/pom/components.rs
@@ -36,3 +36,8 @@ impl MovingState {
         )
     }
 }
+
+#[derive(Component, Default)]
+pub struct InteractionTarget {
+    pub target: Option<(u32, u32)>,
+}
diff --git a/src/features/pom/mod.rs b/src/features/pom/mod.rs
index ce4a7d5..aaa1e74 100644
--- a/src/features/pom/mod.rs
+++ b/src/features/pom/mod.rs
@@ -1,7 +1,9 @@
 use crate::prelude::*;
 use components::*;
-use messages::InvalidMoveMessage;
+use messages::{InteractStartMessage, InvalidMoveMessage};
+use std::collections::VecDeque;
 use utils::find_path;
+use utils::manhattan_distance;
 
 pub mod components;
 pub mod messages;
@@ -16,7 +18,14 @@ impl Plugin for PomPlugin {
 
         app.add_systems(
             Update,
-            (handle_move, move_pom, update_pom).run_if(in_state(AppState::GameScreen)),
+            (
+                handle_move,
+                handle_interact,
+                move_pom,
+                update_pom,
+                perform_interaction,
+            )
+                .run_if(in_state(AppState::GameScreen)),
         );
     }
 }
@@ -27,6 +36,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<Gam
         GridPosition { x: 0, y: 0 },
         PathQueue::default(),
         MovingState::default(),
+        InteractionTarget::default(),
         AseAnimation {
             aseprite: asset_server.load("pom/pom-sleep.aseprite"),
             animation: Animation::tag("sleep-sit-start").with_repeat(AnimationRepeat::Loop),
@@ -53,10 +63,13 @@ fn handle_move(
     mut invalid_move_messages: MessageWriter<InvalidMoveMessage>,
     grid: Res<Grid>,
     tile_query: Query<&TileState>,
-    mut pom_query: Query<(&GridPosition, &mut PathQueue)>,
+    mut pom_query: Query<(&GridPosition, &mut PathQueue, &mut InteractionTarget)>,
 ) {
     for message in move_messages.read() {
-        for (grid_pos, mut path_queue) in pom_query.iter_mut() {
+        for (grid_pos, mut path_queue, mut interaction_target) in pom_query.iter_mut() {
+            // Clear any pending interaction when moving manually
+            interaction_target.target = None;
+
             let grid_start = (grid_pos.x, grid_pos.y);
             let start = path_queue.steps.front().unwrap_or(&grid_start);
             let end = (message.x, message.y);
@@ -78,6 +91,86 @@ fn handle_move(
     }
 }
 
+fn handle_interact(
+    mut interact_messages: MessageReader<InteractStartMessage>,
+    mut pom_query: Query<(&GridPosition, &mut PathQueue, &mut InteractionTarget)>,
+    grid: Res<Grid>,
+    tile_query: Query<&TileState>,
+) {
+    for message in interact_messages.read() {
+        for (grid_pos, mut path_queue, mut interaction_target) in pom_query.iter_mut() {
+            let target_pos = (message.x, message.y);
+            let current_pos = (grid_pos.x, grid_pos.y);
+
+            // If we are already adjacent to the target, just set the target and clear path
+            if manhattan_distance(current_pos.0, current_pos.1, target_pos.0, target_pos.1) == 1 {
+                path_queue.steps.clear();
+                interaction_target.target = Some(target_pos);
+                continue;
+            }
+
+            // Find a path to an adjacent tile
+            let neighbors = [
+                (target_pos.0 as i32 + 1, target_pos.1 as i32),
+                (target_pos.0 as i32 - 1, target_pos.1 as i32),
+                (target_pos.0 as i32, target_pos.1 as i32 + 1),
+                (target_pos.0 as i32, target_pos.1 as i32 - 1),
+            ];
+
+            let mut best_path: Option<VecDeque<(u32, u32)>> = None;
+
+            for (nx, ny) in neighbors {
+                if nx < 0 || ny < 0 {
+                    continue;
+                }
+                let neighbor_pos = (nx as u32, ny as u32);
+
+                if let Some(path) = find_path(current_pos, neighbor_pos, &grid, &tile_query) {
+                    // Pick the shortest path
+                    if best_path.as_ref().map_or(true, |p| path.len() < p.len()) {
+                        best_path = Some(path);
+                    }
+                }
+            }
+
+            if let Some(path) = best_path {
+                path_queue.steps = path;
+                interaction_target.target = Some(target_pos);
+            } else {
+                println!("Cannot reach interaction target at {:?}", target_pos);
+                // Don't set target if unreachable
+                interaction_target.target = None;
+            }
+        }
+    }
+}
+
+fn perform_interaction(
+    mut pom_query: Query<(&GridPosition, &mut InteractionTarget, &PathQueue)>,
+    // grid: Res<Grid>,
+    // mut tile_query: Query<&mut TileState>,
+) {
+    for (pos, mut target_component, path_queue) in pom_query.iter_mut() {
+        if let Some(target) = target_component.target {
+            // Wait until movement stops
+            if !path_queue.steps.is_empty() {
+                continue;
+            }
+
+            if manhattan_distance(pos.x, pos.y, target.0, target.1) == 1 {
+                println!(
+                    "Performing interaction on tile ({}, {})",
+                    target.0, target.1
+                );
+
+                // TODO: Implement interaction logic
+            }
+
+            target_component.target = None;
+        }
+    }
+}
+
 fn move_pom(
     time: Res<Time>,
     mut query: Query<(
@@ -153,3 +246,4 @@ fn update_pom(asset_server: Res<AssetServer>, mut query: Query<(&MovingState, &m
         }
     }
 }
+

From a048d9e84cb38c3167c8a26e4ff115377c3a558a Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 17:49:38 +0100
Subject: [PATCH 4/6] feat: Add placeholder interact menu (#25)

---
 src/features/input/mod.rs           |   5 +-
 src/features/pom/messages.rs        |   6 ++
 src/features/pom/mod.rs             |   2 +
 src/features/pom/ui/context_menu.rs | 122 ++++++++++++++++++++++++++++
 src/features/pom/ui/mod.rs          |  22 +++++
 src/prelude.rs                      |   2 +-
 6 files changed, 156 insertions(+), 3 deletions(-)
 create mode 100644 src/features/pom/ui/context_menu.rs
 create mode 100644 src/features/pom/ui/mod.rs

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 449c7f0..15a377e 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -19,6 +19,7 @@ impl Plugin for InputPlugin {
         app.add_systems(Update, move_click.run_if(in_state(AppState::GameScreen)));
 
         app.add_message::<InteractStartMessage>();
+        app.add_message::<TileClickMessage>();
         app.add_systems(
             Update,
             interact_click.run_if(in_state(AppState::GameScreen)),
@@ -65,7 +66,7 @@ fn move_click(
 }
 
 fn interact_click(
-    mut interact_messages: MessageWriter<InteractStartMessage>,
+    mut tile_click_messages: MessageWriter<TileClickMessage>,
     mouse_btn: Res<ButtonInput<MouseButton>>,
     keys: Res<ButtonInput<KeyCode>>,
     window: Single<&Window, With<PrimaryWindow>>,
@@ -88,7 +89,7 @@ fn interact_click(
         };
 
         println!("Interact Click: ({}, {})", x, y);
-        interact_messages.write(InteractStartMessage { x, y });
+        tile_click_messages.write(TileClickMessage { x, y });
     }
 }
 
diff --git a/src/features/pom/messages.rs b/src/features/pom/messages.rs
index b823c29..60aa82c 100644
--- a/src/features/pom/messages.rs
+++ b/src/features/pom/messages.rs
@@ -16,3 +16,9 @@ pub struct InteractStartMessage {
     pub x: u32,
     pub y: u32,
 }
+
+#[derive(Message)]
+pub struct TileClickMessage {
+    pub x: u32,
+    pub y: u32,
+}
diff --git a/src/features/pom/mod.rs b/src/features/pom/mod.rs
index aaa1e74..447278c 100644
--- a/src/features/pom/mod.rs
+++ b/src/features/pom/mod.rs
@@ -7,12 +7,14 @@ use utils::manhattan_distance;
 
 pub mod components;
 pub mod messages;
+pub mod ui;
 pub mod utils;
 
 pub struct PomPlugin;
 
 impl Plugin for PomPlugin {
     fn build(&self, app: &mut App) {
+        app.add_plugins(ui::PomUiPlugin);
         app.add_systems(OnEnter(AppState::GameScreen), setup);
         app.add_systems(OnExit(AppState::GameScreen), cleanup);
 
diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
new file mode 100644
index 0000000..3139cca
--- /dev/null
+++ b/src/features/pom/ui/context_menu.rs
@@ -0,0 +1,122 @@
+use crate::features::ui::utils::ui_blocks;
+use crate::prelude::*;
+use bevy::window::PrimaryWindow;
+
+#[derive(Component)]
+pub enum RootMarker {
+    ContextMenu,
+}
+
+#[derive(Component)]
+pub enum ButtonType {
+    Interact { x: u32, y: u32 },
+    Cancel,
+}
+
+pub fn spawn_context_menu(
+    mut commands: Commands,
+    mut tile_click_messages: MessageReader<TileClickMessage>,
+    root_query: Query<Entity, With<RootMarker>>,
+    camera_query: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
+    config: Res<GameConfig>,
+) {
+    for message in tile_click_messages.read() {
+        // Despawn existing menu
+        for entity in root_query.iter() {
+            commands.entity(entity).try_despawn();
+        }
+
+        let world_pos = grid_to_world_coords(
+            message.x,
+            message.y,
+            Some(0.0),
+            config.grid_width,
+            config.grid_height,
+        );
+
+        let (camera, camera_transform) = *camera_query;
+
+        if let Ok(screen_pos) = camera.world_to_viewport(camera_transform, world_pos) {
+            commands
+                .spawn((
+                    Node {
+                        position_type: PositionType::Absolute,
+                        left: px(screen_pos.x),
+                        top: px(screen_pos.y),
+                        padding: UiRect::all(px(5.0)),
+                        ..Node::vstack(px(5.0))
+                    },
+                    ZIndex(100),
+                    BackgroundColor(Color::srgb(0.1, 0.1, 0.1)),
+                    BorderRadius::all(px(5)),
+                    RootMarker::ContextMenu,
+                ))
+                .with_children(|parent| {
+                    parent.spawn(button(
+                        ButtonType::Interact {
+                            x: message.x,
+                            y: message.y,
+                        },
+                        ButtonVariant::Primary,
+                        Node {
+                            padding: UiRect::all(px(5)),
+                            ..default()
+                        },
+                        |c| text("<Interact>", 20.0, c),
+                    ));
+
+                    parent.spawn(button(
+                        ButtonType::Cancel,
+                        ButtonVariant::Destructive,
+                        Node {
+                            padding: UiRect::all(px(5)),
+                            ..default()
+                        },
+                        |c| text("Abbrechen", 20.0, c),
+                    ));
+                });
+        }
+    }
+}
+
+pub fn click_outside_context_menu(
+    mut commands: Commands,
+    mouse_btn: Res<ButtonInput<MouseButton>>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
+    root_query: Query<Entity, With<RootMarker>>,
+) {
+    if mouse_btn.just_pressed(MouseButton::Left) {
+        let Some(cursor_pos) = window.cursor_position() else {
+            return;
+        };
+
+        if !ui_blocks(window, cursor_pos, ui_query) {
+            for entity in root_query.iter() {
+                commands.entity(entity).try_despawn();
+            }
+        }
+    }
+}
+
+pub fn buttons(
+    mut commands: Commands,
+    mut button_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
+    mut interact_messages: MessageWriter<InteractStartMessage>,
+    root_query: Query<Entity, With<RootMarker>>,
+) {
+    for (interaction, button_type) in button_query.iter_mut() {
+        if *interaction == Interaction::Pressed {
+            match button_type {
+                ButtonType::Interact { x, y } => {
+                    interact_messages.write(InteractStartMessage { x: *x, y: *y });
+                }
+                ButtonType::Cancel => (),
+            }
+
+            for entity in root_query.iter() {
+                commands.entity(entity).despawn();
+            }
+        }
+    }
+}
diff --git a/src/features/pom/ui/mod.rs b/src/features/pom/ui/mod.rs
new file mode 100644
index 0000000..73256c8
--- /dev/null
+++ b/src/features/pom/ui/mod.rs
@@ -0,0 +1,22 @@
+use crate::prelude::*;
+
+pub mod context_menu;
+
+pub struct PomUiPlugin;
+
+impl Plugin for PomUiPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            Update,
+            context_menu::spawn_context_menu.run_if(in_state(AppState::GameScreen)),
+        );
+        app.add_systems(
+            Update,
+            context_menu::click_outside_context_menu.run_if(in_state(AppState::GameScreen)),
+        );
+        app.add_systems(
+            Update,
+            context_menu::buttons.run_if(in_state(AppState::GameScreen)),
+        );
+    }
+}
diff --git a/src/prelude.rs b/src/prelude.rs
index ccc3a7d..1a2481c 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -11,7 +11,7 @@ pub use crate::features::{
     phase::components::{CurrentPhase, Phase},
     pom::{
         components::{GridPosition, MovingState, Pom},
-        messages::{InteractStartMessage, MoveMessage},
+        messages::{InteractStartMessage, MoveMessage, TileClickMessage},
     },
     savegame::components::SavegamePath,
     ui::{components::ButtonVariant, consts::*, ui::*, utils::*},

From c567872254f65c61f9815e1021c6a8ed82855409 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 17:50:45 +0100
Subject: [PATCH 5/6] style: Remove useless println

---
 src/features/input/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 15a377e..0365c10 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -88,7 +88,6 @@ fn interact_click(
             return;
         };
 
-        println!("Interact Click: ({}, {})", x, y);
         tile_click_messages.write(TileClickMessage { x, y });
     }
 }

From 73382c25a9d00d3688eeb3b485671fc21d88a21c Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 1 Dec 2025 17:51:33 +0100
Subject: [PATCH 6/6] fix: Add GlobalTransform to Context Menu to fix clicking
 through the menu

---
 src/features/pom/ui/context_menu.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
index 3139cca..1253f0b 100644
--- a/src/features/pom/ui/context_menu.rs
+++ b/src/features/pom/ui/context_menu.rs
@@ -50,6 +50,7 @@ pub fn spawn_context_menu(
                     BackgroundColor(Color::srgb(0.1, 0.1, 0.1)),
                     BorderRadius::all(px(5)),
                     RootMarker::ContextMenu,
+                    GlobalTransform::default(),
                 ))
                 .with_children(|parent| {
                     parent.spawn(button(