From 4f41d89f63cbfd986ea93610987057bb293396c1 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 14:52:40 +0100
Subject: [PATCH 01/71] chore: switch to stable rust toolchain

---
 flake.nix | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/flake.nix b/flake.nix
index 59059c3..ab6c9df 100644
--- a/flake.nix
+++ b/flake.nix
@@ -24,10 +24,10 @@
 
       rust-toolchain = with fenix.packages.${system};
         combine [
-          beta.rustc
-          beta.cargo
-          beta.rust-src
-          beta.rust-analyzer
+          stable.rustc
+          stable.cargo
+          stable.rust-src
+          stable.rust-analyzer
         ];
 
       bevyDeps = with pkgs; [

From 881300e0a6c5ab706d14aadff76b8f19d9c295b8 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 14:52:58 +0100
Subject: [PATCH 02/71] feat: close popups with escape key

---
 src/features/hud/mod.rs             | 19 ++++++++++++++++++-
 src/features/input/mod.rs           | 13 +++++++++++++
 src/features/inventory/mod.rs       | 20 +++++++++++++++++++-
 src/features/pom/ui/context_menu.rs | 13 +++++++++++++
 src/features/pom/ui/mod.rs          |  4 ++++
 src/features/savegame/mod.rs        | 18 +++++++++++++++++-
 src/features/shop/mod.rs            | 20 +++++++++++++++++++-
 src/features/ui/messages.rs         |  4 ++++
 src/features/ui/mod.rs              |  1 +
 9 files changed, 108 insertions(+), 4 deletions(-)
 create mode 100644 src/features/ui/messages.rs

diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index 875c501..4d358dd 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -1,5 +1,6 @@
 use crate::features::phase::components::TimerSettings;
 use crate::features::savegame::messages::SavegameDumpMessage;
+use crate::features::ui::messages::ClosePopupMessage;
 use crate::features::{inventory, shop};
 use crate::prelude::*;
 use components::*;
@@ -16,11 +17,27 @@ impl Plugin for HudPlugin {
         app.add_systems(OnExit(AppState::GameScreen), cleanup);
         app.add_systems(
             Update,
-            (update_status, buttons, update_timer_settings).run_if(in_state(AppState::GameScreen)),
+            (update_status, buttons, update_timer_settings, close_popup)
+                .run_if(in_state(AppState::GameScreen)),
         );
     }
 }
 
+fn close_popup(
+    mut commands: Commands,
+    mut close_popup_reader: MessageReader<ClosePopupMessage>,
+    root_query: Query<(Entity, &RootMarker)>,
+) {
+    for _ in close_popup_reader.read() {
+        for (entity, root) in root_query.iter() {
+            match *root {
+                RootMarker::Settings => commands.entity(entity).despawn(),
+                _ => {}
+            }
+        }
+    }
+}
+
 fn setup(mut commands: Commands) {
     commands.spawn((
         RootMarker::Status,
diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 8ed6757..3b7158b 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -3,6 +3,7 @@ use crate::features::{
     phase::messages::{NextPhaseMessage, PhaseTimerPauseMessage},
     pom::messages::InvalidMoveMessage,
     shop::ui::open_shop,
+    ui::messages::ClosePopupMessage,
 };
 use crate::prelude::*;
 use bevy::input::mouse::MouseButton;
@@ -38,6 +39,9 @@ impl Plugin for InputPlugin {
         app.add_systems(Update, next_phase.run_if(in_state(AppState::GameScreen)));
 
         app.add_systems(Update, shop_keybind.run_if(in_state(AppState::GameScreen)));
+
+        app.add_message::<ClosePopupMessage>();
+        app.add_systems(Update, popup_keybind);
     }
 }
 
@@ -163,3 +167,12 @@ fn shop_keybind(
         open_shop(&mut commands, &game_config, &asset_server);
     }
 }
+
+fn popup_keybind(
+    mut close_popup_messages: MessageWriter<ClosePopupMessage>,
+    keys: Res<ButtonInput<KeyCode>>,
+) {
+    if keys.just_pressed(KeyCode::Escape) {
+        close_popup_messages.write(ClosePopupMessage);
+    }
+}
diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index 2218ca2..bfdaf76 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -1,3 +1,4 @@
+use crate::features::ui::messages::ClosePopupMessage;
 use crate::{features::inventory::ui::open_inventory, prelude::*};
 use components::*;
 
@@ -10,13 +11,30 @@ impl Plugin for InventoryPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Inventory>();
 
-        app.add_systems(Update, buttons.run_if(in_state(AppState::GameScreen)));
+        app.add_systems(
+            Update,
+            (buttons, close_popup).run_if(in_state(AppState::GameScreen)),
+        );
 
         #[cfg(debug_assertions)]
         app.add_systems(Update, debug_modify_berries);
     }
 }
 
+fn close_popup(
+    mut commands: Commands,
+    mut close_popup_reader: MessageReader<ClosePopupMessage>,
+    root_query: Query<(Entity, &RootMarker)>,
+) {
+    for _ in close_popup_reader.read() {
+        for (entity, root) in root_query.iter() {
+            match *root {
+                RootMarker::Inventory => commands.entity(entity).despawn(),
+            }
+        }
+    }
+}
+
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
index 580dbaf..b62e9ff 100644
--- a/src/features/pom/ui/context_menu.rs
+++ b/src/features/pom/ui/context_menu.rs
@@ -1,4 +1,5 @@
 use crate::features::pom::actions::InteractionAction;
+use crate::features::ui::messages::ClosePopupMessage;
 use crate::features::ui::utils::ui_blocks;
 use crate::prelude::*;
 use bevy::window::PrimaryWindow;
@@ -147,3 +148,15 @@ pub fn buttons(
         }
     }
 }
+
+pub fn close_context_menu(
+    mut commands: Commands,
+    mut close_popup_reader: MessageReader<ClosePopupMessage>,
+    root_query: Query<Entity, With<RootMarker>>,
+) {
+    for _ in close_popup_reader.read() {
+        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
index 73256c8..37ba9c8 100644
--- a/src/features/pom/ui/mod.rs
+++ b/src/features/pom/ui/mod.rs
@@ -18,5 +18,9 @@ impl Plugin for PomUiPlugin {
             Update,
             context_menu::buttons.run_if(in_state(AppState::GameScreen)),
         );
+        app.add_systems(
+            Update,
+            context_menu::close_context_menu.run_if(in_state(AppState::GameScreen)),
+        );
     }
 }
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index 597e01e..bd65833 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -1,6 +1,8 @@
 use crate::features::phase::components::{SessionTracker, TimerSettings};
 use crate::features::savegame::ui::load_popup_handler;
+use crate::features::ui::messages::ClosePopupMessage;
 use crate::prelude::*;
+use components::*;
 use messages::*;
 use std::fs::File;
 use std::io::{Read, Write};
@@ -19,7 +21,21 @@ impl Plugin for SavegamePlugin {
         app.add_systems(Update, dump_savegame.run_if(in_state(AppState::GameScreen)));
         app.add_systems(Update, load_savegame.run_if(in_state(AppState::GameScreen)));
 
-        app.add_systems(Update, load_popup_handler);
+        app.add_systems(Update, (load_popup_handler, close_popup));
+    }
+}
+
+fn close_popup(
+    mut commands: Commands,
+    mut close_popup_reader: MessageReader<ClosePopupMessage>,
+    root_query: Query<(Entity, &RootMarker)>,
+) {
+    for _ in close_popup_reader.read() {
+        for (entity, root) in root_query.iter() {
+            match *root {
+                RootMarker::PopupSavegameLoad => commands.entity(entity).despawn(),
+            }
+        }
     }
 }
 
diff --git a/src/features/shop/mod.rs b/src/features/shop/mod.rs
index f571ba6..2268529 100644
--- a/src/features/shop/mod.rs
+++ b/src/features/shop/mod.rs
@@ -1,3 +1,4 @@
+use crate::features::ui::messages::ClosePopupMessage;
 use crate::prelude::*;
 use components::*;
 use ui::open_shop;
@@ -9,7 +10,24 @@ pub struct ShopPlugin;
 
 impl Plugin for ShopPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, buttons.run_if(in_state(AppState::GameScreen)));
+        app.add_systems(
+            Update,
+            (buttons, close_popup).run_if(in_state(AppState::GameScreen)),
+        );
+    }
+}
+
+fn close_popup(
+    mut commands: Commands,
+    mut close_popup_reader: MessageReader<ClosePopupMessage>,
+    root_query: Query<(Entity, &RootMarker)>,
+) {
+    for _ in close_popup_reader.read() {
+        for (entity, root) in root_query.iter() {
+            match *root {
+                RootMarker::Shop => commands.entity(entity).despawn(),
+            }
+        }
     }
 }
 
diff --git a/src/features/ui/messages.rs b/src/features/ui/messages.rs
new file mode 100644
index 0000000..c3894be
--- /dev/null
+++ b/src/features/ui/messages.rs
@@ -0,0 +1,4 @@
+use crate::prelude::*;
+
+#[derive(Message)]
+pub struct ClosePopupMessage;
diff --git a/src/features/ui/mod.rs b/src/features/ui/mod.rs
index 677f301..2cca7c9 100644
--- a/src/features/ui/mod.rs
+++ b/src/features/ui/mod.rs
@@ -3,6 +3,7 @@ use bevy::{input::mouse::*, picking::hover::HoverMap};
 
 pub mod components;
 pub mod consts;
+pub mod messages;
 pub mod ui;
 pub mod utils;
 

From 81a7a5d76b1a614d6f382ebfb670006811e82514 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 17:04:58 +0100
Subject: [PATCH 03/71] feat: Add popup helper (#59)

---
 flake.nix                    |  8 ++--
 src/features/ui/mod.rs       |  4 +-
 src/features/ui/ui/mod.rs    |  2 +
 src/features/ui/ui/popups.rs | 79 ++++++++++++++++++++++++++++++++++++
 4 files changed, 88 insertions(+), 5 deletions(-)
 create mode 100644 src/features/ui/ui/popups.rs

diff --git a/flake.nix b/flake.nix
index ab6c9df..59059c3 100644
--- a/flake.nix
+++ b/flake.nix
@@ -24,10 +24,10 @@
 
       rust-toolchain = with fenix.packages.${system};
         combine [
-          stable.rustc
-          stable.cargo
-          stable.rust-src
-          stable.rust-analyzer
+          beta.rustc
+          beta.cargo
+          beta.rust-src
+          beta.rust-analyzer
         ];
 
       bevyDeps = with pkgs; [
diff --git a/src/features/ui/mod.rs b/src/features/ui/mod.rs
index 2cca7c9..cad4dd6 100644
--- a/src/features/ui/mod.rs
+++ b/src/features/ui/mod.rs
@@ -1,4 +1,4 @@
-use crate::prelude::{button::update_buttons, *};
+use crate::prelude::{button::update_buttons, popups::handle_popup_close, *};
 use bevy::{input::mouse::*, picking::hover::HoverMap};
 
 pub mod components;
@@ -15,6 +15,8 @@ impl Plugin for UiPlugin {
         app.add_observer(on_scroll_handler);
 
         app.add_systems(Update, update_buttons);
+
+        app.add_systems(Update, handle_popup_close);
     }
 }
 
diff --git a/src/features/ui/ui/mod.rs b/src/features/ui/ui/mod.rs
index b349580..f491984 100644
--- a/src/features/ui/ui/mod.rs
+++ b/src/features/ui/ui/mod.rs
@@ -1,7 +1,9 @@
 pub mod button;
 pub mod flexbox;
+pub mod popups;
 pub mod texts;
 
 pub use button::{button, pill_button};
 pub use flexbox::Flexbox;
+pub use popups::popup;
 pub use texts::{text, text_with_component};
diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
new file mode 100644
index 0000000..9eeeb31
--- /dev/null
+++ b/src/features/ui/ui/popups.rs
@@ -0,0 +1,79 @@
+use super::super::messages::ClosePopupMessage;
+use crate::prelude::*;
+
+#[derive(Component)]
+pub struct PopupRoot;
+
+#[derive(Component)]
+pub struct PopupCloseButton;
+
+pub fn popup(
+    root: impl Component,
+    title: String,
+    mut node: Node,
+    child: impl Bundle,
+) -> impl Bundle {
+    node.padding = UiRect::all(px(20));
+
+    (
+        PopupRoot,
+        root,
+        Node {
+            position_type: PositionType::Absolute,
+            width: percent(100),
+            height: percent(100),
+            ..Node::center()
+        },
+        ZIndex(100),
+        BackgroundColor(Color::srgba(0., 0., 0., 0.8)),
+        GlobalTransform::default(),
+        children![(
+            node,
+            BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
+            BorderRadius::all(px(10)),
+            children![
+                (
+                    Node {
+                        justify_content: JustifyContent::SpaceBetween,
+                        align_items: AlignItems::Center,
+                        ..Node::hstack(px(20))
+                    },
+                    children![
+                        text(title, 40.0, Color::WHITE),
+                        button(
+                            PopupCloseButton,
+                            ButtonVariant::Destructive,
+                            Node {
+                                width: px(40),
+                                height: px(40),
+                                ..Node::center()
+                            },
+                            |color| text("X", 24.0, color)
+                        )
+                    ]
+                ),
+                child
+            ]
+        )],
+    )
+}
+
+pub fn handle_popup_close(
+    mut commands: Commands,
+    root_query: Query<Entity, With<PopupRoot>>,
+    mut messages: MessageReader<ClosePopupMessage>,
+    buttons: Query<&Interaction, (Changed<Interaction>, With<PopupCloseButton>)>,
+) {
+    for _ in messages.read() {
+        root_query
+            .iter()
+            .for_each(|root| commands.entity(root).despawn());
+    }
+
+    buttons.iter().for_each(|i| match i {
+        Interaction::Pressed => root_query
+            .iter()
+            .for_each(|root| commands.entity(root).despawn()),
+        _ => (),
+    });
+}

From 70768daf82bb3d832e71ecd81fb31b2ab2d0adcd Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 17:14:14 +0100
Subject: [PATCH 04/71] fix: Fix popup title type

---
 src/features/ui/ui/popups.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
index 9eeeb31..e5ad65b 100644
--- a/src/features/ui/ui/popups.rs
+++ b/src/features/ui/ui/popups.rs
@@ -9,7 +9,7 @@ pub struct PopupCloseButton;
 
 pub fn popup(
     root: impl Component,
-    title: String,
+    title: impl Into<String>,
     mut node: Node,
     child: impl Bundle,
 ) -> impl Bundle {

From 23abbbfa02b0b7e759154279a1bfbc894b82cf83 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 17:24:56 +0100
Subject: [PATCH 05/71] fix: Add `flex_direction` and `row_gap` to popup

---
 src/features/ui/ui/popups.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
index e5ad65b..142ca89 100644
--- a/src/features/ui/ui/popups.rs
+++ b/src/features/ui/ui/popups.rs
@@ -13,6 +13,8 @@ pub fn popup(
     mut node: Node,
     child: impl Bundle,
 ) -> impl Bundle {
+    node.flex_direction = FlexDirection::Column;
+    node.row_gap = px(10);
     node.padding = UiRect::all(px(20));
 
     (

From 667cc127bab47ef1528ac71b1103abfe136c86ab Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Mon, 8 Dec 2025 17:28:05 +0100
Subject: [PATCH 06/71] feat: Add  helper to flexbox

---
 src/features/ui/ui/flexbox.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/features/ui/ui/flexbox.rs b/src/features/ui/ui/flexbox.rs
index 89d8d6c..6dace0b 100644
--- a/src/features/ui/ui/flexbox.rs
+++ b/src/features/ui/ui/flexbox.rs
@@ -4,6 +4,7 @@ pub trait Flexbox {
     fn hstack(spacing: Val) -> Self;
     fn vstack(spacing: Val) -> Self;
     fn center() -> Self;
+    fn from_padding(padding: UiRect) -> Self;
 }
 
 impl Flexbox for Node {
@@ -30,4 +31,11 @@ impl Flexbox for Node {
             ..default()
         }
     }
+
+    fn from_padding(padding: UiRect) -> Self {
+        Node {
+            padding,
+            ..default()
+        }
+    }
 }

From c50601c23a8ee1f44dd6dda2a5c83118c38c4cf8 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:06:01 +0100
Subject: [PATCH 07/71] fix: Make popup child a closure

---
 src/features/hud/ui/settings.rs | 188 ++++++++++++--------------------
 src/features/ui/ui/mod.rs       |   2 +-
 src/features/ui/ui/popups.rs    |  94 ++++++++--------
 3 files changed, 124 insertions(+), 160 deletions(-)

diff --git a/src/features/hud/ui/settings.rs b/src/features/hud/ui/settings.rs
index cb82cc4..f0c8247 100644
--- a/src/features/hud/ui/settings.rs
+++ b/src/features/hud/ui/settings.rs
@@ -3,127 +3,83 @@ use super::timer_settings::timer_settings;
 use crate::prelude::*;
 
 pub fn open_settings(commands: &mut Commands) {
-    commands
-        .spawn((
-            RootMarker::Settings,
-            Node {
-                position_type: PositionType::Absolute,
-                width: percent(100),
-                height: percent(100),
-                ..Node::center()
-            },
-            ZIndex(1),
-            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.8)),
-            GlobalTransform::default(),
-        ))
-        .with_children(|parent| {
-            parent
-                .spawn((
-                    Node {
-                        width: px(700),
-                        padding: UiRect::all(px(20.0)),
-                        ..Node::vstack(px(20))
-                    },
-                    BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
-                    BorderRadius::all(px(10.0)),
-                ))
-                .with_children(|parent| {
-                    parent.spawn((
+    spawn_popup(
+        commands,
+        RootMarker::Settings,
+        "Spiel Einstellungen",
+        Node {
+            width: px(700),
+            ..default()
+        },
+        |parent| {
+            parent.spawn((
+                Node::vstack(px(10)),
+                children![
+                    button(
+                        ButtonType::SettingsExit,
+                        ButtonVariant::Secondary,
+                        Node::from_padding(UiRect::all(px(10))),
+                        |color| text("Spiel verlassen", 24.0, color)
+                    ),
+                    button(
+                        ButtonType::SettingsSave,
+                        ButtonVariant::Secondary,
+                        Node::from_padding(UiRect::all(px(10))),
+                        |color| text("Spiel speichern", 24.0, color)
+                    ),(
                         Node {
-                            justify_content: JustifyContent::SpaceBetween,
-                            ..Node::hstack(px(20))
+                            justify_content: JustifyContent::Center,
+                            ..Node::hstack(px(30))
                         },
                         children![
-                            text("Spiel Einstellungen", 40.0, Color::WHITE),
-                            pill_button(
-                                ButtonType::SettingsClose,
-                                ButtonVariant::Destructive,
+                            (
                                 Node {
-                                    width: px(40),
-                                    height: px(40),
-                                    ..default()
-                                },
-                                |color| text("X", 24.0, color)
-                            ),
-                        ],
-                    ));
-
-                    parent
-                        .spawn(Node::vstack(px(10)))
-                        .with_children(|parent| {
-                            parent.spawn(button(
-                                ButtonType::SettingsExit,
-                                ButtonVariant::Secondary,
-                                Node {
-                                    padding: UiRect::all(px(10)),
-                                    ..default()
-                                },
-                                |color| text("Spiel verlassen", 24.0, color)
-                            ));
-
-                            parent.spawn(button(
-                                ButtonType::SettingsSave,
-                                ButtonVariant::Secondary,
-                                Node {
-                                    padding: UiRect::all(px(10)),
-                                    ..default()
-                                },
-                                |color| text("Spiel speichern", 24.0, color)
-                            ));
-
-                            parent.spawn((
-                                Node {
-                                    justify_content: JustifyContent::Center,
-                                    ..Node::hstack(px(30))
+                                    width: percent(40),
+                                    ..Node::vstack(px(10))
                                 },
                                 children![
-                                    (
-                                        Node {
-                                            width: percent(40),
-                                            ..Node::vstack(px(10))
-                                        },
-                                        children![
-                                            text("Spiel Einstellungen", 18.0, Color::WHITE),
-                                            text(
-                                                "Tipp: Benutze [Umstellen] um in 10er Schritten zu inkrementieren oder dekrementieren!",
-                                                16.0,
-                                                Color::WHITE
-                                            ),
-                                        ]
+                                    text("Spiel Einstellungen", 18.0, Color::WHITE),
+                                    text(
+                                        "Tipp: Benutze [Umstellen] um in 10er Schritten zu inkrementieren oder dekrementieren!",
+                                        16.0,
+                                        Color::WHITE
                                     ),
-                                    (
-                                        Node {
-                                            align_items: AlignItems::Center,
-                                            ..Node::vstack(px(10))
-                                        },
-                                        children![
-                                            text("Fokus Phase", 12.0, Color::WHITE),
-                                            timer_settings(TimerType::Focus)
-                                        ]
-                                    ),
-                                    (
-                                        Node {
-                                            align_items: AlignItems::Center,
-                                            ..Node::vstack(px(10))
-                                        },
-                                        children![
-                                            text("Kurze Pause", 12.0, Color::WHITE),
-                                            timer_settings(TimerType::ShortBreak)
-                                        ]
-                                    ),
-                                    (
-                                        Node {
-                                            align_items: AlignItems::Center,
-                                            ..Node::vstack(px(10))
-                                        },
-                                        children![
-                                            text("Lange Pause", 12.0, Color::WHITE),
-                                            timer_settings(TimerType::LongBreak)
-                                        ]
-                                    )
-                                ],
-                            ));
-                        });
-                });
-        });
+                                ]
+                            ),
+                            (
+                                Node {
+                                    align_items: AlignItems::Center,
+                                    ..Node::vstack(px(10))
+                                },
+                                children![
+                                    text("Fokus Phase", 12.0, Color::WHITE),
+                                    timer_settings(TimerType::Focus)
+                                ]
+                            ),
+                            (
+                                Node {
+                                    align_items: AlignItems::Center,
+                                    ..Node::vstack(px(10))
+                                },
+                                children![
+                                    text("Kurze Pause", 12.0, Color::WHITE),
+                                    timer_settings(TimerType::ShortBreak)
+                                ]
+                            ),
+                            (
+                                Node {
+                                    align_items: AlignItems::Center,
+                                    ..Node::vstack(px(10))
+                                },
+                                children![
+                                    text("Lange Pause", 12.0, Color::WHITE),
+                                    timer_settings(TimerType::LongBreak)
+                                ]
+                            )
+                        ],
+                    )
+                ],
+            ));
+        },
+    );
 }
diff --git a/src/features/ui/ui/mod.rs b/src/features/ui/ui/mod.rs
index f491984..d6f4ea3 100644
--- a/src/features/ui/ui/mod.rs
+++ b/src/features/ui/ui/mod.rs
@@ -5,5 +5,5 @@ pub mod texts;
 
 pub use button::{button, pill_button};
 pub use flexbox::Flexbox;
-pub use popups::popup;
+pub use popups::spawn_popup;
 pub use texts::{text, text_with_component};
diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
index 142ca89..dedc8af 100644
--- a/src/features/ui/ui/popups.rs
+++ b/src/features/ui/ui/popups.rs
@@ -1,3 +1,5 @@
+use bevy::ecs::relationship::RelatedSpawnerCommands;
+
 use super::super::messages::ClosePopupMessage;
 use crate::prelude::*;
 
@@ -7,57 +9,63 @@ pub struct PopupRoot;
 #[derive(Component)]
 pub struct PopupCloseButton;
 
-pub fn popup(
+pub fn spawn_popup(
+    commands: &mut Commands,
     root: impl Component,
     title: impl Into<String>,
     mut node: Node,
-    child: impl Bundle,
+    child: impl FnOnce(&mut RelatedSpawnerCommands<ChildOf>),
 ) -> impl Bundle {
     node.flex_direction = FlexDirection::Column;
     node.row_gap = px(10);
     node.padding = UiRect::all(px(20));
 
-    (
-        PopupRoot,
-        root,
-        Node {
-            position_type: PositionType::Absolute,
-            width: percent(100),
-            height: percent(100),
-            ..Node::center()
-        },
-        ZIndex(100),
-        BackgroundColor(Color::srgba(0., 0., 0., 0.8)),
-        GlobalTransform::default(),
-        children![(
-            node,
-            BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
-            BorderRadius::all(px(10)),
-            children![
-                (
-                    Node {
-                        justify_content: JustifyContent::SpaceBetween,
-                        align_items: AlignItems::Center,
-                        ..Node::hstack(px(20))
-                    },
-                    children![
-                        text(title, 40.0, Color::WHITE),
-                        button(
-                            PopupCloseButton,
-                            ButtonVariant::Destructive,
-                            Node {
-                                width: px(40),
-                                height: px(40),
-                                ..Node::center()
-                            },
-                            |color| text("X", 24.0, color)
-                        )
-                    ]
-                ),
-                child
-            ]
-        )],
-    )
+    commands
+        .spawn((
+            PopupRoot,
+            root,
+            Node {
+                position_type: PositionType::Absolute,
+                width: percent(100),
+                height: percent(100),
+                ..Node::center()
+            },
+            ZIndex(100),
+            BackgroundColor(Color::srgba(0., 0., 0., 0.8)),
+            GlobalTransform::default(),
+        ))
+        .with_children(|parent| {
+            parent
+                .spawn((
+                    node,
+                    BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
+                    BorderRadius::all(px(10)),
+                ))
+                .with_children(|parent| {
+                    parent.spawn((
+                        Node {
+                            justify_content: JustifyContent::SpaceBetween,
+                            align_items: AlignItems::Center,
+                            ..Node::hstack(px(20))
+                        },
+                        children![
+                            text(title, 40.0, Color::WHITE),
+                            button(
+                                PopupCloseButton,
+                                ButtonVariant::Destructive,
+                                Node {
+                                    width: px(40),
+                                    height: px(40),
+                                    ..Node::center()
+                                },
+                                |color| text("X", 24.0, color)
+                            )
+                        ],
+                    ));
+
+                    child(parent);
+                });
+        });
 }
 
 pub fn handle_popup_close(

From d9a1c9c2a71243eb899dae789392b46fa612f3da Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:21:51 +0100
Subject: [PATCH 08/71] feat: Replace old popup with new UI element

---
 src/features/hud/components.rs         |   1 -
 src/features/hud/mod.rs                |  28 +---
 src/features/inventory/components.rs   |   1 -
 src/features/inventory/mod.rs          |  28 +---
 src/features/inventory/ui/inventory.rs |  75 +++-------
 src/features/savegame/components.rs    |   1 -
 src/features/savegame/mod.rs           |  17 +--
 src/features/savegame/ui/load.rs       | 189 ++++++++++---------------
 src/features/shop/components.rs        |   2 -
 src/features/shop/mod.rs               |  27 +---
 src/features/shop/ui/shop.rs           |  68 +++------
 11 files changed, 115 insertions(+), 322 deletions(-)

diff --git a/src/features/hud/components.rs b/src/features/hud/components.rs
index 6d93783..9de7636 100644
--- a/src/features/hud/components.rs
+++ b/src/features/hud/components.rs
@@ -15,7 +15,6 @@ pub enum TextType {
 #[derive(Component)]
 pub enum ButtonType {
     SettingsOpen,
-    SettingsClose,
     SettingsExit,
     SettingsSave,
     SettingsTimerChange {
diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index 4d358dd..4661850 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -1,6 +1,5 @@
 use crate::features::phase::components::TimerSettings;
 use crate::features::savegame::messages::SavegameDumpMessage;
-use crate::features::ui::messages::ClosePopupMessage;
 use crate::features::{inventory, shop};
 use crate::prelude::*;
 use components::*;
@@ -17,27 +16,11 @@ impl Plugin for HudPlugin {
         app.add_systems(OnExit(AppState::GameScreen), cleanup);
         app.add_systems(
             Update,
-            (update_status, buttons, update_timer_settings, close_popup)
-                .run_if(in_state(AppState::GameScreen)),
+            (update_status, buttons, update_timer_settings).run_if(in_state(AppState::GameScreen)),
         );
     }
 }
 
-fn close_popup(
-    mut commands: Commands,
-    mut close_popup_reader: MessageReader<ClosePopupMessage>,
-    root_query: Query<(Entity, &RootMarker)>,
-) {
-    for _ in close_popup_reader.read() {
-        for (entity, root) in root_query.iter() {
-            match *root {
-                RootMarker::Settings => commands.entity(entity).despawn(),
-                _ => {}
-            }
-        }
-    }
-}
-
 fn setup(mut commands: Commands) {
     commands.spawn((
         RootMarker::Status,
@@ -106,7 +89,6 @@ fn update_status(phase_res: Res<CurrentPhase>, mut text_query: Query<(&mut Text,
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
-    root_query: Query<(Entity, &RootMarker)>,
     mut savegame_messages: MessageWriter<SavegameDumpMessage>,
     mut next_state: ResMut<NextState<AppState>>,
     mut timer_settings: ResMut<TimerSettings>,
@@ -117,14 +99,6 @@ fn buttons(
                 ButtonType::SettingsOpen => {
                     open_settings(&mut commands);
                 }
-                ButtonType::SettingsClose => {
-                    for (entity, root) in root_query.iter() {
-                        match *root {
-                            RootMarker::Settings => commands.entity(entity).despawn(),
-                            _ => {}
-                        }
-                    }
-                }
                 ButtonType::SettingsExit => {
                     savegame_messages.write(SavegameDumpMessage);
                     next_state.set(AppState::StartScreen);
diff --git a/src/features/inventory/components.rs b/src/features/inventory/components.rs
index b5889bc..6185bac 100644
--- a/src/features/inventory/components.rs
+++ b/src/features/inventory/components.rs
@@ -199,5 +199,4 @@ pub enum RootMarker {
 #[derive(Component)]
 pub enum ButtonType {
     InventoryOpen,
-    InventoryClose,
 }
diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index bfdaf76..55c8811 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -1,4 +1,3 @@
-use crate::features::ui::messages::ClosePopupMessage;
 use crate::{features::inventory::ui::open_inventory, prelude::*};
 use components::*;
 
@@ -11,35 +10,17 @@ impl Plugin for InventoryPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Inventory>();
 
-        app.add_systems(
-            Update,
-            (buttons, close_popup).run_if(in_state(AppState::GameScreen)),
-        );
+        app.add_systems(Update, buttons.run_if(in_state(AppState::GameScreen)));
 
         #[cfg(debug_assertions)]
         app.add_systems(Update, debug_modify_berries);
     }
 }
 
-fn close_popup(
-    mut commands: Commands,
-    mut close_popup_reader: MessageReader<ClosePopupMessage>,
-    root_query: Query<(Entity, &RootMarker)>,
-) {
-    for _ in close_popup_reader.read() {
-        for (entity, root) in root_query.iter() {
-            match *root {
-                RootMarker::Inventory => commands.entity(entity).despawn(),
-            }
-        }
-    }
-}
-
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
     itemstack_query: Query<&ItemStack>,
-    root_query: Query<(Entity, &RootMarker)>,
     game_config: Res<GameConfig>,
     asset_server: Res<AssetServer>,
 ) {
@@ -49,13 +30,6 @@ fn buttons(
                 ButtonType::InventoryOpen => {
                     open_inventory(&mut commands, itemstack_query, &game_config, &asset_server);
                 }
-                ButtonType::InventoryClose => {
-                    for (entity, root) in root_query.iter() {
-                        match *root {
-                            RootMarker::Inventory => commands.entity(entity).despawn(),
-                        }
-                    }
-                }
             },
             _ => {}
         }
diff --git a/src/features/inventory/ui/inventory.rs b/src/features/inventory/ui/inventory.rs
index f045e65..d98ce79 100644
--- a/src/features/inventory/ui/inventory.rs
+++ b/src/features/inventory/ui/inventory.rs
@@ -1,4 +1,4 @@
-use super::super::components::{ButtonType, RootMarker};
+use super::super::components::RootMarker;
 use crate::prelude::GameConfig;
 use crate::{features::inventory::ui::list_itemstack, prelude::*};
 
@@ -8,63 +8,26 @@ pub fn open_inventory(
     game_config: &Res<GameConfig>,
     asset_server: &Res<AssetServer>,
 ) {
-    commands
-        .spawn((
-            RootMarker::Inventory,
-            Node {
-                position_type: PositionType::Absolute,
-                width: percent(100),
-                height: percent(100),
-                ..Node::center()
-            },
-            ZIndex(1),
-            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.8)),
-            GlobalTransform::default(),
-        ))
-        .with_children(|parent| {
+    spawn_popup(
+        commands,
+        RootMarker::Inventory,
+        "Inventar",
+        Node::default(),
+        |parent| {
             parent
-                .spawn((
-                    Node {
-                        padding: UiRect::all(px(20.0)),
-                        ..Node::vstack(px(0))
-                    },
-                    BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
-                    BorderRadius::all(px(10.0)),
-                ))
+                .spawn(Node {
+                    width: percent(100),
+                    margin: UiRect::top(px(10.0)),
+                    ..Node::vstack(px(10))
+                })
                 .with_children(|parent| {
-                    parent.spawn((
-                        Node {
-                            width: percent(100.0),
-                            justify_content: JustifyContent::SpaceBetween,
-                            margin: UiRect::bottom(px(20.0)),
-                            ..Node::hstack(px(20))
-                        },
-                        children![
-                            text("Inventar", 40.0, Color::WHITE),
-                            pill_button(
-                                ButtonType::InventoryClose,
-                                ButtonVariant::Destructive,
-                                Node {
-                                    width: px(40),
-                                    height: px(40),
-                                    ..default()
-                                },
-                                |color| text("X", 24.0, color)
-                            ),
-                        ],
-                    ));
-
-                    parent
-                        .spawn(Node {
-                            width: percent(100),
-                            margin: UiRect::top(px(10.0)),
-                            ..Node::vstack(px(10))
-                        })
-                        .with_children(|parent| {
-                            for itemstack in items.iter() {
-                                parent.spawn(list_itemstack(itemstack, game_config, asset_server));
-                            }
+                    items
+                        .iter()
+                        .map(|item| list_itemstack(item, game_config, asset_server))
+                        .for_each(|itemstack| {
+                            parent.spawn(itemstack);
                         });
                 });
-        });
+        },
+    );
 }
diff --git a/src/features/savegame/components.rs b/src/features/savegame/components.rs
index c167311..456bfff 100644
--- a/src/features/savegame/components.rs
+++ b/src/features/savegame/components.rs
@@ -102,5 +102,4 @@ pub enum RootMarker {
 pub enum ButtonType {
     SavegameLoad { savegame_path: SavegamePath },
     SavegameDelete { savegame_path: SavegamePath },
-    PopupClose,
 }
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index bd65833..61b97e4 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -1,6 +1,5 @@
 use crate::features::phase::components::{SessionTracker, TimerSettings};
 use crate::features::savegame::ui::load_popup_handler;
-use crate::features::ui::messages::ClosePopupMessage;
 use crate::prelude::*;
 use components::*;
 use messages::*;
@@ -21,21 +20,7 @@ impl Plugin for SavegamePlugin {
         app.add_systems(Update, dump_savegame.run_if(in_state(AppState::GameScreen)));
         app.add_systems(Update, load_savegame.run_if(in_state(AppState::GameScreen)));
 
-        app.add_systems(Update, (load_popup_handler, close_popup));
-    }
-}
-
-fn close_popup(
-    mut commands: Commands,
-    mut close_popup_reader: MessageReader<ClosePopupMessage>,
-    root_query: Query<(Entity, &RootMarker)>,
-) {
-    for _ in close_popup_reader.read() {
-        for (entity, root) in root_query.iter() {
-            match *root {
-                RootMarker::PopupSavegameLoad => commands.entity(entity).despawn(),
-            }
-        }
+        app.add_systems(Update, load_popup_handler);
     }
 }
 
diff --git a/src/features/savegame/ui/load.rs b/src/features/savegame/ui/load.rs
index 2a111c4..729cea4 100644
--- a/src/features/savegame/ui/load.rs
+++ b/src/features/savegame/ui/load.rs
@@ -2,126 +2,90 @@ use super::super::components::{ButtonType, RootMarker};
 use crate::{features::savegame::messages::SavegameLoadMessage, prelude::*};
 
 pub fn spawn_load_popup(commands: &mut Commands) {
-    commands
-        .spawn((
-            RootMarker::PopupSavegameLoad,
-            Node {
-                position_type: PositionType::Absolute,
-                width: percent(100),
-                height: percent(100),
-                ..Node::center()
-            },
-            ZIndex(1),
-            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.8)),
-            GlobalTransform::default(),
-        ))
-        .with_children(|parent| {
+    spawn_popup(
+        commands,
+        RootMarker::PopupSavegameLoad,
+        "Spielstand wählen",
+        Node {
+            width: px(600),
+            height: px(500),
+            ..default()
+        },
+        |parent| {
             parent
-                .spawn((
-                    Node {
-                        width: px(600.0),
-                        height: px(500.0),
-                        padding: UiRect::all(px(20.0)),
-                        align_items: AlignItems::Center,
-                        ..Node::vstack(px(10))
-                    },
-                    BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
-                    BorderRadius::all(px(10.0)),
-                ))
+                .spawn(Node {
+                    width: percent(100),
+                    flex_direction: FlexDirection::Column,
+                    overflow: Overflow::scroll_y(),
+                    padding: UiRect::all(px(10)),
+                    row_gap: px(10),
+                    ..default()
+                })
                 .with_children(|parent| {
-                    parent.spawn((
-                        Node {
-                            width: percent(100.0),
-                            justify_content: JustifyContent::SpaceBetween,
-                            align_items: AlignItems::Center,
-                            margin: UiRect::bottom(px(20.0)),
-                            ..default()
-                        },
-                        children![
-                            text("Spielstand Auswahl", 40.0, Color::WHITE),
-                            pill_button(
-                                ButtonType::PopupClose,
-                                ButtonVariant::Destructive,
-                                Node {
-                                    width: px(40),
-                                    height: px(40),
-                                    ..default()
-                                },
-                                |color| text("X", 24.0, color)
-                            )
-                        ],
-                    ));
-
-                    parent
-                        .spawn(Node {
-                            width: percent(100),
-                            flex_direction: FlexDirection::Column,
-                            overflow: Overflow::scroll_y(),
-                            margin: UiRect::all(px(20.0)),
-                            row_gap: px(10.0),
-                            ..default()
-                        })
-                        .with_children(|parent| {
-                            for savegame in SavegamePath::list() {
-                                parent.spawn(
-                                    button(
-                                        ButtonType::SavegameLoad { savegame_path: savegame.path.clone() },
-                                        ButtonVariant::Secondary,
-                                        Node {
-                                            width: percent(100),
-                                            padding: UiRect::all(px(10)),
-                                            ..Node::center()
-                                        },
-                                        |color| (
+                    for savegame in SavegamePath::list() {
+                        parent.spawn(button(
+                            ButtonType::SavegameLoad {
+                                savegame_path: savegame.path.clone(),
+                            },
+                            ButtonVariant::Secondary,
+                            Node {
+                                width: percent(100),
+                                padding: UiRect::all(px(10)),
+                                ..Node::center()
+                            },
+                            |color| {
+                                (
+                                    Node {
+                                        width: percent(100),
+                                        align_items: AlignItems::Center,
+                                        ..Node::hstack(px(10))
+                                    },
+                                    children![
+                                        (
                                             Node {
                                                 width: percent(100),
-                                                align_items: AlignItems::Center,
-                                                ..Node::hstack(px(10))
+                                                height: percent(100),
+                                                flex_direction: FlexDirection::Column,
+                                                justify_content: JustifyContent::Center,
+                                                ..default()
                                             },
-                                            children![(
-                                                Node {
-                                                    width: percent(100),
-                                                    height: percent(100),
-                                                    flex_direction: FlexDirection::Column,
-                                                    justify_content: JustifyContent::Center,
-                                                    ..default()
-                                                },
-                                                children![
-                                                    text(
-                                                        format!("Spielstand {}", savegame.index + 1),
-                                                        24.0,
-                                                        color
+                                            children![
+                                                text(
+                                                    format!("Spielstand {}", savegame.index + 1),
+                                                    24.0,
+                                                    color
+                                                ),
+                                                text(
+                                                    format!(
+                                                        "Beeren: {}, Fokusphasen abgeschlossen: {}",
+                                                        savegame.total_berries,
+                                                        savegame.completed_focus
                                                     ),
-                                                    text(
-                                                        format!(
-                                                            "Beeren: {}, Fokusphasen abgeschlossen: {}",
-                                                            savegame.total_berries,
-                                                            savegame.completed_focus
-                                                        ),
-                                                        18.0,
-                                                        Color::WHITE,
-                                                    ),
-                                                ]
-                                            ),
-                                            pill_button(
-                                                ButtonType::SavegameDelete {
-                                                    savegame_path: savegame.path.clone()
-                                                },
-                                                ButtonVariant::Destructive,
-                                                Node {
-                                                    width: px(40),
-                                                    height: px(40),
-                                                    ..default()
-                                                },
-                                                |color| text("X", 24.0, color)
-                                            )]
+                                                    18.0,
+                                                    Color::WHITE,
+                                                ),
+                                            ]
+                                        ),
+                                        pill_button(
+                                            ButtonType::SavegameDelete {
+                                                savegame_path: savegame.path.clone()
+                                            },
+                                            ButtonVariant::Destructive,
+                                            Node {
+                                                width: px(40),
+                                                height: px(40),
+                                                ..default()
+                                            },
+                                            |color| text("X", 24.0, color)
                                         )
-                                    ),
-                                );
-                            }
-                        });
+                                    ],
+                                )
+                            },
+                        ));
+                    }
                 });
-        });
+        },
+    );
 }
 
 pub fn load_popup_handler(
@@ -135,7 +99,6 @@ pub fn load_popup_handler(
         match *interaction {
             Interaction::Pressed => {
                 match button_type {
-                    ButtonType::PopupClose => {}
                     ButtonType::SavegameLoad { savegame_path } => {
                         commands.insert_resource(savegame_path.clone());
                         next_state.set(AppState::GameScreen);
diff --git a/src/features/shop/components.rs b/src/features/shop/components.rs
index 3ef70b0..d479bbd 100644
--- a/src/features/shop/components.rs
+++ b/src/features/shop/components.rs
@@ -8,7 +8,6 @@ pub enum RootMarker {
 #[derive(Component)]
 pub enum ButtonType {
     ShopOpen,
-    ShopClose,
     ShopBuyItem(ShopOffer),
 }
 
@@ -71,4 +70,3 @@ impl ShopOffer {
         }
     }
 }
-
diff --git a/src/features/shop/mod.rs b/src/features/shop/mod.rs
index 2268529..ccb0cfa 100644
--- a/src/features/shop/mod.rs
+++ b/src/features/shop/mod.rs
@@ -1,4 +1,3 @@
-use crate::features::ui::messages::ClosePopupMessage;
 use crate::prelude::*;
 use components::*;
 use ui::open_shop;
@@ -10,24 +9,7 @@ pub struct ShopPlugin;
 
 impl Plugin for ShopPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(
-            Update,
-            (buttons, close_popup).run_if(in_state(AppState::GameScreen)),
-        );
-    }
-}
-
-fn close_popup(
-    mut commands: Commands,
-    mut close_popup_reader: MessageReader<ClosePopupMessage>,
-    root_query: Query<(Entity, &RootMarker)>,
-) {
-    for _ in close_popup_reader.read() {
-        for (entity, root) in root_query.iter() {
-            match *root {
-                RootMarker::Shop => commands.entity(entity).despawn(),
-            }
-        }
+        app.add_systems(Update, buttons.run_if(in_state(AppState::GameScreen)));
     }
 }
 
@@ -46,13 +28,6 @@ fn buttons(
                 ButtonType::ShopOpen => {
                     open_shop(&mut commands, &game_config, &asset_server);
                 }
-                ButtonType::ShopClose => {
-                    for (entity, root) in root_query.iter() {
-                        match *root {
-                            RootMarker::Shop => commands.entity(entity).despawn(),
-                        }
-                    }
-                }
                 ButtonType::ShopBuyItem(offer) => {
                     if offer.buy(&mut inventory, &mut commands, &mut items) {
                         // Item bought, exit the menu
diff --git a/src/features/shop/ui/shop.rs b/src/features/shop/ui/shop.rs
index c730772..0b260ab 100644
--- a/src/features/shop/ui/shop.rs
+++ b/src/features/shop/ui/shop.rs
@@ -9,56 +9,20 @@ pub fn open_shop(
     // TODO: calculate tile_count
     let offers = ShopOffer::list_all(game_config, 0);
 
-    commands
-        .spawn((
-            RootMarker::Shop,
-            Node {
-                position_type: PositionType::Absolute,
-                width: percent(100),
-                height: percent(100),
-                ..Node::center()
-            },
-            ZIndex(1),
-            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.8)),
-            GlobalTransform::default(),
-        ))
-        .with_children(|parent| {
-            parent
-                .spawn((
-                    Node {
-                        width: px(700),
-                        padding: UiRect::all(px(20.0)),
-                        ..Node::vstack(px(20))
-                    },
-                    BackgroundColor(Color::srgb(0.2, 0.2, 0.2)),
-                    BorderRadius::all(px(10.0)),
-                ))
-                .with_children(|parent| {
-                    parent.spawn((
-                        Node {
-                            justify_content: JustifyContent::SpaceBetween,
-                            ..Node::hstack(px(20))
-                        },
-                        children![
-                            text("Shop", 40.0, Color::WHITE),
-                            pill_button(
-                                ButtonType::ShopClose,
-                                ButtonVariant::Destructive,
-                                Node {
-                                    width: px(40),
-                                    height: px(40),
-                                    ..default()
-                                },
-                                |color| text("X", 24.0, color)
-                            ),
-                        ],
-                    ));
-
-                    parent.spawn(Node::vstack(px(10))).with_children(|parent| {
-                        for offer in offers {
-                            parent.spawn(shop_offer(&offer, game_config, asset_server));
-                        }
-                    });
-                });
-        });
+    spawn_popup(
+        commands,
+        RootMarker::Shop,
+        "Einkaufsladen",
+        Node {
+            width: px(700),
+            ..default()
+        },
+        |parent| {
+            parent.spawn(Node::vstack(px(10))).with_children(|parent| {
+                for offer in offers {
+                    parent.spawn(shop_offer(&offer, game_config, asset_server));
+                }
+            });
+        },
+    );
 }

From 21f33590773bc0b5086cd569de8eee1b1fa833cb Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:29:18 +0100
Subject: [PATCH 09/71] feat: Add context menu UI element

---
 src/features/ui/ui/popups.rs | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
index dedc8af..34a7bde 100644
--- a/src/features/ui/ui/popups.rs
+++ b/src/features/ui/ui/popups.rs
@@ -15,7 +15,7 @@ pub fn spawn_popup(
     title: impl Into<String>,
     mut node: Node,
     child: impl FnOnce(&mut RelatedSpawnerCommands<ChildOf>),
-) -> impl Bundle {
+) {
     node.flex_direction = FlexDirection::Column;
     node.row_gap = px(10);
     node.padding = UiRect::all(px(20));
@@ -68,6 +68,31 @@ pub fn spawn_popup(
         });
 }
 
+pub fn spawn_context_menu(
+    commands: &mut Commands,
+    root: impl Component,
+    position: Vec2,
+    child: impl FnOnce(&mut RelatedSpawnerCommands<ChildOf>),
+) {
+    commands
+        .spawn((
+            PopupRoot,
+            root,
+            Node {
+                position_type: PositionType::Absolute,
+                left: px(position.x),
+                top: px(position.y),
+                padding: UiRect::all(px(5)),
+                ..Node::vstack(px(5))
+            },
+            ZIndex(100),
+            BackgroundColor(Color::srgb(0.1, 0.1, 0.1)),
+            BorderRadius::all(px(5)),
+            GlobalTransform::default(),
+        ))
+        .with_children(child);
+}
+
 pub fn handle_popup_close(
     mut commands: Commands,
     root_query: Query<Entity, With<PopupRoot>>,

From bd89ac7435ec5e31378cd0cdd3b2df7765d368ae Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:30:20 +0100
Subject: [PATCH 10/71] feat: Add `spawn_context_menu` to prelude.rs

---
 src/features/ui/ui/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/ui/ui/mod.rs b/src/features/ui/ui/mod.rs
index d6f4ea3..06a212e 100644
--- a/src/features/ui/ui/mod.rs
+++ b/src/features/ui/ui/mod.rs
@@ -5,5 +5,5 @@ pub mod texts;
 
 pub use button::{button, pill_button};
 pub use flexbox::Flexbox;
-pub use popups::spawn_popup;
+pub use popups::{spawn_context_menu, spawn_popup};
 pub use texts::{text, text_with_component};

From e2b6e6ab0afe63c7c618eff32b22f706f6498a93 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:34:12 +0100
Subject: [PATCH 11/71] feat: Use `spawn_context_menu` in features/pom

---
 src/features/pom/ui/context_menu.rs | 26 ++++++++------------------
 src/features/pom/ui/mod.rs          |  2 +-
 2 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
index b62e9ff..b8b5b84 100644
--- a/src/features/pom/ui/context_menu.rs
+++ b/src/features/pom/ui/context_menu.rs
@@ -19,7 +19,7 @@ pub enum ButtonType {
     Cancel,
 }
 
-pub fn spawn_context_menu(
+pub fn open_context_menu(
     mut commands: Commands,
     mut tile_click_messages: MessageReader<TileClickMessage>,
     root_query: Query<Entity, With<RootMarker>>,
@@ -57,22 +57,11 @@ pub fn spawn_context_menu(
             let options =
                 InteractionAction::list_options(tile_state, &inventory, item_query, &game_config);
 
-            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,
-                    GlobalTransform::default(),
-                ))
-                .with_children(|parent| {
+            spawn_context_menu(
+                &mut commands,
+                RootMarker::ContextMenu,
+                screen_pos,
+                |parent| {
                     for option in options {
                         parent.spawn(button(
                             ButtonType::Interact {
@@ -98,7 +87,8 @@ pub fn spawn_context_menu(
                         },
                         |c| text("Abbrechen", 20.0, c),
                     ));
-                });
+                },
+            );
         }
     }
 }
diff --git a/src/features/pom/ui/mod.rs b/src/features/pom/ui/mod.rs
index 37ba9c8..a59c0ca 100644
--- a/src/features/pom/ui/mod.rs
+++ b/src/features/pom/ui/mod.rs
@@ -8,7 +8,7 @@ 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)),
+            context_menu::open_context_menu.run_if(in_state(AppState::GameScreen)),
         );
         app.add_systems(
             Update,

From 11bd858fa8347e6d31c9b1f2edd2c296534676d2 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 13:46:56 +0100
Subject: [PATCH 12/71] refactor: Use `Node::from_padding` helper

---
 src/features/hud/mod.rs             | 15 +++------------
 src/features/pom/ui/context_menu.rs | 10 ++--------
 2 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index 4661850..a753243 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -44,28 +44,19 @@ fn setup(mut commands: Commands) {
             button(
                 shop::components::ButtonType::ShopOpen,
                 ButtonVariant::Secondary,
-                Node {
-                    padding: UiRect::all(px(10)),
-                    ..default()
-                },
+                Node::from_padding(UiRect::all(px(10))),
                 |color| text("Shop [P]", 16.0, color)
             ),
             button(
                 inventory::components::ButtonType::InventoryOpen,
                 ButtonVariant::Secondary,
-                Node {
-                    padding: UiRect::all(px(10)),
-                    ..default()
-                },
+                Node::from_padding(UiRect::all(px(10))),
                 |color| text("Inventar", 16.0, color)
             ),
             button(
                 ButtonType::SettingsOpen,
                 ButtonVariant::Secondary,
-                Node {
-                    padding: UiRect::all(px(10)),
-                    ..default()
-                },
+                Node::from_padding(UiRect::all(px(10))),
                 |color| text("Einstellungen", 16.0, color)
             )
         ],
diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
index b8b5b84..5b3165d 100644
--- a/src/features/pom/ui/context_menu.rs
+++ b/src/features/pom/ui/context_menu.rs
@@ -70,10 +70,7 @@ pub fn open_context_menu(
                                 action: option.clone(),
                             },
                             ButtonVariant::Primary,
-                            Node {
-                                padding: UiRect::all(px(5)),
-                                ..default()
-                            },
+                            Node::from_padding(UiRect::all(px(5))),
                             |c| text(option.clone().get_name(&game_config), 20.0, c), // TODO: add sprite
                         ));
                     }
@@ -81,10 +78,7 @@ pub fn open_context_menu(
                     parent.spawn(button(
                         ButtonType::Cancel,
                         ButtonVariant::Destructive,
-                        Node {
-                            padding: UiRect::all(px(5)),
-                            ..default()
-                        },
+                        Node::from_padding(UiRect::all(px(5))),
                         |c| text("Abbrechen", 20.0, c),
                     ));
                 },

From 14cd5419ac09ca7b9745ff7657c9b83b7719e34b Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 15:20:42 +0100
Subject: [PATCH 13/71] feat: Add `wonder_event_url` to GameConfig

---
 assets/config.json                | 6 ++++--
 src/features/config/components.rs | 2 ++
 tests/config.rs                   | 3 ++-
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/assets/config.json b/assets/config.json
index 56bc933..0eaa793 100644
--- a/assets/config.json
+++ b/assets/config.json
@@ -26,5 +26,7 @@
       "slice": "Seed3",
       "growth_stages": 6
     }
-  ]
-}
\ No newline at end of file
+  ],
+  "wonder_event_url": "wss://pomomon.farm/ws"
+}
+
diff --git a/src/features/config/components.rs b/src/features/config/components.rs
index 6533682..d9b3b14 100644
--- a/src/features/config/components.rs
+++ b/src/features/config/components.rs
@@ -10,6 +10,7 @@ pub struct GameConfig {
     pub shovel_base_price: u32,
     pub shovel_rate: f32,
     pub berry_seeds: Vec<BerrySeedConfig>,
+    pub wonder_event_url: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -52,6 +53,7 @@ impl Default for GameConfig {
                     growth_stages: 6,
                 },
             ],
+            wonder_event_url: "wss://pomomon.farm/ws".into(),
         }
     }
 }
diff --git a/tests/config.rs b/tests/config.rs
index 90b2dc6..1ea4a20 100644
--- a/tests/config.rs
+++ b/tests/config.rs
@@ -25,7 +25,8 @@ fn test_load_valid_config() {
             "pom_speed": 2.0,
             "shovel_base_price": 10,
             "shovel_rate": 0.2,
-            "berry_seeds": []
+            "berry_seeds": [],
+            "wonder_event_url": "wss://pomomon.farm/ws"
         }"#,
     );
 

From 576d9fc311553b775c2b2b8e066bd8a4e90566d5 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 15:21:38 +0100
Subject: [PATCH 14/71] feat: Implement wonder event request (#40)

---
 Cargo.lock                             | 499 ++++++++++++++++++++++++-
 Cargo.toml                             |   2 +
 README.md                              |   1 +
 flake.nix                              |   2 +
 src/features/mod.rs                    |   2 +
 src/features/wonderevent/components.rs |  36 ++
 src/features/wonderevent/mod.rs        | 117 ++++++
 src/main.rs                            |   1 +
 8 files changed, 657 insertions(+), 3 deletions(-)
 create mode 100644 src/features/wonderevent/components.rs
 create mode 100644 src/features/wonderevent/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index a56f128..043f79f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1638,6 +1638,15 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -1892,7 +1901,7 @@ dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
  "core-graphics-types 0.1.3",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1984,6 +1993,15 @@ dependencies = [
  "windows 0.54.0",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -2029,6 +2047,16 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "ctrlc"
 version = "3.5.0"
@@ -2079,6 +2107,16 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "directories"
 version = "6.0.0"
@@ -2106,6 +2144,17 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "disqualified"
 version = "1.0.0"
@@ -2330,6 +2379,15 @@ dependencies = [
  "ttf-parser 0.20.0",
 ]
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -2337,7 +2395,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
 dependencies = [
  "foreign-types-macros",
- "foreign-types-shared",
+ "foreign-types-shared 0.3.1",
 ]
 
 [[package]]
@@ -2351,12 +2409,27 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "foreign-types-shared"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
 
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -2391,6 +2464,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "gethostname"
 version = "1.1.0"
@@ -2693,6 +2776,124 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
 [[package]]
 name = "image"
 version = "0.25.8"
@@ -2927,6 +3128,12 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
 [[package]]
 name = "litrs"
 version = "0.4.2"
@@ -2999,7 +3206,7 @@ dependencies = [
  "bitflags 2.9.4",
  "block",
  "core-graphics-types 0.2.0",
- "foreign-types",
+ "foreign-types 0.5.0",
  "log",
  "objc",
  "paste",
@@ -3075,6 +3282,23 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "native-tls"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
 [[package]]
 name = "ndk"
 version = "0.8.0"
@@ -3496,6 +3720,50 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "openssl"
+version = "0.10.74"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ad14dd45412269e1a30f52ad8f0664f0f4f4a89ee8fe28c3b3527021ebb654"
+dependencies = [
+ "bitflags 2.9.4",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.110"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a9f0075ba3c21b09f8e8b2026584b1d18d49388648f2fbbf3c97ea8deced8e2"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -3663,6 +3931,8 @@ dependencies = [
  "directories",
  "serde",
  "serde_json",
+ "tungstenite",
+ "url",
  "uuid",
 ]
 
@@ -3681,6 +3951,15 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "pp-rs"
 version = "0.2.1"
@@ -4019,6 +4298,15 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -4044,6 +4332,29 @@ dependencies = [
  "tiny-skia",
 ]
 
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.9.4",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "self_cell"
 version = "1.2.0"
@@ -4099,6 +4410,17 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -4277,6 +4599,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "sys-locale"
 version = "0.3.2"
@@ -4312,6 +4645,19 @@ dependencies = [
  "slotmap",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix 1.1.2",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "termcolor"
 version = "1.4.1"
@@ -4395,6 +4741,16 @@ dependencies = [
  "strict-num",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.10.0"
@@ -4542,6 +4898,24 @@ version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
 
+[[package]]
+name = "tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "native-tls",
+ "rand",
+ "sha1",
+ "thiserror 2.0.17",
+ "utf-8",
+]
+
 [[package]]
 name = "twox-hash"
 version = "2.1.2"
@@ -4554,6 +4928,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "typewit"
 version = "1.14.2"
@@ -4620,6 +5000,30 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "uuid"
 version = "1.18.1"
@@ -4649,6 +5053,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -5581,6 +5991,12 @@ version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
 [[package]]
 name = "x11-dl"
 version = "2.21.0"
@@ -5650,6 +6066,29 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5"
 
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zeno"
 version = "0.3.3"
@@ -5675,3 +6114,57 @@ dependencies = [
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 411a34b..d19f9fa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,6 +20,8 @@ bevy_dev_tools = "0.17.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 directories = "6.0"
+tungstenite = { version = "0.28.0", features = ["native-tls"] }
+url = "2.5.7"
 
 [dev-dependencies]
 uuid = "1.18.1"
diff --git a/README.md b/README.md
index b77f1be..3a50b5b 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ cargo run
 
 1. [Install Rust](https://rust-lang.org/tools/install/)
 2. [Install Bevy OS depedencies](https://bevy.org/learn/quick-start/getting-started/setup/#installing-os-dependencies)
+3. Install `openssl`
 
 ```sh
 git clone https://gitlab.uni-ulm.de/softwaregrundprojekt/2025-2026/einzelprojekt/tutorium-moritz/bernroider-dominik/bernroider-dominik pomomon-garden
diff --git a/flake.nix b/flake.nix
index 59059c3..3469861 100644
--- a/flake.nix
+++ b/flake.nix
@@ -48,6 +48,8 @@
         libxkbcommon
         # linker
         lld
+
+        openssl
       ];
       runtimeLibs = pkgs.lib.makeLibraryPath bevyDeps;
 
diff --git a/src/features/mod.rs b/src/features/mod.rs
index 5ef139a..609a10c 100644
--- a/src/features/mod.rs
+++ b/src/features/mod.rs
@@ -11,6 +11,7 @@ pub mod savegame;
 pub mod shop;
 pub mod start_screen;
 pub mod ui;
+pub mod wonderevent;
 
 pub use core::CorePlugin;
 pub use game_screen::GameScreenPlugin;
@@ -24,3 +25,4 @@ pub use savegame::SavegamePlugin;
 pub use shop::ShopPlugin;
 pub use start_screen::StartScreenPlugin;
 pub use ui::UiPlugin;
+pub use wonderevent::WonderEventPlugin;
diff --git a/src/features/wonderevent/components.rs b/src/features/wonderevent/components.rs
new file mode 100644
index 0000000..822f738
--- /dev/null
+++ b/src/features/wonderevent/components.rs
@@ -0,0 +1,36 @@
+use crate::prelude::*;
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub struct MaxFieldSize {
+    #[serde(rename = "minX")]
+    pub min_x: u32,
+    #[serde(rename = "maxX")]
+    pub max_x: u32,
+    #[serde(rename = "minY")]
+    pub min_y: u32,
+    #[serde(rename = "maxY")]
+    pub max_y: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub struct Position {
+    pub x: u32,
+    pub y: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "messageType")]
+pub enum WonderEventMessage {
+    #[serde(rename = "WONDER_REQUEST")]
+    WonderRequest {
+        #[serde(rename = "maxFieldSize")]
+        max_field_size: MaxFieldSize,
+    },
+    #[serde(rename = "REQUEST_ERROR")]
+    RequestError { error: String },
+    #[serde(rename = "NO_WONDER")]
+    NoWonder,
+    #[serde(rename = "WONDER_GRANTED")]
+    WonderGranted { position: Position },
+}
+
diff --git a/src/features/wonderevent/mod.rs b/src/features/wonderevent/mod.rs
new file mode 100644
index 0000000..bc40d1d
--- /dev/null
+++ b/src/features/wonderevent/mod.rs
@@ -0,0 +1,117 @@
+use self::components::{MaxFieldSize, WonderEventMessage};
+use crate::features::phase::components::{CurrentPhase, Phase, TimerSettings};
+use crate::prelude::*;
+use std::thread;
+use tungstenite::{Message as WsMessage, connect};
+use url::Url;
+
+pub mod components;
+
+pub struct WonderEventPlugin;
+
+#[derive(Message)]
+pub struct RequestWonderEvent {
+    pub url_str: String,
+    pub max_field_size: MaxFieldSize,
+}
+
+impl Plugin for WonderEventPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<WonderEventState>();
+        app.add_message::<RequestWonderEvent>();
+        app.add_systems(
+            Update,
+            (
+                check_halfway_focus.run_if(in_state(AppState::GameScreen)),
+                handle_wonder_event_trigger,
+            ),
+        );
+    }
+}
+
+#[derive(Resource, Default)]
+struct WonderEventState {
+    triggered_for_current_phase: bool,
+}
+
+fn check_halfway_focus(
+    mut state: ResMut<WonderEventState>,
+    phase_res: Res<CurrentPhase>,
+    settings: Res<TimerSettings>,
+    mut messages: MessageWriter<RequestWonderEvent>,
+    config: Res<GameConfig>,
+    grid: Res<Grid>,
+) {
+    match &phase_res.0 {
+        Phase::Focus { duration } => {
+            let half_duration = settings.focus_duration as f32 / 2.0;
+            if *duration <= half_duration && !state.triggered_for_current_phase {
+                state.triggered_for_current_phase = true;
+                println!("WonderEvent: Halfway point reached! Requesting event...");
+
+                let max_field_size = MaxFieldSize {
+                    min_x: 0,
+                    max_x: if grid.width > 0 { grid.width - 1 } else { 0 },
+                    min_y: 0,
+                    max_y: if grid.height > 0 { grid.height - 1 } else { 0 },
+                };
+
+                messages.write(RequestWonderEvent {
+                    url_str: config.wonder_event_url.clone(),
+                    max_field_size,
+                });
+            }
+        }
+        Phase::Paused { previous_phase } => {
+            // If the paused phase was not Focus we can reset
+            if !matches!(**previous_phase, Phase::Focus { .. }) {
+                state.triggered_for_current_phase = false;
+            }
+        }
+        _ => {
+            // Break, Finished
+            state.triggered_for_current_phase = false;
+        }
+    }
+}
+
+fn handle_wonder_event_trigger(mut events: MessageReader<RequestWonderEvent>) {
+    for event in events.read() {
+        let url_str = event.url_str.clone();
+        let max_field_size = event.max_field_size.clone();
+
+        thread::spawn(move || {
+            println!("WonderEvent: Connecting to {}", url_str);
+            match Url::parse(&url_str) {
+                Ok(url) => match connect(url.to_string()) {
+                    Ok((mut socket, response)) => {
+                        println!("WonderEvent: Connected to the server");
+                        println!("Response HTTP code: {}", response.status());
+
+                        let request = WonderEventMessage::WonderRequest { max_field_size };
+
+                        if let Ok(json_msg) = serde_json::to_string(&request) {
+                            let msg = WsMessage::Text(json_msg.into());
+                            if let Err(e) = socket.send(msg) {
+                                eprintln!("WonderEvent: Error sending message: {}", e);
+                            } else {
+                                println!("WonderEvent: Request sent successfully");
+                            }
+                        } else {
+                            eprintln!("WonderEvent: Error serializing request");
+                        }
+
+                        let _ = socket.close(None);
+                    }
+                    Err(e) => {
+                        eprintln!(
+                            "WonderEvent: Could not connect (is the server running?): {}",
+                            e
+                        );
+                    }
+                },
+                Err(e) => eprintln!("WonderEvent: Invalid URL: {}", e),
+            }
+        });
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index a7791c4..0d615bb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -34,6 +34,7 @@ fn main() {
             features::UiPlugin,
             features::InventoryPlugin,
             features::ShopPlugin,
+            features::WonderEventPlugin,
         ))
         .insert_resource(config)
         .add_systems(Startup, overwrite_default_font)

From 8c1ba2654bdda716d80f67aae7030c91090db73a Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 15:22:02 +0100
Subject: [PATCH 15/71] test: Added a test for triggering wonder events

---
 tests/wonderevent.rs | 85 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 tests/wonderevent.rs

diff --git a/tests/wonderevent.rs b/tests/wonderevent.rs
new file mode 100644
index 0000000..3680e45
--- /dev/null
+++ b/tests/wonderevent.rs
@@ -0,0 +1,85 @@
+use bevy::prelude::*;
+use pomomon_garden::features::config::components::GameConfig;
+use pomomon_garden::features::core::states::AppState;
+use pomomon_garden::features::grid::components::Grid;
+use pomomon_garden::features::phase::components::{CurrentPhase, Phase, TimerSettings};
+use pomomon_garden::features::wonderevent::{RequestWonderEvent, WonderEventPlugin};
+
+#[test]
+fn test_wonder_event_triggers() {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.add_plugins(bevy::state::app::StatesPlugin);
+    app.add_plugins(WonderEventPlugin);
+
+    app.insert_resource(GameConfig::default());
+    app.insert_resource(TimerSettings {
+        focus_duration: 60, // 60 seconds
+        short_break_duration: 5,
+        long_break_duration: 15,
+        long_break_interval: 4,
+    });
+
+    app.insert_resource(Grid {
+        width: 10,
+        height: 10,
+        tiles: vec![],
+    });
+
+    app.init_state::<AppState>();
+    let mut next_state = app.world_mut().resource_mut::<NextState<AppState>>();
+    next_state.set(AppState::GameScreen);
+
+    app.insert_resource(CurrentPhase(Phase::Focus { duration: 60.0 }));
+
+    // 1. Full Duration (60.0). No trigger.
+    app.update();
+    verify_event_count(&mut app, 0);
+
+    // 2. Half Duration (30.0). Trigger!
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Focus { duration: 30.0 });
+    app.update();
+    verify_event_count(&mut app, 1);
+
+    // 3. Less than half (29.0). Already triggered. No new trigger.
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Focus { duration: 29.0 });
+    app.update();
+    verify_event_count(&mut app, 0); // New events should be 0
+
+    // 4. Pause (Focus). Logic should NOT reset trigger.
+    let prev = Box::new(Phase::Focus { duration: 29.0 });
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Paused {
+        previous_phase: prev,
+    });
+    app.update();
+    verify_event_count(&mut app, 0);
+
+    // 5. Resume Focus. Logic should remember it was triggered.
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Focus { duration: 29.0 });
+    app.update();
+    verify_event_count(&mut app, 0);
+
+    // 6. Break. Logic should reset trigger.
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Break { duration: 5.0 });
+    app.update();
+    verify_event_count(&mut app, 0);
+
+    // 7. New Focus (Half Duration). Logic should trigger again.
+    *app.world_mut().resource_mut::<CurrentPhase>() = CurrentPhase(Phase::Focus { duration: 30.0 });
+    app.update();
+    verify_event_count(&mut app, 1);
+}
+
+fn verify_event_count(app: &mut App, expected: usize) {
+    let count = app
+        .world_mut()
+        .resource_mut::<Messages<RequestWonderEvent>>()
+        .drain()
+        .count();
+
+    assert_eq!(
+        count, expected,
+        "Expected {} events, found {}",
+        expected, count
+    );
+}

From d3414728d45150486eb58e7dc270c28c89fd7315 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 16:12:31 +0100
Subject: [PATCH 16/71] feat: implement wonder event response handling and
 visual feedback

---
 src/features/wonderevent/mod.rs | 140 +++++++++++++++++++++++++++++++-
 1 file changed, 139 insertions(+), 1 deletion(-)

diff --git a/src/features/wonderevent/mod.rs b/src/features/wonderevent/mod.rs
index bc40d1d..4ac2770 100644
--- a/src/features/wonderevent/mod.rs
+++ b/src/features/wonderevent/mod.rs
@@ -1,6 +1,8 @@
 use self::components::{MaxFieldSize, WonderEventMessage};
 use crate::features::phase::components::{CurrentPhase, Phase, TimerSettings};
 use crate::prelude::*;
+use std::sync::Mutex;
+use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 use tungstenite::{Message as WsMessage, connect};
 use url::Url;
@@ -15,8 +17,24 @@ pub struct RequestWonderEvent {
     pub max_field_size: MaxFieldSize,
 }
 
+#[derive(Resource)]
+pub struct WonderEventSender(pub Sender<WonderEventMessage>);
+
+#[derive(Resource)]
+pub struct WonderEventReceiver(pub Mutex<Receiver<WonderEventMessage>>);
+
+#[derive(Component)]
+struct FloatingText {
+    timer: Timer,
+    velocity: Vec3,
+}
+
 impl Plugin for WonderEventPlugin {
     fn build(&self, app: &mut App) {
+        let (tx, rx) = channel();
+        app.insert_resource(WonderEventSender(tx));
+        app.insert_resource(WonderEventReceiver(Mutex::new(rx)));
+
         app.init_resource::<WonderEventState>();
         app.add_message::<RequestWonderEvent>();
         app.add_systems(
@@ -24,6 +42,8 @@ impl Plugin for WonderEventPlugin {
             (
                 check_halfway_focus.run_if(in_state(AppState::GameScreen)),
                 handle_wonder_event_trigger,
+                handle_wonder_event_response.run_if(in_state(AppState::GameScreen)),
+                animate_floating_text,
             ),
         );
     }
@@ -75,10 +95,14 @@ fn check_halfway_focus(
     }
 }
 
-fn handle_wonder_event_trigger(mut events: MessageReader<RequestWonderEvent>) {
+fn handle_wonder_event_trigger(
+    mut events: MessageReader<RequestWonderEvent>,
+    sender: Res<WonderEventSender>,
+) {
     for event in events.read() {
         let url_str = event.url_str.clone();
         let max_field_size = event.max_field_size.clone();
+        let tx = sender.0.clone();
 
         thread::spawn(move || {
             println!("WonderEvent: Connecting to {}", url_str);
@@ -96,6 +120,25 @@ fn handle_wonder_event_trigger(mut events: MessageReader<RequestWonderEvent>) {
                                 eprintln!("WonderEvent: Error sending message: {}", e);
                             } else {
                                 println!("WonderEvent: Request sent successfully");
+
+                                // Read response
+                                if let Ok(msg) = socket.read() {
+                                    if let Ok(text) = msg.into_text() {
+                                        println!("WonderEvent: Received response: {}", text);
+                                        if let Ok(response) =
+                                            serde_json::from_str::<WonderEventMessage>(&text)
+                                        {
+                                            if let Err(e) = tx.send(response) {
+                                                eprintln!(
+                                                    "WonderEvent: Failed to send response to main thread: {}",
+                                                    e
+                                                );
+                                            }
+                                        } else {
+                                            eprintln!("WonderEvent: Failed to parse response JSON");
+                                        }
+                                    }
+                                }
                             }
                         } else {
                             eprintln!("WonderEvent: Error serializing request");
@@ -115,3 +158,98 @@ fn handle_wonder_event_trigger(mut events: MessageReader<RequestWonderEvent>) {
         });
     }
 }
+
+fn handle_wonder_event_response(
+    receiver: Res<WonderEventReceiver>,
+    grid: Res<Grid>,
+    mut tile_query: Query<&mut TileState>,
+    game_config: Res<GameConfig>,
+    mut commands: Commands,
+) {
+    if let Ok(rx) = receiver.0.try_lock() {
+        while let Ok(msg) = rx.try_recv() {
+            match msg {
+                WonderEventMessage::WonderGranted { position } => {
+                    println!("WonderEvent: GRANTED at ({}, {})", position.x, position.y);
+
+                    // Update Tile State
+                    if let Ok(_) = grid.map_tile_state(
+                        (position.x, position.y),
+                        |state| {
+                            if let TileState::Occupied {
+                                seed,
+                                watered,
+                                growth_stage,
+                                withered,
+                                dry_counter,
+                            } = state
+                            {
+                                // Progress growth stage
+                                let mut new_stage = *growth_stage;
+                                if let Some(config) = seed.get_seed_config(&game_config) {
+                                    if new_stage < config.growth_stages {
+                                        new_stage += 1;
+                                    }
+                                }
+
+                                TileState::Occupied {
+                                    seed: seed.clone(),
+                                    watered: *watered,
+                                    growth_stage: new_stage,
+                                    withered: *withered,
+                                    dry_counter: *dry_counter,
+                                }
+                            } else {
+                                state.clone()
+                            }
+                        },
+                        tile_query.reborrow(),
+                    ) {
+                        let world_pos = grid_to_world_coords(
+                            position.x,
+                            position.y,
+                            None,
+                            grid.width,
+                            grid.height,
+                        );
+                        commands.spawn((
+                            Text2d::new("Wonder!"),
+                            TextFont {
+                                font_size: 20.0,
+                                ..Default::default()
+                            },
+                            TextColor(Color::srgb(1.0, 0.8, 0.2)),
+                            Transform::from_translation(world_pos + Vec3::new(0.0, 20.0, 10.0)),
+                            FloatingText {
+                                timer: Timer::from_seconds(1.5, TimerMode::Once),
+                                velocity: Vec3::new(0.0, 20.0, 0.0),
+                            },
+                        ));
+                    }
+                }
+                WonderEventMessage::RequestError { error } => {
+                    println!("WonderEvent: REQUEST ERROR: {}", error);
+                }
+                WonderEventMessage::NoWonder => {
+                    println!("WonderEvent: NO WONDER");
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+fn animate_floating_text(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut query: Query<(Entity, &mut FloatingText, &mut Transform)>,
+) {
+    for (entity, mut float, mut transform) in query.iter_mut() {
+        float.timer.tick(time.delta());
+        transform.translation += float.velocity * time.delta_secs();
+
+        if float.timer.is_finished() {
+            commands.entity(entity).despawn();
+        }
+    }
+}

From bac4894d8ba5710e8fb7801878d5f3d4c309e26c Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 16:14:24 +0100
Subject: [PATCH 17/71] test: Add wonder event response handling test

---
 tests/wonderevent.rs | 94 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 3 deletions(-)

diff --git a/tests/wonderevent.rs b/tests/wonderevent.rs
index 3680e45..2fb9a6d 100644
--- a/tests/wonderevent.rs
+++ b/tests/wonderevent.rs
@@ -1,9 +1,13 @@
 use bevy::prelude::*;
-use pomomon_garden::features::config::components::GameConfig;
+use pomomon_garden::features::config::components::{BerrySeedConfig, GameConfig};
 use pomomon_garden::features::core::states::AppState;
-use pomomon_garden::features::grid::components::Grid;
+use pomomon_garden::features::grid::components::{Grid, Tile, TileState};
+use pomomon_garden::features::inventory::components::ItemType;
 use pomomon_garden::features::phase::components::{CurrentPhase, Phase, TimerSettings};
-use pomomon_garden::features::wonderevent::{RequestWonderEvent, WonderEventPlugin};
+use pomomon_garden::features::wonderevent::components::{Position, WonderEventMessage};
+use pomomon_garden::features::wonderevent::{
+    RequestWonderEvent, WonderEventPlugin, WonderEventSender,
+};
 
 #[test]
 fn test_wonder_event_triggers() {
@@ -83,3 +87,87 @@ fn verify_event_count(app: &mut App, expected: usize) {
         expected, count
     );
 }
+
+#[test]
+fn test_wonder_response_handling() {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.add_plugins(bevy::state::app::StatesPlugin);
+    app.add_plugins(WonderEventPlugin);
+    app.insert_resource(GameConfig {
+        berry_seeds: vec![BerrySeedConfig {
+            name: "TestSeed".to_string(),
+            cost: 1,
+            grants: 1,
+            slice: "Seed1".to_string(),
+            growth_stages: 5,
+        }],
+        ..Default::default()
+    });
+    app.insert_resource(CurrentPhase(Phase::Focus { duration: 60.0 }));
+
+    // Setup Grid with an occupied tile
+    let mut tiles = Vec::new();
+    let column = vec![
+        app.world_mut()
+            .spawn((
+                Tile { x: 0, y: 0 },
+                TileState::Occupied {
+                    seed: ItemType::BerrySeed {
+                        name: "TestSeed".to_string(),
+                    },
+                    watered: true,
+                    growth_stage: 1,
+                    withered: false,
+                    dry_counter: 0,
+                },
+            ))
+            .id(),
+    ];
+    tiles.push(column);
+    app.insert_resource(Grid {
+        width: 1,
+        height: 1,
+        tiles,
+    });
+
+    app.insert_resource(TimerSettings::default());
+
+    // Init State
+    app.init_state::<AppState>();
+    let mut next_state = app.world_mut().resource_mut::<NextState<AppState>>();
+    next_state.set(AppState::GameScreen);
+
+    // Run update to enter state
+    app.update();
+
+    // Send WonderEventMessage directly to the channel
+    let sender = app.world().resource::<WonderEventSender>().0.clone();
+    sender
+        .send(WonderEventMessage::WonderGranted {
+            position: Position { x: 0, y: 0 },
+        })
+        .expect("Failed to send WonderEventMessage");
+
+    // Run update to process message
+    app.update();
+
+    // Verify Tile State (growth should increase from 1 to 2)
+    let grid = app.world().resource::<Grid>();
+    let tile_entity = grid.get_tile((0, 0)).unwrap();
+    let tile_state = app.world().get::<TileState>(tile_entity).unwrap();
+
+    if let TileState::Occupied { growth_stage, .. } = tile_state {
+        assert_eq!(*growth_stage, 2, "Growth stage should increase to 2");
+    } else {
+        panic!("Tile state should be Occupied");
+    }
+
+    // Verify Floating Text Spawned
+    let mut text_query = app.world_mut().query::<&Text2d>();
+    assert_eq!(
+        text_query.iter(app.world()).count(),
+        1,
+        "Should spawn one floating text"
+    );
+}

From f21b44d2e040aae0bfad290d8290116940575540 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 16:18:25 +0100
Subject: [PATCH 18/71] fix: Changed wonder event text from `Wonder!` to
 `Wunder!`

---
 src/features/wonderevent/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/wonderevent/mod.rs b/src/features/wonderevent/mod.rs
index 4ac2770..949e1d1 100644
--- a/src/features/wonderevent/mod.rs
+++ b/src/features/wonderevent/mod.rs
@@ -213,7 +213,7 @@ fn handle_wonder_event_response(
                             grid.height,
                         );
                         commands.spawn((
-                            Text2d::new("Wonder!"),
+                            Text2d::new("Wunder!"),
                             TextFont {
                                 font_size: 20.0,
                                 ..Default::default()

From d227e7171e23d3242993f3936a83158a620d393f Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 16:32:40 +0100
Subject: [PATCH 19/71] fix: Timer settings change by 10 while pressing shift

---
 src/features/hud/mod.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index a753243..c780242 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -83,7 +83,14 @@ fn buttons(
     mut savegame_messages: MessageWriter<SavegameDumpMessage>,
     mut next_state: ResMut<NextState<AppState>>,
     mut timer_settings: ResMut<TimerSettings>,
+    keys: Res<ButtonInput<KeyCode>>,
 ) {
+    let shift_multiplier = if keys.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]) {
+        10
+    } else {
+        1
+    };
+
     for (interaction, button_type) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => match button_type {
@@ -99,10 +106,10 @@ fn buttons(
                 }
                 ButtonType::SettingsTimerChange { input, amount } => match input {
                     SettingsTimerInput::Minutes(timer_type) => {
-                        timer_settings.change(timer_type, 60 * amount)
+                        timer_settings.change(timer_type, 60 * amount * shift_multiplier)
                     }
                     SettingsTimerInput::Seconds(timer_type) => {
-                        timer_settings.change(timer_type, *amount)
+                        timer_settings.change(timer_type, *amount * shift_multiplier)
                     }
                 },
             },

From a96ad857a62ad03958476d86df60b96a348dd86d Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 17:21:54 +0100
Subject: [PATCH 20/71] feat: Add shovel asset and inventory helper (#15)

---
 assets/shovel.aseprite               | Bin 0 -> 639 bytes
 src/features/inventory/components.rs |  18 ++++++++++--------
 2 files changed, 10 insertions(+), 8 deletions(-)
 create mode 100644 assets/shovel.aseprite

diff --git a/assets/shovel.aseprite b/assets/shovel.aseprite
new file mode 100644
index 0000000000000000000000000000000000000000..9c21f81ef8a970265e9986eaf81a952d26685549
GIT binary patch
literal 639
zcmb<tVqkc%l#xLJ3>g_17*c>30dyG{L4phdKu8PlA87iok8EID*?<;^0WrG**h(bp
zCIZ<k3_wv`AVW#P#8ty4&C;+x%=&(z+RX)N?+(xU{mE?R(}1jf2If=pyfgKKyj6^B
zEbZ+}3=*26^ByM8{vUt#$?4mF{{R0!d+qj?y7tVhtjMsSGN-OJMn*Toldo6r>Ywh_
zm2c4GZgVKt<w|e%u0sDMTdwRl{b}8ym&>=`*m3-6;iM~WSsP6v7O1$k$%7oEz>MU?
z|3Ef7gHK{*YLSAW9@v@4zF=br&d4uI%|X(^paA56Fdv9k07e85{Qv(JNU|z`{L9Ah
zA0h}85oZu(sF;(Suz+VrYVM!@K1~y$yk{?O*Z+HO@%QEbUC#OkC61_FuZc-hN-jFn
zKC|=e+9@-7PygR>$A8Vu7tfk9X6!WZ(Jh{MHfGaPuCAL$+SoVke35qOj4S8!$NrvX
z;<INO^yKJi7IFkFe{`$us?Us_3bR6rCo-O>iFr0js{TbDdt%nC?m7Px(wgq{=jnO$
zgcM&q+cJ~Uc)m>W>^r&t-fMmNe_uY0*GxXv{!C8MnZ1{0^O{Rfuk$+VyV+#P4w+?J
ccN!S4%+%v(IJ2mA=ZR;R55+K48rm`g03L(GMgRZ+

literal 0
HcmV?d00001

diff --git a/src/features/inventory/components.rs b/src/features/inventory/components.rs
index 6185bac..b2ac89f 100644
--- a/src/features/inventory/components.rs
+++ b/src/features/inventory/components.rs
@@ -80,8 +80,8 @@ impl ItemType {
                 aseprite: asset_server.load("berry.aseprite"),
             },
             ItemType::Shovel => AseSlice {
-                name: "Berry".into(),
-                aseprite: asset_server.load("berry.aseprite"),
+                name: "Shovel".into(),
+                aseprite: asset_server.load("shovel.aseprite"),
             },
             ItemType::BerrySeed { name } => {
                 let seed_config = game_config.berry_seeds.iter().find(|s| s.name == *name);
@@ -114,12 +114,14 @@ pub struct Inventory {
 }
 
 impl Inventory {
-    pub fn has_item(&self, items_query: Query<&ItemStack>) -> bool {
-        self.items
-            .iter()
-            .map(|entity| items_query.get(*entity).ok())
-            .find(|option| option.is_some())
-            .is_some()
+    pub fn has_item_type(&self, items_query: &Query<&ItemStack>, item_type: ItemType) -> bool {
+        self.items.iter().any(|&entity| {
+            if let Ok(stack) = items_query.get(entity) {
+                stack.item_type == item_type
+            } else {
+                false
+            }
+        })
     }
 
     pub fn update_item_stack(

From bde09ec5f260399b357594966efc2dda7a10410e Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 17:30:36 +0100
Subject: [PATCH 21/71] feat: Enable dynamic shovel pricing calculation (#15)

---
 src/features/grid/components.rs | 17 ++++++++++++++++-
 src/features/input/mod.rs       | 10 +++++++++-
 src/features/shop/mod.rs        |  4 +++-
 src/features/shop/ui/shop.rs    |  6 ++++--
 4 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/src/features/grid/components.rs b/src/features/grid/components.rs
index 571e63f..94f1e5a 100644
--- a/src/features/grid/components.rs
+++ b/src/features/grid/components.rs
@@ -74,4 +74,19 @@ impl Grid {
         *tile_state = mapper(&*tile_state);
         Ok(())
     }
-}
\ No newline at end of file
+
+    pub fn count_claimed_tiles(&self, tile_query: &Query<&TileState>) -> u32 {
+        self.tiles
+            .iter()
+            .flatten()
+            .filter(|&entity| {
+                if let Ok(state) = tile_query.get(*entity) {
+                    !matches!(state, TileState::Unclaimed)
+                } else {
+                    false
+                }
+            })
+            .count() as u32
+    }
+}
+
diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 3b7158b..0059c66 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -162,9 +162,17 @@ fn shop_keybind(
     mut commands: Commands,
     game_config: Res<GameConfig>,
     asset_server: Res<AssetServer>,
+    grid: Res<Grid>,
+    tile_query: Query<&TileState>,
 ) {
     if keys.just_pressed(KeyCode::KeyP) {
-        open_shop(&mut commands, &game_config, &asset_server);
+        open_shop(
+            &mut commands,
+            &game_config,
+            &asset_server,
+            &grid,
+            &tile_query,
+        );
     }
 }
 
diff --git a/src/features/shop/mod.rs b/src/features/shop/mod.rs
index ccb0cfa..b347b56 100644
--- a/src/features/shop/mod.rs
+++ b/src/features/shop/mod.rs
@@ -21,12 +21,14 @@ fn buttons(
     asset_server: Res<AssetServer>,
     mut inventory: ResMut<Inventory>,
     mut items: Query<&mut ItemStack>,
+    grid: Res<Grid>,
+    tile_query: Query<&TileState>,
 ) {
     for (interaction, button_type) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => match button_type {
                 ButtonType::ShopOpen => {
-                    open_shop(&mut commands, &game_config, &asset_server);
+                    open_shop(&mut commands, &game_config, &asset_server, &grid, &tile_query);
                 }
                 ButtonType::ShopBuyItem(offer) => {
                     if offer.buy(&mut inventory, &mut commands, &mut items) {
diff --git a/src/features/shop/ui/shop.rs b/src/features/shop/ui/shop.rs
index 0b260ab..4983b00 100644
--- a/src/features/shop/ui/shop.rs
+++ b/src/features/shop/ui/shop.rs
@@ -5,9 +5,11 @@ pub fn open_shop(
     commands: &mut Commands,
     game_config: &GameConfig,
     asset_server: &Res<AssetServer>,
+    grid: &Grid,
+    tile_query: &Query<&TileState>,
 ) {
-    // TODO: calculate tile_count
-    let offers = ShopOffer::list_all(game_config, 0);
+    let tile_count = grid.count_claimed_tiles(tile_query);
+    let offers = ShopOffer::list_all(game_config, tile_count);
 
     spawn_popup(
         commands,

From 8f01e0bc80c3f9415c099a4ae21f93fbda14da20 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 17:30:55 +0100
Subject: [PATCH 22/71] feat: Implement shovel interaction and tile
 highlighting (#15)

---
 src/features/grid/mod.rs  | 55 +++++++++++++++++++++++++-
 src/features/input/mod.rs | 82 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 133 insertions(+), 4 deletions(-)

diff --git a/src/features/grid/mod.rs b/src/features/grid/mod.rs
index d2a064f..95ecebc 100644
--- a/src/features/grid/mod.rs
+++ b/src/features/grid/mod.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 use components::{CropVisual, WaterVisual};
+use std::collections::HashSet;
 
 pub mod components;
 pub mod consts;
@@ -88,7 +89,10 @@ fn cleanup(mut commands: Commands, tile_query: Query<Entity, With<Tile>>) {
 }
 
 fn update_tiles(
-    mut query: Query<(&TileState, &mut AseSlice, &Children), (With<Tile>, Without<CropVisual>)>,
+    mut query: Query<
+        (&TileState, &mut AseSlice, &Children, &Tile),
+        (With<Tile>, Without<CropVisual>),
+    >,
     mut crop_query: Query<
         (&mut Visibility, &mut Transform, &mut AseSlice),
         (With<CropVisual>, Without<WaterVisual>, Without<Tile>),
@@ -99,8 +103,27 @@ fn update_tiles(
     >,
     asset_server: Res<AssetServer>,
     game_config: Res<GameConfig>,
+    inventory: Res<Inventory>,
+    item_stacks: Query<&ItemStack>,
+    grid: Res<Grid>,
+    mut sprite_query: Query<&mut Sprite, With<Tile>>,
 ) {
-    for (state, mut slice, children) in &mut query {
+    let has_shovel = inventory.has_item_type(&item_stacks, ItemType::Shovel);
+
+    let owned_tiles: HashSet<(u32, u32)> = query
+        .iter()
+        .filter_map(|(state, _, _, tile)| {
+            if !matches!(state, TileState::Unclaimed) {
+                Some((tile.x, tile.y))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    for (state, mut slice, children, tile) in &mut query {
+        let entity = grid.get_tile((tile.x, tile.y)).unwrap(); // Get entity for sprite query
+
         slice.name = match state {
             TileState::Unclaimed => "Unclaimed",
             TileState::Empty => "Empty",
@@ -133,6 +156,34 @@ fn update_tiles(
             _ => Vec3::ONE,
         };
 
+        let mut is_highlighted = false;
+        if has_shovel && matches!(state, TileState::Unclaimed) {
+            // Check if not on edge
+            if tile.x > 0 && tile.x < grid.width - 1 && tile.y > 0 && tile.y < grid.height - 1 {
+                // Check neighbors
+                let neighbors = [
+                    (tile.x + 1, tile.y),
+                    (tile.x.saturating_sub(1), tile.y),
+                    (tile.x, tile.y + 1),
+                    (tile.x, tile.y.saturating_sub(1)),
+                ];
+                for n in neighbors.iter() {
+                    if owned_tiles.contains(n) {
+                        is_highlighted = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if let Ok(mut sprite) = sprite_query.get_mut(entity) {
+            if is_highlighted {
+                sprite.color = Color::srgb(0.3, 1.0, 0.3); // Green tint
+            } else {
+                sprite.color = Color::WHITE;
+            }
+        }
+
         for child in children.iter() {
             if let Ok((mut visibility, mut transform, mut sprite)) = crop_query.get_mut(child) {
                 *visibility = match state {
diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 0059c66..41c7225 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -53,7 +53,13 @@ fn move_click(
     config: Res<GameConfig>,
     phase: Res<CurrentPhase>,
     ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
+    inventory: Res<Inventory>,
+    item_stacks: Query<&ItemStack>,
 ) {
+    if inventory.has_item_type(&item_stacks, ItemType::Shovel) {
+        return; // Block movement if player has a shovel
+    }
+
     match phase.0 {
         Phase::Focus { .. } => return,
         _ => {}
@@ -78,12 +84,25 @@ fn interact_click(
     config: Res<GameConfig>,
     phase: Res<CurrentPhase>,
     ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
+    mut commands: Commands,
+    mut inventory: ResMut<Inventory>,
+    mut item_stacks: Query<&mut ItemStack>,
+    grid: Res<Grid>,
+    mut tile_states: Query<&mut TileState>,
 ) {
     match phase.0 {
         Phase::Focus { .. } => return,
         _ => {}
     }
 
+    let has_shovel = inventory.items.iter().any(|&entity| {
+        if let Ok(stack) = item_stacks.get(entity) {
+            stack.item_type == ItemType::Shovel
+        } else {
+            false
+        }
+    });
+
     if mouse_btn.just_pressed(MouseButton::Left) {
         if keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight) {
             return;
@@ -92,10 +111,69 @@ fn interact_click(
             return;
         };
 
-        tile_click_messages.write(TileClickMessage { x, y });
+        if has_shovel {
+            // Shovel interaction logic
+            let tile_entity = match grid.get_tile((x, y)) {
+                Ok(entity) => entity,
+                Err(_) => return, // Clicked outside grid
+            };
+
+            // Before getting mutable tile_state, check neighbors with immutable borrow
+            let mut has_claimed_neighbor = false;
+            // Check if not on edge first for early exit to avoid checking neighbors outside grid.
+            if x == 0 || x == grid.width - 1 || y == 0 || y == grid.height - 1 {
+                return;
+            }
+
+            let neighbors = [
+                (x + 1, y),
+                (x.saturating_sub(1), y),
+                (x, y + 1),
+                (x, y.saturating_sub(1)),
+            ];
+
+            for (nx, ny) in neighbors.iter() {
+                // Ensure neighbor coordinates are within grid boundaries before attempting to get tile
+                if *nx < grid.width && *ny < grid.height {
+                    if let Ok(neighbor_entity) = grid.get_tile((*nx, *ny)) {
+                        if let Ok(neighbor_state) = tile_states.get(neighbor_entity) {
+                            if !matches!(*neighbor_state, TileState::Unclaimed) {
+                                has_claimed_neighbor = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if !has_claimed_neighbor {
+                return; // No claimed neighbor, cannot unlock
+            }
+
+            // Now get mutable tile_state, after all immutable neighbor checks are done
+            let mut tile_state = match tile_states.get_mut(tile_entity) {
+                Ok(state) => state,
+                Err(_) => return, // Should not happen
+            };
+
+            // Check if unclaimed AFTER determining neighbor status
+            if !matches!(*tile_state, TileState::Unclaimed) {
+                return;
+            }
+
+            if has_claimed_neighbor {
+                // This check is redundant due to early return above, but kept for clarity
+                // Unlock tile
+                *tile_state = TileState::Empty;
+                inventory.update_item_stack(&mut commands, &mut item_stacks, ItemType::Shovel, -1);
+            }
+            return; // Consume click event, prevent normal tile_click_messages
+        } else {
+            // Normal interaction
+            tile_click_messages.write(TileClickMessage { x, y });
+        }
     }
 }
-
 fn debug_click(
     mouse_btn: Res<ButtonInput<MouseButton>>,
     keys: Res<ButtonInput<KeyCode>>,

From 4b86f4bb40e4b1d77cafe0ba8c130d0f22c60ce5 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 17:31:42 +0100
Subject: [PATCH 23/71] chore: Update shovel price rate in config (#15)

---
 assets/config.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/assets/config.json b/assets/config.json
index 0eaa793..1b2e028 100644
--- a/assets/config.json
+++ b/assets/config.json
@@ -3,7 +3,7 @@
   "grid_height": 4,
   "pom_speed": 1.5,
   "shovel_base_price": 10,
-  "shovel_rate": 0.5,
+  "shovel_rate": 0.2,
   "berry_seeds": [
     {
       "name": "Normale Samen",
@@ -29,4 +29,3 @@
   ],
   "wonder_event_url": "wss://pomomon.farm/ws"
 }
-

From 9437a5400a5d26e69f8160bc0fbd5fd177381167 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 17:48:15 +0100
Subject: [PATCH 24/71] fix: Derive `PartialEq` and `Eq` for `TileState` and
 remove trailing empty line

---
 src/features/grid/components.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/features/grid/components.rs b/src/features/grid/components.rs
index 94f1e5a..6bbbb55 100644
--- a/src/features/grid/components.rs
+++ b/src/features/grid/components.rs
@@ -13,7 +13,7 @@ pub struct CropVisual;
 #[derive(Component)]
 pub struct WaterVisual;
 
-#[derive(Component, Default, Serialize, Deserialize, Clone, Debug)]
+#[derive(Component, Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub enum TileState {
     #[default]
     Unclaimed,
@@ -89,4 +89,3 @@ impl Grid {
             .count() as u32
     }
 }
-

From 9483c0e3b423ef1fddd9f40d81d06ff98f283d12 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 18:01:00 +0100
Subject: [PATCH 25/71] feat: Derive `Debug` for `ItemStack`

---
 src/features/inventory/components.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/inventory/components.rs b/src/features/inventory/components.rs
index b2ac89f..ab3f75a 100644
--- a/src/features/inventory/components.rs
+++ b/src/features/inventory/components.rs
@@ -102,7 +102,7 @@ impl ItemType {
     }
 }
 
-#[derive(Component, Serialize, Deserialize, Clone)]
+#[derive(Component, Serialize, Deserialize, Clone, Debug)]
 pub struct ItemStack {
     pub item_type: ItemType,
     pub amount: u32,

From ed18fffa43626a9f535e1d6afb0ab5ebe4bb39ed Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 18:04:03 +0100
Subject: [PATCH 26/71] test: Add grid expansion test (#15)

---
 tests/expansion.rs | 116 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)
 create mode 100644 tests/expansion.rs

diff --git a/tests/expansion.rs b/tests/expansion.rs
new file mode 100644
index 0000000..71c9801
--- /dev/null
+++ b/tests/expansion.rs
@@ -0,0 +1,116 @@
+use bevy::ecs::system::RunSystemOnce;
+use pomomon_garden::features::config::components::GameConfig;
+use pomomon_garden::features::grid::components::{Grid, TileState};
+use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
+use pomomon_garden::prelude::*;
+
+mod common;
+use common::setup_app;
+
+#[test]
+fn test_shovel_expansion() {
+    let mut app = setup_app(
+        5,
+        5,
+        &[(2, 2, TileState::Empty)], // (2,2) is Empty, making it a "claimed" neighbor
+        vec![(ItemType::Shovel, 1)], // One shovel in inventory
+        None,
+    );
+
+    let target_pos = (2, 3); // Unclaimed tile next to (2,2), not on edge of 5x5 grid
+
+    let _ = app.world_mut().run_system_once(
+        move |
+            grid: Res<Grid>,
+            mut tile_states: Query<&mut TileState>,
+            mut inventory: ResMut<Inventory>,
+            mut item_stack_query: Query<&mut ItemStack>,
+            mut commands: Commands,
+            _game_config: Res<GameConfig> // Not directly used but required by signature
+        | {
+            let (x, y) = target_pos;
+
+            let tile_entity = match grid.get_tile((x, y)) {
+                Ok(entity) => entity,
+                Err(_) => panic!("Clicked outside grid at {:?}", (x,y)),
+            };
+
+            // Mimic the edge check from interact_click
+            if x == 0 || x == grid.width - 1 || y == 0 || y == grid.height - 1 {
+                panic!("Should not return early due to edge check for {:?} in a 5x5 grid", target_pos);
+            }
+
+            let neighbors = [
+                (x + 1, y),
+                (x.saturating_sub(1), y),
+                (x, y + 1),
+                (x, y.saturating_sub(1)),
+            ];
+
+            let mut has_claimed_neighbor = false;
+            for (nx, ny) in neighbors.iter() {
+                if *nx < grid.width && *ny < grid.height {
+                    if let Ok(neighbor_entity) = grid.get_tile((*nx, *ny)) {
+                        if let Ok(neighbor_state) = tile_states.get(neighbor_entity) {
+                            if !matches!(*neighbor_state, TileState::Unclaimed) {
+                                has_claimed_neighbor = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            assert!(has_claimed_neighbor, "Target tile {:?} should have a claimed neighbor", target_pos);
+
+            let mut tile_state = match tile_states.get_mut(tile_entity) {
+                Ok(state) => state,
+                Err(_) => panic!("Failed to get mutable tile state for {:?}", target_pos),
+            };
+
+            assert!(matches!(*tile_state, TileState::Unclaimed), "Target tile {:?} should be Unclaimed initially, but was {:?}", target_pos, tile_state);
+
+            // Execute the expansion
+            if inventory.update_item_stack(
+                &mut commands,
+                &mut item_stack_query,
+                ItemType::Shovel,
+                -1,
+            ) {
+                *tile_state = TileState::Empty;
+            } else {
+                panic!("Shovel not consumed or not found in inventory");
+            }
+        },
+    );
+
+    app.update(); // Apply commands
+
+    // Assert Tile State
+    let grid = app.world().resource::<Grid>();
+    let tile_entity = grid.get_tile(target_pos).unwrap();
+    let tile_state = app.world().entity(tile_entity).get::<TileState>().unwrap();
+
+    assert!(
+        matches!(*tile_state, TileState::Empty),
+        "Tile (1,2) should be Empty after expansion, but was {:?}",
+        tile_state
+    );
+
+    // Assert Inventory
+    let inventory = app.world().resource::<Inventory>();
+    let shovel_stack = inventory.items.iter().find_map(|&entity| {
+        let stack = app.world().entity(entity).get::<ItemStack>()?;
+        if stack.item_type == ItemType::Shovel {
+            Some(stack)
+        } else {
+            None
+        }
+    });
+
+    assert!(
+        shovel_stack.is_none() || shovel_stack.unwrap().amount == 0,
+        "Shovel should have been consumed, found {:?}",
+        shovel_stack
+    );
+}

From 04eb3d7c2ee66e90538d3ea386bfcfd8d8131784 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 18:16:02 +0100
Subject: [PATCH 27/71] chore: Update grid size

---
 assets/config.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/assets/config.json b/assets/config.json
index 1b2e028..4798184 100644
--- a/assets/config.json
+++ b/assets/config.json
@@ -1,6 +1,6 @@
 {
-  "grid_width": 12,
-  "grid_height": 4,
+  "grid_width": 15,
+  "grid_height": 5,
   "pom_speed": 1.5,
   "shovel_base_price": 10,
   "shovel_rate": 0.2,

From eb0b8ca91a683d35fe08aa9c46947b9b2d90f739 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 18:22:40 +0100
Subject: [PATCH 28/71] feat: Set (1,1) to `TileState::Empty` on new game

---
 src/features/grid/mod.rs | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/features/grid/mod.rs b/src/features/grid/mod.rs
index 95ecebc..4aa951e 100644
--- a/src/features/grid/mod.rs
+++ b/src/features/grid/mod.rs
@@ -27,13 +27,28 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<Gam
         let mut column = Vec::with_capacity(grid_height as usize);
 
         for y in 0..grid_height {
+            let initial_state = if x == 1 && y == 1 {
+                TileState::Empty
+            } else {
+                TileState::Unclaimed
+            };
+
             let tile_entity = commands
                 .spawn((
                     Tile { x, y },
-                    TileState::Unclaimed,
+                    initial_state.clone(),
                     AseSlice {
-                        name: "Unclaimed".into(),
-                        aseprite: asset_server.load("tiles/tile-unclaimed.aseprite"),
+                        name: match initial_state {
+                            TileState::Unclaimed => "Unclaimed",
+                            TileState::Empty => "Empty",
+                            _ => unreachable!(),
+                        }
+                        .into(),
+                        aseprite: asset_server.load(match initial_state {
+                            TileState::Unclaimed => "tiles/tile-unclaimed.aseprite",
+                            TileState::Empty => "tiles/tile-empty.aseprite",
+                            _ => unreachable!(),
+                        }),
                     },
                     Sprite::default(),
                     Transform::from_translation(grid_to_world_coords(

From 50314e6c4ea23cfd5d69c172daf3e8c6341fe19b Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 18:33:48 +0100
Subject: [PATCH 29/71] feat: Add HUD text for shovel mode

---
 src/features/hud/components.rs |  1 +
 src/features/hud/mod.rs        | 85 +++++++++++++++++++++++++++++++++-
 2 files changed, 84 insertions(+), 2 deletions(-)

diff --git a/src/features/hud/components.rs b/src/features/hud/components.rs
index 9de7636..be49eb9 100644
--- a/src/features/hud/components.rs
+++ b/src/features/hud/components.rs
@@ -4,6 +4,7 @@ use crate::{features::phase::components::TimerSettings, prelude::*};
 pub enum RootMarker {
     Status,
     Settings,
+    ShovelOverlay,
 }
 
 #[derive(Component)]
diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index c780242..41937d0 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -16,12 +16,18 @@ impl Plugin for HudPlugin {
         app.add_systems(OnExit(AppState::GameScreen), cleanup);
         app.add_systems(
             Update,
-            (update_status, buttons, update_timer_settings).run_if(in_state(AppState::GameScreen)),
+            (
+                update_status,
+                buttons,
+                update_timer_settings,
+                update_shovel_overlay_visibility,
+            )
+                .run_if(in_state(AppState::GameScreen)),
         );
     }
 }
 
-fn setup(mut commands: Commands) {
+fn setup(mut commands: Commands, game_config: Res<GameConfig>, asset_server: Res<AssetServer>) {
     commands.spawn((
         RootMarker::Status,
         Node {
@@ -61,6 +67,63 @@ fn setup(mut commands: Commands) {
             )
         ],
     ));
+
+    // Shovel Overlay
+    commands.spawn((
+        RootMarker::ShovelOverlay,
+        Node {
+            position_type: PositionType::Absolute,
+            top: px(20),
+            left: px(0),
+            right: px(0),
+            width: percent(100),
+            justify_content: JustifyContent::Center,
+            align_items: AlignItems::Center,
+            flex_direction: FlexDirection::Column,
+            row_gap: px(5),
+            ..default()
+        },
+        Visibility::Hidden,
+        children![(
+            Node {
+                flex_direction: FlexDirection::Column,
+                align_items: AlignItems::Center,
+                padding: UiRect::all(px(10)),
+                row_gap: px(5),
+                ..default()
+            },
+            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.7)),
+            BorderRadius::all(px(10)),
+            children![
+                (
+                    Node {
+                        flex_direction: FlexDirection::Row,
+                        align_items: AlignItems::Center,
+                        column_gap: px(10),
+                        ..default()
+                    },
+                    children![
+                        (
+                            Node {
+                                width: px(32),
+                                height: px(32),
+                                ..default()
+                            },
+                            inventory::components::ItemType::Shovel
+                                .get_sprite(&asset_server, &game_config),
+                            ImageNode::default()
+                        ),
+                        text("Schaufel-Modus", 20.0, Color::WHITE)
+                    ]
+                ),
+                text(
+                    "Klicke auf ein freies Feld, um es freizuschalten.",
+                    14.0,
+                    Color::WHITE
+                )
+            ]
+        )],
+    ));
 }
 
 fn update_status(phase_res: Res<CurrentPhase>, mut text_query: Query<(&mut Text, &TextType)>) {
@@ -151,3 +214,21 @@ fn update_timer_settings(
         }
     }
 }
+
+fn update_shovel_overlay_visibility(
+    inventory: Res<inventory::components::Inventory>,
+    item_stacks: Query<&inventory::components::ItemStack>,
+    mut overlay_query: Query<(&RootMarker, &mut Visibility)>,
+) {
+    let has_shovel = inventory.has_item_type(&item_stacks, inventory::components::ItemType::Shovel);
+
+    for (marker, mut vis) in overlay_query.iter_mut() {
+        if let RootMarker::ShovelOverlay = marker {
+            *vis = if has_shovel {
+                Visibility::Inherited
+            } else {
+                Visibility::Hidden
+            };
+        }
+    }
+}

From a7aa54c5706e59d53eb044ee4d0a6fc66afb9669 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Tue, 9 Dec 2025 19:29:14 +0100
Subject: [PATCH 30/71] feat: track total berries earned in session and
 savegames (#61)

---
 src/features/inventory/mod.rs       |  6 +++++-
 src/features/phase/components.rs    |  1 +
 src/features/pom/actions.rs         |  4 +++-
 src/features/pom/mod.rs             |  2 ++
 src/features/savegame/components.rs |  4 +++-
 tests/common/mod.rs                 |  3 +++
 tests/harvest.rs                    | 17 ++++++++++++++---
 tests/planting.rs                   |  9 +++++++--
 tests/session.rs                    |  3 +++
 tests/watering.rs                   |  5 ++++-
 10 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index 55c8811..821ad23 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -1,4 +1,5 @@
 use crate::{features::inventory::ui::open_inventory, prelude::*};
+use crate::features::phase::components::SessionTracker;
 use components::*;
 
 pub mod components;
@@ -42,11 +43,14 @@ fn debug_modify_berries(
     mut inventory: ResMut<Inventory>,
     mut items: Query<&mut ItemStack>,
     keys: Res<ButtonInput<KeyCode>>,
+    mut session_tracker: ResMut<SessionTracker>,
 ) {
     if keys.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]) {
         if keys.just_pressed(KeyCode::ArrowUp) {
             println!("Adding 1 berry using debug bind");
-            inventory.update_item_stack(&mut commands, &mut items, ItemType::Berry, 1);
+            if inventory.update_item_stack(&mut commands, &mut items, ItemType::Berry, 1) {
+                session_tracker.total_berries_earned += 1;
+            }
         } else if keys.just_pressed(KeyCode::ArrowDown) {
             println!("Removing 1 berry using debug bind");
             inventory.update_item_stack(&mut commands, &mut items, ItemType::Berry, -1);
diff --git a/src/features/phase/components.rs b/src/features/phase/components.rs
index 45d399e..be541f6 100644
--- a/src/features/phase/components.rs
+++ b/src/features/phase/components.rs
@@ -62,4 +62,5 @@ impl Default for TimerSettings {
 #[derive(Resource, Debug, Default, Serialize, Deserialize, Clone)]
 pub struct SessionTracker {
     pub completed_focus_phases: u32,
+    pub total_berries_earned: u32,
 }
diff --git a/src/features/pom/actions.rs b/src/features/pom/actions.rs
index de80406..3e22179 100644
--- a/src/features/pom/actions.rs
+++ b/src/features/pom/actions.rs
@@ -1,4 +1,4 @@
-use crate::prelude::*;
+use crate::{features::phase::components::SessionTracker, prelude::*};
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum InteractionAction {
@@ -88,6 +88,7 @@ impl InteractionAction {
         item_stack_query: &mut Query<&mut ItemStack>,
         commands: &mut Commands,
         game_config: &GameConfig,
+        session_tracker: &mut SessionTracker,
     ) {
         let Ok(tile_entity) = grid.get_tile(pos) else {
             println!("Error during interaction: Couldn't get tile_entity");
@@ -165,6 +166,7 @@ impl InteractionAction {
                                         ItemType::Berry,
                                         config.grants as i32,
                                     );
+                                    session_tracker.total_berries_earned += config.grants;
                                 }
                             }
                         }
diff --git a/src/features/pom/mod.rs b/src/features/pom/mod.rs
index 328df1d..c8dffb4 100644
--- a/src/features/pom/mod.rs
+++ b/src/features/pom/mod.rs
@@ -192,6 +192,7 @@ fn perform_interaction(
     mut item_stack_query: Query<&mut ItemStack>,
     mut commands: Commands,
     config: Res<GameConfig>,
+    mut session_tracker: ResMut<crate::features::phase::components::SessionTracker>,
 ) {
     for (pos, mut target_component, path_queue) in pom_query.iter_mut() {
         if let Some(target) = target_component.target {
@@ -215,6 +216,7 @@ fn perform_interaction(
                         &mut item_stack_query,
                         &mut commands,
                         &config,
+                        &mut session_tracker,
                     );
                 }
             }
diff --git a/src/features/savegame/components.rs b/src/features/savegame/components.rs
index 456bfff..5aa082e 100644
--- a/src/features/savegame/components.rs
+++ b/src/features/savegame/components.rs
@@ -21,6 +21,8 @@ struct PartialSaveData {
 #[derive(Deserialize)]
 struct PartialSessionTracker {
     completed_focus_phases: u32,
+    #[serde(default)]
+    total_berries_earned: u32,
 }
 
 impl SavegamePath {
@@ -77,7 +79,7 @@ impl SavegamePath {
             savegames.push(SavegameInfo {
                 path: SavegamePath(path),
                 index,
-                total_berries: 0, // TODO: add total_berries
+                total_berries: data.session_tracker.total_berries_earned,
                 completed_focus: data.session_tracker.completed_focus_phases,
             });
         }
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index 6e20f7e..da9319b 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -2,6 +2,7 @@ use bevy::prelude::*;
 use pomomon_garden::features::config::components::{BerrySeedConfig, GameConfig};
 use pomomon_garden::features::grid::components::{Grid, Tile, TileState};
 use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
+use pomomon_garden::features::phase::components::SessionTracker;
 
 pub fn setup_app(
     grid_width: u32,
@@ -64,6 +65,8 @@ pub fn setup_app(
         berry_seeds: seeds,
         ..Default::default()
     });
+    
+    app.init_resource::<SessionTracker>();
 
     app
 }
diff --git a/tests/harvest.rs b/tests/harvest.rs
index 7b8e68f..4e608ac 100644
--- a/tests/harvest.rs
+++ b/tests/harvest.rs
@@ -2,6 +2,7 @@ use bevy::ecs::system::RunSystemOnce;
 use pomomon_garden::features::config::components::{BerrySeedConfig, GameConfig};
 use pomomon_garden::features::grid::components::{Grid, TileState};
 use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
+use pomomon_garden::features::phase::components::SessionTracker;
 use pomomon_garden::features::pom::actions::InteractionAction;
 use pomomon_garden::prelude::*;
 
@@ -41,7 +42,8 @@ fn test_harvest_fully_grown() {
          mut tile_query: Query<&mut TileState>,
          mut inventory: ResMut<Inventory>,
          mut item_stack_query: Query<&mut ItemStack>,
-         config: Res<GameConfig>| {
+         config: Res<GameConfig>,
+         mut session_tracker: ResMut<SessionTracker>| {
             InteractionAction::Harvest.execute(
                 (0, 0),
                 &grid,
@@ -50,6 +52,7 @@ fn test_harvest_fully_grown() {
                 &mut item_stack_query,
                 &mut commands,
                 &config,
+                &mut session_tracker,
             );
         },
     );
@@ -70,6 +73,10 @@ fn test_harvest_fully_grown() {
     let stack = app.world().entity(stack_entity).get::<ItemStack>().unwrap();
     assert_eq!(stack.item_type, ItemType::Berry);
     assert_eq!(stack.amount, 5);
+    
+    // Check Session Tracker
+    let tracker = app.world().resource::<SessionTracker>();
+    assert_eq!(tracker.total_berries_earned, 5);
 }
 
 #[test]
@@ -105,7 +112,8 @@ fn test_harvest_withered() {
          mut tile_query: Query<&mut TileState>,
          mut inventory: ResMut<Inventory>,
          mut item_stack_query: Query<&mut ItemStack>,
-         config: Res<GameConfig>| {
+         config: Res<GameConfig>,
+         mut session_tracker: ResMut<SessionTracker>| {
             InteractionAction::Harvest.execute(
                 (0, 0),
                 &grid,
@@ -114,6 +122,7 @@ fn test_harvest_withered() {
                 &mut item_stack_query,
                 &mut commands,
                 &config,
+                &mut session_tracker,
             );
         },
     );
@@ -164,7 +173,8 @@ fn test_cannot_harvest_growing() {
          mut tile_query: Query<&mut TileState>,
          mut inventory: ResMut<Inventory>,
          mut item_stack_query: Query<&mut ItemStack>,
-         config: Res<GameConfig>| {
+         config: Res<GameConfig>,
+         mut session_tracker: ResMut<SessionTracker>| {
             InteractionAction::Harvest.execute(
                 (0, 0),
                 &grid,
@@ -173,6 +183,7 @@ fn test_cannot_harvest_growing() {
                 &mut item_stack_query,
                 &mut commands,
                 &config,
+                &mut session_tracker,
             );
         },
     );
diff --git a/tests/planting.rs b/tests/planting.rs
index 1c2a0b3..d64b1c0 100644
--- a/tests/planting.rs
+++ b/tests/planting.rs
@@ -2,6 +2,7 @@ use bevy::ecs::system::RunSystemOnce;
 use pomomon_garden::features::config::components::GameConfig;
 use pomomon_garden::features::grid::components::{Grid, TileState};
 use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
+use pomomon_garden::features::phase::components::SessionTracker;
 use pomomon_garden::features::pom::actions::InteractionAction;
 use pomomon_garden::prelude::*;
 
@@ -27,7 +28,8 @@ fn test_plant_seed_interaction() {
               mut inventory: ResMut<Inventory>,
               mut item_stack_query: Query<&mut ItemStack>,
               mut commands: Commands,
-              game_config: Res<GameConfig>| {
+              game_config: Res<GameConfig>,
+              mut session_tracker: ResMut<SessionTracker>| {
             let action = InteractionAction::Plant(seed_type.clone());
             action.execute(
                 (1, 1),
@@ -37,6 +39,7 @@ fn test_plant_seed_interaction() {
                 &mut item_stack_query,
                 &mut commands,
                 &game_config,
+                &mut session_tracker,
             );
         },
     );
@@ -98,7 +101,8 @@ fn test_plant_seed_no_inventory() {
               mut inventory: ResMut<Inventory>,
               mut item_stack_query: Query<&mut ItemStack>,
               mut commands: Commands,
-              game_config: Res<GameConfig>| {
+              game_config: Res<GameConfig>,
+              mut session_tracker: ResMut<SessionTracker>| {
             let action = InteractionAction::Plant(seed_type.clone());
             action.execute(
                 (1, 1),
@@ -108,6 +112,7 @@ fn test_plant_seed_no_inventory() {
                 &mut item_stack_query,
                 &mut commands,
                 &game_config,
+                &mut session_tracker,
             );
         },
     );
diff --git a/tests/session.rs b/tests/session.rs
index 8007a69..ce8c486 100644
--- a/tests/session.rs
+++ b/tests/session.rs
@@ -39,6 +39,7 @@ fn test_session_tracker_focus_to_long_break() {
     let timer_settings = TimerSettings::default();
     let mut session_tracker = SessionTracker {
         completed_focus_phases: timer_settings.long_break_interval - 1,
+        total_berries_earned: 0,
     }; // To trigger long break on next phase
 
     next_phase(&mut current_phase, &mut session_tracker, &timer_settings);
@@ -66,6 +67,7 @@ fn test_session_tracker_break_to_focus() {
     });
     let mut session_tracker = SessionTracker {
         completed_focus_phases: 1,
+        total_berries_earned: 0,
     }; // Arbitrary value, should not change
     let timer_settings = TimerSettings::default();
 
@@ -91,6 +93,7 @@ fn test_session_tracker_not_finished_phase_no_change() {
     let mut current_phase = CurrentPhase(Phase::Focus { duration: 100.0 });
     let mut session_tracker = SessionTracker {
         completed_focus_phases: 0,
+        total_berries_earned: 0,
     };
     let timer_settings = TimerSettings::default();
 
diff --git a/tests/watering.rs b/tests/watering.rs
index 9729cda..b83fcbf 100644
--- a/tests/watering.rs
+++ b/tests/watering.rs
@@ -2,6 +2,7 @@ use bevy::ecs::system::RunSystemOnce;
 use pomomon_garden::features::config::components::GameConfig;
 use pomomon_garden::features::grid::components::{Grid, TileState};
 use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
+use pomomon_garden::features::phase::components::SessionTracker;
 use pomomon_garden::features::pom::actions::InteractionAction;
 use pomomon_garden::prelude::*;
 
@@ -57,7 +58,8 @@ fn test_water_crop() {
               mut inventory: ResMut<Inventory>,
               mut item_stack_query: Query<&mut ItemStack>,
               mut commands: Commands,
-              game_config: Res<GameConfig>| {
+              game_config: Res<GameConfig>,
+              mut session_tracker: ResMut<SessionTracker>| {
             let action = InteractionAction::Water;
             action.execute(
                 (1, 1),
@@ -67,6 +69,7 @@ fn test_water_crop() {
                 &mut item_stack_query,
                 &mut commands,
                 &game_config,
+                &mut session_tracker,
             );
         },
     );

From ceeeca7b5b2fec3b07c6e72b55252ae60186851f Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 13:36:07 +0100
Subject: [PATCH 31/71] refactor: Format code

---
 src/features/inventory/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index 821ad23..49df63b 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -1,5 +1,5 @@
-use crate::{features::inventory::ui::open_inventory, prelude::*};
 use crate::features::phase::components::SessionTracker;
+use crate::{features::inventory::ui::open_inventory, prelude::*};
 use components::*;
 
 pub mod components;

From 2e429605f3c1ea046df1acee550740de093728f1 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 13:47:51 +0100
Subject: [PATCH 32/71] fix: Fix new game reset bug (#60)

---
 src/features/pom/components.rs |  2 +-
 src/features/savegame/mod.rs   | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/src/features/pom/components.rs b/src/features/pom/components.rs
index 43dfa25..5e9866a 100644
--- a/src/features/pom/components.rs
+++ b/src/features/pom/components.rs
@@ -5,7 +5,7 @@ use std::collections::VecDeque;
 #[derive(Component)]
 pub struct Pom;
 
-#[derive(Component, Serialize, Deserialize, Clone, Copy)]
+#[derive(Component, Serialize, Deserialize, Clone, Copy, Default)]
 pub struct GridPosition {
     pub x: u32,
     pub y: u32,
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index 61b97e4..347cf06 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -19,6 +19,7 @@ impl Plugin for SavegamePlugin {
 
         app.add_systems(Update, dump_savegame.run_if(in_state(AppState::GameScreen)));
         app.add_systems(Update, load_savegame.run_if(in_state(AppState::GameScreen)));
+        app.add_systems(OnExit(AppState::GameScreen), reset_savegame);
 
         app.add_systems(Update, load_popup_handler);
     }
@@ -172,3 +173,36 @@ fn load_savegame(
         }
     }
 }
+
+// Resets all components/resources loaded by `load_savegame`
+fn reset_savegame(
+    mut commands: Commands,
+    grid: Res<Grid>,
+    mut tile_query: Query<&mut TileState>,
+    mut phase: ResMut<CurrentPhase>,
+    mut tracker: ResMut<SessionTracker>,
+    mut settings: ResMut<TimerSettings>,
+    mut pom_query: Query<(&mut GridPosition, &mut Transform), With<Pom>>,
+    mut inventory: ResMut<Inventory>,
+) {
+    *tracker = SessionTracker::default();
+    *settings = TimerSettings::default();
+    *phase = CurrentPhase(Phase::Focus {
+        duration: settings.focus_duration as f32,
+    });
+
+    inventory
+        .items
+        .iter()
+        .for_each(|entity| commands.entity(*entity).despawn());
+    inventory.items.clear();
+
+    if let Ok((mut pom_pos, mut pom_transform)) = pom_query.single_mut() {
+        *pom_pos = GridPosition::default();
+        pom_transform.translation = grid_to_world_coords(0, 0, Some(1.0), grid.width, grid.height);
+    }
+
+    tile_query
+        .iter_mut()
+        .for_each(|mut state| *state = TileState::default());
+}

From 036262043347ede8a6e752265b49d2f7d44d1cd2 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 14:00:47 +0100
Subject: [PATCH 33/71] feat: Add `berries_per_focus_minute` option in
 `GameConfig` (#63)

---
 assets/config.json                | 3 ++-
 src/features/config/components.rs | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/assets/config.json b/assets/config.json
index 4798184..0e6ba58 100644
--- a/assets/config.json
+++ b/assets/config.json
@@ -27,5 +27,6 @@
       "growth_stages": 6
     }
   ],
-  "wonder_event_url": "wss://pomomon.farm/ws"
+  "wonder_event_url": "wss://pomomon.farm/ws",
+  "berries_per_focus_minute": 1
 }
diff --git a/src/features/config/components.rs b/src/features/config/components.rs
index d9b3b14..1f3ccb8 100644
--- a/src/features/config/components.rs
+++ b/src/features/config/components.rs
@@ -11,6 +11,7 @@ pub struct GameConfig {
     pub shovel_rate: f32,
     pub berry_seeds: Vec<BerrySeedConfig>,
     pub wonder_event_url: String,
+    pub berries_per_focus_minute: u32,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -54,6 +55,7 @@ impl Default for GameConfig {
                 },
             ],
             wonder_event_url: "wss://pomomon.farm/ws".into(),
+            berries_per_focus_minute: 1,
         }
     }
 }

From a20807ce09e2aee63930c217af576402cd545c5f Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 14:11:02 +0100
Subject: [PATCH 34/71] feat: Add focus minute berry reward (#63)

---
 src/features/phase/mod.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 77cbf6d..31b067a 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -70,13 +70,35 @@ fn tick_timer(
     mut phase_res: ResMut<CurrentPhase>,
     mut finish_writer: MessageWriter<PhaseTimerFinishedMessage>,
     mut savegame_messages: MessageWriter<SavegameDumpMessage>,
+    config: Res<GameConfig>,
+    mut inventory: ResMut<Inventory>,
+    mut commands: Commands,
+    mut items_query: Query<&mut ItemStack>,
+    mut session_tracker: ResMut<SessionTracker>,
 ) {
     let delta = time.delta_secs();
     let phase = &mut phase_res.0;
 
     match phase {
         Phase::Focus { duration } | Phase::Break { duration } => {
+            let old_minutes = (*duration / 60.0).floor() as i32;
             *duration -= delta;
+            let new_minutes = (*duration / 60.0).floor() as i32;
+
+            if new_minutes < old_minutes {
+                println!(
+                    "A minute of focus has been completed. Granting {} berries as a reward.",
+                    config.berries_per_focus_minute
+                );
+
+                inventory.update_item_stack(
+                    &mut commands,
+                    &mut items_query,
+                    ItemType::Berry,
+                    config.berries_per_focus_minute as i32,
+                );
+                session_tracker.total_berries_earned += config.berries_per_focus_minute;
+            }
 
             if *duration <= 0.0 {
                 finish_writer.write(PhaseTimerFinishedMessage {

From 3a8e16d0855fec09e4e5c94ae0a4cc2aa3079803 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:01:29 +0100
Subject: [PATCH 35/71] feat: Add notification feature and display notification
 for berry reward (#63)

---
 src/features/mod.rs                     |  2 +
 src/features/notification/components.rs | 74 +++++++++++++++++++++++++
 src/features/notification/mod.rs        | 58 +++++++++++++++++++
 src/features/notification/ui.rs         | 60 ++++++++++++++++++++
 src/features/phase/mod.rs               | 14 +++++
 src/main.rs                             |  1 +
 src/prelude.rs                          |  1 +
 7 files changed, 210 insertions(+)
 create mode 100644 src/features/notification/components.rs
 create mode 100644 src/features/notification/mod.rs
 create mode 100644 src/features/notification/ui.rs

diff --git a/src/features/mod.rs b/src/features/mod.rs
index 609a10c..6b6c2b8 100644
--- a/src/features/mod.rs
+++ b/src/features/mod.rs
@@ -5,6 +5,7 @@ pub mod grid;
 pub mod hud;
 pub mod input;
 pub mod inventory;
+pub mod notification;
 pub mod phase;
 pub mod pom;
 pub mod savegame;
@@ -19,6 +20,7 @@ pub use grid::GridPlugin;
 pub use hud::HudPlugin;
 pub use input::InputPlugin;
 pub use inventory::InventoryPlugin;
+pub use notification::NotificationPlugin;
 pub use phase::PhasePlugin;
 pub use pom::PomPlugin;
 pub use savegame::SavegamePlugin;
diff --git a/src/features/notification/components.rs b/src/features/notification/components.rs
new file mode 100644
index 0000000..3f1f2b0
--- /dev/null
+++ b/src/features/notification/components.rs
@@ -0,0 +1,74 @@
+use crate::prelude::*;
+
+#[derive(Resource)]
+pub struct Notifications {
+    items: Vec<(Notification, NotificationLevel)>,
+}
+
+impl Default for Notifications {
+    fn default() -> Self {
+        Self { items: Vec::new() }
+    }
+}
+
+impl Notifications {
+    fn new(
+        &mut self,
+        level: NotificationLevel,
+        title: Option<impl Into<String>>,
+        message: impl Into<String>,
+    ) {
+        self.items.push((
+            Notification {
+                title: title.map(|s| s.into()),
+                message: message.into(),
+            },
+            level,
+        ));
+    }
+
+    pub fn drain(&mut self) -> std::vec::Drain<'_, (Notification, NotificationLevel)> {
+        self.items.drain(..)
+    }
+
+    pub fn info(&mut self, title: Option<impl Into<String>>, message: impl Into<String>) {
+        self.new(NotificationLevel::Info, title, message);
+    }
+
+    pub fn warn(&mut self, title: Option<impl Into<String>>, message: impl Into<String>) {
+        self.new(NotificationLevel::Warning, title, message);
+    }
+
+    pub fn error(&mut self, title: Option<impl Into<String>>, message: impl Into<String>) {
+        self.new(NotificationLevel::Error, title, message);
+    }
+}
+
+#[derive(Component)]
+pub struct NotificationContainer;
+
+#[derive(Component)]
+pub struct NotificationLifetime(pub Timer);
+
+#[derive(Component)]
+pub struct Notification {
+    pub title: Option<String>,
+    pub message: String,
+}
+
+#[derive(Component)]
+pub enum NotificationLevel {
+    Info,
+    Warning,
+    Error,
+}
+
+impl NotificationLevel {
+    pub fn bg_color(&self) -> Color {
+        match self {
+            NotificationLevel::Info => Color::srgba(0.0, 0.0, 0.0, 0.7),
+            NotificationLevel::Warning => Color::srgba(1.0, 1.0, 0.0, 0.7),
+            NotificationLevel::Error => Color::srgba(1.0, 0.0, 0.0, 0.7),
+        }
+    }
+}
diff --git a/src/features/notification/mod.rs b/src/features/notification/mod.rs
new file mode 100644
index 0000000..a639706
--- /dev/null
+++ b/src/features/notification/mod.rs
@@ -0,0 +1,58 @@
+use crate::{
+    features::notification::ui::{notification_container, spawn_notification},
+    prelude::*,
+};
+use components::{NotificationContainer, NotificationLifetime, Notifications};
+
+pub mod components;
+pub mod ui;
+
+pub struct NotificationPlugin;
+
+impl Plugin for NotificationPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<Notifications>()
+            .add_systems(Startup, setup)
+            .add_systems(Update, handle_notification);
+    }
+}
+
+// Spawns the notification container up
+fn setup(mut commands: Commands) {
+    commands.spawn(notification_container());
+}
+
+// Spawns/Despawns UI elements for each item in the `Notifications` Resource
+fn handle_notification(
+    mut commands: Commands,
+    mut notifications: ResMut<Notifications>,
+    container_q: Query<Entity, With<NotificationContainer>>,
+    mut notification_entities: Query<(Entity, &mut NotificationLifetime)>,
+    time: Res<Time>,
+) {
+    if let Some(container) = container_q.iter().next() {
+        let mut spawned_entities = Vec::new();
+
+        for (content, level) in notifications.drain() {
+            let entity = spawn_notification(&mut commands, content, level);
+            commands.entity(container).add_child(entity);
+            spawned_entities.push(entity);
+        }
+
+        for entity in spawned_entities {
+            commands
+                .entity(entity)
+                .insert(NotificationLifetime(Timer::from_seconds(
+                    5.0,
+                    TimerMode::Once,
+                )));
+        }
+    }
+
+    for (entity, mut timer) in notification_entities.iter_mut() {
+        timer.0.tick(time.delta());
+        if timer.0.is_finished() {
+            commands.entity(entity).despawn();
+        }
+    }
+}
diff --git a/src/features/notification/ui.rs b/src/features/notification/ui.rs
new file mode 100644
index 0000000..231bb2e
--- /dev/null
+++ b/src/features/notification/ui.rs
@@ -0,0 +1,60 @@
+use super::components::*;
+use crate::prelude::*;
+
+pub fn notification_container() -> impl Bundle {
+    (
+        NotificationContainer,
+        Node {
+            position_type: PositionType::Absolute,
+            top: px(0),
+            left: px(0),
+            padding: UiRect::all(px(5)),
+            flex_direction: FlexDirection::Column,
+            row_gap: px(5),
+            ..default()
+        },
+    )
+}
+
+pub fn spawn_notification(
+    commands: &mut Commands,
+    content: Notification,
+    level: NotificationLevel,
+) -> Entity {
+    let entity = commands
+        .spawn((
+            Node {
+                flex_direction: FlexDirection::Column,
+                row_gap: px(5),
+                padding: UiRect::all(px(10)),
+                margin: UiRect::all(px(2)),
+                width: px(400),
+                ..default()
+            },
+            BackgroundColor(level.bg_color()),
+            BorderRadius::all(px(4)),
+        ))
+        .with_children(|p| {
+            if let Some(title) = content.title {
+                p.spawn((
+                    Text::new(format!("{}\n", title)),
+                    TextFont {
+                        font_size: 20.0,
+                        ..default()
+                    },
+                    TextColor(Color::WHITE),
+                ));
+            }
+            p.spawn((
+                Text::new(content.message),
+                TextFont {
+                    font_size: 16.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE),
+            ));
+        })
+        .id();
+
+    entity
+}
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 31b067a..eb62f0c 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -75,6 +75,8 @@ fn tick_timer(
     mut commands: Commands,
     mut items_query: Query<&mut ItemStack>,
     mut session_tracker: ResMut<SessionTracker>,
+    game_config: Res<GameConfig>,
+    mut notifications: ResMut<Notifications>,
 ) {
     let delta = time.delta_secs();
     let phase = &mut phase_res.0;
@@ -98,6 +100,18 @@ fn tick_timer(
                     config.berries_per_focus_minute as i32,
                 );
                 session_tracker.total_berries_earned += config.berries_per_focus_minute;
+
+                let berries_name = match config.berries_per_focus_minute {
+                    1 => ItemType::Berry.singular(&game_config),
+                    _ => ItemType::Berry.plural(&game_config),
+                };
+                notifications.info(
+                    Some("Fokus Belohnung"),
+                    format!(
+                        "Du hast {} {} als Belohnung für das Abschließen einer Minute der Fokus-Phase erhalten!",
+                        config.berries_per_focus_minute, berries_name
+                    ),
+                );
             }
 
             if *duration <= 0.0 {
diff --git a/src/main.rs b/src/main.rs
index 0d615bb..01c3643 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -35,6 +35,7 @@ fn main() {
             features::InventoryPlugin,
             features::ShopPlugin,
             features::WonderEventPlugin,
+            features::NotificationPlugin,
         ))
         .insert_resource(config)
         .add_systems(Startup, overwrite_default_font)
diff --git a/src/prelude.rs b/src/prelude.rs
index 1a2481c..1799214 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -8,6 +8,7 @@ pub use crate::features::{
         utils::{grid_to_world_coords, world_to_grid_coords},
     },
     inventory::components::{Inventory, ItemStack, ItemType},
+    notification::components::Notifications,
     phase::components::{CurrentPhase, Phase},
     pom::{
         components::{GridPosition, MovingState, Pom},

From 3b310ea1987338177cf0065fd4aca71ac6f34c87 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:26:11 +0100
Subject: [PATCH 36/71] fix: Stop granting berries for minutes passed in pause
 phase

---
 src/features/phase/messages.rs |  3 ++
 src/features/phase/mod.rs      | 83 +++++++++++++++++++++-------------
 2 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/src/features/phase/messages.rs b/src/features/phase/messages.rs
index 620aad1..d4311b7 100644
--- a/src/features/phase/messages.rs
+++ b/src/features/phase/messages.rs
@@ -10,3 +10,6 @@ pub struct PhaseTimerPauseMessage;
 
 #[derive(Message)]
 pub struct NextPhaseMessage;
+
+#[derive(Message)]
+pub struct PhaseMinutePassedMessage;
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index eb62f0c..8851cfc 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -18,11 +18,18 @@ impl Plugin for PhasePlugin {
         }));
 
         app.add_message::<PhaseTimerFinishedMessage>();
+        app.add_message::<PhaseMinutePassedMessage>();
 
         app.add_systems(OnEnter(AppState::GameScreen), load_rules);
         app.add_systems(
             Update,
-            (tick_timer, handle_pause, handle_continue).run_if(in_state(AppState::GameScreen)),
+            (
+                tick_timer,
+                handle_pause,
+                handle_continue,
+                grant_focus_rewards,
+            )
+                .run_if(in_state(AppState::GameScreen)),
         );
 
         #[cfg(debug_assertions)]
@@ -69,14 +76,8 @@ fn tick_timer(
     time: Res<Time>,
     mut phase_res: ResMut<CurrentPhase>,
     mut finish_writer: MessageWriter<PhaseTimerFinishedMessage>,
+    mut minute_writer: MessageWriter<PhaseMinutePassedMessage>,
     mut savegame_messages: MessageWriter<SavegameDumpMessage>,
-    config: Res<GameConfig>,
-    mut inventory: ResMut<Inventory>,
-    mut commands: Commands,
-    mut items_query: Query<&mut ItemStack>,
-    mut session_tracker: ResMut<SessionTracker>,
-    game_config: Res<GameConfig>,
-    mut notifications: ResMut<Notifications>,
 ) {
     let delta = time.delta_secs();
     let phase = &mut phase_res.0;
@@ -88,30 +89,7 @@ fn tick_timer(
             let new_minutes = (*duration / 60.0).floor() as i32;
 
             if new_minutes < old_minutes {
-                println!(
-                    "A minute of focus has been completed. Granting {} berries as a reward.",
-                    config.berries_per_focus_minute
-                );
-
-                inventory.update_item_stack(
-                    &mut commands,
-                    &mut items_query,
-                    ItemType::Berry,
-                    config.berries_per_focus_minute as i32,
-                );
-                session_tracker.total_berries_earned += config.berries_per_focus_minute;
-
-                let berries_name = match config.berries_per_focus_minute {
-                    1 => ItemType::Berry.singular(&game_config),
-                    _ => ItemType::Berry.plural(&game_config),
-                };
-                notifications.info(
-                    Some("Fokus Belohnung"),
-                    format!(
-                        "Du hast {} {} als Belohnung für das Abschließen einer Minute der Fokus-Phase erhalten!",
-                        config.berries_per_focus_minute, berries_name
-                    ),
-                );
+                minute_writer.write(PhaseMinutePassedMessage);
             }
 
             if *duration <= 0.0 {
@@ -131,6 +109,47 @@ fn tick_timer(
     }
 }
 
+fn grant_focus_rewards(
+    mut messages: MessageReader<PhaseMinutePassedMessage>,
+    phase_res: Res<CurrentPhase>,
+    config: Res<GameConfig>,
+    mut inventory: ResMut<Inventory>,
+    mut commands: Commands,
+    mut items_query: Query<&mut ItemStack>,
+    mut session_tracker: ResMut<SessionTracker>,
+    game_config: Res<GameConfig>,
+    mut notifications: ResMut<Notifications>,
+) {
+    for _ in messages.read() {
+        if let Phase::Focus { .. } = &phase_res.0 {
+            println!(
+                "A minute of focus has been completed. Granting {} berries as a reward.",
+                config.berries_per_focus_minute
+            );
+
+            inventory.update_item_stack(
+                &mut commands,
+                &mut items_query,
+                ItemType::Berry,
+                config.berries_per_focus_minute as i32,
+            );
+            session_tracker.total_berries_earned += config.berries_per_focus_minute;
+
+            let berries_name = match config.berries_per_focus_minute {
+                1 => ItemType::Berry.singular(&game_config),
+                _ => ItemType::Berry.plural(&game_config),
+            };
+            notifications.info(
+                Some("Fokus Belohnung"),
+                format!(
+                    "Du hast {} {} als Belohnung für das Abschließen einer Minute der Fokus-Phase erhalten!",
+                    config.berries_per_focus_minute, berries_name
+                ),
+            );
+        }
+    }
+}
+
 fn handle_pause(
     mut messages: MessageReader<PhaseTimerPauseMessage>,
     mut phase_res: ResMut<CurrentPhase>,

From 0b9cae2dfa19615b60bd60ed2408f7e9d1f436a4 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:45:38 +0100
Subject: [PATCH 37/71] fix: Grant focus reward berries at the end of the focus
 phase

---
 src/features/phase/messages.rs |  3 ---
 src/features/phase/mod.rs      | 32 +++++++++++---------------------
 2 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/src/features/phase/messages.rs b/src/features/phase/messages.rs
index d4311b7..620aad1 100644
--- a/src/features/phase/messages.rs
+++ b/src/features/phase/messages.rs
@@ -10,6 +10,3 @@ pub struct PhaseTimerPauseMessage;
 
 #[derive(Message)]
 pub struct NextPhaseMessage;
-
-#[derive(Message)]
-pub struct PhaseMinutePassedMessage;
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 8851cfc..e5756a6 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -18,7 +18,6 @@ impl Plugin for PhasePlugin {
         }));
 
         app.add_message::<PhaseTimerFinishedMessage>();
-        app.add_message::<PhaseMinutePassedMessage>();
 
         app.add_systems(OnEnter(AppState::GameScreen), load_rules);
         app.add_systems(
@@ -76,7 +75,6 @@ fn tick_timer(
     time: Res<Time>,
     mut phase_res: ResMut<CurrentPhase>,
     mut finish_writer: MessageWriter<PhaseTimerFinishedMessage>,
-    mut minute_writer: MessageWriter<PhaseMinutePassedMessage>,
     mut savegame_messages: MessageWriter<SavegameDumpMessage>,
 ) {
     let delta = time.delta_secs();
@@ -84,13 +82,7 @@ fn tick_timer(
 
     match phase {
         Phase::Focus { duration } | Phase::Break { duration } => {
-            let old_minutes = (*duration / 60.0).floor() as i32;
             *duration -= delta;
-            let new_minutes = (*duration / 60.0).floor() as i32;
-
-            if new_minutes < old_minutes {
-                minute_writer.write(PhaseMinutePassedMessage);
-            }
 
             if *duration <= 0.0 {
                 finish_writer.write(PhaseTimerFinishedMessage {
@@ -110,8 +102,7 @@ fn tick_timer(
 }
 
 fn grant_focus_rewards(
-    mut messages: MessageReader<PhaseMinutePassedMessage>,
-    phase_res: Res<CurrentPhase>,
+    mut messages: MessageReader<PhaseTimerFinishedMessage>,
     config: Res<GameConfig>,
     mut inventory: ResMut<Inventory>,
     mut commands: Commands,
@@ -119,31 +110,30 @@ fn grant_focus_rewards(
     mut session_tracker: ResMut<SessionTracker>,
     game_config: Res<GameConfig>,
     mut notifications: ResMut<Notifications>,
+    timer_settings: Res<TimerSettings>,
 ) {
-    for _ in messages.read() {
-        if let Phase::Focus { .. } = &phase_res.0 {
-            println!(
-                "A minute of focus has been completed. Granting {} berries as a reward.",
-                config.berries_per_focus_minute
-            );
+    for message in messages.read() {
+        if matches!(message.phase, Phase::Focus { .. }) {
+            let berries = config.berries_per_focus_minute
+                * (timer_settings.focus_duration as f32 / 60.0).floor() as u32;
 
             inventory.update_item_stack(
                 &mut commands,
                 &mut items_query,
                 ItemType::Berry,
-                config.berries_per_focus_minute as i32,
+                berries as i32,
             );
-            session_tracker.total_berries_earned += config.berries_per_focus_minute;
+            session_tracker.total_berries_earned += berries;
 
-            let berries_name = match config.berries_per_focus_minute {
+            let berries_name = match berries {
                 1 => ItemType::Berry.singular(&game_config),
                 _ => ItemType::Berry.plural(&game_config),
             };
             notifications.info(
                 Some("Fokus Belohnung"),
                 format!(
-                    "Du hast {} {} als Belohnung für das Abschließen einer Minute der Fokus-Phase erhalten!",
-                    config.berries_per_focus_minute, berries_name
+                    "Du hast {} {} als Belohnung für das Abschließen einer Fokus-Phase erhalten!",
+                    berries, berries_name
                 ),
             );
         }

From 53b10d6c0b8e68fad329f829f9044f69d3bb1dd1 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:46:03 +0100
Subject: [PATCH 38/71] chore: Capitalize debug print

---
 src/features/phase/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index e5756a6..2eb0efa 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -93,7 +93,7 @@ fn tick_timer(
                     completed_phase: Box::new(completed),
                 };
 
-                println!("phase ended");
+                println!("Phase ended");
                 savegame_messages.write(SavegameDumpMessage);
             }
         }

From 110b306194155a9b75bb34c585eec0ebeb645ce3 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:48:02 +0100
Subject: [PATCH 39/71] docs: Add system description comment for berry reward
 system

---
 src/features/phase/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 2eb0efa..ba6c001 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -101,6 +101,7 @@ fn tick_timer(
     }
 }
 
+// Rewards the player at the end of a focus phase with `berries_per_focus_minute` * `focus_duration`
 fn grant_focus_rewards(
     mut messages: MessageReader<PhaseTimerFinishedMessage>,
     config: Res<GameConfig>,

From a4f5771d57dd8b7be35e24be23f3805057dd54b3 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 15:50:51 +0100
Subject: [PATCH 40/71] feat: Add notification for wonder event (#41)

---
 src/features/wonderevent/mod.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/features/wonderevent/mod.rs b/src/features/wonderevent/mod.rs
index 949e1d1..164eabe 100644
--- a/src/features/wonderevent/mod.rs
+++ b/src/features/wonderevent/mod.rs
@@ -165,6 +165,7 @@ fn handle_wonder_event_response(
     mut tile_query: Query<&mut TileState>,
     game_config: Res<GameConfig>,
     mut commands: Commands,
+    mut notifications: ResMut<Notifications>,
 ) {
     if let Ok(rx) = receiver.0.try_lock() {
         while let Ok(msg) = rx.try_recv() {
@@ -191,6 +192,7 @@ fn handle_wonder_event_response(
                                         new_stage += 1;
                                     }
                                 }
+                                notifications.info(Some("Wunder Ereignis"), "Es ist ein Wunder passiert! Eine deiner Pflanzen ist auf magischer Weise gewachsen.");
 
                                 TileState::Occupied {
                                     seed: seed.clone(),

From 5376a38288a2def670b5e2e9ca7b57ae2c0c9a4f Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 16:17:41 +0100
Subject: [PATCH 41/71] feat: Add phase end sound effect (#64)

---
 Cargo.lock                |  59 ++++++++++++++++++++++++++++++++++++++
 Cargo.toml                |   2 +-
 assets/sounds/beep.mp3    | Bin 0 -> 27360 bytes
 src/features/phase/mod.rs |   6 ++++
 4 files changed, 66 insertions(+), 1 deletion(-)
 create mode 100644 assets/sounds/beep.mp3

diff --git a/Cargo.lock b/Cargo.lock
index 043f79f..0ac9b38 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2235,6 +2235,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -4192,6 +4201,7 @@ checksum = "e7ceb6607dd738c99bc8cb28eff249b7cd5c8ec88b9db96c0608c1480d140fb1"
 dependencies = [
  "cpal",
  "lewton",
+ "symphonia",
 ]
 
 [[package]]
@@ -4588,6 +4598,55 @@ dependencies = [
  "zeno",
 ]
 
+[[package]]
+name = "symphonia"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039"
+dependencies = [
+ "lazy_static",
+ "symphonia-bundle-mp3",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af"
+dependencies = [
+ "arrayvec",
+ "bitflags 1.3.2",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.106"
diff --git a/Cargo.toml b/Cargo.toml
index d19f9fa..bdee263 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ codegen-units = 1
 lto = "thin"
 
 [dependencies]
-bevy = "0.17.2"
+bevy = { version = "0.17.2", features = ["mp3"] }
 bevy_aseprite_ultra = "0.7.0"
 bevy_dev_tools = "0.17.2"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/assets/sounds/beep.mp3 b/assets/sounds/beep.mp3
new file mode 100644
index 0000000000000000000000000000000000000000..0d1f2556583596c5c581ecff6813ef117c1a9815
GIT binary patch
literal 27360
zcmaI7cT^M08~?wl1PG8&6KV)WN`%l6Q33)2QWY^E%7!K=Doq9DN)n0zf^-asN)tg*
zL-7iVlF*wJ!K-*xda+z-7EmO=@cEweJ>S26yK`n|W+&&cymp?M=RMB~)@FkNwZmH4
zko(KPjgN0Z7?lHvIW(@T8)8s&du3Xcyg?|u%>gO7H$*eguFF0<VlZ_$B2a%vIQ47?
z@+|V4*$MevF!RbW&V|7)v0srNvF*iO=}N%<`2h2x#^=FxHL1LaFkb1w?-lBFy4bKN
zg5z&ai*(tIi`Yxc_IqGRJFnt>Y5xxl=&6H~?46dJ(|@cGiz!U{tn$0`Jigt((7*k=
zPO4hpj?+d84zd<fZ}SgmkGK0@*kRB$vGG^WyH@X#hf25dP5y2*{Hi>0(sAy`?^<&E
z^8D|+`GpqF&I1Cm14@-#c7oJ^wE!>?h{W0qZMLsj!`9W>ZA{i7lWKgNWg;5ON!$n6
zY*N;~aw{v@2Mqdke2>bcG$v~jX5M_UKlq3Ee)=6AElCVvv{B9wqL{nIZ(&?pcBNJV
zOhxSg;@s-5%Z;Nk(1hoUg#L31FGfq5C=0<STe0hIrlWTbO1KRhUK{=Rgx$W`QcCcg
zrC{Om8~YOlQk!aj@=ETM%*g><6zU~yxT%!FQXa%Nz{r-dJm3*2dUUwgE-ChDTUiYL
zOcy=$syF0Xc{I{#e<aRR0W>>GZ)3?wP|$AK1hS^cz6zLFTP0c_0g~I$6h4lKe48U!
zo3*E^>fW=f9Hauzy|v2{i>sla1cV?4?^sq^K1b(KFfb(D9>T!juuy;iOQHZIM)XzR
zwqAJynG**}KQMx)5|Q-3QkTJ*x#^C{$9X9;=CrrFS=IL)BkiI-99QXHyZzccMAt=G
zW4QT>=4BOo|7h`)_ST`qyxA!$hxAJCVp5(~l1alYLBK}j^MsY=weJ4T(UdukvY|kD
zT*Gb5c;^@yr;CukJJtfCu2na#9ecDI-0j(A-K))s&y+7PsQkT3BENs?v!?QZbV3J`
zAu$=WiV+v5yelnjwwr`W%L3V&EdYZ{js%d<Ni-BcnzG!f36v1aVkl&Ybau#8xQdA6
z+CICf3M^Bc<yolYV2jbrHFSsb_R&|!?gtzlUP3*!hw{@xj<-)9JysN9UD)5XL-tJ1
zwIiF(d0xzj^BvT3*K4Tlzg^gVBLn&QzTC}29^&nqMK?5#=wHLVXM4s3A2hbQcYjBo
z{(U*+3y%_RI@b^$A2GE~Xs$|FiJM9oTUk4(=qmFk;OO@!t-W@{0IT!I_QuUN#eVtN
z34;V8IO6nXdXu>D(u5Nq4Q`}^B)8m`a`ZY7F&Zp}6h7G|Scn8@CPp~F7<}m*6y8hU
z=4+{h5FrCg5rCDLG!^pU4ZzjHRY^07bB6I*QnpObL{1T_cii}vV560zQjk-RD|u0L
zRJYy+QZJzgO6X8SOzUFgT};bBJzq`+1Hta_M}gta4xxZo?D$S%gnUUOOP&!X>*ul4
zDxxsQJh9*XIuQUSk+n5%>+gJb{&ee=hR+G9yxl({H%uPCSWcJ_>0SE~Ik>0)r{TLS
zL6VJN3mt8<^!}H}9btNQ;iI7lq?Tie7?z|$WFQzUSro|S!EtcFmI~+mFP8_{wWt9U
zpT%SAuyy#XHa2P??P%>F$JcciET6~H8Q3L~J-``f_g=|v&lc9~^EXgev+^IX-&AL^
zSUrm`*z6vTu*9`bNDg&$j0g^4Y6KEV*dn}IK~5ox&0^IO+U#7~TnU6)0#}*_QKhNx
zr8~$_tRQ2~j)}vP^z%IdsRK{{)mu9DVf<R+gRX%so7^LRHWM`;ZWeni&8P>jUReFU
z=hLO1d;j~Le@(D8w?pvLZ}a=m(C=Tb@U}_&C7xT7|CMV3bvQ739m7c*r^29sB1j;f
z4hjJSid+O>N`N>5RGu;<4`TqGij*hkiJC~#yG=mka>p;Sl|&u{>?RBO2HR<>U(<tJ
z3QN>EsTYj?TKq*vR3o#o)z}GEA&Wgv?iMu}r|&X~am_QIjA1mI4F}PW>HC{B!K`%5
z#@cm}MnMfa3goCD1*CXB$H<B5-+7h2SlNbTI5+~*V!CoDayFC)=r~)n!wz9;l?^00
zHR*Rw#*rj(%A5x-nK)cvoo)7|+}UQ&Q+Xo0JYxz(n#r-aIok;&e>hm}t4HhW@S2Zj
z4+Y$AS+}owUNHI0Ex}eaIZnO-k@Pu;UvpbZv#s*p;j9|!uf)mIj^?eOPrLotdK-V^
z$-iHHtQqfouO+|IKmD~fXu+wd?gH1IIh2f9f6@t}bfn$>iB9L9Dp1PolHCB2u68`A
z4}d!_$${Z;fMg*emscOy3!Z+vNgLM;YKo-|pFcB*gH=JsK?uVV1PV$>0GS{TpckPH
zsemXQ04a$DbP|LNxWC9JoIP?W;r+u=i)Hdhd@Aj=N{}Uc@)rEE$>zrDMs&=zLFH>5
zvr}sg%>tW2wZRgbL4~Y2!P>3&|11dvu1tMSZFxPvp;$&yCoL2JTZvTp9oTy6@VrjH
z4v&pu;~4Dre4PR3gQd0ct~w0%b{mSp{=^q^E$YZ`&kh&s$nMFGNBhFJ`MPM_kI@EB
zymit|xAF(Rj(y4REeUtkNzLxc)?wq?^E>i!{Xhq;2kk&FC(nv$APGU_3NhoB6B*d!
z8r|%N_=>K$5mi&iWk!yBcu&$H#Xtm8yNFC??NUs`L&db|=kOFFyA%u1XHOajI1XqS
z|L?`l%sKzyN6*te=gmVtJiTrbvTckbTA{})pLtxK+cEm?shjh%+@}L$KNfZm9{KMp
zEm7j+U|h_te=p8ooNvA*?EE8Z`IoZIlg-}`{%To!ZDUP-pY_!T!RH0a8}FeXc0X;9
z^0cwc?$a?+GPaC+k;^fFNB~t3ATqit5ib^)LO-|L737h5kyL)9KS>r3Rlzkw6s=Vd
zj35LrNGZ)k=}nMT>KcLpHhG>(V+4;f6pT~ab>zuWF$%h_lun?@=mxAH1F4%Tl8O|b
zBB>$>e%thdwx_*_Ql@^i)5WIP8BYL8;Q$O->FFtH1Ieqbro{}EjAYNrG!+F@&Sgsj
zg&^ie_*ucV!v0mEeY~hwjy!s8>G#_y%X{JdXI)RiBxQTCbZ}AZs)@thQ_Qkk&4+>y
zfzly*pi^papvWd!1BOsA!`hY7+j6}dT+ICrn>vNwyloKp>k_SI=A7NTZTsw{a#8e%
zRQSR}t0&rE<Iwr)@>8C(&l}mZJ(Vr0cjoiw**$l(PNm2Dy_<dN^JrK2{mPrg^rKP#
zDE(`8;DU<Zg@$KE-&UXH{1jB>9Q#BVDR%y_p>@gdT9t&X_mZo$e;VhOluKIgegCpo
zkH3HS|9$4k<44zHe_ddWt3Llre|$&5mxsqSo_=86__pMAR?SAzwlTsxT(CMPz7=5D
zHBxhMr17Did7;h`=I!;jREn6lf%8=(_D0r0XJ)1t9fN0yf<|}H#)vAoBnsEB!}TpF
zDsWiIrWJwv$vUb=&&+pSi8E!NF^X^`C$yS=(A-NNHNJ0dYJJ8iY}B}VztOrz5>xE{
z^-EDjS=Xa?QCIHYhnsL#g@u$X+_G;<3b8pwDp{<YOR3LH7ONfy6LhS{75#i#Kl+cp
zj`7Ity%u|;vbBEy4<~`?-`6!0ubX&Ov3hTwnh-c2aC5u-UCV5b;mZ%rZs!YUUFL>v
zvkv_wtO|a&3N8q~9&5f__@8ENLzGT_-4QLC`lnjW@cY)&w9)4`?*|-{bmzbmKrDnx
zrvMm0_Ls!{fMs%1V`&gRJiW7uB#&!c41BdQf3>PrSfrkC*x=vYQJkc#ioR@8#)trw
zLG`m7`E9-q%J@H;K+IUAg^4^Fczu`62xov+IC(~dRQVglPWmZ%xKFYV<f<~#I?m_~
zITE)r$>(DygSufNH0&_A3{GZnt&1pumVu0D*hLgl;)_<$dO_CIFT2m12CXTt)txAv
zpaILjV!3(Cru*Z|kE7k<9q*>r#^boA8T%K$+<v5A&UBqg8<)A~*AEE{n9F@F*zywy
za?Y;w?RQXNdyZ{A5m+S(1U5q(ard$1U2!X_)+aLX<y};_$=Og%+q7fzY518ApR55H
zh9%cH^ym)o1Sr}i+U81?j=`(vkwkahp!ed<m{G+#J8%LTwhJ3kz|LVt9xH?{@~xeD
zy`Q=45}XIpV6rU|zw12q7$dKDGI%=Dz69y9BiWf3yc(zY<pxsbx$w?|-bv*+agDYf
zSf6TSJz*7yWRX}z6cP$0+(JSv?J;P08rRY`W8V?c0iXTWG0t}W?)KI5R}*5K!*#WG
zkz6)oYy<*@AQ|fz%gCRWiF<|?tfxN22ucJSb4FLhjP30)36v2FD$XjFntQJdBZ@&q
zyKo{qLtI7}dvR|0cqXXMVE|=Gi|QQl<XueLU7Q41^Oc@p+?zD@tfQ7n<h1zYH-$JX
z6Q2Z%ZSy^-ETN(aIW^|J2YS^S__2WDxG~AfI+Rc&#^zhBy$H7&Z%0S5L|#Ge11Bhq
z5-ThQZHWX>5&%*e3BUjr5r$%*ZomROMFS<1u?i%l87BLfy{uaI`j)Q(xkIh<O@>ta
z@|J-Y%g){#ieNon5xhS5Ak$dq?S65WV@uC2Ca}Ki`_^Ri?p=CP-mfr-k#GF0B%^7r
zeDOj-VwoMK2h@SL*+#>mrIX@hDFDaeK{P4Jfah@QJam#`3e|>Al6(-iK{_}sIgeQs
z3tWdF#Y(B*7YI_V?M$$FRTTzuInYrt)pDv9JWcG1o+pZ7X5avdOooo4B4f$fc@Ii0
zVx-$dIr2p`T2pBeH;Sc{1RF+EmAvvKrN}eU4dvV!Nn4UgVj-+w<V4;{%*|doT@VqV
z^(ph0{v)4z|9NwPn*6!D)nhmAnmOLB@t!^GOi|(+Zu%sAnd)8r^4wu4WSSo_HNLUA
z`88l>$Ds0{q;uWI=)%U*)+O51`97Uf@`n%9F3X}rf6-c-(<#FVVBB6BXq7QTz!5Nq
zak^K?rCixehe`^i8tEf~ix5f5NHSB5@kKUBTrrVMX@_OZ==;a$IC+MbfUKtA4CC{+
z-ub|``8wgI_7fo&Leh6Xxk`rqRFW-1DRBr&czInFR{VoUg~)+7mQ#{_F9yQi;gqT7
zCfqf1DHB>bzxlcdE^0zh2or2_|3OEip?3Q=AxJmPb=R=5y)XSf58jDX;1BN05qb15
z!LNVr+@A~wwZ2>zrJrX4?q9^WkoTG>n`CwKBKh2piASD(?vlA8lEoGXGVOky9>7zo
z`Th_#oY%y&huZ<eP{>0gIswh5ulvK<2*8uCjDXN3eUM#{$unRarYba*b>bq{5i&hU
z!-%A6PF*}ju+ui5vZA3VU3f4qF!0m<LD0`<XQ&KanU)Wk7lE7)j5o^ia$rU!b#;~4
z7bLN7N}B4t;Yyi0z2ncsh~)JHGa{Mnh%~_}Z$i+Is<0bpB4=$Cv@B&Z|03SKeM;*`
z5XjTS;ZWbLIccmrBQ|5sGP0pg!ySN@S7q>H!nkSf0d3*Hmv{HJOs{Wya5SfMdar%n
zfr*kmDjp|xc_m&Y?h1Y=*g7nHW7mMm5V91k{G~iV6@v<m9V1L0Btjv)WCC=06hd#|
z>!4j>^rZn!JA2-u<bVh73-61jt0aAqXKm=3b3nN#7>|b07dxx*XunsRuROc^q1rS8
zF%+`R_ZWVUhB9y|Gu1@8*cuqR%jOe7RcXYjQ4zdrY_`6LB1IXT8oA2v+O2|Hj0KmY
zzzcKqM2_`&A4w9dk3TOdQjnC+?*ymYz76DP;1K;TegUg5<!=c#0UPKL;|$`tXiu$Z
z4<IF29r>?NuCQP1xsTt`odQ8YbaSY;k0@;vjv4b__Yd(#sY)LDbpB31phPbO)?lDH
z3GSTwX%|k3(adO4Dg@r}-boCc8_4eHARYiBXiZ90<lwC^>)=$SGHF^9avnJuLBk;V
zvJ~8#2(&#Tvuij|8!0EoNP*IWBTI3fx-hX6N?VyH%M-09D=b6RJy193uOJkhYg%=I
zs6T?YVk%vxpWU=&lb!S}S;0C*EhD7vDxTPT#;@Q0xbM!P6CO8j?2TM$`w`a?eKGOo
z%}v3r57#5^|2uy6(HFGRU3ID$TKHB%#Q3t=KFLTO4Xebm`ft@eo;Vbgjeww0A_H*w
z9=9L|U>}r{hi*4PG7p7c%TsOtWdaq`FxD8oEg@rlg(58m$ny40O7P@Mk%RMe&71bX
zV~Z4HReel2w!9_WME$#>!CSrZyL!5P`ii+XUS6RnAN=S&sQCHB!O+^7rpymF3#HCa
zyA?V|Z}ZJjc%>v9zr=KdXl;Aw*CS~6E#8qGO;g<lAKrDv&rN)J4Y_jiuvhoL302yU
z_Zc33?{yOO<^11&L?aW&%1X}2&Sr}^*l`^+`E<XkU|*Y_z=r(b)+tCcovt%X#2|_s
zvx{|fanf+Q$RXr_$<Dq*s$GHgY!=3ZczsXrb+WQCIo6mwaL}m4WOsx4s`cC5*R9il
z?9;(y!b?P8krXE@K6m}4o;miQKCxcErcLiQ<b5yJ;NER~<PBtuc14swNVQR{-79r6
z$6G_B;vC*tBt@a{+1#~%KR5c^)IRlVto822j6Vm0Hf|iqTZyTA`|md`zTjYL)FW40
zHwO~~BQp8$|L<WO9nCk&W5QLF#f59Pw7uat|7@pSpz>I1zgS3+Ba==oHI<d-?<vTh
zVgjBVLW&gU0|Ihooxt%F+elv~;5-}CuB?CH5D<_QfKUicZlhydb!_47n;104F1alk
zBi5G8hhxM6Ce|DoF>F7KZ=lK0WIWTjCXUN#P4;8N2+5*SF-4p#nOfSOqBIkCHj{V8
zs0B~qwMU+jm}=3%QZg6cE7c9jvUJEXX|w^Y)<ISEg@!9bLcYN*igh74;Ov+W>0+uS
zbSSL4#5&RPLXCE1<^yKYjoK&0$94%87Frh)H^$UX6up<1#I*SUk$Oc3@19*YyPcFF
zf?p`=#=kH6bG>V&ptMU~vdSu@$}nT@qUhZ!K6soY-WAb2e^*KCWEuFzC@w%>fwwdP
zYfaFI(}=@gLXu#9jS_*p^x?n(iIY4e6>Xs4Po8{Zj052YKngt^eV7*s@s*1@(&=fB
z)a&%o+mK7|@#lv<>R0~TZ>K`W+y?k0ZY8!Q?s?>oi?N$O7w)v)+P&NGn#qF4VB%We
z|7BPQY2#6GlJJ~lCwn=eJ>V+gNJ3XuasZ&fYq4wu#gpfaa7EZEbLF(<2y7~P2E9CJ
z^hBuvy_Tnsp5~n>gju#*n+!U(TlR5G2F|1|*4D61o||@k5nj5!bbUF)K9l;T-O{A5
z-MZFfz$A51*qd$AZpp>Z(Fbi>E6$u<{d-z?&YU@8KEGyeZW0q@VX<azVG<P0uk)?D
ze!XA}S6W7`Nl!0CBnqcIJtSba2PuN0qY24&STq^}+m$4nst0@4E}N=9l@5~=t##QD
zRo5gm8)FjHQMQ|x)lmmA{<m|-BkKM7gQ<<w!k*@BzCVf0e~AH?V)FHMyGX!L7)O3*
zPhCX4Lr<CP6-NW=rcKsnqI#mbre@-nU7}!B_F==9nWcuC(Y%zj^kEY4>Hw6(ENQ#-
z7k;7OCRH{ATEwA`_aW7jC?o0iw4793PICAgV4QR3qp+NFWh&<e{#J8QQeaU|ayZpA
zum~5bQw0uJ`bgk$y0|I{oT)^75;y`X>LW9N*9A$T60lHRm@p5aht(>PU?JcL)ohO8
zTFZv9Wzjkm76lBLuGeD{96W2qI()2sXusOjSJqRyS7ii(tndGq@BcGIO&Thstn{<Z
zZDZt(jDoqQ)i^FH5Mcz((B^}U{bvUn8~Wu#GEB5&pBXW5(sc}SgSdvc5yRqF$f!8E
zo?I_Z<oOn5`8Lm&{lx2_MSXP&p*>vrP_lY3RoIbSufN?vE+r?0<IA{D#rh%ZKnGB<
zGdpnD>>1@B5;8Vf=#M1HQ~s$%o`c0&<1Eo}%itHH6<P&#6>WJ8d@^;eT~dK6e9O&o
zV0$XgpwTSy9*juwAy)e!sQ2XT>h+qz^c=g9h`$|fGkaza9OTW(XGD+4?sRHt*x8R@
z_69dncVZ9nPdaS#{Y>1`i{2i;x{9GX!0Rx!c$A)cytulJK&|;~;Q{MLhXZhGy#uS}
zL}5tz1SwIiNg$XJY>3V=ue_;YSWy8V*nnju|2AD4fH0s`9pS0JMWqe=?w3ea>W4*T
zw#VN(F&+?oV*FcB<U6X;z%SZn*Gg0E8U4NNvr6=zXHiS2ugMpZFTgMG`nq9RICLdQ
zqZr?&^vS_8mC<EX`%-)1623G<jMujxDGRd{StkSbXgBrrO*fcqs?N%KA`FT0pV;L3
z7VZinw(gW~-I=&Lcy#uVpzzf;Uvivf_o?<+dv=e&Jd8S?p<z=yQ0M~1qg7kXW-3=d
z!d{3=b&J?2usXeC`r-LBZtB8uzs6|vuKC-g&rihd>Y`3Q4=Pzr4I|#A)jK<iPu~qH
z3EOde|HYsZC2b}3day;WN=cpTql8ofo`Wq)+Ty(Dfp@nrEmXvE=5okn=H%|z{A;|W
z0MrN6gwSB&8vX}fh`yl|A2=ySRYImJD<NSZF9M(Pk9aLEvOQJV;JHK+^mEETD~Hod
zUojh|8w7&s+QY&zHoGG`Sx2BQ^3^VJ=7*isyJV8`UnM8LQNIjX4*l0-TiHqB>P;T*
zSGjfUfBx@pW%UDSq5tc&>wvK`FjSqrdkwKXP7XlKXqE<;JVQ*^d6S?US0fFJeQRi`
zJVSX{aIHC7p&!?eiRlNP)3{1n^f%;jiCk^~c^ok#k$s$e9I?tXjAyPJGA5p5pQBr_
z&ydHH43ktCS?7_KaY|*ppl;hFdUqC53JFM1^$C`!lYCz}yK1wzlYDO&4^Cmwp?WFc
z;q;+&-pQ93H^hJqCMQN}Bs#lZCaXhNT&<FHS#5fL%i(tYSUt7pfy3&%za3T$e1)o3
zc1z;QW@47`4HRVGw7I*@_wHTtVdxBWvVsIHqf_+cffinicps0=W1;#1dr*4Yn>r3k
zi&cqEotqcs-I!y@>SGVNJhwE7!`ju!u8HO%NXE|D>QK4t9URv^Ic2+!6+zRZvUTnh
zB=>^ak~cY~ec*lL@O*xi3?jML5A3khz@pe)8b;Dt106&Xs&60!%!4!0(kQYMflm+?
zUHDoclYbZ*k`wWQ^SnofQv8*~xP0J;1Rzcq=a?mVnq5YsYLPl;u&m01MwpDAj%W*F
zPB1N1qi0;9r`|>*Dy8S8#j0s$&qU8Hwyv~;2HIv-S2=^Y$s%|7D&>fM;-pt;MZMY{
zzZ<H$4D|N;*>u`~0KER2jX9^VzDuM?_QR=;;_q{8$24pZ7SwjtMp$-QYr9z-?-`9e
zlmQ{r$huuJ5aTd+83et^$X%4lbH%x)M}ZIeA;y6>Wwd3~jpi~c+&xG;6#p8zvm>z}
zryvK9#U52F!sBzWcr2dk!J#-OCv%)^lamXQInGhZ$uO2Ds@z4Je%33?D+T}k!?==0
z=#Rc}C6myI593EQ3*CEsHE()oZ)p5pjko!|ak+3)?ZAPHH~;Jy{Y&fZ(Z@D|kI(<~
zB|h_T6a4&WI3aj;-Xtcl>ti5caJKIsi4bs*=eqcXCnAAYuJ!CZc2%43B6Hx~JK>}`
zVA8eN^<|blyA(U<bY@_C+O!B&v)4PTV$o$+_9Iw_Jg-K17vhfZ%9<*n-Nbj&N__Bh
zv>T`;*!vcZCaKGlp_6-l(}fmC&l6n>8s|)gxFowky7jO+X#HfDBr!@~KJ2O|QbD**
zN9s#+JBdEp%rIP~&;X@*2G;4P)f!QYQ*~2yWW3h>ne%Ylif_q1?l%1n<+?lNQ4dKu
z&I&u_S;AS<ujer-q&A~4flJ*P^iya^H>eUgU1m;lm@ZC(t`1`Rco-fDn&Yo0+<hoT
z3HjO!l+Bzah4$Ie%J?b{`0+0qL;<M)9R*gwLd7T+b97r00s`8w|88IJ`eu{PhjV3-
zvg(w;=SLka7<RNxlr~D868z(V<G%71nw_k++9VTX%4*TJ62Bqo^e`Q*WN4#IsjZbP
zv=c%DxO6IoMA#@TEyRd*wQx<TN+bz+WO`SISZGzHkED*&Qr_%_$(2rxT%#3n`vACC
z<Z(FpsRCknpE&=d0z@jM)L()4Whd?_an=`?nG=tp1t(<WL?vtF^t?1u*idz3o2F?5
zAKXF2u3F^uJhC)yr=62Pnr)OuVJlUO$>CR!V(J7;TPLfM-N^2F#oTb9SCT#Cb9s%5
zn+o9%dm!>~&kl^as~<q0c~$3{(-zzg0t4h^PM0%upxGAa!04i7lIU&u0NWOlFvdOP
zTH|^XY8++Fb67LXW0zE##&L~~PDM9^`?tbY@Sv&>ksP^ulRr7ljRKV|<90grD2MHW
zn~ud9`duun*;l6X_UVIKtJ4p@oj#e?IR30YA*a5cHLEeX_4i-S;KI%idA$!4@D7qA
zjt@r?cCUJ*ZdvTJwQ#%i*yiIFQ!vr`)LRgJ^jq{q61XnZ#oj$kY84tW!Q`lthDxAO
z%m4VQVI9PPv+o?OE~evviKa>*x~x&UnBHrIHHuFaFE0aFn#w(??U^qK5>Ra>nc7Bv
zrf4G0%Ot_^Ox`gZI;}TJQGt^q5|#4C5jSvU<#o#Z$O^qsn^FQ`tEf8wae~2AwpSH}
zP;6QfJPn9K19Nc6Ia9q*-r3Dg^?Dwm))dV4*kD4mz+9f@SkP=wBJI(cBVQbXT9@=w
zr>xl@?K$VV&aavueR%D;n&wNpra`sdTLycLeRr>KInNGX;6I+e_7VIoklonPaXEMH
z&26)fW<$RcpC&F%<l2ASnzQ+EXG62tO(0lW>fL^N!E8F&1Asw*!$??j3ND9(WiXNm
zjyOGtXtL8jjs$%q*-0q{!fm69xk}oN@nR*>J0Nj9Z;b(IK8Zgp&(5UqM#r27#3_xP
zEN8a1i}IW0e)d;8ux)+sfSK)Be=6Qh)Fq$C)k9MmV;#!kuGAFP;A7V>Z+=R$7cEBz
z`$k__z8QJl2}^m1c-W8XWbBia)0cv>7_9yF!CeHX57b9P(>RCMhS+_wN7_)Y>d?<;
zP#Y#zt`l_M=YKer^F)y{Y~;`z?&TY<=XXSZH%@xozq;OgPsRbq!1D4Me{S{PN21%x
zK5g?|ApFS?+UL`$dk)FV0$;DAP2}XOFBKNnc?AdrTUJ3Id=9J5<<J921@isYjgPx%
ziy#LLa_NCW4SQV~q{M0(;#_1o0J2$~2jJ9k5H<h|XalYW2(+T&fCS8yrJEV}a?oCt
zZ6Prrr8?m1<GSDM#f*&WJ11tP^A!);4MbULPcLKExk|m6F&W?G9W`0p)Qu}Ezv{yp
z;aj<7e%yEF+rQSNLnI~R)bzeAs0!4YSKG5_$IT7o=Sh~RpUl+#{Kd;Cf3j9>_%iIS
zV!NjdCR2jUDkuN~#HzD$Se16<qdgtYnEl<;rfGT_eOK_|C;QS_^_tx3O#O_GXq`!4
zFWfO@`@oTe>W4!9Dn?8C#BN<xcZFT5-bYERMrUg;9wx_%kxQsXa3Yx_f0zscpbjdz
ze)3KeC=F(#K}!NiCxVu;G@N4~CY7p$rvF9n@?y2^$|}Qx?#5rz$?y7%G3F*5597RW
z3+@x6cRAz^ce1w;*^?{}@a?C2rYZMFSuze#zEc$yqa5jPzwTvpo1e5!)Aw?ek&^{S
zRg4>o5b)>j&nE;|Zs>4Z;SOzYNDpoepL8uE>FGEg9`5pf>1r_N{@<bNRrPuwYYGKF
zx98tRrPFD$zy;k@t5Io9=+|o)2mRU?4-fxGOcQ)od;gbl+>wtb&#{eO4t@S9-1zt-
z^;IC4cqwRo)<gcLOzr?-ur4g!5eFgiSc~>Zpg$c6f90u&F<GAE<|~sMcai}J2{!-t
zK4fA#Qa9aEFC~Q$_aa}X1ER^dh4-l^3>ml%9|C3BoL`1G)4d$?y||-D>_#o=l$u<X
z8AIatblb3QH5u(i1(+DpKcY~v@7`i8w`3m!KImj6&E6@h7t3Fox%PF_tH8=IX~jYE
zLj^0KqE)3zOIugrhGy;&Qxh$j*RBJr^Vv_*4NjJocU5JSo=N-@ZFjf2zQ3lr>h2xy
zKMw2$vlwWSgLP*NRIg+DeBk4n&xsGWPJb5sdfR%x_KE%>qemtOGxe1$Um2Q42O;3b
zfiZ|3`UvCT7`UTxbc}YGm8=Y<)Jkn;M}wtNi<k@?V@ocDs~J6`w=3}kWLv2jbzT{X
z5<WzJ$a$DK#YA~>JeiOb6hV#&p?VfV>DvMaWZygrU?RhY@fBcfCgZv}+7ub_PBN!S
zSZ}9<X2RY0sk|3Tusg0el0(}Rgjudb<YOs(TI95z1q_-w%-@%ARt$9}DB*182t{a<
zQ@8mx5z>Z`+y0S-UNHbH+^zQZ42nD}20!cg)uQFh`h-%&g)TwnmPOaB@K;YPDq^-Q
z9KU#K#GT2UP->6K?0MhyQ!o>wB)qjgF%x-q{r#3j+y{YDiD$x@%N8%}Y|SL%CO*j|
z>KqV*wk3D8Me{H{ZPDCu&^&}#l;0Ps<XCKk^I5WpX}bR*Os~=*Xr1;>WlorXu&J`C
z*sjdmFy8stq?(SLjEg(%5ahN+RRm2H(Go}|s+6fi2t*T;V77!d9YVUWEeT0jcM#$A
zz*VsXMl}lH5pc37q&Aen02mkpG!z6q31k!!4o#+%VRY=pkq}!t1;h{$NdUKrCXZs$
zJzt0?v$+0*4AgT4QEY_67LgHIZpdnM2-NL3Dqyt=g!#1oy6SZgle(7;6;@W3kQk&0
znHJc<<-M{Z1JYb*UAwHDDeWMyhSqey<=^KS=m$Zu7NK~42^GD{dtcPsGoCs89``;q
zJ~i?L?!CV6FyVbc>V<;TDC&tqsHRYbZS4onZp*DmAF^<BC#nxppo3;(^^l&W#+LYD
z0tmn<$rM|<Egj(9fB^v3P&@_hxUWL8#GgMb)xN%IC*ov>Nm}08=3B1vivK^p`nfKe
zsIMN922tz&<s^fsn9e?7r}YdcYID$Liu(Sk81eke3fgu-KWxOWW!zGm)kWFFZP~0u
zV_K4hMoo}4k+mY&Ojb|aOctmc%cxcAiq7f@rC2D8sZK;dL%v0%d^^?yr;y1QvL<Sk
zCk;|CAVr!M=^ykyI(%4I^$#pP9)iQ1eW@qRX_4P(k<ua3IteQud=!KNC$3sSE@kcl
z9$sW2kJ`=Jokqg=*yirv5PBM_RIP?mxB6@24Szd)AcAiUavTd7^$+Hb9P58Fi-54;
zM2t%N)Cv$qtBVAnFLUYwH=8{Sl@#&~Gy7y$i#+-_&rnYu+O+$>a>(8P9s03+fCnGB
z{sMl0=xh8-PPlNSM!tvhfZwrSHG4I`5(d&52UpphUY^~hgu&&ejd|SrLz>;(rh!~m
zpH}kQc1<2*kw<Uou3PN%Y(i7$fy-u}+sq(L;PpcoMjMSmAIAp3Fa)A-lL(ChOzu#4
z5F{jd+dafW(XsF%hcVl@PK@_4@v>M0S~R9&GkIo3^eRnHd&Fl~a%296VeaZ7t(ogu
z@p`+G>-4o+wVu1oa_8fBcJ>Q-tS{tl^W`fdy2XGKjoyaPY31$tcU)JndbBrcuzOpt
z+OnzYL&&jH6`<;EqM*6~6QfP6!~i?JYXM2X6$`kM#I3pV1$UA1S8p@M+J+lz1I&C}
zOu*wt3I9v4ijDtx3C%PKkwR~*-D%;zd4D8JWh>|kXKH@eI8`7ZNg1^d>yHKrB{{03
z?=P<l@4uCYntB`FM~9ujX3Jf18Zcqc*c8fLO-V^{$oX98a+~u#E1vqZU#r>cM4`O=
zfsmBCFNZfDtEPk;eAjp}#35&C=Cx{l`GlbBjLBhr=u4hF#|p8MOjqHkFh-~%40;_j
z59DzmuA;mWUJ1k%$&27c$o2!~;3q^1LxdbFvQNbRf{~XT3_ARr+$uf;<rkY>w`<3j
zA%(Ry5id`2D<&pzwbiItd<I_{OD2iWh)|we969)Onjc;$FZbm7y)xhM!YBCfvxVZW
zjokk2?EQg+TI<1f_7}_c_RU&rVL6GNuu~4}E7uP>UU4$!Q`Dr=FbgH1pG|fY?b$)N
zkxnmxUf^4$bKM<m56N{#9g-`rzQ0~0=a9JmP%gz|{kdV_x1Hq1&Xq)Q>N5qzWaIV_
z6Kn~0<O88SvVMVFcQO{(<||NjE(5mLSLS|OvZx<N(FhkRBvzdA$VnZL0WcVSNbDOJ
z3@hBT+MvpFBGSu*8VAP^x<WO?MTpffH-b2Kp&Ot=281irZjh-{Tp#gyp^!sG%pfL@
zn+)!KYLaF0Wbe@4L6ae~f826Me?>49+_KH8<*y^EzKv5JQcA54G;c=S*V+s})htNV
zyw5S~ien1{me3zGyl$GHH_zd_Xg9604!*2gJX#Qv67|K;S9Q+8q3P$&ojXaYokH#*
zDfKVQzWR9kSal_Y3a;MTGGR{$u2wv}T5(sPFV!GM4kT*`1B=KS<o%F+B9Z$^Kp9m`
z9-_?i#IlLNJKj4Bu{Hu%EmVU4!$-~W0)i5(?X6Aby$eFyRSCV|lTCK1A<25ddcq#_
zezYGF-LERp!Fs|j{2#O*<as;Bx6}W1eRxMbYrfQ~f5!aB>eB`fccI@O9d&2N#+@C7
zGHf=RYwu%EB^nzWu4!nPTWMgmy$E0$3zcLq>!j=`v4f({LJ?$n6mbB-Xa@iiut5hB
z3jr~n7*8C~)B2<>jNkJrz<HU;cxg#fc2u{qb$Ibpvr>Ci<Kn00q{#7Qvr;<owAsln
zWRpXiVKT)mnG%TJ=DVd;H24F!6q#<=m$C`W-`0tXZ@rRl&0P~IR0ZoX_14yJ;*)yN
z>I%zgQwp0z;m(NBa>gbR9x#O=+Gb65)G|*>i?)s-9W`(qu|S%YKEl@4(-(B5LW`79
zR0&R4WeEB82JIbnOX=x4^+LhZ%=dq67S{SDS06_mZ4tD#J&r%x!u_g$p%8^QDcwfr
zQj8&RE`@|~FKVa^dr`b*9#%WzTi$8RZ!kSIFkapeFqgF7rPxvKN`iQP?%te-x2iK{
ziNj5lrm&0-Z--<bBGZ7#)Kfr1!yKkb#0hMIL!I1~f)w^Rabk<eNsmk4bXbvPwNCG3
z{Y`As|Gy^r|52#7i#y2*(xV)mLWm^FN&}F8P{YO?0Q7<!Fq7yt_6&P%;Q7N0#0qsW
zsFX?z`*f1+7qa|`2Kv!JDh*sr__rgdnkr1RFu&~t`pyN_fTUF}mn$z1i6kHQ3l?+B
z7vD+1(Y&Vt#G$)BwXX^+BLQ_G(6c}F(9wT95>!NXVS);0Z3n%T1juHCfFxVGG63=}
zO4(0t3ZqmfH&xL|gaKK>7J#!rPEH`eQnDNZ;^{3b)H(0)siv|3CU~1~r&8ua6ma6s
z@txAe%0PE0Tb7x9mRb5hOc<CdU~+VsrKLLP$suM69VZl<k594Du_{R0=Xa|gP(|r`
zsfYtW4U=h9VARYkH)7JusCr;En~Lr04y;q=ipfh<=-KYW@(&3U0&=hpho@M1OEw}s
z@tz@&0<@1dBRxqrt-3g^v>2%;-Qv<Q?85Wsr}u|2Y;)}NNjY|Wg?>bHaC*N({dm~p
z9@}WaW*zAOqUG_<!h}bp!eGCnB>7!|)I#GSVrP*&Nq(+=JW$w_fq3A%+QG%%C9{e8
zsPrxqsNIZs+nP9Yl}o5aky}t+1u|sH4l)5nLd?;k(%PcZI!CVAMZJjeI;t5m5*rvF
zOEq|r`?tgng8_GgzK&(nvA=;?=RBB#tu^{sMyb(x83to764j2eH-bTgF`#H$OgDo`
zu*bq}F%C#5fkhN%!tfmi14EFfs8Ut|5CibykfJ=+Qw+xsrl^3ZRf<g!Peq4WIlSq>
zB}p6E%VT^LvY9Igq|Or@BdATB?QiRqrVzNKuus}3D%}XF^EBguLFaHM+y5Av+R3(M
z8Pp-V2ptOk#~cYy+xrEZ*4b+~RTbQM5stD7r_Wd(So=Tr89~_s9=ri|Uq=FvV_X2n
z`%z6rxk3P-v^ku@55ti4h4Jubi$Z-1#Z9_7GTm=vNd3n3121wCUip$<FcP?i1sRi}
zkSqvC28twgmY{vbE$t2AcFSZ#NXldjR-DJ%&OmDs2z@yg4f#K%Nfi`*nI#2-Oj;6Q
zT$ZG;up1@<S}KwJ+ZLq8+(f2gGO{V^Kr&2@b8_)sde2>nV{&#4={@%(j-|I8-t-}I
z75~=9`nLOsHPt$RhvV+0mmTR0)Jr+i37Q4_5bx@>92Rt*kjs)|9}aAgyR~^Z?yg*5
zUHTJ(bx?<hwg){*`dh_kMAD%-Rhi+ioa#wq)Z2&qCr>xzYoZTInwyyRQ<C)3Bx-Ak
zhB#{%+FIEf=tz@=?L$IEl%38)rRnLkwjfWff#Ygqo+iJII&v{ckMj&secAiicXp;4
z1xWrO32PPZfSY7pzQr$<dklNDa1*jqZ}9Tm!QXXF?-A%wi<QUICQ4;V)r-|Oi;I&J
z?BS8Wq((-%boQdzf2p8D&AtVEBcJH1)>+iqy0Rz`EQW2Rrzb7yR96RiW3vQ;3PDBY
z@Q9bAjqui%iDIVL-fvOGic;mJnIm4qUDaDjLcaE&wTxvXfftd${sDPS(UL`AvAQDG
zE8Rv=QNjKLKf9I6G}$Lm`ej(YK5$~ORj{}i7M8de<n49WN~)|PvrD)HW2R>aCfDD~
zhMEWjD_7}@A)u-epxM=x<gHQjL9S&@5mg%Y8CWEDFKH<nE4lvi4LWD*j=>CI2yB0e
zwv_PH$+9H6?SFO6PfzYD(nw>L5@9J2+hIZ{#GZ!%_&^JvB5R3(riMb3d7#4)J#+N!
z<>=?yK=4DQbytaAVl9*74K0g39wxC~nP_;(T1xTL?Zk%;MAO%2CNlh=;>#~r2bsnO
zT$+7(_UZZW{ofwfgzx>nXV0gLM{ixu`}p8}YxE!M-0u^=uU-D5)#n%RyVd#9)}K8~
zzXccn`?oc5Dd1W3!pneWVVltZ|M_(^@x9=g@TnKx|Ndzh@HFx3pZ;r!OM*X3&n|yA
z{P67Z+`kio%L{*&TBGN*1eMRCXRj?K3Is2YHUC_C|MdKSki&Y_wO{YvOD~%3u*`~H
zJ8l>=$<(0dY0l_%(oB1eM%&FL$dEi22{h8E2exCsk$Mt7SV9l2tq40c53j!4_f8V3
zpHHSA{HHU8QQ9+qYh+SO_s}l0H&A5mp85+L^TCgG1Es6+KiRhVQ`>w`t7eYMQwP2P
zyi*1w><umiqJQyb@qvq4J8oA+ZT*M%-FWc#w{JF=3j;3C{qjAAuKI4a<HPT<{MCP3
zot=Mv?Gyfkp59-G`93k^w-u7A{Et8~rpbG#_^Zu}v&Xtu7JmM`W+MnVOZ~jEG*xRd
zbWE`HlVouy{<2_i(67z!&p%tozdQFwupszsGymJ)=7mG~#Fg8oTR7)~t9R3qLTK5^
z;Y@W7SWJYx{>ZisTa?Y_gR-?qY)Ys;tLvax7vu_Z*9Aw2Sn6F4aIW(TBnJyeB6&FF
zHwKizMOAtj7M3WgjK;tSI!HROgTeIN3#H4#=uWsO2!-duilPW*I1v^Su;g4xb~$5I
zp-4d>ZM(_2$VChm)n~B7%jzm~@{3_Q)eS{^xw3LfW?#3Ybj8iMk5~hRtC)|HmH~!0
z46jK!<+QKeIdMX~`(8oD9w;I1W8{}FsWlFNH|UO@DlN{>b@CZlI#ODo{gGJU^2B|h
z@t>57<L1G&mE+aKf2vk_k0#PrX5uIQoL+Q4R5U6`hki)iI{6DG_x5iwr~^cN<(Spg
z+(5?w&CJ-vLvcJJ)^mhzt9?ER?;1?f518i9z{}Zy5*g*mpQIa!MMCL7Fs~Yppy+J#
zwNt$PQxf&n8!#Dw>R{iO0(&JW1S(Mj1U1i!p>cpLrqs3?9-K<v<MkX@9o(<JSg2L5
z<KRd>gNj;}or-HoxNy_PGInZnD)M7{_kocinXv03)`ePW)CK8!|H7-mQ!{slZr!rE
zY3+Y==%#hd-hc%u)&B1O(bge%<so<Xo4afVhdgeTEJ&$stQ9RS+*xQ4SjLp>URc<B
z`QoLmn6=S6S1~t1GCC0C1cD?5v3&>=2qOqWk3qEM@(e&rG>sxjb2^BV#~B!K&?>lh
zDx8B6CHn7>N{pnMv@+W(wj-QRMODO)X$)KD)Eivn<jDg-w<k^+P0}tK$u1j4mBtbm
z)KaZ8<i+>JW@NS*7{>?K`|ZSfWok<tIB7v?@ldgKF*ZMFkREm;7#;S~L9Vi=>XX}p
z{`>B)LxV}h;hwSH-`*pSIXWF(II(L;aO2jO+*b~o_YR+~ak_Wu{+Yhk1)IV6(Y&Ie
zg<V6!IkEc{$ac+corlmJc}3Bn!R({c8N(7f%ZJq&K$RN0$bN6+-kM|zp>!pw`?ja^
zLl@vS3KvW>hU8zl5=7v%s9pspi%?obie2C<^=TfTm#yz}<cmtQ^}u_ddw-`yeaJM4
z+nXY#T=i?4Z<w;~j2Jv9&D~<HOIdp8AjfaBwcc^-kIJ6)({;fbPg1m`@zSEXAGKYI
z!>!jgzU}uayCA4C{6KKtoBdQ^E4Vc3_$_y=<jJwU#hBIb3yE(mS5>3L*Gd;AZZ&sb
zy}Z!;M^k{g{VoM{y}tObKNHU;ZvQ&5`-w*D)7vj&25%;MtUXf@+}iv&Bv?pGCJ+vK
z9T;$ARuYoqZG)2$t;v0IKI##(V@vMFAgdaDQyF&SQ<QL_`o>=tYMWG6@*bN?5c;-y
zr)1!cJCk)$%Blp@e26r>I6XiXwwR`UCBQPiGwy>}T=-ebRqEy9n;z%aHYF;Tophui
zkTEGKOza6M4W}C>vuQg<rRA(*O{emvf9ciBx(mJuF6AA#Gx1C6cS*5@cFt^x%Po(}
ztg35?oAyy13DY~oV-tR-v|bug{<C!Hm-E)_@9eSz+1j@fFMPf5aVz)OAF;&NJENEK
zVx9!t85aB&xETt*y5$8@1qvqJY-&BPo+sx*0Q?T}qen}rvdv(#Z;&C0OC8Cu|0gOR
zr3HZjguWBR(4h7FAOZ=Ab0s^vr>L=w)aa$nX|yz|;k-DsOPtwxTOZL6Jc&R6m4_X?
z4|`P}K9r(#DF4WzTi-3eE0Rgue53JE@lfE@-Qz}U=@{U(d!txIDE8WaKg!s)6Annz
zYd<`+@_P6DN&HjgJTbX!!#E(7^hOpo`9m%4!n%><WXEo)q@KhpW$UuEuLxk>`U-bV
z3RXIRmz?UkKtHq`yo+Zz^$w4;*@QAiF@%mZvuP=L4F}eJ{GE$uj~7R4F|?n>KfHVD
zHK(9UD{An@f>l)IKfTxN;z19R=p2JJf4OAPmc_-!r%acnSC{46m8G<mF#uZz;FPTs
zKt~z-LVp`{^}Nzd;|O{uet!RxII-|2ulKo!w!uE!4iP<Z$eLSBN4vJzi{>lUV5o(X
ztO4~@W`>LWTwioWbf;sdW0GBG5Un(J_j+Vx>~2hZvt3<HRL#K||I-GC40Q{ykq8}@
z7ciT)>q#qUTLCMPWz$};7V~0>3~z&>_Av>t!-ujn<mCxKvfix$)!q8WxW)5FWJr?z
zz%)1hp=+v?2*+AAsBFA)XK0Iv@E%p95YkDHMidr7GhF=a-?-6%FX9A0KyoGFxVZPu
zsMr9=8wF|0Hm3~?TZ7eMdxcF(ca%1|LhO<~hhMpAC0TB2b+w}M9DX)hUD2M1Hj;Me
zQqag@t-t8@Dv4#Ue`XChYM7o-*>8(iN!aFFgA>hw13{Ti#_6d-{n_uEqhRJvw@0_@
z3HFTTqSgB6nFm%urlBfm(}Si#-}){FUCw8lc3RBHzDmuLQIwGXYECpAVKhkOvzeu4
zV)QXR7$I9+OvY2kO+-U~s#pRZW{Pc{=sr#;RGX)G7D4Pz2*~mM7egR+fe^b8fGI41
z!@>|Ob77()*-G0fo!{u=kcdKz&AI<2H?}YqE+>21eUG~x#9P!Rv)EO*)n8QKD$t6k
zzwl=(G5DpgMX%aWt~kff;e(+#^M_&QVvFJQS3~i-*qw3DGU_fG#643;`Qon-_`^`R
z)IojvKT#bT)1oMjwVp3@QvaJ3!L`9HeiVXuX(}5hBIY|zx1B8Wy((ALj3~%}mX5;3
z2ZoC=P&7tVUkUfN>a<9F3Ln9^z#&NcU`V-3uC|1{Xv1*KVX9o(1qooW^q(G=L&%BQ
zy4sdotdlh#2k%~NsXT1G?@4L4se1b5>Tpf{Zs&fYt@3{pj#YjI%U&^ii`~awzs>&n
zm&^0uhh}DmW<RntKNhJy&792}xSF&hPpT~5GHy4XomMuZp<x7EmvN-6FtRTitqA4j
z%fRyT(xe6AGMXf5dJ>^ja%G;?;}zbb$k^sPqev@)!=o1Nng45y0$v}lHP+Ce*p(s=
zaK44EyxARoRhb0*TVd2DYgT#wP@Xt^6bfAtoegr@){cFYIA>DT>LGY}xIA=;Oc2!<
zaYe(9Tnu_Js}s<6QTN39cLhiz$6VAe_}|UK%<L)IJax|vFA2F6lEsfjPJ^}MH`f)-
z6JU-ZWb~nw#L13?@LO&>PM!QO?9zkahc!ov-@Yz>x<5C;>Ca2U-W|ozy&lAnRg>Pg
z-tJGUo(sQpdC>Cucfh%~mma$;Bnn;&1dW2XiMyU2*e?(aPmHPwM$c`NG?wj?xoro5
zBGClRdzKQSF3~iqE#9MM1`D7aHH<0fp{O8YTHk;+T!z)Qu=_+&_886Bmn~KWd3GJH
z917@CF&&fpWEk)(Wq@ot3g7^WJ`xTN$dlKS32>Bx`7&sdoWCyDzQ8=e3^R3G`!-{M
z{3M@PcBY{BWyejApMTxIcO!Ux@kp80qX&oLnl*~^bXI4JPo7WKm%8RS9d(~F_D?YW
zK%eyv)4$Ag6th1FpXtE<<GYFz_YDt@ydHivJ0$q_+BNLuABz{JZ6QW4qy(m;x{X7w
z-`Y-_2}}il%ml8Ni(J1=xE1D$wJZ!8VIj`&G!ZPE5f-@3_qU2x>J|``Wo>a(5-#N1
zi22XIgCRNTV_(atOOL?ekA^1x5JoS2BEt~_F3<tb6Uf{{l1U~abP$U<dokGG^bHKb
z1Dp7Os9FbsX;alOTZ2oQtk6|C_uMP@&+iqaF~{QHvuL=KtlbUVIpG5Gu=kSlJqXWj
z<NHw3LbdOhhn!fEjG=6|>AeN3qH^B?!!_$rU3^GRU2{!Qd|Ji9`dfM*#u6_7_xhyA
z(?7>+zdrSQRFf$9?QwkX@X*_f$}KIe!%KpFuZtCa2?D~x1Z9G)5yA04e_d+)Q9!2W
zKHBG9VYa`)Q23#09%MIJrUIg3Qr52Qs}B)27>JUyneF4r&+vcYuih;yG8Y}EQ}%Ea
zAW<ne1x~uuIIC2T1BZ>!DR7*ExM&`zfD4AiQx$M}!tae07-Q0Cf23BNJq4FT2!un@
zj;n%_cJdT?M^%bY+z`nYe!4@4L7`{>Yl#IUhH>TMECYk-?JSkh**+w$A!T?a+nTW;
zly_2f)BIh^h4H}X!!jOerGeR<%5L^AwP@+fop#>1T9>Kx$WEd+uGGliCHWs*x$s6)
z!FsW1Kw7|hV6B^tl&Mf=TwWE)lQLI5uIg_+mlR}fZYks&EKu8d`G;_S(AzA1V;Pw6
ztIZ2iwlb+`umbc|NI=2Wf^<%48BMv9p8=gmONMsMN1O@m>K5}B5zCynkoW+WUJYNq
z8q_3|t#pLS747MR@HFALE`$a0PS2~*kt#_-tB(W#ExK^u1;(?3Si*-fK(g?Q>|s%!
zE!`brnaSUaty9EzfQ}ttEVjigm2H}u1r3q_T$B7wQ@LY`++jr+HB7=&n^yY&mGkZK
zP^SOi_Z$r~n87fE7&AgfHI5Nw9HWq&Lek8j6dOvd+P;}F<9rrHDTgFP4dt6!F*A;#
za_G3*)=;5cZ4<RkCG%Xf-{-fl*YkS*cz(aXA9K48*LA(_nfrcU*XR8C*r9v$9ply6
zSM`MxV2>Qsr}zn{vbayw10U-rPh{1=WA)SG71I}&?b+AV4edMv6SDq~Kz6#_-nYa_
z>-+hLd_-ZsmY6eDAz(C*QJ6NbIN>;9>%=*S)WVwMFX9*z<@~*c-nxjr12+w1z{WZe
z9^dEFchcI=&Vas#l;{wqZw2$iAeZ2(V;D0A1>dR`86=9j(JVZNYOq3;taS*qxN*1R
zoCR@S2Za?24?T<w*!tv9?W3kn)@<tih(4zi5kozjK~DSKC1TeV;)if;UQ`GX6>Z5n
zFK;6bq_tS8Np8+uwak-rT_es2+mH((dDWpvX&5oBO*uGZXI^ESAW4C#rV0G0+c4;i
zjCc!F&SZN>`*m|~x;caCfl}i8r-5p!97-sRc625z0DNyC8G-JiHRo-rCZ1)VKgNdU
z1J&=$;%f0~{n~h>_9_*35iqOHhhu^32$!06|Ht+DFm`5LQYG*{q^ca_iPFFDM8|m2
zLy5=s=Ldvg8zqUl=iyWPrr7X1@MWAX<WJ0G2Zj*6SOK-?rRUW?MD0ZWk;grsS849v
z)kM!ormM9_g$=NyRmYoDA8J>J<t>L1GXn!M15}5v($!{~npB@&wd7nAJ5FoMilLX7
z9B+vWO+u5H3*tQ`6sil=1W(9t1=eyynxz{nV?e5fsq=W)W@6Y|`&hIZD&J>e8N=DH
zYt0yYweQ^XS(G|ySf7)esE;eElpAq4zWKaajfhpLWt<c;pZCfQR^r2KV0g1A#Es8_
zJDn2l{jk6<U-Yt`W|fltG*e6Ujot|5$c`Vg_tW-RiL(N*LGlypiabYsAD^`g_BVH{
zKNs)ch~1>G%HQ6o^0q#{;pWu-8+YsO*$r70+6{lR`}%`TyxBd3zk};3-;8?>@gIP&
zy>iyi?38MG@f-eMMOAhi*@w<Ll_;)Xvgcph#K`*S)bNX9X`e!|IsNs#T(LCwVb}2X
z>7WczkR&EZ=cNi`5Z-b(1C^5rIV<V2V%6@PugHDH;TsbOa?F$HroE)xOiV0AtK80Q
z@PfK4c{96WIo{$Rhs9ydbHY`|A~nal;NDQ5s^}D4`=TXRT#6KNO+|reVi{f?FG_>L
zajQ#>_MfE;`p@TB7SD9rmagoKom5Y8uv#^ld8{oe-r4CCI?}LbJloEsO&xPUe{yp2
z4nOhtXs6qY3zHt(V4YL`^w}DxGd%$npBh{nPpQy-8xNbEQCF?DtGlyW;eT?x%D*uf
z`SYg-?>7Al_s5`zJ1Oh%J6!x`{HwWZCcml2Z&obJ6^bd>C0}dB+nP_KHS?C%aJ7C?
z<{)h%7k|W)m_sMbn!1Ib(&}oRW=*qTxmp}c<973)=0{B&J^ks`3B|v8d<y9gT|y41
zmmRlhqKGMcBz8oM;>?J;gcv$f7lz`xWw@c(eGvCVD-;f;S0dq;Pgbs6KDBCl^DpO*
zzu$f7Yhqg!{D<?`|Gg);H+ZFTB=zz`#n%gdAp^UwT>sVP-R>*x9e*dcQ{N>PmUf`I
zkJQ<hdA91X278ttvl3nVSf5#$)ul}t*O&Sw19DZbpSFMcD)K(^fqFWKLE5a(-^1S`
zZcz_RP$>AmY<A?-u7~a0NABsWkUk9XW*v_eE7$KQL!#g#SidJ6&wihWp6FK_#tfZa
zWzar2e~k6^O~NbwD!=evYnHI}_kBC|=d%Wn=#qrLhgsRS8ZIZi(#4(_sF$?w=OJg!
zwJUfot*URhRLiExLW^JM^*1XrddJto?>KDR%44z*zdn~#+?2m@U(%VTe5ZkwK<$zM
zFLqQ2h#8Yst7UXGsfxe?Hm6kQ%`}7|Ux9^LO?BJ?y}(Qp1Oc#a%argi<ZJDmtEvwH
z6=McCw$SrRazq<ksO}pu(|7{R05e`daP&;uB4MCEV_rfpC7{dEn{E^{RQX}x;Hbt}
z@{H(}k@Gzpj>x@h)+MFbFl@fni1lHjL1k}gC%I%KrZ$B&9Hwdis#dsB85AFL(Pll)
zP?M3o(0Vkc_84D0sEg&fzwJQl!7`h4(0XZsI(XuahMgGfn&A)~o)4hJ=Ttj*(UIu~
z^3GrRDKzBWjuy)!+lkcLzn|&`l2Q#nsygfqo{3vTm^P$R47zE|4Ie_Z>jHNYGt*k>
zd8J`=FSl@-APp_`#!MR`QW5Ex@mzs7!2}Px4eKG85HQ?aK_V4SQ$C%!#Ejs|ixG9g
zhvd4;@1yD6J0A*#kFBgUt(>j<MiHY*e7~<+b952l8{kw{C54`()glU#We&)v@OG<c
z=O?3j1=oj0M%OQjPY9#w>nqNTj1HzYRXv;!>#=PT4%9zb%OLfiTO(w%ZtWNG4v8Y*
zQ*jQiqrPv2ks)ddX2a8uYF5w*cj&K{X8mg|fl~d(kJyiDAF+#*wLvJep)dPS#Vp^r
z)TmJS7k|Y17l*X%dSn|GGIH*h-fZaXwNCG*W(6q2azODe;!2Cx)<=)%AqUz*uXG-5
zYR-qyEsuV=*}1o=Ir3uYft6+=E$qNZwGcY+Zs+%4`>?BzHnrG;)ZD<w36}p+h+5oO
z$BK+%I=<XC409POUNUn0hyuLVGA7k=@n`F2>f=izj*GEY9%i|?##Oj1m4ZeUTvqPo
z*;TlnaE(0C()Ph%1ixPB*jEcS7g6oMh#A}<kjGc83w8Q|sA3a{NWFxI)I&rNint?!
zSQ;9j^TxY8(E<gj)JDRGq%aXaufD6r5`NUuiyab*oTaNtYOhJP-JFop5WuP`uR?Cb
z+Ukr$z{Bre+X8r%WuE-1s_3d^#^C{Gz|4(MqE|}P&Wuz`HerR(i>bkI)#tZhiUo;?
zlLTYACo;`j!T|FEq~@%kibb6YCB7ews^%Aw32nQq7nS&0R!bv!F^UI9wp((91#QQ2
znmC?kr_m<Ia--5pja>HT6Hev6iCx;QU6>l+Qsr{De^Knx&#~z%Y4r@F(g{^gsR{MR
zA{>PQR@!-YXE8`pS9I7q1szGEXldY^YCs*178`CHc}F?CX(ZR8rs+(rPETRYlcaC4
z%#4M^{2n9bQu0!EnNeT|Wl80XrWv>f2Ro}GBi7=w%lINY)?{vaPLp!XeHfg)UI7E~
zOMUnHMvRi=$4q8{I4YjauF+g)6n`vZ&DkXq^}c()6FhCEKKLipy`!;qC8<N~DUZAW
zmy1sKNurn9wZ6qYvDRlb4{H$87%FDkYj4@xXA^07F`pq)iQ!bJ$Jg25eeTWh2)JRt
zWXENRcdZEqqi2Q65vUfhlIwUGyyRLIMu?z8U^bdS_FjHEkP4(2J=@&fu|J1rnX2R0
zU*z)!|H;)fCCDq_X>iDadx6~x5kXD%?+>(`XNHii?=V9xFZ|V7doPrk{!8cNQrCU`
ze}B!nlGKn|A=`J*c1FJW&`wZUsG@V}MChoaU&xUE&4DFfbMg5eqtX$I+%!RYzsBsa
z;$3Kq{hkAg6)>?CE$M$<c^9F?S3z;}kwJ%_yW8oPeuQ2|m$ZBfS;DSzAWR(!*ie>C
z;x!bKWvV&cvm~cJTJ;aIT?MnX#hsW@chiAIE^o~Sz3VQx0&DqYhKzwS^v3J&1re3B
zj4T~!7J-y7xw14GEPsJV9C>50F+*q<KXIU^$7kpGxY)GjQsB$O9v+W#oXKRfx7VdF
zS$<`2{;K#?7LvVc?~`Z`jl->za~loMzB7;f@Zg(oN5?_KEufCULiT8+@cDs+)DyQ8
zj;7x};7**)y-W{obm)xP6I<1GzAf_IZbkH-=y%4SR_=TyfBn2a`j1abfOs<sVApX>
zeZ~N03KuxQ2!>sU)fO;<U>9+Lg^XZaFlNG@Q3wv>28=?@N#TIC{c3HTyLiJS&f}PH
znX!zbp(x-cni655^-JwwT%Z9%9~X?G>M_16yA0?k8mv|y1XT`DZ+pj2L|n8>ym!{h
zU{SOvQqYZOU5+WKN0?)4`j_zci|wMg3+Ieikn5BbJ?_$4ll^xb@D@txdv&9K#?)8T
zag=VU!zKqjeTsFXCo<hXW74dDT{i>dp5fH_vfJagUy#yvpCnjOnYnONOgV{}OOZ%c
zBTQHlz8X4+t%bm1%Knbu_)Kg5I1l|4oab?|;wkj9DaQ;)VRSJnJ$YKlZ7Vo)$vX6A
z0x<iaot5D|PZW~%l64AM{z%`wa>r+;0q!5~zxFR*xc|&=e*S(@k+<iw*nm&vuao>-
z8~R@RfsAv>$G9<#Y~0hX?!wc|1&Pem55X&uFcAf&aL>Mm^?qb`PtgKG^jj>#a6!{T
zX5A<HO%q|{h@%ANC9?uSejt;<gCr<~8Xjli!=QLtfPV_Z!ZTb|M^8;pjXGngr$*4x
z!;x6G#YZH6pq`+`vP47D2`^-zSAVpghMop>#)2wY2hYrymVkV%K6UIhoSlIR>T%{1
z>@~?BS^6L&b^6G3b|z@RZB|}nXBmOJEh}H9I$GS#SkVI+V3I#%ebd?4t9pA@z?kvd
z;w%M-VPpIV_RG{w8K}zZCixvTv@e&iRk^&%4stG+oHH;0xD`~uO_Dk=i53_Zdc8F-
zluIF1x+2zah1d#idtu#n9)B5!YD7cpSS-UvLvA?=7ORFpkoO0(9kkgFf%GXhFyT#v
z281Lm-?-cU7N}f0yy$aKH3-e()V5`$fWWL)Iy@C*(bF@IAm3wN5MU&l`(^?|eL=Z?
zPn#UX$dF0*BAu5$0etJbLVy@^Rdu+H$a6-{TIS8%1oA-T7L42*Bg+*qJy!@l^t}3p
zFtHQS%P#~uzY{6d<_2(@t`cAb!1>)>6_^}PWB>u5gAtQxg6)`>5<4IdC`F1oErKib
z5~wi)X-)LJu4bb3E}|lDMhMiN0ba+T$>2=QOjTrQb0PUTucL$ft4U;4__OB1%BK^}
zg%>Dbr(ZHLGgH;sDK2z8N%97@i74KcYv5HyvYQ~zq?9|ZUcr6F(iyXM^J}H~p}8P%
z4&AMWUVV8{sLQMu>aE=f%)So6u|oKp%ZpQHl0>r+RO3jZqBf}dEB$yiwZ8gzb$xv`
z>M@uB43Mb#631X?OxLfGO!r55d4_wrPrFYG!oAXVC*KC;xq7i}U^;<xKfOJDnrN~3
z$n+7#be60y%UC%*`rQ9uXUo}q4P5Q$GHo-VSA0sbOmkHrZYrmRcZ*>&W^Zn8W5X}0
zx}EGtdL^`u6gY$<5%FS?MNX_)mgeKbVs2gPega%yVYmP7?hMLA-0+lbTtv?r3vV|y
zuYphfoJV2v%N8&{!?i})!(&`V+NPFGsg{?X&sNrcW6QR+nD_#GJ>v`t-@)~N$Q9g9
zB`o_4mbKb(^vqmx->2D(pxzFYWtm^tc4oIl)g4RsW0aIK%Grb7I8%+KvEG?NidSFn
zdDpckruV4YZ`y|1qj8Y)v8>p4L-rt^=Jwq9xap*KnfqOnpLWl;zpWXlURgL3rnmje
z<ifMhH`{#=l}C2QmNh?I(sJJX^;oBsT<UH-uuA86x4v5J!=Gq{Ya4{KMQ1Fw#xD4|
zOWQpHEpCtO<$KeD^ys{j)t*CvkwxpxutY=nwEc1Wu>r$CFA^CNl`$3>p>8%hYg=WB
zwT3Dx&`lnO+3<5U4WHdNqgJeKSLSo}P>e;?X9~eYOXbDJ%FMgY^`4Wa<5w%Ms~_-~
zLB^=w(!Z<uV~+7azr+sHbJDnf`yp$!-J^F*SWXjv-n=zj=HvJJ)W0+@y7O;W=h}@o
zoNmmV+5Fo5&uyrQJHP$uHBRw2PdQoReZdLaubNBty^&ekc-Gyt^w!<U&96_r{qfe_
zA3sh!+Hn}2e2?RpJ^ZVImv>ukNox4f7_F)!-lY*W%mh?bvbRt8jaNC8{@#I+5NSWE
zz%+Ko<{l=I>9`dh!`WLN&V>8m#nVDGvUqGA0pX3hpI0bzv{Z%WGGQ`PDa%U7F)=Jz
zPM-U_zRG@M4a_o>us_7PfbbETA{x#i|NX(5bJW?LQCmbU4JSOPSq^^if!T_k3pkk;
zlJ<V?%d6?W86NXWT5x`zd|K-F$ygIxz5LzyFJp~lPlZnUKye;Q;gX)I(3{g(HTPg8
zZO&z#$|}vnGjnMt-mav6S*rO?OksU^|KP%$MvdN_LRT~U%lrE$t&-<leyVXySM<GH
zdj3W9axSg?r9yM5y&-Nr$L0*P%Jyi`z{W5+Ij=!0;nx1E3__^?!RvO!>$b95O7dY-
z;*b_vPiS+*Py%(AjCU=V!jZL<P>n$R7{6IiVp>CGtXWm3of}(DnZKt>jttE6@l*Za
z;B2fJ<g&4D{6H+nXsg{}GaJWpoL}H2b+tIcS-UmmUOFBH7a0s&17EX1+-q}BQ>ylk
z@^O6Qj@+i#euR8+*HNltL#n5mwfO07PEJ?U`l6y&8S~QGrtU38d8iMhXlK2mqWrF8
zFE6U&>_#U&?2s4Xc@PaVF}6F;OENEgof_pl<7!xxpYd65fT|$Wf3hN-Tl&(m`ka+`
z|A;cw3NFf+*F6Vu`gE-kdb%j?7>cjWVAzc8uq|gGP+WEnP7hXfo$QuOu|lCle3OV}
zG!`)OflK}ZEK^CJ{S8c37NDfIFvhvNQi~`0O&wFGE8xq(X9XAOirRSzkcJ#e!?Fy-
zMg;B#Mxo#Y74AZXJ9>jq-89cU(fK@4wVNYy0m`t1A3?r`@+`f4t`NQ0VRSB6yDmgq
zsnV)(&kqFVa1XMzF_qrjgC}9Vfa1e}LqNJq8o^8A0R>&I%dlF8Ho?cRt_t`|<u&Mw
z^vuY(|1kM<-P(yzqS`=OV5DVzhb2-Evo5bOO&%C=A$IS#$`D;0%?c3N7voyPy?Yp&
zSzu+&Sj7Fw6msj86-a>ckVbPiBfzu)i-AAY<s!Otx!2(j!-$-Q5Ltj%d<*?Uq@|ju
zdcZ9zjOey8?<ueha*_A|>tJH$K|1F~2yvzhDBJa2t#mc%d3dU&T7A=1OL>!0%~7f<
z+H%iySuxO3(md0rjWIw-5#}ya)0I?s+K8YA*YoGDi8<Y`UZ56rL+bvf5pW5ZutG>@
z#f?_iOT#E}*(4i-Wfq%t8&w&;E`={Amm{&KOC+x#`*Pe`1a?%(kFlE^0@shPm+NwG
zLK@5tRF`fVln(F523kQXtVsB{E^`ALPms7u7@ndHKrJ=_tkGwS65kW#h~Iw)`fr#S
zAK?4qY(IvZ1HD|PApwq#Xc<tav<NbFX)&f6OVX{4;Hog&mD&~jiEM2;fMy@~k`vf;
z1usF=DO(FmQt*<byWm5-82A%j0{Hw;zSaWYKTxoBa@1eSQL4R(U-k#b-pIUcopMOj
zMHbB3GAG|OtX*?CfDI=KtdNX4EKc*Upeay`^aM6dR|x%us>Zs4ClFe}V)AC1%n2dd
zrQzCjVZbtbV<!+Y#LmP_w~$a-0I+}zu=fn?hzcdnG_?%`s6N1y6iZwc3dsh*^8{O_
zjaLB5;QjY1K&yoMPiX9avK9UZ`>mEWD+wPIgO}>-nzz~!nDwQB)W%-@M{i<mgh7^P
z_XuJb9}4=0ud;+6TBgN_HwIp;y2R1gBTm6(puZvm#Khep5<-bPb`W>$did%)k&Oq&
zi#kJ^Xaj_h>(++DAEUaw1zUi*)zK5o8zA-|eYS9ukm<Yws9Gz40Yao)ezh>!T43L}
zDL6?GZ2-m``4&tO!H|}mizx;sA6J1A-zJ02(C^5Y!mVcfOJmRz(}E-bzfw&upn^$&
zOqwQ04a5d3gf8?)ASOZ21&K7aw#0$pDxuJzB=ENIg>QIf-M)LSx0nhkZ7Dg?9OP*v
ziMKkTyB|Z3=E!_AP_rRBs@{i(y{B7Nn&Md{ZW(Hqlo{=Q_;uFFrVm&d?Z?7RTk&D4
z;!_xrx4W%?LntYjCSm$%hGb&}mI@-bJwUm*C6yAFt_VHw*fc521do7La3oJg4j-br
zN<rf13ZZ6M1DIw1^EXWv?2}mk1K~f>%~l%;JI3#g|AuRSXf_`p2v4Q<)G93I5B1f3
zVUKrTYr<-PHrnq-wf5;>f3<B=abIj7?|uxGE#I$Qg%NHvuAC3Jc2;B_sH@^mU!^%R
z<UVbbshB3^ORRNh1h-OMLXOZemyqU7WzJZ62{;zsR3yj3hU#vuMabci@>B>MiVYRk
z?~_N!sU6Nmd-`}&Wd&Y*D#g(AKMm1@oGx#wfMZ1_uu`;?ooLT+Z|X^v*oAU(Y=*;j
zh2k-xBV93VuzH1%)2%`E+#?;%!R7P{IO_;GHHe&cJdNOPtta=UvXuC~qeMtsp`ZQ=
zSt}rpPd=~159j}V!xLmea)Fn`S{r-=`0<8F;i3=`0bEMQSda*EQHI)^K^s}LOI)q?
z$#zM{jL7ZGnW}%0TUtmyZsEQHy-JS>7Hy1TDq{LA0N)V~LJASnz`jPxVX*PC92raC
zAu&O#NX2Ls0gFaCY)B^Au<oM0ajY1=A$6IGAbAP`^9YO>G(Hy%(;=~9fMG_Qt>9xA
z7-5V!i{L^{jsfoa8rfp<qQ`^2d%zeHZImt<PM06+l>w`WBD?DU#`hnf|LcUua_nnR
z2O3^cfs0EYe^e!oyC_P@K2Ls{!g6VK>?_La>lThA^5*Q`pZnOr?f^+~Uc8B_omtK*
zy08J((kfHGqnh+p$5@8pDzMMI&#=#O>*PE^5RPddZYy!Y$+u)|lKxA2pYKSUHWvH@
zE?qIp<QD`5W|<}{mf3}a(Y%&)K`@$Po8iiL#jFtIw%wZF_%5_@4y+}a!#Yr6&&)%H
zP<cdYKjtbSiZ;G4xj0?EWtpsyTbmHk=E{#aSMHU}kysJ}Iig2yxe_`bPZcWheQsE>
z`~sg;7Q*=XHzuX`&*VJ5HhLX8A5GKMxC5ylN6ov_$HNGYaIlH`xJM@Q$NfR$HthJ>
zkJ#~wqYpOSh~-{iGXG=rk^IN3JE%YAjxT;hC5-DtXVzR5Z-IaV3)U>oj5#9MI)JIj
z?@Z1O?|k_f=Lkz?iyS?rMg%&@j0o?+(G6OuVJ@Vw^-<I?+8%Kx=RX@u(rzCrm9)2D
zDhe*I+?0E^?(PlhCb@6<lVD=b$9OALOG^0|A2j|H*xv;BLr;EH$k-sW2~8}z^xwc&
ziL;es80^zCmNpWRstp-0ArVNeA#dy@7RV@rhrznua{to5JHZ82*R~F+KTQ=vED9Qe
zv&{FxH?ly<aEJw=SPVOaro_S%&EOE2{ZwSQ7np+>Aq&TRf`;j$OE?5r7Qvn3C5Xbg
z6%l}UOI$#eGth=4xfdTtVrx(1amfrpG?=q|j6R>lKpPR<*GsHOGEi<dSIi})=?k{Y
ztygex3WKk?LNL(=*7*}uUI9t42h-)n*W|-HKCp#9<TXd6jSkFod^mG%bKK0|`M*y|
zhaf4mFFC|f`+GGs7cV`HeG{i}=!+d4c(wk_SkE4t4=27nUut=@b#yR#{b>X9`z^#X
z1wDHfMcv1tp0M>q5d8e(HQtL}K~kEH%v-Un@qOO=Bl#rZjx0_Vw?I}wyP=tAH;fn~
z0(8uT1PvSExCEYn#Ts^%#cC=rFJ#W2g@tmP&k}|^!-PZ`HY6j-U`e|(PSD^4K1MW6
zG8VAp-Z(Nsz!I>;B_|1dUfV7i=c)BxLO5X;a7@$FF|B-12UW%yqakTv*hw5uZi6Gk
z{$KcVp?K<TIu!_Fl0vXGOMqj<k}3>T3oZ{+<N372{-Cv&;=p=p7p7j{{yo0!cf0UN
zdefxk*J^4@VbhcP4!V4cAUQ_{bbEqQ?T<&xy#>j|0_GN8EH(<8486wgfe)gDR!oF&
zEsujL0lf1hKxbN?P-jHQFvT(;sjf(f60U`@uoT$1Rq|RMIEj=iSuSwvCg(`ZF*V$S
zf+P%()nw}Pp4=pNQ|e{{V2%<~s)+$czD1S;j0`mxP^l+ZmV@CIW5n8d?IGINh#X~o
zhS-;@>eXJ`|EM0jJ{87<KL1&(UD=GB4<&NCfS0v3Y)NVa^<U$<x}3PgacK|#ZR1eu
zLE>YlU~XzK7Zt5r0E`><)7o6<xpA_9nv9aH(}Yz+$ry%IO_-|+C~QeCMigs`KlKPx
zkt-IMN=!|^cX_r3EaL<mEw+}HyD3e^R&^l(vk2${OHd*3@c}KH(e7@Tmta-CT)~-`
z3w(S(r7IreOn_iWTPC@0SB_{UxjT9a&L|Y%wrLDO4RDg7cgq=Z574+<0`Dl%U=%s!
z|Ap^=5$XTqNan)BkZlt@$8b1HqY`i-l?p(z5zvog7`PC{@|&JoSP((B+^r&As7hoM
z4iAG`VSCc8U{)|0i;pD12qF<159)A}JSpO3Dg&@01Vn;36fpuXWf`GiXo$gxl@1G7
zWEe?YipaqX+rX_6RhS{ZDb0ignhiCmXh&;IEen?%gNBAy2yO+WWP3iw3#@1*5eR3<
z@}(lGyA>5I{&cyuLSkVp7AOe<o<m^8<J`Dj(jh?<Nr~?W`NQHb$OC}|)~CKOpx!?N
zWo+Oo4|PYa*OZiZ)9FEfU5MVXtzTHWZF1kYWV-9~hd+PmYTG8si#}wz=J<i=V5<Ys
z&BsH7mP8Nl1j*KHdm416%WK=cR9^PCNnY9OZPlc06+JyT*B3Zz^J{XS{ya&6Z*o<x
zD<9`8&NAI8F*8k<)klp4OH6O|wvx78z^xu8ZL4IQS<BXnlH?wiGtR6R-95Z|RDmX)
z;^TZ|wpxBZpZ@)FVny+k%JE_J7lTH*XMfGFD+FuW3eK8J0Athns)xmbTmN19{13d>
z>4twCG&ilvzOXYYI_>928v~5Dq`c$oG%#)3l=g4@>8C&Yb-$rI%w5sXRD15Yv|4Q&
zQBWjHITr^vbh|V>N*k8Wpi?xmC$q9oxdrUp_-mC@`W5T3yE)Z8r@h#+;Rmmdx7U5_
z{ifj&<g6$)bhvJ>5SLclC_XxcbkIVr&JqKnepYDOlD|gXy-e(J*cI1d^)n@|FRn34
zf3)IxQ=lm<?&7_yXky&by{IYu(d(eYAqw;lM$zN`_r(K?YM1t2jyUAspY9|9d_5l!
zb}Z*X|KhLn)SifkJ}0<@zwG5yH<|xBv12oR`>m|w&phrF?QEN?zuvnkY2Cgm_GXKk
zeASikH^+bL-Wc}d$;Im@3%KulCE3T@?7}pElDbU|4t%qnj5k_ub#pA2IvNt>^o_jK
z{pW`FFX;QfJl}t*BW?4V^$ibjUw-||RwS(X!>Ho&vf}aL;3FdOn^S0Gf#^ZZGsJ-T
zy>0#TAMI4wD(lSd<F`MkP*;EUOnhoCW^mr@(s#GuucfLF9w2RBkE6GLeVAuHj;ML?
zu=fOc^Yof;8?kMExSCt%&3fzb(l!;DtJ|_xNg*QDK;#6g$FbV9O;U8HZ*R?>IKn7A
z#dyC#bEy=!aa^#LbjE*mS<@q}%qSuj<LN=8A!3oS@DBIGdo?fE#a5PAhJXUc?NgZ}
z7KLyJ1I7v2!%|bvQtd*!`Z1TjVQqip!y7?fRL=mrS6i*>i*3gJk>f!VzB&!B{2e>;
z8S<Y6<B_NHeEod~t0TOO_4IVJ*82MU`%RVa^3+6VwbYrItd4JDFsws&AmD;2KZZy=
zx(<iKZ9U5riF6|@wjrV7bDgT={?*r?l56j7D;Udx8^)KK<0AL|Ib<8|V3=}xZz`@#
zpso_&JfyQ&7VL-WQ{t;2A4$CcZ8AIEH#N`-y<}wad>5}5Y}>A~+o<ve7NOUfvnKVP
z52R&!;C%1#-*R^ywk95MItc&ioc=ZATPNQ9toMG;+)qW}Z;C<>`rC)>;Oo3Ij;BAo
z6@BUW)?=}Ep0C~d+nLbQdQL7E!f!<G(k~dS8E?i8CjaD7vg^)^bcOTiUvcB}0=L2R
zOZHcv|J*9;b8)`E)IDT%Xvpfwo#)qr?wIyi5Vh`PU$kjjC_@DHC7gb}&VS3^N7e1h
z0ZF@Fkf&e#c>cZf-@l;c-j+xkSO16Cx^4Tq-#dejA-ZMAtaIF@gu>sV9;5$u1pi%A
z^nal2{xeiv!xjC59Ztmo4@(#>x0Bcsp^Xf2Mm!lt8^K|G#_aC021=SqFb`AwjFvx#
ze!Sd9C7OQdxXttLlbunLFOmB-OP@RVkP}@VM_ibB5Ze5P9wS#zXc&2y;o`GoOAi@s
z{9HO)6LEd6b$j@!%O8H(OU2)qYz{ht4~&4nwvfnTN>PmO+ALOv9k#YJpSOYO)SZ-=
zHv9IM5gj+rG;5F82#ixnaft2hLpvQr*=Hw1l=QiSYQ1m)6}M1yP79W5$13<}YWDWT
zFVW_aS!Yt-v@w6p8Kp9|YN9WO=j^bmA(ds9HgWgXZ|-%u@y0eW8hI(UDRGbGWXS6G
z{hty?1BLwue?8RZp>CXKJ7KX}MIaul+!fgLDP<(I^vdrQH^ueWS{iu4KC1evbNP?y
zW@Xv+U&LPp`x-q<`vd3~bRTZ++qX|K7ASUuJG=gVp{eFk`Zs5PU$5r}6U($LFlVtr
zp1!JDocMz$70b^q1~|(6?w+wFCas{<@>B}d@^X!vyM$LQ?{RuYpt>EDw1+|e@ZWzx
J`v2<We*r_Fk}&`P

literal 0
HcmV?d00001

diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index ba6c001..0b78d39 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -72,6 +72,8 @@ fn load_rules(mut phase_res: ResMut<CurrentPhase>, settings: Res<TimerSettings>)
 }
 
 fn tick_timer(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
     time: Res<Time>,
     mut phase_res: ResMut<CurrentPhase>,
     mut finish_writer: MessageWriter<PhaseTimerFinishedMessage>,
@@ -94,6 +96,10 @@ fn tick_timer(
                 };
 
                 println!("Phase ended");
+                commands.spawn((
+                    AudioPlayer::new(asset_server.load("sounds/beep.mp3")),
+                    PlaybackSettings::DESPAWN,
+                ));
                 savegame_messages.write(SavegameDumpMessage);
             }
         }

From ccab27b933900804140d36e969f950b1ec7a8b47 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 17:38:25 +0100
Subject: [PATCH 42/71] feat: Prevent player from being trapped by planting

---
 src/features/pom/mod.rs   | 14 +++++++-
 src/features/pom/utils.rs | 71 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/src/features/pom/mod.rs b/src/features/pom/mod.rs
index c8dffb4..ed55560 100644
--- a/src/features/pom/mod.rs
+++ b/src/features/pom/mod.rs
@@ -184,7 +184,7 @@ fn handle_interact(
     }
 }
 
-fn perform_interaction(
+pub fn perform_interaction(
     mut pom_query: Query<(&GridPosition, &mut InteractionTarget, &PathQueue)>,
     grid: Res<Grid>,
     mut tile_query: Query<&mut TileState>,
@@ -193,6 +193,7 @@ fn perform_interaction(
     mut commands: Commands,
     config: Res<GameConfig>,
     mut session_tracker: ResMut<crate::features::phase::components::SessionTracker>,
+    mut notifications: ResMut<Notifications>,
 ) {
     for (pos, mut target_component, path_queue) in pom_query.iter_mut() {
         if let Some(target) = target_component.target {
@@ -202,6 +203,17 @@ fn perform_interaction(
             }
 
             if manhattan_distance(pos.x, pos.y, target.0, target.1) == 1 {
+                if let Some(actions::InteractionAction::Plant(_)) = &target_component.action {
+                    if utils::is_trapped((pos.x, pos.y), target, &grid, |e| {
+                        tile_query.get(e).ok().cloned()
+                    }) {
+                        notifications.error(None::<String>, "That would trap you!");
+                        target_component.target = None;
+                        target_component.action = None;
+                        continue;
+                    }
+                }
+
                 println!(
                     "Performing interaction on tile ({}, {})",
                     target.0, target.1
diff --git a/src/features/pom/utils.rs b/src/features/pom/utils.rs
index 73ad8fb..0658684 100644
--- a/src/features/pom/utils.rs
+++ b/src/features/pom/utils.rs
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use std::cmp::Ordering;
-use std::collections::{BinaryHeap, HashMap, VecDeque};
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Node {
@@ -29,6 +29,75 @@ pub fn manhattan_distance(x1: u32, y1: u32, x2: u32, y2: u32) -> u32 {
     x1.abs_diff(x2) + y1.abs_diff(y2)
 }
 
+/// Checks if Pom would be trapped in a small, isolated area if a specific tile is blocked
+pub fn is_trapped<F>(
+    start: (u32, u32),
+    blocked_pos: (u32, u32),
+    grid: &Grid,
+    get_tile_state: F,
+) -> bool
+where
+    F: Fn(Entity) -> Option<TileState>,
+{
+    let mut open_set = VecDeque::new();
+    let mut visited = HashSet::new();
+
+    open_set.push_back(start);
+    visited.insert(start);
+
+    if start == blocked_pos {
+        return true;
+    }
+
+    let max_search = 50;
+    let min_safe_area = 5;
+
+    while let Some(current) = open_set.pop_front() {
+        if visited.len() >= max_search {
+            return false;
+        }
+
+        let neighbors = [
+            (current.0 as i32 + 1, current.1 as i32),
+            (current.0 as i32 - 1, current.1 as i32),
+            (current.0 as i32, current.1 as i32 + 1),
+            (current.0 as i32, current.1 as i32 - 1),
+        ];
+
+        for (nx, ny) in neighbors {
+            if nx < 0 || ny < 0 {
+                continue;
+            }
+            let next_pos = (nx as u32, ny as u32);
+
+            if next_pos == blocked_pos {
+                continue;
+            }
+
+            if visited.contains(&next_pos) {
+                continue;
+            }
+
+            let tile_entity = match grid.get_tile(next_pos) {
+                Ok(e) => e,
+                Err(_) => continue,
+            };
+
+            if let Some(state) = get_tile_state(tile_entity) {
+                if let TileState::Unclaimed = state {
+                    return false;
+                }
+                if !state.is_blocking() {
+                    visited.insert(next_pos);
+                    open_set.push_back(next_pos);
+                }
+            }
+        }
+    }
+
+    visited.len() < min_safe_area
+}
+
 pub fn find_path(
     start: (u32, u32),
     end: (u32, u32),

From 2dcf2cd133a03868189625d5496c09d45252187d Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 17:38:38 +0100
Subject: [PATCH 43/71] test: Add integration tests for trapping prevention

---
 tests/trapped.rs | 109 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 tests/trapped.rs

diff --git a/tests/trapped.rs b/tests/trapped.rs
new file mode 100644
index 0000000..c5c38a4
--- /dev/null
+++ b/tests/trapped.rs
@@ -0,0 +1,109 @@
+use bevy::ecs::system::RunSystemOnce;
+use pomomon_garden::features::grid::components::{Grid, TileState};
+use pomomon_garden::features::inventory::components::ItemType;
+use pomomon_garden::features::notification::components::Notifications;
+use pomomon_garden::features::pom::actions::InteractionAction;
+use pomomon_garden::features::pom::components::{GridPosition, InteractionTarget, PathQueue, Pom};
+use pomomon_garden::features::pom::perform_interaction;
+use pomomon_garden::prelude::*;
+
+mod common;
+use common::setup_app;
+
+#[test]
+fn test_prevent_trapping_plant() {
+    let occupied = TileState::Occupied {
+        seed: ItemType::BerrySeed {
+            name: "Wall".into(),
+        },
+        watered: false,
+        growth_stage: 0,
+        withered: false,
+        dry_counter: 0,
+    };
+
+    let mut app = setup_app(
+        2,
+        2,
+        &[
+            (0, 0, TileState::Empty), // Pom
+            (1, 0, TileState::Empty), // Target
+            (0, 1, occupied.clone()),
+            (1, 1, occupied.clone()),
+        ],
+        vec![(
+            ItemType::BerrySeed {
+                name: "Test".into(),
+            },
+            10,
+        )],
+        None,
+    );
+
+    app.init_resource::<Notifications>();
+
+    app.world_mut().spawn((
+        Pom,
+        GridPosition { x: 0, y: 0 },
+        InteractionTarget {
+            target: Some((1, 0)),
+            action: Some(InteractionAction::Plant(ItemType::BerrySeed {
+                name: "Test".into(),
+            })),
+        },
+        PathQueue::default(),
+    ));
+
+    let _ = app.world_mut().run_system_once(perform_interaction);
+
+    let grid = app.world().resource::<Grid>();
+    let tile_entity = grid.get_tile((1, 0)).unwrap();
+    let tile_state = app.world().entity(tile_entity).get::<TileState>().unwrap();
+
+    // Should remain Empty because planting was blocked
+    match tile_state {
+        TileState::Empty => (),
+        _ => panic!("Should have prevented planting! State is {:?}", tile_state),
+    }
+}
+
+#[test]
+fn test_allow_safe_plant() {
+    let mut app = setup_app(
+        10,
+        10,
+        &[(0, 0, TileState::Empty), (1, 0, TileState::Empty)],
+        vec![(
+            ItemType::BerrySeed {
+                name: "Test".into(),
+            },
+            10,
+        )],
+        None,
+    );
+    app.init_resource::<Notifications>();
+
+    app.world_mut().spawn((
+        Pom,
+        GridPosition { x: 0, y: 0 },
+        InteractionTarget {
+            target: Some((1, 0)),
+            action: Some(InteractionAction::Plant(ItemType::BerrySeed {
+                name: "Test".into(),
+            })),
+        },
+        PathQueue::default(),
+    ));
+
+    let _ = app.world_mut().run_system_once(perform_interaction);
+
+    let grid = app.world().resource::<Grid>();
+    let tile_entity = grid.get_tile((1, 0)).unwrap();
+    let tile_state = app.world().entity(tile_entity).get::<TileState>().unwrap();
+
+    // Should be Occupied
+    match tile_state {
+        TileState::Occupied { .. } => (),
+        _ => panic!("Should have allowed planting! State is {:?}", tile_state),
+    }
+}

From 5106561503ebdf8e21f3c4f2685fe1dcd2dd1fec Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 17:46:27 +0100
Subject: [PATCH 44/71] docs: Change `//` (regular comment) to `///` (doc
 comment)

---
 src/features/notification/mod.rs | 4 ++--
 src/features/phase/mod.rs        | 2 +-
 src/features/savegame/mod.rs     | 2 +-
 tests/config.rs                  | 2 +-
 tests/pathfinding.rs             | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/features/notification/mod.rs b/src/features/notification/mod.rs
index a639706..29e3c8f 100644
--- a/src/features/notification/mod.rs
+++ b/src/features/notification/mod.rs
@@ -17,12 +17,12 @@ impl Plugin for NotificationPlugin {
     }
 }
 
-// Spawns the notification container up
+/// Spawns the notification container up
 fn setup(mut commands: Commands) {
     commands.spawn(notification_container());
 }
 
-// Spawns/Despawns UI elements for each item in the `Notifications` Resource
+/// Spawns/Despawns UI elements for each item in the `Notifications` Resource
 fn handle_notification(
     mut commands: Commands,
     mut notifications: ResMut<Notifications>,
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 0b78d39..1a63fba 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -107,7 +107,7 @@ fn tick_timer(
     }
 }
 
-// Rewards the player at the end of a focus phase with `berries_per_focus_minute` * `focus_duration`
+/// Rewards the player at the end of a focus phase with `berries_per_focus_minute` * `focus_duration`
 fn grant_focus_rewards(
     mut messages: MessageReader<PhaseTimerFinishedMessage>,
     config: Res<GameConfig>,
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index 347cf06..3be631f 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -174,7 +174,7 @@ fn load_savegame(
     }
 }
 
-// Resets all components/resources loaded by `load_savegame`
+/// Resets all components/resources loaded by `load_savegame`
 fn reset_savegame(
     mut commands: Commands,
     grid: Res<Grid>,
diff --git a/tests/config.rs b/tests/config.rs
index 1ea4a20..b046c1c 100644
--- a/tests/config.rs
+++ b/tests/config.rs
@@ -3,7 +3,7 @@ use std::fs;
 use std::io::Write;
 use uuid::Uuid;
 
-// Helper function to create a temporary file with content
+/// Helper function to create a temporary file with content
 fn create_temp_file(content: &str) -> (std::path::PathBuf, String) {
     let filename = format!("test_config_{}.json", Uuid::new_v4());
     let temp_dir = std::env::temp_dir();
diff --git a/tests/pathfinding.rs b/tests/pathfinding.rs
index 4ddea09..4df44a6 100644
--- a/tests/pathfinding.rs
+++ b/tests/pathfinding.rs
@@ -4,7 +4,7 @@ use pomomon_garden::features::pom::utils::find_path;
 use pomomon_garden::prelude::*;
 use std::collections::VecDeque;
 
-// Helper to set up a Bevy App for pathfinding tests
+/// Helper to set up a Bevy App for pathfinding tests
 fn setup_pathfinding_app(
     grid_width: u32,
     grid_height: u32,

From 70720f82e21bd105654d58e038e3a8c35c4585d0 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 17:48:17 +0100
Subject: [PATCH 45/71] fix: Add `berries_per_focus_minute` to the config test

---
 tests/config.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/config.rs b/tests/config.rs
index b046c1c..066c5b4 100644
--- a/tests/config.rs
+++ b/tests/config.rs
@@ -26,7 +26,8 @@ fn test_load_valid_config() {
             "shovel_base_price": 10,
             "shovel_rate": 0.2,
             "berry_seeds": [],
-            "wonder_event_url": "wss://pomomon.farm/ws"
+            "wonder_event_url": "wss://pomomon.farm/ws",
+            "berries_per_focus_minute": 1
         }"#,
     );
 

From 49302948d2036992ee3e8663f1f9ea9e8ec74952 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:12:06 +0100
Subject: [PATCH 46/71] docs: add documentation to core, config, and utility
 modules (#65)

---
 src/features/config/components.rs | 4 ++++
 src/features/core/mod.rs          | 2 ++
 src/features/core/states.rs       | 1 +
 src/utils/path.rs                 | 1 +
 4 files changed, 8 insertions(+)

diff --git a/src/features/config/components.rs b/src/features/config/components.rs
index 1f3ccb8..f1c5076 100644
--- a/src/features/config/components.rs
+++ b/src/features/config/components.rs
@@ -2,6 +2,7 @@ use crate::prelude::*;
 use std::fs::File;
 use std::io::BufReader;
 
+/// Global configuration loaded from file, containing balancing numbers and paths.
 #[derive(Resource, Deserialize, Debug)]
 pub struct GameConfig {
     pub grid_width: u32,
@@ -14,6 +15,7 @@ pub struct GameConfig {
     pub berries_per_focus_minute: u32,
 }
 
+/// Configuration for a specific type of seed.
 #[derive(Deserialize, Debug, Clone)]
 pub struct BerrySeedConfig {
     pub name: String,
@@ -61,10 +63,12 @@ impl Default for GameConfig {
 }
 
 impl GameConfig {
+    /// Reads `config.json` from assets.
     pub fn read_config() -> Option<Self> {
         Self::read_from_path(std::path::Path::new("assets/config.json"))
     }
 
+    /// Reads configuration from a specific path.
     pub fn read_from_path(path: &std::path::Path) -> Option<Self> {
         let file = File::open(path).ok()?;
         let reader = BufReader::new(file);
diff --git a/src/features/core/mod.rs b/src/features/core/mod.rs
index bc0e573..cc979a0 100644
--- a/src/features/core/mod.rs
+++ b/src/features/core/mod.rs
@@ -2,6 +2,7 @@ use crate::prelude::*;
 
 pub mod states;
 
+/// Handles core engine setup like camera and initial state.
 pub struct CorePlugin;
 
 impl Plugin for CorePlugin {
@@ -11,6 +12,7 @@ impl Plugin for CorePlugin {
     }
 }
 
+/// Spawns the main 2D camera.
 fn setup_camera(mut commands: Commands) {
     commands.spawn(Camera2d::default());
 }
diff --git a/src/features/core/states.rs b/src/features/core/states.rs
index e14ed92..8ae853b 100644
--- a/src/features/core/states.rs
+++ b/src/features/core/states.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Global states of the application.
 #[derive(States, Clone, PartialEq, Eq, Debug, Hash, Default)]
 pub enum AppState {
     #[default]
diff --git a/src/utils/path.rs b/src/utils/path.rs
index 22d3cfb..c65cf2e 100644
--- a/src/utils/path.rs
+++ b/src/utils/path.rs
@@ -1,6 +1,7 @@
 use directories::ProjectDirs;
 use std::path::PathBuf;
 
+/// Returns the platform-specific data directory for the application.
 pub fn get_internal_path() -> Option<PathBuf> {
     let project_dirs = ProjectDirs::from("de", "demenik", "pomomon-garden");
 

From 040b2742ca7c3a5ef75d8f5f1fe271d7579b8c54 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:12:27 +0100
Subject: [PATCH 47/71] docs: document grid system and game screen environment
 (#65)

---
 src/features/game_screen/mod.rs | 3 +++
 src/features/grid/components.rs | 8 ++++++++
 src/features/grid/consts.rs     | 1 +
 src/features/grid/errors.rs     | 1 +
 src/features/grid/mod.rs        | 4 ++++
 src/features/grid/utils.rs      | 4 ++++
 6 files changed, 21 insertions(+)

diff --git a/src/features/game_screen/mod.rs b/src/features/game_screen/mod.rs
index 2a74417..2d865ce 100644
--- a/src/features/game_screen/mod.rs
+++ b/src/features/game_screen/mod.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Plugin for the main game screen, managing the game loop and environment.
 pub struct GameScreenPlugin;
 
 impl Plugin for GameScreenPlugin {
@@ -9,10 +10,12 @@ impl Plugin for GameScreenPlugin {
     }
 }
 
+/// Sets up the game screen environment (e.g., background color).
 fn setup(mut clear_color: ResMut<ClearColor>) {
     *clear_color = ClearColor(Color::srgb(0.294, 0.412, 0.184));
 }
 
+/// Cleans up resources when exiting the game screen.
 fn cleanup(mut clear_color: ResMut<ClearColor>) {
     *clear_color = ClearColor(Color::srgb(0.2, 0.2, 0.2));
 }
diff --git a/src/features/grid/components.rs b/src/features/grid/components.rs
index 6bbbb55..89c95a5 100644
--- a/src/features/grid/components.rs
+++ b/src/features/grid/components.rs
@@ -1,18 +1,22 @@
 use super::errors::GridError;
 use crate::prelude::*;
 
+/// Component representing a single tile on the grid.
 #[derive(Component)]
 pub struct Tile {
     pub x: u32,
     pub y: u32,
 }
 
+/// Visual marker component for the crop on a tile.
 #[derive(Component)]
 pub struct CropVisual;
 
+/// Visual marker component for the water on a tile.
 #[derive(Component)]
 pub struct WaterVisual;
 
+/// The logical state of a tile.
 #[derive(Component, Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub enum TileState {
     #[default]
@@ -38,6 +42,7 @@ impl TileState {
     }
 }
 
+/// Resource containing grid dimensions and tile entities.
 #[derive(Resource)]
 pub struct Grid {
     pub width: u32,
@@ -46,6 +51,7 @@ pub struct Grid {
 }
 
 impl Grid {
+    /// Returns the entity of the tile at the given position.
     pub fn get_tile(&self, pos: (u32, u32)) -> Result<Entity, GridError> {
         if pos.0 >= self.width || pos.1 >= self.height {
             return Err(GridError::OutOfBounds {
@@ -56,6 +62,7 @@ impl Grid {
         Ok(self.tiles[pos.0 as usize][pos.1 as usize])
     }
 
+    /// Modifies the state of a tile using a mapping function.
     pub fn map_tile_state<F>(
         &self,
         pos: (u32, u32),
@@ -75,6 +82,7 @@ impl Grid {
         Ok(())
     }
 
+    /// Counts the number of tiles that are not unclaimed.
     pub fn count_claimed_tiles(&self, tile_query: &Query<&TileState>) -> u32 {
         self.tiles
             .iter()
diff --git a/src/features/grid/consts.rs b/src/features/grid/consts.rs
index bc45548..d1f91b7 100644
--- a/src/features/grid/consts.rs
+++ b/src/features/grid/consts.rs
@@ -1 +1,2 @@
+/// The pixel size of a tile (width and height).
 pub const TILE_SIZE: f32 = 32.0;
diff --git a/src/features/grid/errors.rs b/src/features/grid/errors.rs
index fc77c3c..ee80a0f 100644
--- a/src/features/grid/errors.rs
+++ b/src/features/grid/errors.rs
@@ -1,5 +1,6 @@
 use std::{error::Error, fmt};
 
+/// Errors related to grid operations.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum GridError {
     OutOfBounds { x: i32, y: i32 },
diff --git a/src/features/grid/mod.rs b/src/features/grid/mod.rs
index 4aa951e..02e6eee 100644
--- a/src/features/grid/mod.rs
+++ b/src/features/grid/mod.rs
@@ -7,6 +7,7 @@ pub mod consts;
 pub mod errors;
 pub mod utils;
 
+/// Manages the game grid, including tiles, visuals, and updates.
 pub struct GridPlugin;
 
 impl Plugin for GridPlugin {
@@ -18,6 +19,7 @@ impl Plugin for GridPlugin {
     }
 }
 
+/// Initializes the grid and spawns tile entities.
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<GameConfig>) {
     let grid_width = config.grid_width;
     let grid_height = config.grid_height;
@@ -96,6 +98,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<Gam
     });
 }
 
+/// Despawns all grid entities and removes resources.
 fn cleanup(mut commands: Commands, tile_query: Query<Entity, With<Tile>>) {
     for tile_entity in tile_query.iter() {
         commands.entity(tile_entity).despawn();
@@ -103,6 +106,7 @@ fn cleanup(mut commands: Commands, tile_query: Query<Entity, With<Tile>>) {
     commands.remove_resource::<Grid>();
 }
 
+/// Updates tile visuals based on their state (e.g., crop growth, highlighting).
 fn update_tiles(
     mut query: Query<
         (&TileState, &mut AseSlice, &Children, &Tile),
diff --git a/src/features/grid/utils.rs b/src/features/grid/utils.rs
index 95c722e..fb816ef 100644
--- a/src/features/grid/utils.rs
+++ b/src/features/grid/utils.rs
@@ -1,14 +1,17 @@
 use super::errors::GridError;
 use crate::prelude::*;
 
+/// Calculates the starting X coordinate for centering the grid.
 pub fn grid_start_x(grid_width: u32) -> f32 {
     -(grid_width as f32 * TILE_SIZE) / 2.0 + TILE_SIZE / 2.0
 }
 
+/// Calculates the starting Y coordinate for centering the grid.
 pub fn grid_start_y(grid_height: u32) -> f32 {
     -(grid_height as f32 * TILE_SIZE) / 2.0 + TILE_SIZE / 2.0
 }
 
+/// Converts world coordinates to grid coordinates.
 pub fn world_to_grid_coords(
     world_pos: Vec3,
     grid_width: u32,
@@ -30,6 +33,7 @@ pub fn world_to_grid_coords(
     Ok((x as u32, y as u32))
 }
 
+/// Converts grid coordinates to world coordinates.
 pub fn grid_to_world_coords(
     grid_x: u32,
     grid_y: u32,

From 604bbf5f7863b9a242b985b46a40744d058e1b87 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:12:36 +0100
Subject: [PATCH 48/71] docs: add comments to UI components, HUD, and start
 screen (#65)

---
 src/features/hud/components.rs          | 6 ++++++
 src/features/hud/mod.rs                 | 7 +++++++
 src/features/hud/ui/settings.rs         | 1 +
 src/features/hud/ui/timer_settings.rs   | 1 +
 src/features/start_screen/components.rs | 2 ++
 src/features/start_screen/mod.rs        | 4 ++++
 src/features/ui/components.rs           | 2 ++
 src/features/ui/consts.rs               | 4 ++++
 src/features/ui/messages.rs             | 1 +
 src/features/ui/mod.rs                  | 3 +++
 src/features/ui/ui/button.rs            | 3 +++
 src/features/ui/ui/flexbox.rs           | 1 +
 src/features/ui/ui/popups.rs            | 5 +++++
 src/features/ui/ui/texts.rs             | 2 ++
 src/features/ui/utils.rs                | 1 +
 15 files changed, 43 insertions(+)

diff --git a/src/features/hud/components.rs b/src/features/hud/components.rs
index be49eb9..ccd9a63 100644
--- a/src/features/hud/components.rs
+++ b/src/features/hud/components.rs
@@ -1,5 +1,6 @@
 use crate::{features::phase::components::TimerSettings, prelude::*};
 
+/// Markers for root UI nodes.
 #[derive(Component)]
 pub enum RootMarker {
     Status,
@@ -7,12 +8,14 @@ pub enum RootMarker {
     ShovelOverlay,
 }
 
+/// Markers for text components in the HUD.
 #[derive(Component)]
 pub enum TextType {
     Phase,
     Timer,
 }
 
+/// Markers for buttons in the HUD and settings.
 #[derive(Component)]
 pub enum ButtonType {
     SettingsOpen,
@@ -24,6 +27,7 @@ pub enum ButtonType {
     },
 }
 
+/// Types of timers available in the game.
 #[derive(Clone)]
 pub enum TimerType {
     Focus,
@@ -32,6 +36,7 @@ pub enum TimerType {
 }
 
 impl TimerSettings {
+    /// Changes the duration of a specific timer.
     pub fn change(&mut self, timer_type: &TimerType, amount: i32) {
         match timer_type {
             TimerType::Focus => {
@@ -59,6 +64,7 @@ impl TimerSettings {
     }
 }
 
+/// Input types for adjusting timer settings.
 #[derive(Component, Clone)]
 pub enum SettingsTimerInput {
     Minutes(TimerType),
diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index 41937d0..3d50a06 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -8,6 +8,7 @@ use ui::*;
 pub mod components;
 pub mod ui;
 
+/// Plugin for the Head-Up Display (HUD) containing status bars and buttons.
 pub struct HudPlugin;
 
 impl Plugin for HudPlugin {
@@ -27,6 +28,7 @@ impl Plugin for HudPlugin {
     }
 }
 
+/// Initializes the HUD UI.
 fn setup(mut commands: Commands, game_config: Res<GameConfig>, asset_server: Res<AssetServer>) {
     commands.spawn((
         RootMarker::Status,
@@ -126,6 +128,7 @@ fn setup(mut commands: Commands, game_config: Res<GameConfig>, asset_server: Res
     ));
 }
 
+/// Updates the status text (phase and timer).
 fn update_status(phase_res: Res<CurrentPhase>, mut text_query: Query<(&mut Text, &TextType)>) {
     if !phase_res.is_changed() {
         return;
@@ -140,6 +143,7 @@ fn update_status(phase_res: Res<CurrentPhase>, mut text_query: Query<(&mut Text,
     }
 }
 
+/// Handles HUD button interactions.
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
@@ -181,12 +185,14 @@ fn buttons(
     }
 }
 
+/// Cleans up HUD resources.
 fn cleanup(mut commands: Commands, query: Query<Entity, With<RootMarker>>) {
     for entity in query.iter() {
         commands.entity(entity).despawn();
     }
 }
 
+/// Updates the timer settings display in the settings menu.
 fn update_timer_settings(
     timer_settings: ResMut<TimerSettings>,
     mut query: Query<(&SettingsTimerInput, &mut Text)>,
@@ -215,6 +221,7 @@ fn update_timer_settings(
     }
 }
 
+/// Updates the visibility of the shovel overlay based on inventory.
 fn update_shovel_overlay_visibility(
     inventory: Res<inventory::components::Inventory>,
     item_stacks: Query<&inventory::components::ItemStack>,
diff --git a/src/features/hud/ui/settings.rs b/src/features/hud/ui/settings.rs
index f0c8247..1ae8962 100644
--- a/src/features/hud/ui/settings.rs
+++ b/src/features/hud/ui/settings.rs
@@ -2,6 +2,7 @@ use super::super::components::*;
 use super::timer_settings::timer_settings;
 use crate::prelude::*;
 
+/// Spawns the settings popup.
 pub fn open_settings(commands: &mut Commands) {
     spawn_popup(
         commands,
diff --git a/src/features/hud/ui/timer_settings.rs b/src/features/hud/ui/timer_settings.rs
index 136b391..744680b 100644
--- a/src/features/hud/ui/timer_settings.rs
+++ b/src/features/hud/ui/timer_settings.rs
@@ -1,6 +1,7 @@
 use super::super::components::*;
 use crate::prelude::*;
 
+/// Creates a UI bundle for a specific timer setting.
 pub fn timer_settings(timer_type: TimerType) -> impl Bundle {
     (
         Node {
diff --git a/src/features/start_screen/components.rs b/src/features/start_screen/components.rs
index 6e57872..eea6455 100644
--- a/src/features/start_screen/components.rs
+++ b/src/features/start_screen/components.rs
@@ -1,10 +1,12 @@
 use crate::prelude::*;
 
+/// Markers for main menu UI.
 #[derive(Component)]
 pub enum RootMarker {
     MainMenu,
 }
 
+/// Buttons in the main menu.
 #[derive(Component)]
 pub enum ButtonType {
     LoadGame,
diff --git a/src/features/start_screen/mod.rs b/src/features/start_screen/mod.rs
index 89483c2..bed89e7 100644
--- a/src/features/start_screen/mod.rs
+++ b/src/features/start_screen/mod.rs
@@ -4,6 +4,7 @@ use components::*;
 
 pub mod components;
 
+/// Plugin for the main menu screen.
 pub struct StartScreenPlugin;
 
 impl Plugin for StartScreenPlugin {
@@ -14,6 +15,7 @@ impl Plugin for StartScreenPlugin {
     }
 }
 
+/// Spawns the main menu UI.
 fn setup(mut commands: Commands) {
     commands.spawn((
         RootMarker::MainMenu,
@@ -60,6 +62,7 @@ fn setup(mut commands: Commands) {
     ));
 }
 
+/// Handles main menu button interactions.
 fn menu(
     mut commands: Commands,
     mut next_state: ResMut<NextState<AppState>>,
@@ -84,6 +87,7 @@ fn menu(
     }
 }
 
+/// Cleans up main menu resources.
 fn cleanup(mut commands: Commands, query: Query<Entity, With<RootMarker>>) {
     for entity in query.iter() {
         commands.entity(entity).despawn();
diff --git a/src/features/ui/components.rs b/src/features/ui/components.rs
index b20eb12..4138278 100644
--- a/src/features/ui/components.rs
+++ b/src/features/ui/components.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Event triggering a scroll action on an entity.
 #[derive(EntityEvent, Debug)]
 #[entity_event(propagate, auto_propagate)]
 pub struct Scroll {
@@ -7,6 +8,7 @@ pub struct Scroll {
     pub delta: Vec2,
 }
 
+/// Visual styles for buttons.
 #[derive(Component, Clone)]
 pub enum ButtonVariant {
     Primary,
diff --git a/src/features/ui/consts.rs b/src/features/ui/consts.rs
index 2803ec3..f185010 100644
--- a/src/features/ui/consts.rs
+++ b/src/features/ui/consts.rs
@@ -1,6 +1,10 @@
 use crate::prelude::*;
 
+/// Pixel height of a single scroll line.
 pub const LINE_HEIGHT: f32 = 21.0;
+/// Default background color for buttons.
 pub const NORMAL_BUTTON: Color = Color::srgb(0.15, 0.15, 0.15);
+/// Background color when hovering a button.
 pub const HOVERED_BUTTON: Color = Color::srgb(0.25, 0.25, 0.25);
+/// Background color when pressing a button.
 pub const PRESSED_BUTTON: Color = Color::srgb(0.35, 0.75, 0.35);
diff --git a/src/features/ui/messages.rs b/src/features/ui/messages.rs
index c3894be..05e48f6 100644
--- a/src/features/ui/messages.rs
+++ b/src/features/ui/messages.rs
@@ -1,4 +1,5 @@
 use crate::prelude::*;
 
+/// Message to close any open popup.
 #[derive(Message)]
 pub struct ClosePopupMessage;
diff --git a/src/features/ui/mod.rs b/src/features/ui/mod.rs
index cad4dd6..e85dabb 100644
--- a/src/features/ui/mod.rs
+++ b/src/features/ui/mod.rs
@@ -7,6 +7,7 @@ pub mod messages;
 pub mod ui;
 pub mod utils;
 
+/// Plugin for general UI behavior like scrolling and button states.
 pub struct UiPlugin;
 
 impl Plugin for UiPlugin {
@@ -20,6 +21,7 @@ impl Plugin for UiPlugin {
     }
 }
 
+/// Reads mouse wheel events and triggers scroll actions.
 fn scroll_events(
     mut mouse_wheel_reader: MessageReader<MouseWheel>,
     hover_map: Res<HoverMap>,
@@ -45,6 +47,7 @@ fn scroll_events(
     }
 }
 
+/// Updates scroll position based on scroll events.
 fn on_scroll_handler(
     mut scroll: On<components::Scroll>,
     mut query: Query<(&mut ScrollPosition, &Node, &ComputedNode)>,
diff --git a/src/features/ui/ui/button.rs b/src/features/ui/ui/button.rs
index 9d51dca..acd6a00 100644
--- a/src/features/ui/ui/button.rs
+++ b/src/features/ui/ui/button.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Creates a standard button UI bundle.
 pub fn button<C, R>(
     button_type: impl Component,
     variant: ButtonVariant,
@@ -24,6 +25,7 @@ where
     )
 }
 
+/// Creates a rounded pill-shaped button UI bundle.
 pub fn pill_button<C, R>(
     button_type: impl Component,
     variant: ButtonVariant,
@@ -48,6 +50,7 @@ where
     )
 }
 
+/// Updates button colors based on interaction state.
 pub fn update_buttons(
     mut interaction_query: Query<
         (&Interaction, &ButtonVariant, &mut BackgroundColor),
diff --git a/src/features/ui/ui/flexbox.rs b/src/features/ui/ui/flexbox.rs
index 6dace0b..0962acd 100644
--- a/src/features/ui/ui/flexbox.rs
+++ b/src/features/ui/ui/flexbox.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Trait for easy flexbox layout construction.
 pub trait Flexbox {
     fn hstack(spacing: Val) -> Self;
     fn vstack(spacing: Val) -> Self;
diff --git a/src/features/ui/ui/popups.rs b/src/features/ui/ui/popups.rs
index 34a7bde..3341050 100644
--- a/src/features/ui/ui/popups.rs
+++ b/src/features/ui/ui/popups.rs
@@ -3,12 +3,15 @@ use bevy::ecs::relationship::RelatedSpawnerCommands;
 use super::super::messages::ClosePopupMessage;
 use crate::prelude::*;
 
+/// Marker for popup root nodes.
 #[derive(Component)]
 pub struct PopupRoot;
 
+/// Marker for the close button in a popup.
 #[derive(Component)]
 pub struct PopupCloseButton;
 
+/// Spawns a generic popup window.
 pub fn spawn_popup(
     commands: &mut Commands,
     root: impl Component,
@@ -68,6 +71,7 @@ pub fn spawn_popup(
         });
 }
 
+/// Spawns a context menu at a specific position.
 pub fn spawn_context_menu(
     commands: &mut Commands,
     root: impl Component,
@@ -93,6 +97,7 @@ pub fn spawn_context_menu(
         .with_children(child);
 }
 
+/// Handles closing popups via message or close button.
 pub fn handle_popup_close(
     mut commands: Commands,
     root_query: Query<Entity, With<PopupRoot>>,
diff --git a/src/features/ui/ui/texts.rs b/src/features/ui/ui/texts.rs
index 70b19df..9256f83 100644
--- a/src/features/ui/ui/texts.rs
+++ b/src/features/ui/ui/texts.rs
@@ -1,5 +1,6 @@
 pub use crate::prelude::*;
 
+/// Creates a basic text bundle.
 pub fn text(content: impl Into<String>, size: f32, color: Color) -> (Text, TextFont, TextColor) {
     (
         Text::new(content),
@@ -8,6 +9,7 @@ pub fn text(content: impl Into<String>, size: f32, color: Color) -> (Text, TextF
     )
 }
 
+/// Creates a text bundle with an additional component attached.
 pub fn text_with_component(
     component: impl Component,
     content: impl Into<String>,
diff --git a/src/features/ui/utils.rs b/src/features/ui/utils.rs
index c147e31..3a61d3a 100644
--- a/src/features/ui/utils.rs
+++ b/src/features/ui/utils.rs
@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use bevy::window::PrimaryWindow;
 
+/// Checks if the cursor is hovering over any UI element.
 pub fn ui_blocks(
     window: Single<&Window, With<PrimaryWindow>>,
     cursor_pos: Vec2,

From e5713fdb94b6b75b69a3911d7b76bde37b2c74ea Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:13:13 +0100
Subject: [PATCH 49/71] docs: document player character (Pom) and input
 handling (#65)

---
 src/features/input/mod.rs           | 8 ++++++++
 src/features/input/utils.rs         | 1 +
 src/features/pom/actions.rs         | 1 +
 src/features/pom/components.rs      | 5 +++++
 src/features/pom/messages.rs        | 4 ++++
 src/features/pom/mod.rs             | 9 +++++++++
 src/features/pom/ui/context_menu.rs | 6 ++++++
 src/features/pom/ui/mod.rs          | 1 +
 src/features/pom/utils.rs           | 5 ++++-
 9 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index 41c7225..d2dd287 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -11,6 +11,7 @@ use bevy::window::PrimaryWindow;
 
 pub mod utils;
 
+/// Handles user input for the game.
 pub struct InputPlugin;
 
 impl Plugin for InputPlugin {
@@ -45,6 +46,7 @@ impl Plugin for InputPlugin {
     }
 }
 
+/// Handles right-click movement input.
 fn move_click(
     mut move_messages: MessageWriter<MoveMessage>,
     mouse_btn: Res<ButtonInput<MouseButton>>,
@@ -75,6 +77,7 @@ fn move_click(
     }
 }
 
+/// Handles left-click interactions (tile selection, shovel).
 fn interact_click(
     mut tile_click_messages: MessageWriter<TileClickMessage>,
     mouse_btn: Res<ButtonInput<MouseButton>>,
@@ -174,6 +177,7 @@ fn interact_click(
         }
     }
 }
+/// Handles debug interactions (shift + left click).
 fn debug_click(
     mouse_btn: Res<ButtonInput<MouseButton>>,
     keys: Res<ButtonInput<KeyCode>>,
@@ -220,6 +224,7 @@ fn debug_click(
     }
 }
 
+/// Pauses/resumes the phase timer on Space press.
 fn phase_timer_pause(
     mut pause_messages: MessageWriter<PhaseTimerPauseMessage>,
     keys: Res<ButtonInput<KeyCode>>,
@@ -229,12 +234,14 @@ fn phase_timer_pause(
     }
 }
 
+/// Skips to the next phase on Enter press.
 fn next_phase(mut messages: MessageWriter<NextPhaseMessage>, keys: Res<ButtonInput<KeyCode>>) {
     if keys.just_pressed(KeyCode::Enter) {
         messages.write(NextPhaseMessage);
     }
 }
 
+/// Opens the shop on 'P' press.
 fn shop_keybind(
     keys: Res<ButtonInput<KeyCode>>,
     mut commands: Commands,
@@ -254,6 +261,7 @@ fn shop_keybind(
     }
 }
 
+/// Closes popups on Escape press.
 fn popup_keybind(
     mut close_popup_messages: MessageWriter<ClosePopupMessage>,
     keys: Res<ButtonInput<KeyCode>>,
diff --git a/src/features/input/utils.rs b/src/features/input/utils.rs
index 7f38b6e..2cff5e1 100644
--- a/src/features/input/utils.rs
+++ b/src/features/input/utils.rs
@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use bevy::window::PrimaryWindow;
 
+/// Converts mouse position to grid coordinates, respecting UI blocks.
 pub fn mouse_to_grid(
     window: Single<&Window, With<PrimaryWindow>>,
     camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
diff --git a/src/features/pom/actions.rs b/src/features/pom/actions.rs
index 3e22179..4b2c0d6 100644
--- a/src/features/pom/actions.rs
+++ b/src/features/pom/actions.rs
@@ -1,5 +1,6 @@
 use crate::{features::phase::components::SessionTracker, prelude::*};
 
+/// Actions Pom can perform on tiles.
 #[derive(Clone, Debug, PartialEq)]
 pub enum InteractionAction {
     Plant(ItemType),
diff --git a/src/features/pom/components.rs b/src/features/pom/components.rs
index 5e9866a..d6a9243 100644
--- a/src/features/pom/components.rs
+++ b/src/features/pom/components.rs
@@ -2,20 +2,24 @@ use crate::features::pom::actions::InteractionAction;
 use crate::prelude::*;
 use std::collections::VecDeque;
 
+/// Marker component for the main character.
 #[derive(Component)]
 pub struct Pom;
 
+/// Current logical position on the grid.
 #[derive(Component, Serialize, Deserialize, Clone, Copy, Default)]
 pub struct GridPosition {
     pub x: u32,
     pub y: u32,
 }
 
+/// Queue of grid positions to visit.
 #[derive(Component, Default)]
 pub struct PathQueue {
     pub steps: VecDeque<(u32, u32)>,
 }
 
+/// Movement direction state for animation.
 #[derive(Component, Default)]
 pub enum MovingState {
     #[default]
@@ -38,6 +42,7 @@ impl MovingState {
     }
 }
 
+/// Target tile and action for pending interaction.
 #[derive(Component, Default)]
 pub struct InteractionTarget {
     pub target: Option<(u32, u32)>,
diff --git a/src/features/pom/messages.rs b/src/features/pom/messages.rs
index 58b2355..8afc36e 100644
--- a/src/features/pom/messages.rs
+++ b/src/features/pom/messages.rs
@@ -1,17 +1,20 @@
 use crate::features::pom::actions::InteractionAction;
 use crate::prelude::*;
 
+/// Request to move Pom to a specific tile.
 #[derive(Message)]
 pub struct MoveMessage {
     pub x: u32,
     pub y: u32,
 }
 
+/// Notification that a move request was invalid.
 #[derive(Message)]
 pub struct InvalidMoveMessage {
     pub message: String,
 }
 
+/// Request to start an interaction sequence.
 #[derive(Message)]
 pub struct InteractStartMessage {
     pub x: u32,
@@ -19,6 +22,7 @@ pub struct InteractStartMessage {
     pub action: InteractionAction,
 }
 
+/// Notification that a tile was clicked (requesting context menu).
 #[derive(Message)]
 pub struct TileClickMessage {
     pub x: u32,
diff --git a/src/features/pom/mod.rs b/src/features/pom/mod.rs
index ed55560..2eb2cdd 100644
--- a/src/features/pom/mod.rs
+++ b/src/features/pom/mod.rs
@@ -11,6 +11,7 @@ pub mod messages;
 pub mod ui;
 pub mod utils;
 
+/// Plugin controlling the main character (Pom) behavior.
 pub struct PomPlugin;
 
 impl Plugin for PomPlugin {
@@ -34,6 +35,7 @@ impl Plugin for PomPlugin {
     }
 }
 
+/// Draws the path Pom will follow using gizmos.
 fn draw_path(
     mut gizmos: Gizmos,
     query: Query<(&Transform, &PathQueue), With<Pom>>,
@@ -65,6 +67,7 @@ fn draw_path(
     }
 }
 
+/// Spawns the Pom character.
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<GameConfig>) {
     commands.spawn((
         Pom,
@@ -87,12 +90,14 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, config: Res<Gam
     ));
 }
 
+/// Despawns the Pom character.
 fn cleanup(mut commands: Commands, pom_query: Query<Entity, With<Pom>>) {
     for pom_entity in pom_query.iter() {
         commands.entity(pom_entity).despawn();
     }
 }
 
+/// Calculates path for manual movement requests.
 fn handle_move(
     mut move_messages: MessageReader<MoveMessage>,
     mut invalid_move_messages: MessageWriter<InvalidMoveMessage>,
@@ -127,6 +132,7 @@ fn handle_move(
     }
 }
 
+/// Calculates path to interaction target.
 fn handle_interact(
     mut interact_messages: MessageReader<InteractStartMessage>,
     mut pom_query: Query<(&GridPosition, &mut PathQueue, &mut InteractionTarget)>,
@@ -184,6 +190,7 @@ fn handle_interact(
     }
 }
 
+/// Executes the pending interaction when target is reached.
 pub fn perform_interaction(
     mut pom_query: Query<(&GridPosition, &mut InteractionTarget, &PathQueue)>,
     grid: Res<Grid>,
@@ -239,6 +246,7 @@ pub fn perform_interaction(
     }
 }
 
+/// Moves the Pom character along the path.
 fn move_pom(
     time: Res<Time>,
     mut query: Query<(
@@ -288,6 +296,7 @@ fn move_pom(
     }
 }
 
+/// Updates Pom animation based on movement state.
 fn update_pom(asset_server: Res<AssetServer>, mut query: Query<(&MovingState, &mut AseAnimation)>) {
     for (moving_state, mut animation) in query.iter_mut() {
         match moving_state {
diff --git a/src/features/pom/ui/context_menu.rs b/src/features/pom/ui/context_menu.rs
index 5b3165d..f6bf013 100644
--- a/src/features/pom/ui/context_menu.rs
+++ b/src/features/pom/ui/context_menu.rs
@@ -4,11 +4,13 @@ use crate::features::ui::utils::ui_blocks;
 use crate::prelude::*;
 use bevy::window::PrimaryWindow;
 
+/// Marker for context menu UI root.
 #[derive(Component)]
 pub enum RootMarker {
     ContextMenu,
 }
 
+/// Buttons available in the context menu.
 #[derive(Component)]
 pub enum ButtonType {
     Interact {
@@ -19,6 +21,7 @@ pub enum ButtonType {
     Cancel,
 }
 
+/// Spawns the context menu at the clicked tile position.
 pub fn open_context_menu(
     mut commands: Commands,
     mut tile_click_messages: MessageReader<TileClickMessage>,
@@ -87,6 +90,7 @@ pub fn open_context_menu(
     }
 }
 
+/// Closes context menu when clicking elsewhere.
 pub fn click_outside_context_menu(
     mut commands: Commands,
     mouse_btn: Res<ButtonInput<MouseButton>>,
@@ -107,6 +111,7 @@ pub fn click_outside_context_menu(
     }
 }
 
+/// Handles context menu button clicks.
 pub fn buttons(
     mut commands: Commands,
     mut button_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
@@ -133,6 +138,7 @@ pub fn buttons(
     }
 }
 
+/// Closes context menu on ClosePopupMessage.
 pub fn close_context_menu(
     mut commands: Commands,
     mut close_popup_reader: MessageReader<ClosePopupMessage>,
diff --git a/src/features/pom/ui/mod.rs b/src/features/pom/ui/mod.rs
index a59c0ca..57351c3 100644
--- a/src/features/pom/ui/mod.rs
+++ b/src/features/pom/ui/mod.rs
@@ -2,6 +2,7 @@ use crate::prelude::*;
 
 pub mod context_menu;
 
+/// Plugin for Pom-related UI (context menu).
 pub struct PomUiPlugin;
 
 impl Plugin for PomUiPlugin {
diff --git a/src/features/pom/utils.rs b/src/features/pom/utils.rs
index 0658684..0b99728 100644
--- a/src/features/pom/utils.rs
+++ b/src/features/pom/utils.rs
@@ -2,6 +2,7 @@ use crate::prelude::*;
 use std::cmp::Ordering;
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
+/// A star pathfinding node.
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Node {
     x: u32,
@@ -25,11 +26,12 @@ impl PartialOrd for Node {
     }
 }
 
+/// Calculates Manhattan distance between two points.
 pub fn manhattan_distance(x1: u32, y1: u32, x2: u32, y2: u32) -> u32 {
     x1.abs_diff(x2) + y1.abs_diff(y2)
 }
 
-/// Checks if Pom would be trapped in a small, isolated area if a specific tile is blocked
+/// Checks if Pom would be trapped in a small, isolated area if a specific tile is blocked.
 pub fn is_trapped<F>(
     start: (u32, u32),
     blocked_pos: (u32, u32),
@@ -98,6 +100,7 @@ where
     visited.len() < min_safe_area
 }
 
+/// Finds a path from start to end using A* algorithm.
 pub fn find_path(
     start: (u32, u32),
     end: (u32, u32),

From 392b93d47baeb6bee26c0eda86ac67748eb8af1b Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:13:22 +0100
Subject: [PATCH 50/71] docs: add documentation for inventory and shop systems
 (#65)

---
 src/features/inventory/components.rs   | 7 +++++++
 src/features/inventory/mod.rs          | 3 +++
 src/features/inventory/ui/inventory.rs | 1 +
 src/features/inventory/ui/item.rs      | 1 +
 src/features/shop/components.rs        | 5 +++++
 src/features/shop/mod.rs               | 2 ++
 src/features/shop/ui/offer.rs          | 2 ++
 src/features/shop/ui/shop.rs           | 1 +
 8 files changed, 22 insertions(+)

diff --git a/src/features/inventory/components.rs b/src/features/inventory/components.rs
index ab3f75a..2efa7a6 100644
--- a/src/features/inventory/components.rs
+++ b/src/features/inventory/components.rs
@@ -1,6 +1,7 @@
 use crate::features::config::components::BerrySeedConfig;
 use crate::prelude::*;
 
+/// Types of items available in the game.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ItemType {
     Berry,
@@ -102,18 +103,21 @@ impl ItemType {
     }
 }
 
+/// A stack of items of a specific type.
 #[derive(Component, Serialize, Deserialize, Clone, Debug)]
 pub struct ItemStack {
     pub item_type: ItemType,
     pub amount: u32,
 }
 
+/// Resource containing all items owned by the player.
 #[derive(Resource, Default, Serialize, Deserialize)]
 pub struct Inventory {
     pub items: Vec<Entity>,
 }
 
 impl Inventory {
+    /// Checks if the inventory contains a specific item type.
     pub fn has_item_type(&self, items_query: &Query<&ItemStack>, item_type: ItemType) -> bool {
         self.items.iter().any(|&entity| {
             if let Ok(stack) = items_query.get(entity) {
@@ -124,6 +128,7 @@ impl Inventory {
         })
     }
 
+    /// Adds or removes items from the inventory.
     pub fn update_item_stack(
         &mut self,
         commands: &mut Commands,
@@ -193,11 +198,13 @@ impl Inventory {
     }
 }
 
+/// Markers for inventory UI root nodes.
 #[derive(Component)]
 pub enum RootMarker {
     Inventory,
 }
 
+/// Markers for inventory-related buttons.
 #[derive(Component)]
 pub enum ButtonType {
     InventoryOpen,
diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index 49df63b..878fc95 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -5,6 +5,7 @@ use components::*;
 pub mod components;
 pub mod ui;
 
+/// Plugin for the inventory system, including storage and UI.
 pub struct InventoryPlugin;
 
 impl Plugin for InventoryPlugin {
@@ -18,6 +19,7 @@ impl Plugin for InventoryPlugin {
     }
 }
 
+/// Handles inventory button interactions.
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
@@ -37,6 +39,7 @@ fn buttons(
     }
 }
 
+/// Debug system to add/remove berries with arrow keys.
 #[cfg(debug_assertions)]
 fn debug_modify_berries(
     mut commands: Commands,
diff --git a/src/features/inventory/ui/inventory.rs b/src/features/inventory/ui/inventory.rs
index d98ce79..a807c48 100644
--- a/src/features/inventory/ui/inventory.rs
+++ b/src/features/inventory/ui/inventory.rs
@@ -2,6 +2,7 @@ use super::super::components::RootMarker;
 use crate::prelude::GameConfig;
 use crate::{features::inventory::ui::list_itemstack, prelude::*};
 
+/// Spawns the inventory popup.
 pub fn open_inventory(
     commands: &mut Commands,
     items: Query<&ItemStack>,
diff --git a/src/features/inventory/ui/item.rs b/src/features/inventory/ui/item.rs
index 39a9f0a..9088e93 100644
--- a/src/features/inventory/ui/item.rs
+++ b/src/features/inventory/ui/item.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Creates a UI bundle for a single item stack in the inventory list.
 pub fn list_itemstack(
     itemstack: &ItemStack,
     game_config: &GameConfig,
diff --git a/src/features/shop/components.rs b/src/features/shop/components.rs
index d479bbd..99288d4 100644
--- a/src/features/shop/components.rs
+++ b/src/features/shop/components.rs
@@ -1,16 +1,19 @@
 use crate::prelude::*;
 
+/// Markers for shop UI.
 #[derive(Component)]
 pub enum RootMarker {
     Shop,
 }
 
+/// Buttons in the shop.
 #[derive(Component)]
 pub enum ButtonType {
     ShopOpen,
     ShopBuyItem(ShopOffer),
 }
 
+/// An item available for purchase.
 #[derive(Clone)]
 pub struct ShopOffer {
     pub item: ItemStack,
@@ -18,6 +21,7 @@ pub struct ShopOffer {
 }
 
 impl ShopOffer {
+    /// Generates a list of all current offers.
     pub fn list_all(game_config: &GameConfig, tile_count: u32) -> Vec<ShopOffer> {
         let mut offers = Vec::new();
 
@@ -50,6 +54,7 @@ impl ShopOffer {
         offers
     }
 
+    /// Attempts to purchase the offer.
     pub fn buy(
         &self,
         inventory: &mut Inventory,
diff --git a/src/features/shop/mod.rs b/src/features/shop/mod.rs
index b347b56..a8a65ac 100644
--- a/src/features/shop/mod.rs
+++ b/src/features/shop/mod.rs
@@ -5,6 +5,7 @@ use ui::open_shop;
 pub mod components;
 pub mod ui;
 
+/// Plugin for the in-game shop.
 pub struct ShopPlugin;
 
 impl Plugin for ShopPlugin {
@@ -13,6 +14,7 @@ impl Plugin for ShopPlugin {
     }
 }
 
+/// Handles shop button interactions.
 fn buttons(
     mut commands: Commands,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
diff --git a/src/features/shop/ui/offer.rs b/src/features/shop/ui/offer.rs
index 6c971b7..c15af2b 100644
--- a/src/features/shop/ui/offer.rs
+++ b/src/features/shop/ui/offer.rs
@@ -1,6 +1,7 @@
 use super::super::components::*;
 use crate::{features::inventory::ui::item::list_itemstack, prelude::*};
 
+/// Creates the UI bundle for a shop offer.
 pub fn shop_offer(
     offer: &ShopOffer,
     game_config: &GameConfig,
@@ -26,6 +27,7 @@ pub fn shop_offer(
     )
 }
 
+/// Creates the UI bundle for displaying a price.
 pub fn shop_price(
     price: u32,
     asset_server: &Res<AssetServer>,
diff --git a/src/features/shop/ui/shop.rs b/src/features/shop/ui/shop.rs
index 4983b00..2ef28c8 100644
--- a/src/features/shop/ui/shop.rs
+++ b/src/features/shop/ui/shop.rs
@@ -1,6 +1,7 @@
 use super::super::components::*;
 use crate::{features::shop::ui::shop_offer, prelude::*};
 
+/// Spawns the shop popup.
 pub fn open_shop(
     commands: &mut Commands,
     game_config: &GameConfig,

From 04a9125a31f374b4f545ef8a55256746c36b2850 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:14:15 +0100
Subject: [PATCH 51/71] docs: document game phases, save system, notifications,
 and events (#65)

---
 src/features/notification/components.rs |  5 +++++
 src/features/notification/mod.rs        |  5 +++--
 src/features/notification/ui.rs         |  2 ++
 src/features/phase/components.rs        |  4 ++++
 src/features/phase/messages.rs          |  3 +++
 src/features/phase/mod.rs               |  9 ++++++++-
 src/features/phase/utils.rs             |  1 +
 src/features/savegame/components.rs     |  9 +++++++++
 src/features/savegame/messages.rs       |  2 ++
 src/features/savegame/mod.rs            |  6 +++++-
 src/features/savegame/ui/load.rs        |  2 ++
 src/features/wonderevent/components.rs  |  3 +++
 src/features/wonderevent/mod.rs         | 10 ++++++++++
 13 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/src/features/notification/components.rs b/src/features/notification/components.rs
index 3f1f2b0..db48b3f 100644
--- a/src/features/notification/components.rs
+++ b/src/features/notification/components.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Resource managing active notifications.
 #[derive(Resource)]
 pub struct Notifications {
     items: Vec<(Notification, NotificationLevel)>,
@@ -44,18 +45,22 @@ impl Notifications {
     }
 }
 
+/// Marker for the UI node containing notifications.
 #[derive(Component)]
 pub struct NotificationContainer;
 
+/// Component tracking the lifetime of a displayed notification.
 #[derive(Component)]
 pub struct NotificationLifetime(pub Timer);
 
+/// Data for a single notification.
 #[derive(Component)]
 pub struct Notification {
     pub title: Option<String>,
     pub message: String,
 }
 
+/// Severity level of a notification.
 #[derive(Component)]
 pub enum NotificationLevel {
     Info,
diff --git a/src/features/notification/mod.rs b/src/features/notification/mod.rs
index 29e3c8f..479f740 100644
--- a/src/features/notification/mod.rs
+++ b/src/features/notification/mod.rs
@@ -7,6 +7,7 @@ use components::{NotificationContainer, NotificationLifetime, Notifications};
 pub mod components;
 pub mod ui;
 
+/// Plugin for the notification system.
 pub struct NotificationPlugin;
 
 impl Plugin for NotificationPlugin {
@@ -17,12 +18,12 @@ impl Plugin for NotificationPlugin {
     }
 }
 
-/// Spawns the notification container up
+/// Spawns the notification container up.
 fn setup(mut commands: Commands) {
     commands.spawn(notification_container());
 }
 
-/// Spawns/Despawns UI elements for each item in the `Notifications` Resource
+/// Spawns/Despawns UI elements for each item in the `Notifications` Resource.
 fn handle_notification(
     mut commands: Commands,
     mut notifications: ResMut<Notifications>,
diff --git a/src/features/notification/ui.rs b/src/features/notification/ui.rs
index 231bb2e..9844a32 100644
--- a/src/features/notification/ui.rs
+++ b/src/features/notification/ui.rs
@@ -1,6 +1,7 @@
 use super::components::*;
 use crate::prelude::*;
 
+/// Creates the notification container UI bundle.
 pub fn notification_container() -> impl Bundle {
     (
         NotificationContainer,
@@ -16,6 +17,7 @@ pub fn notification_container() -> impl Bundle {
     )
 }
 
+/// Spawns a single notification UI element.
 pub fn spawn_notification(
     commands: &mut Commands,
     content: Notification,
diff --git a/src/features/phase/components.rs b/src/features/phase/components.rs
index be541f6..7dc430d 100644
--- a/src/features/phase/components.rs
+++ b/src/features/phase/components.rs
@@ -1,6 +1,7 @@
 use super::utils::format_time;
 use crate::prelude::*;
 
+/// Represents the different states of the Pomodoro timer.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum Phase {
     Break { duration: f32 },
@@ -37,9 +38,11 @@ impl Phase {
     }
 }
 
+/// Resource holding the current phase state.
 #[derive(Resource, Debug, Serialize, Deserialize, Clone)]
 pub struct CurrentPhase(pub Phase);
 
+/// Configuration for phase durations.
 #[derive(Resource, Debug, Serialize, Deserialize, Clone)]
 pub struct TimerSettings {
     pub focus_duration: u32,
@@ -59,6 +62,7 @@ impl Default for TimerSettings {
     }
 }
 
+/// Tracks statistics for the current session.
 #[derive(Resource, Debug, Default, Serialize, Deserialize, Clone)]
 pub struct SessionTracker {
     pub completed_focus_phases: u32,
diff --git a/src/features/phase/messages.rs b/src/features/phase/messages.rs
index 620aad1..52dd5cc 100644
--- a/src/features/phase/messages.rs
+++ b/src/features/phase/messages.rs
@@ -1,12 +1,15 @@
 use crate::prelude::*;
 
+/// Message sent when a phase timer reaches zero.
 #[derive(Message)]
 pub struct PhaseTimerFinishedMessage {
     pub phase: Phase,
 }
 
+/// Message to toggle pause state.
 #[derive(Message)]
 pub struct PhaseTimerPauseMessage;
 
+/// Message to proceed to the next phase.
 #[derive(Message)]
 pub struct NextPhaseMessage;
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index 1a63fba..d730262 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -7,6 +7,7 @@ pub mod components;
 pub mod messages;
 pub mod utils;
 
+/// Plugin managing the Pomodoro phase timer and state.
 pub struct PhasePlugin;
 
 impl Plugin for PhasePlugin {
@@ -36,6 +37,7 @@ impl Plugin for PhasePlugin {
     }
 }
 
+/// Debug system to shorten phase duration for testing.
 #[cfg(debug_assertions)]
 fn debug_short_phase_duration(
     mut phase_res: ResMut<CurrentPhase>,
@@ -55,6 +57,7 @@ fn debug_short_phase_duration(
     }
 }
 
+/// Updates the current phase duration from settings.
 fn load_rules(mut phase_res: ResMut<CurrentPhase>, settings: Res<TimerSettings>) {
     let phase = &mut phase_res.0;
 
@@ -71,6 +74,7 @@ fn load_rules(mut phase_res: ResMut<CurrentPhase>, settings: Res<TimerSettings>)
     }
 }
 
+/// Ticks the phase timer and handles completion.
 fn tick_timer(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -107,7 +111,7 @@ fn tick_timer(
     }
 }
 
-/// Rewards the player at the end of a focus phase with `berries_per_focus_minute` * `focus_duration`
+/// Rewards the player at the end of a focus phase with `berries_per_focus_minute` * `focus_duration`.
 fn grant_focus_rewards(
     mut messages: MessageReader<PhaseTimerFinishedMessage>,
     config: Res<GameConfig>,
@@ -147,6 +151,7 @@ fn grant_focus_rewards(
     }
 }
 
+/// Toggles pause state of the timer.
 fn handle_pause(
     mut messages: MessageReader<PhaseTimerPauseMessage>,
     mut phase_res: ResMut<CurrentPhase>,
@@ -171,6 +176,7 @@ fn handle_pause(
     }
 }
 
+/// Transitions to the next phase based on current state.
 pub fn next_phase(
     current_phase: &mut CurrentPhase,
     session_tracker: &mut SessionTracker,
@@ -204,6 +210,7 @@ pub fn next_phase(
     }
 }
 
+/// Handles transition to the next phase after user confirmation.
 pub fn handle_continue(
     mut messages: MessageReader<NextPhaseMessage>,
     mut phase_res: ResMut<CurrentPhase>,
diff --git a/src/features/phase/utils.rs b/src/features/phase/utils.rs
index fb280fe..cc352a1 100644
--- a/src/features/phase/utils.rs
+++ b/src/features/phase/utils.rs
@@ -1,3 +1,4 @@
+/// Formats seconds into MM:SS or HH:MM:SS string.
 pub fn format_time(seconds: f32) -> String {
     let seconds = seconds.max(0.0) as u32;
 
diff --git a/src/features/savegame/components.rs b/src/features/savegame/components.rs
index 5aa082e..4ed2aaf 100644
--- a/src/features/savegame/components.rs
+++ b/src/features/savegame/components.rs
@@ -2,9 +2,11 @@ use crate::prelude::*;
 use std::fs;
 use std::path::PathBuf;
 
+/// Resource containing the path to the current save file.
 #[derive(Resource, Clone, Debug)]
 pub struct SavegamePath(pub PathBuf);
 
+/// Metadata about a savegame.
 #[derive(Debug)]
 pub struct SavegameInfo {
     pub path: SavegamePath,
@@ -13,11 +15,13 @@ pub struct SavegameInfo {
     pub completed_focus: u32,
 }
 
+/// Helper for partial JSON deserialization.
 #[derive(Deserialize)]
 struct PartialSaveData {
     session_tracker: PartialSessionTracker,
 }
 
+/// Helper for partial JSON deserialization of session stats.
 #[derive(Deserialize)]
 struct PartialSessionTracker {
     completed_focus_phases: u32,
@@ -26,6 +30,7 @@ struct PartialSessionTracker {
 }
 
 impl SavegamePath {
+    /// Constructs a new path for a specific save index.
     pub fn new(index: u32) -> Self {
         let base_path = get_internal_path().unwrap_or_else(|| {
             println!(
@@ -41,6 +46,7 @@ impl SavegamePath {
         Self(base_path.join(format!("savegame-{}.json", index)))
     }
 
+    /// Lists all available savegames.
     pub fn list() -> Vec<SavegameInfo> {
         let mut savegames = Vec::new();
 
@@ -88,6 +94,7 @@ impl SavegamePath {
         savegames
     }
 
+    /// Returns a path for a new savegame (incremented index).
     pub fn next() -> Self {
         let savegames = Self::list();
         let next_index = savegames.last().map(|s| s.index + 1).unwrap_or(0);
@@ -95,11 +102,13 @@ impl SavegamePath {
     }
 }
 
+/// Markers for savegame UI.
 #[derive(Component)]
 pub enum RootMarker {
     PopupSavegameLoad,
 }
 
+/// Buttons for savegame management.
 #[derive(Component)]
 pub enum ButtonType {
     SavegameLoad { savegame_path: SavegamePath },
diff --git a/src/features/savegame/messages.rs b/src/features/savegame/messages.rs
index 3c03fad..6dbfdfa 100644
--- a/src/features/savegame/messages.rs
+++ b/src/features/savegame/messages.rs
@@ -1,7 +1,9 @@
 use crate::prelude::*;
 
+/// Trigger to save the current game.
 #[derive(Message)]
 pub struct SavegameDumpMessage;
 
+/// Trigger to load a game from disk.
 #[derive(Message)]
 pub struct SavegameLoadMessage;
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index 3be631f..ca6441b 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -10,6 +10,7 @@ pub mod components;
 pub mod messages;
 pub mod ui;
 
+/// Plugin dealing with savegame loading and saving.
 pub struct SavegamePlugin;
 
 impl Plugin for SavegamePlugin {
@@ -25,6 +26,7 @@ impl Plugin for SavegamePlugin {
     }
 }
 
+/// The structure of a save file.
 #[derive(Serialize, Deserialize)]
 struct SaveData {
     grid_width: u32,
@@ -37,6 +39,7 @@ struct SaveData {
     inventory: Vec<ItemStack>,
 }
 
+/// Serializes game state and writes it to a file.
 fn dump_savegame(
     mut messages: MessageReader<SavegameDumpMessage>,
     save_path: Res<SavegamePath>,
@@ -106,6 +109,7 @@ fn dump_savegame(
     }
 }
 
+/// Reads a save file and restores game state.
 fn load_savegame(
     mut commands: Commands,
     mut messages: MessageReader<SavegameLoadMessage>,
@@ -174,7 +178,7 @@ fn load_savegame(
     }
 }
 
-/// Resets all components/resources loaded by `load_savegame`
+/// Resets all components/resources loaded by `load_savegame`.
 fn reset_savegame(
     mut commands: Commands,
     grid: Res<Grid>,
diff --git a/src/features/savegame/ui/load.rs b/src/features/savegame/ui/load.rs
index 729cea4..8871061 100644
--- a/src/features/savegame/ui/load.rs
+++ b/src/features/savegame/ui/load.rs
@@ -1,6 +1,7 @@
 use super::super::components::{ButtonType, RootMarker};
 use crate::{features::savegame::messages::SavegameLoadMessage, prelude::*};
 
+/// Spawns the "Load Game" popup.
 pub fn spawn_load_popup(commands: &mut Commands) {
     spawn_popup(
         commands,
@@ -88,6 +89,7 @@ pub fn spawn_load_popup(commands: &mut Commands) {
     );
 }
 
+/// Handles interactions in the load popup.
 pub fn load_popup_handler(
     mut commands: Commands,
     mut next_state: ResMut<NextState<AppState>>,
diff --git a/src/features/wonderevent/components.rs b/src/features/wonderevent/components.rs
index 822f738..43c232a 100644
--- a/src/features/wonderevent/components.rs
+++ b/src/features/wonderevent/components.rs
@@ -1,5 +1,6 @@
 use crate::prelude::*;
 
+/// Defines the bounds of the grid for the server.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub struct MaxFieldSize {
     #[serde(rename = "minX")]
@@ -12,12 +13,14 @@ pub struct MaxFieldSize {
     pub max_y: u32,
 }
 
+/// Coordinates for a wonder event target.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub struct Position {
     pub x: u32,
     pub y: u32,
 }
 
+/// WebSocket messages exchanged with the wonder event server.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 #[serde(tag = "messageType")]
 pub enum WonderEventMessage {
diff --git a/src/features/wonderevent/mod.rs b/src/features/wonderevent/mod.rs
index 164eabe..aa7dd08 100644
--- a/src/features/wonderevent/mod.rs
+++ b/src/features/wonderevent/mod.rs
@@ -9,20 +9,25 @@ use url::Url;
 
 pub mod components;
 
+/// Plugin managing random wonder events via WebSocket.
 pub struct WonderEventPlugin;
 
+/// Message to initiate a wonder event request.
 #[derive(Message)]
 pub struct RequestWonderEvent {
     pub url_str: String,
     pub max_field_size: MaxFieldSize,
 }
 
+/// Resource holding the channel sender for wonder events.
 #[derive(Resource)]
 pub struct WonderEventSender(pub Sender<WonderEventMessage>);
 
+/// Resource holding the channel receiver for wonder events.
 #[derive(Resource)]
 pub struct WonderEventReceiver(pub Mutex<Receiver<WonderEventMessage>>);
 
+/// Component for animated floating text effects.
 #[derive(Component)]
 struct FloatingText {
     timer: Timer,
@@ -49,11 +54,13 @@ impl Plugin for WonderEventPlugin {
     }
 }
 
+/// Tracks if an event has already triggered this phase.
 #[derive(Resource, Default)]
 struct WonderEventState {
     triggered_for_current_phase: bool,
 }
 
+/// Checks if the focus phase is halfway through to trigger an event.
 fn check_halfway_focus(
     mut state: ResMut<WonderEventState>,
     phase_res: Res<CurrentPhase>,
@@ -95,6 +102,7 @@ fn check_halfway_focus(
     }
 }
 
+/// Spawns a thread to request a wonder event from the server.
 fn handle_wonder_event_trigger(
     mut events: MessageReader<RequestWonderEvent>,
     sender: Res<WonderEventSender>,
@@ -159,6 +167,7 @@ fn handle_wonder_event_trigger(
     }
 }
 
+/// Processes responses from the wonder event server.
 fn handle_wonder_event_response(
     receiver: Res<WonderEventReceiver>,
     grid: Res<Grid>,
@@ -241,6 +250,7 @@ fn handle_wonder_event_response(
     }
 }
 
+/// Updates floating text positions and lifetimes.
 fn animate_floating_text(
     mut commands: Commands,
     time: Res<Time>,

From 81ff75630e6acf9b2ba6a010a4db593b655ac78b Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:28:55 +0100
Subject: [PATCH 52/71] feat: add keybinds for inventory and settings (#66)

---
 src/features/input/mod.rs | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index d2dd287..a57be0b 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -1,9 +1,11 @@
 use crate::features::{
+    hud::ui::settings::open_settings,
     input::utils::mouse_to_grid,
+    inventory::{components::ItemStack, ui::open_inventory},
     phase::messages::{NextPhaseMessage, PhaseTimerPauseMessage},
     pom::messages::InvalidMoveMessage,
     shop::ui::open_shop,
-    ui::messages::ClosePopupMessage,
+    ui::{messages::ClosePopupMessage, ui::popups::PopupRoot},
 };
 use crate::prelude::*;
 use bevy::input::mouse::MouseButton;
@@ -40,6 +42,7 @@ impl Plugin for InputPlugin {
         app.add_systems(Update, next_phase.run_if(in_state(AppState::GameScreen)));
 
         app.add_systems(Update, shop_keybind.run_if(in_state(AppState::GameScreen)));
+        app.add_systems(Update, inventory_keybind.run_if(in_state(AppState::GameScreen)));
 
         app.add_message::<ClosePopupMessage>();
         app.add_systems(Update, popup_keybind);
@@ -261,12 +264,31 @@ fn shop_keybind(
     }
 }
 
-/// Closes popups on Escape press.
+/// Opens the inventory on 'I' press.
+fn inventory_keybind(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut commands: Commands,
+    item_stacks: Query<&ItemStack>,
+    game_config: Res<GameConfig>,
+    asset_server: Res<AssetServer>,
+) {
+    if keys.just_pressed(KeyCode::KeyI) {
+        open_inventory(&mut commands, item_stacks, &game_config, &asset_server);
+    }
+}
+
+/// Closes popups on Escape press or opens settings if no popup is open.
 fn popup_keybind(
     mut close_popup_messages: MessageWriter<ClosePopupMessage>,
     keys: Res<ButtonInput<KeyCode>>,
+    popup_query: Query<Entity, With<PopupRoot>>,
+    mut commands: Commands,
 ) {
     if keys.just_pressed(KeyCode::Escape) {
-        close_popup_messages.write(ClosePopupMessage);
+        if !popup_query.is_empty() {
+            close_popup_messages.write(ClosePopupMessage);
+        } else {
+            open_settings(&mut commands);
+        }
     }
 }

From ccf8209a7f97ce1b543e2e98c76e5ef6945e863c Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:29:20 +0100
Subject: [PATCH 53/71] feat: show keybinds on hud buttons (#66)

---
 src/features/hud/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index 3d50a06..f736d89 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -59,13 +59,13 @@ fn setup(mut commands: Commands, game_config: Res<GameConfig>, asset_server: Res
                 inventory::components::ButtonType::InventoryOpen,
                 ButtonVariant::Secondary,
                 Node::from_padding(UiRect::all(px(10))),
-                |color| text("Inventar", 16.0, color)
+                |color| text("Inventar [I]", 16.0, color)
             ),
             button(
                 ButtonType::SettingsOpen,
                 ButtonVariant::Secondary,
                 Node::from_padding(UiRect::all(px(10))),
-                |color| text("Einstellungen", 16.0, color)
+                |color| text("Einstellungen [Esc]", 16.0, color)
             )
         ],
     ));

From 57904e055be6e9c54665867cfdbd359c709a5401 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 18:37:22 +0100
Subject: [PATCH 54/71] fix: Initialize Notifications resource in wonderevent
 tests

---
 tests/wonderevent.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/wonderevent.rs b/tests/wonderevent.rs
index 2fb9a6d..80fc32f 100644
--- a/tests/wonderevent.rs
+++ b/tests/wonderevent.rs
@@ -3,6 +3,7 @@ use pomomon_garden::features::config::components::{BerrySeedConfig, GameConfig};
 use pomomon_garden::features::core::states::AppState;
 use pomomon_garden::features::grid::components::{Grid, Tile, TileState};
 use pomomon_garden::features::inventory::components::ItemType;
+use pomomon_garden::features::notification::components::Notifications;
 use pomomon_garden::features::phase::components::{CurrentPhase, Phase, TimerSettings};
 use pomomon_garden::features::wonderevent::components::{Position, WonderEventMessage};
 use pomomon_garden::features::wonderevent::{
@@ -16,6 +17,7 @@ fn test_wonder_event_triggers() {
     app.add_plugins(bevy::state::app::StatesPlugin);
     app.add_plugins(WonderEventPlugin);
 
+    app.insert_resource(Notifications::default());
     app.insert_resource(GameConfig::default());
     app.insert_resource(TimerSettings {
         focus_duration: 60, // 60 seconds
@@ -94,6 +96,7 @@ fn test_wonder_response_handling() {
     app.add_plugins(MinimalPlugins);
     app.add_plugins(bevy::state::app::StatesPlugin);
     app.add_plugins(WonderEventPlugin);
+    app.insert_resource(Notifications::default());
     app.insert_resource(GameConfig {
         berry_seeds: vec![BerrySeedConfig {
             name: "TestSeed".to_string(),

From c4bbe2015f14c1453dec1d463ce25e5113200500 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 19:50:25 +0100
Subject: [PATCH 55/71] fix: `SessionTracker` now updates at the same time
 berries are granted (#54)

---
 src/features/phase/mod.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index d730262..baf6397 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -135,6 +135,7 @@ fn grant_focus_rewards(
                 berries as i32,
             );
             session_tracker.total_berries_earned += berries;
+            session_tracker.completed_focus_phases += 1;
 
             let berries_name = match berries {
                 1 => ItemType::Berry.singular(&game_config),
@@ -179,14 +180,12 @@ fn handle_pause(
 /// Transitions to the next phase based on current state.
 pub fn next_phase(
     current_phase: &mut CurrentPhase,
-    session_tracker: &mut SessionTracker,
+    session_tracker: &SessionTracker,
     settings: &TimerSettings,
 ) {
     if let Phase::Finished { completed_phase } = &current_phase.0 {
         match **completed_phase {
             Phase::Focus { .. } => {
-                session_tracker.completed_focus_phases += 1;
-
                 let is_long_break = session_tracker.completed_focus_phases > 0
                     && session_tracker.completed_focus_phases % settings.long_break_interval == 0;
 
@@ -214,7 +213,7 @@ pub fn next_phase(
 pub fn handle_continue(
     mut messages: MessageReader<NextPhaseMessage>,
     mut phase_res: ResMut<CurrentPhase>,
-    mut session_tracker: ResMut<SessionTracker>,
+    session_tracker: Res<SessionTracker>,
     settings: Res<TimerSettings>,
     mut tile_query: Query<&mut TileState>,
     game_config: Res<GameConfig>,
@@ -226,7 +225,7 @@ pub fn handle_continue(
             false
         };
 
-        next_phase(&mut phase_res, &mut session_tracker, &settings);
+        next_phase(&mut phase_res, &session_tracker, &settings);
 
         if entering_break {
             println!("Growing crops and resetting watered state.");

From 24cecb582a3966ffcbd819a1df9201c25ec8f3b8 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Wed, 10 Dec 2025 20:00:07 +0100
Subject: [PATCH 56/71] test: Update session test to reflect `SessionTracker`
 bug fix

---
 tests/session.rs | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/tests/session.rs b/tests/session.rs
index ce8c486..b17efec 100644
--- a/tests/session.rs
+++ b/tests/session.rs
@@ -11,9 +11,13 @@ fn test_session_tracker_focus_to_short_break() {
         }),
     });
     let timer_settings = TimerSettings::default();
-    let mut session_tracker = SessionTracker::default();
+    // Simulate that grant_focus_rewards has already incremented the counter
+    let session_tracker = SessionTracker {
+        completed_focus_phases: 1,
+        total_berries_earned: 0,
+    };
 
-    next_phase(&mut current_phase, &mut session_tracker, &timer_settings);
+    next_phase(&mut current_phase, &session_tracker, &timer_settings);
 
     assert_eq!(
         session_tracker.completed_focus_phases, 1,
@@ -37,16 +41,17 @@ fn test_session_tracker_focus_to_long_break() {
         }),
     });
     let timer_settings = TimerSettings::default();
-    let mut session_tracker = SessionTracker {
-        completed_focus_phases: timer_settings.long_break_interval - 1,
+    // Simulate that grant_focus_rewards has already incremented the counter to the interval
+    let session_tracker = SessionTracker {
+        completed_focus_phases: timer_settings.long_break_interval,
         total_berries_earned: 0,
-    }; // To trigger long break on next phase
+    };
 
-    next_phase(&mut current_phase, &mut session_tracker, &timer_settings);
+    next_phase(&mut current_phase, &session_tracker, &timer_settings);
 
     assert_eq!(
         session_tracker.completed_focus_phases, timer_settings.long_break_interval,
-        "Completed focus phases should reach long break interval"
+        "Completed focus phases should remain at long break interval"
     );
     if let Phase::Break { duration } = current_phase.0 {
         assert_eq!(
@@ -65,13 +70,13 @@ fn test_session_tracker_break_to_focus() {
             duration: 5.0 * 60.0,
         }),
     });
-    let mut session_tracker = SessionTracker {
+    let session_tracker = SessionTracker {
         completed_focus_phases: 1,
         total_berries_earned: 0,
     }; // Arbitrary value, should not change
     let timer_settings = TimerSettings::default();
 
-    next_phase(&mut current_phase, &mut session_tracker, &timer_settings);
+    next_phase(&mut current_phase, &session_tracker, &timer_settings);
 
     assert_eq!(
         session_tracker.completed_focus_phases, 1,
@@ -91,7 +96,7 @@ fn test_session_tracker_break_to_focus() {
 fn test_session_tracker_not_finished_phase_no_change() {
     // Test that nothing changes if the phase is not `Finished`
     let mut current_phase = CurrentPhase(Phase::Focus { duration: 100.0 });
-    let mut session_tracker = SessionTracker {
+    let session_tracker = SessionTracker {
         completed_focus_phases: 0,
         total_berries_earned: 0,
     };
@@ -100,7 +105,7 @@ fn test_session_tracker_not_finished_phase_no_change() {
     let initial_phase = current_phase.0.clone();
     let initial_completed_focus = session_tracker.completed_focus_phases;
 
-    next_phase(&mut current_phase, &mut session_tracker, &timer_settings);
+    next_phase(&mut current_phase, &session_tracker, &timer_settings);
 
     assert_eq!(
         current_phase.0, initial_phase,
@@ -111,3 +116,4 @@ fn test_session_tracker_not_finished_phase_no_change() {
         "Session tracker should not change if phase not Finished"
     );
 }
+

From 2a1f8a7e7cde32da3e895e24f1e27b564fa4705c Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 13:55:14 +0100
Subject: [PATCH 57/71] feat: Implement timer settings in start screen

---
 src/features/start_screen/components.rs |   5 ++
 src/features/start_screen/mod.rs        | 115 +++++++++++++++++++++---
 2 files changed, 107 insertions(+), 13 deletions(-)

diff --git a/src/features/start_screen/components.rs b/src/features/start_screen/components.rs
index eea6455..cc077d0 100644
--- a/src/features/start_screen/components.rs
+++ b/src/features/start_screen/components.rs
@@ -1,9 +1,11 @@
+use crate::features::phase::components::TimerSettings;
 use crate::prelude::*;
 
 /// Markers for main menu UI.
 #[derive(Component)]
 pub enum RootMarker {
     MainMenu,
+    Settings,
 }
 
 /// Buttons in the main menu.
@@ -13,3 +15,6 @@ pub enum ButtonType {
     NewGame,
     Settings,
 }
+
+#[derive(Resource, Default, Debug)]
+pub struct StartScreenTimerSettings(pub Option<TimerSettings>);
diff --git a/src/features/start_screen/mod.rs b/src/features/start_screen/mod.rs
index bed89e7..81a833d 100644
--- a/src/features/start_screen/mod.rs
+++ b/src/features/start_screen/mod.rs
@@ -1,17 +1,30 @@
+use crate::features::hud::components::{SettingsTimerInput, TimerType};
+use crate::features::phase::components::TimerSettings;
 use crate::features::savegame::ui::spawn_load_popup;
 use crate::prelude::*;
 use components::*;
+use ui::settings::open_settings_menu;
 
 pub mod components;
+pub mod ui;
 
 /// Plugin for the main menu screen.
 pub struct StartScreenPlugin;
 
 impl Plugin for StartScreenPlugin {
     fn build(&self, app: &mut App) {
+        app.init_resource::<StartScreenTimerSettings>();
         app.add_systems(OnEnter(AppState::StartScreen), setup);
         app.add_systems(OnExit(AppState::StartScreen), cleanup);
-        app.add_systems(Update, menu.run_if(in_state(AppState::StartScreen)));
+        app.add_systems(
+            Update,
+            (menu, handle_settings_buttons, update_timer_settings_display)
+                .run_if(in_state(AppState::StartScreen)),
+        );
+        app.add_systems(
+            PostUpdate,
+            apply_start_screen_settings.run_if(in_state(AppState::GameScreen)),
+        );
     }
 }
 
@@ -70,18 +83,18 @@ fn menu(
 ) {
     for (interaction, button_type) in &mut interaction_query {
         match *interaction {
-            Interaction::Pressed => {
-                match button_type {
-                    ButtonType::LoadGame => {
-                        spawn_load_popup(&mut commands);
-                    }
-                    ButtonType::NewGame => {
-                        commands.insert_resource(SavegamePath::next());
-                        next_state.set(AppState::GameScreen);
-                    }
-                    ButtonType::Settings => todo!(),
-                };
-            }
+            Interaction::Pressed => match button_type {
+                ButtonType::LoadGame => {
+                    spawn_load_popup(&mut commands);
+                }
+                ButtonType::NewGame => {
+                    commands.insert_resource(SavegamePath::next());
+                    next_state.set(AppState::GameScreen);
+                }
+                ButtonType::Settings => {
+                    open_settings_menu(&mut commands);
+                }
+            },
             _ => (),
         }
     }
@@ -93,3 +106,79 @@ fn cleanup(mut commands: Commands, query: Query<Entity, With<RootMarker>>) {
         commands.entity(entity).despawn();
     }
 }
+
+/// Handles button interactions within the settings menu.
+fn handle_settings_buttons(
+    mut interaction_query: Query<
+        (&Interaction, &crate::features::hud::components::ButtonType),
+        (Changed<Interaction>, With<Button>),
+    >,
+    mut timer_settings: ResMut<TimerSettings>,
+    mut ss_timer_settings: ResMut<StartScreenTimerSettings>,
+    keys: Res<ButtonInput<KeyCode>>,
+) {
+    let shift_multiplier = if keys.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]) {
+        10
+    } else {
+        1
+    };
+
+    for (interaction, button_type) in &mut interaction_query {
+        if *interaction == Interaction::Pressed {
+            if let crate::features::hud::components::ButtonType::SettingsTimerChange {
+                input,
+                amount,
+            } = button_type
+            {
+                match input {
+                    SettingsTimerInput::Minutes(timer_type) => {
+                        timer_settings.change(timer_type, 60 * amount * shift_multiplier)
+                    }
+                    SettingsTimerInput::Seconds(timer_type) => {
+                        timer_settings.change(timer_type, *amount * shift_multiplier)
+                    }
+                }
+                ss_timer_settings.0 = Some(timer_settings.clone());
+            }
+        }
+    }
+}
+
+/// Updates the timer settings display in the settings menu.
+fn update_timer_settings_display(
+    timer_settings: Res<TimerSettings>,
+    mut query: Query<(&SettingsTimerInput, &mut Text)>,
+) {
+    for (input_type, mut text) in query.iter_mut() {
+        match input_type {
+            SettingsTimerInput::Minutes(timer_type) => {
+                let value = match timer_type {
+                    TimerType::Focus => timer_settings.focus_duration,
+                    TimerType::ShortBreak => timer_settings.short_break_duration,
+                    TimerType::LongBreak => timer_settings.long_break_duration,
+                } as f32;
+
+                text.0 = format!("{:0>2}", (value / 60.0).floor());
+            }
+            SettingsTimerInput::Seconds(timer_type) => {
+                let value = match timer_type {
+                    TimerType::Focus => timer_settings.focus_duration,
+                    TimerType::ShortBreak => timer_settings.short_break_duration,
+                    TimerType::LongBreak => timer_settings.long_break_duration,
+                };
+
+                text.0 = format!("{:0>2}", (value % 60));
+            }
+        }
+    }
+}
+
+/// Applies the timer settings from the start screen once the game screen is entered.
+fn apply_start_screen_settings(
+    mut settings: ResMut<TimerSettings>,
+    mut ss_settings: ResMut<StartScreenTimerSettings>,
+) {
+    if let Some(new_settings) = ss_settings.0.take() {
+        *settings = new_settings;
+    }
+}

From ac06bc598b3dd3c357957f2d72df0daaeb1295f2 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 13:55:43 +0100
Subject: [PATCH 58/71] feat: Add UI for start screen settings

---
 src/features/start_screen/ui/mod.rs      |  1 +
 src/features/start_screen/ui/settings.rs | 71 ++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 src/features/start_screen/ui/mod.rs
 create mode 100644 src/features/start_screen/ui/settings.rs

diff --git a/src/features/start_screen/ui/mod.rs b/src/features/start_screen/ui/mod.rs
new file mode 100644
index 0000000..6e98cef
--- /dev/null
+++ b/src/features/start_screen/ui/mod.rs
@@ -0,0 +1 @@
+pub mod settings;
diff --git a/src/features/start_screen/ui/settings.rs b/src/features/start_screen/ui/settings.rs
new file mode 100644
index 0000000..8c113cd
--- /dev/null
+++ b/src/features/start_screen/ui/settings.rs
@@ -0,0 +1,71 @@
+use crate::features::hud::components::TimerType;
+use crate::features::hud::ui::timer_settings::timer_settings;
+use crate::features::start_screen::components::RootMarker;
+use crate::prelude::*;
+
+/// Spawns the settings popup for the start screen.
+pub fn open_settings_menu(commands: &mut Commands) {
+    spawn_popup(
+        commands,
+        RootMarker::Settings,
+        "Einstellungen",
+        Node {
+            width: px(700),
+            ..default()
+        },
+        |parent| {
+            parent.spawn((
+                Node {
+                    justify_content: JustifyContent::Center,
+                    ..Node::hstack(px(30))
+                },
+                children![
+                    (
+                        Node {
+                            width: percent(40),
+                            ..Node::vstack(px(10))
+                        },
+                        children![
+                            text("Timer Einstellungen", 18.0, Color::WHITE),
+                            text(
+                                "Tipp: Benutze [Umschalt] um in 10er Schritten zu inkrementieren oder dekrementieren!",
+                                16.0,
+                                Color::WHITE
+                            ),
+                        ]
+                    ),
+                    (
+                        Node {
+                            align_items: AlignItems::Center,
+                            ..Node::vstack(px(10))
+                        },
+                        children![
+                            text("Fokus Phase", 12.0, Color::WHITE),
+                            timer_settings(TimerType::Focus)
+                        ]
+                    ),
+                    (
+                        Node {
+                            align_items: AlignItems::Center,
+                            ..Node::vstack(px(10))
+                        },
+                        children![
+                            text("Kurze Pause", 12.0, Color::WHITE),
+                            timer_settings(TimerType::ShortBreak)
+                        ]
+                    ),
+                    (
+                        Node {
+                            align_items: AlignItems::Center,
+                            ..Node::vstack(px(10))
+                        },
+                        children![
+                            text("Lange Pause", 12.0, Color::WHITE),
+                            timer_settings(TimerType::LongBreak)
+                        ]
+                    )
+                ],
+            ));
+        },
+    );
+}

From 172f32a4d8a4fb23975baa81c6a73155f689a0b9 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 17:26:19 +0100
Subject: [PATCH 59/71] feat: Add achievement tracking and persistence (#42)

---
 Cargo.lock                             | 26 +++++++++--
 Cargo.toml                             |  2 +
 src/features/achievement/components.rs | 65 ++++++++++++++++++++++++++
 src/features/achievement/mod.rs        | 32 +++++++++++++
 src/features/mod.rs                    |  2 +
 src/features/phase/components.rs       |  1 +
 src/features/phase/mod.rs              |  6 ++-
 src/features/savegame/mod.rs           |  8 ++++
 src/main.rs                            |  1 +
 9 files changed, 139 insertions(+), 4 deletions(-)
 create mode 100644 src/features/achievement/components.rs
 create mode 100644 src/features/achievement/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0ac9b38..1e88b66 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -210,7 +210,7 @@ dependencies = [
  "flate2",
  "itertools 0.13.0",
  "nom",
- "strum",
+ "strum 0.26.3",
  "thiserror 1.0.69",
 ]
 
@@ -3940,6 +3940,8 @@ dependencies = [
  "directories",
  "serde",
  "serde_json",
+ "strum 0.27.2",
+ "strum_macros 0.27.2",
  "tungstenite",
  "url",
  "uuid",
@@ -4565,9 +4567,15 @@ version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.26.4",
 ]
 
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+
 [[package]]
 name = "strum_macros"
 version = "0.26.4"
@@ -4581,6 +4589,18 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "svg_fmt"
 version = "0.4.5"
@@ -4714,7 +4734,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.2",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index bdee263..2dedd2b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,6 +22,8 @@ serde_json = "1.0"
 directories = "6.0"
 tungstenite = { version = "0.28.0", features = ["native-tls"] }
 url = "2.5.7"
+strum = "0.27.2"
+strum_macros = "0.27.2"
 
 [dev-dependencies]
 uuid = "1.18.1"
diff --git a/src/features/achievement/components.rs b/src/features/achievement/components.rs
new file mode 100644
index 0000000..788daf8
--- /dev/null
+++ b/src/features/achievement/components.rs
@@ -0,0 +1,65 @@
+use crate::{features::phase::components::SessionTracker, prelude::*};
+use std::collections::HashMap;
+use strum_macros::EnumIter;
+
+/// Represents an unlockable achievement.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash, EnumIter)]
+pub enum AchievementId {
+    // Berry achievements
+    FirstSteps,
+    MasterFarmer,
+    BerryTycoon,
+    // Focus achievements,
+    GettingStarted,
+    FocusMaster,
+    ZenMaster,
+    // Withered achievements
+    Negligent,
+    CompostKing,
+}
+
+impl AchievementId {
+    /// Label to be displayed ingame
+    pub fn label(&self) -> String {
+        match self {
+            AchievementId::FirstSteps => "Erste Schritte: Verdiene eine Beere.",
+            AchievementId::MasterFarmer => "Meisterbauer: Verdiene 100 Beeren.",
+            AchievementId::BerryTycoon => "Beeren-Tycoon: Verdiene 1.000 Beeren.",
+            AchievementId::GettingStarted => "Aller Anfang: Schließe deine erste Fokus-Phase ab.",
+            AchievementId::FocusMaster => "Fokus-Meister: Schließe 10 Fokus-Phasen ab.",
+            AchievementId::ZenMaster => "Zen-Meister: Schließe 50 Fokus-Phasen ab.",
+            AchievementId::Negligent => "Nachlässig: Lasse eine Pflanze verdorren.",
+            AchievementId::CompostKing => "Kompost-König: Lasse 10 Pflanzen verdorren.",
+        }
+        .into()
+    }
+
+    /// Checks if an achievement's conditions are met
+    pub fn conditions_met(&self, tracker: &SessionTracker) -> bool {
+        match self {
+            AchievementId::FirstSteps => tracker.total_berries_earned >= 1,
+            AchievementId::MasterFarmer => tracker.total_berries_earned >= 100,
+            AchievementId::BerryTycoon => tracker.total_berries_earned >= 1000,
+            AchievementId::GettingStarted => tracker.completed_focus_phases >= 1,
+            AchievementId::FocusMaster => tracker.completed_focus_phases >= 10,
+            AchievementId::ZenMaster => tracker.completed_focus_phases >= 50,
+            AchievementId::Negligent => tracker.total_plants_withered >= 1,
+            AchievementId::CompostKing => tracker.total_plants_withered >= 10,
+        }
+    }
+}
+
+#[derive(Resource, Default, Debug, Serialize, Deserialize, Clone)]
+pub struct AchievementProgress {
+    pub unlocked: HashMap<AchievementId, bool>,
+}
+
+impl AchievementProgress {
+    pub fn is_unlocked(&self, id: &AchievementId) -> bool {
+        *self.unlocked.get(id).unwrap_or(&false)
+    }
+
+    pub fn unlock(&mut self, id: AchievementId) {
+        self.unlocked.insert(id, true);
+    }
+}
diff --git a/src/features/achievement/mod.rs b/src/features/achievement/mod.rs
new file mode 100644
index 0000000..eaff214
--- /dev/null
+++ b/src/features/achievement/mod.rs
@@ -0,0 +1,32 @@
+use crate::features::notification::components::Notifications;
+use crate::features::phase::components::SessionTracker;
+use crate::prelude::*;
+use components::{AchievementId, AchievementProgress};
+use strum::IntoEnumIterator;
+
+pub mod components;
+
+pub struct AchievementPlugin;
+
+impl Plugin for AchievementPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<AchievementProgress>();
+        app.add_systems(
+            Update,
+            check_achievements.run_if(in_state(AppState::GameScreen)),
+        );
+    }
+}
+
+fn check_achievements(
+    tracker: Res<SessionTracker>,
+    mut progress: ResMut<AchievementProgress>,
+    mut notifications: ResMut<Notifications>,
+) {
+    for achievement in AchievementId::iter() {
+        if !progress.is_unlocked(&achievement) && achievement.conditions_met(&tracker) {
+            progress.unlock(achievement.clone());
+            notifications.info(Some("Erfolg freigeschaltet!"), achievement.label());
+        }
+    }
+}
diff --git a/src/features/mod.rs b/src/features/mod.rs
index 6b6c2b8..a47c7ad 100644
--- a/src/features/mod.rs
+++ b/src/features/mod.rs
@@ -1,3 +1,4 @@
+pub mod achievement;
 pub mod config;
 pub mod core;
 pub mod game_screen;
@@ -14,6 +15,7 @@ pub mod start_screen;
 pub mod ui;
 pub mod wonderevent;
 
+pub use achievement::AchievementPlugin;
 pub use core::CorePlugin;
 pub use game_screen::GameScreenPlugin;
 pub use grid::GridPlugin;
diff --git a/src/features/phase/components.rs b/src/features/phase/components.rs
index 7dc430d..e41947d 100644
--- a/src/features/phase/components.rs
+++ b/src/features/phase/components.rs
@@ -67,4 +67,5 @@ impl Default for TimerSettings {
 pub struct SessionTracker {
     pub completed_focus_phases: u32,
     pub total_berries_earned: u32,
+    pub total_plants_withered: u32,
 }
diff --git a/src/features/phase/mod.rs b/src/features/phase/mod.rs
index baf6397..0bb49e2 100644
--- a/src/features/phase/mod.rs
+++ b/src/features/phase/mod.rs
@@ -213,7 +213,7 @@ pub fn next_phase(
 pub fn handle_continue(
     mut messages: MessageReader<NextPhaseMessage>,
     mut phase_res: ResMut<CurrentPhase>,
-    session_tracker: Res<SessionTracker>,
+    mut session_tracker: ResMut<SessionTracker>,
     settings: Res<TimerSettings>,
     mut tile_query: Query<&mut TileState>,
     game_config: Res<GameConfig>,
@@ -256,6 +256,10 @@ pub fn handle_continue(
                         }
                     }
 
+                    if new_withered && !*withered {
+                        session_tracker.total_plants_withered += 1;
+                    }
+
                     *state = TileState::Occupied {
                         seed: seed.clone(),
                         watered: false,
diff --git a/src/features/savegame/mod.rs b/src/features/savegame/mod.rs
index ca6441b..4584e23 100644
--- a/src/features/savegame/mod.rs
+++ b/src/features/savegame/mod.rs
@@ -1,3 +1,4 @@
+use crate::features::achievement::components::AchievementProgress;
 use crate::features::phase::components::{SessionTracker, TimerSettings};
 use crate::features::savegame::ui::load_popup_handler;
 use crate::prelude::*;
@@ -34,6 +35,7 @@ struct SaveData {
     tiles: Vec<Vec<TileState>>,
     current_phase: CurrentPhase,
     session_tracker: SessionTracker,
+    achievement_progress: AchievementProgress,
     timer_settings: TimerSettings,
     pom_position: GridPosition,
     inventory: Vec<ItemStack>,
@@ -47,6 +49,7 @@ fn dump_savegame(
     tile_query: Query<&TileState>,
     phase: Res<CurrentPhase>,
     tracker: Res<SessionTracker>,
+    achievement_progress: Res<AchievementProgress>,
     settings: Res<TimerSettings>,
     pom_query: Query<&GridPosition, With<Pom>>,
     inventory: Res<Inventory>,
@@ -85,6 +88,7 @@ fn dump_savegame(
             tiles: tile_states,
             current_phase: phase.clone(),
             session_tracker: tracker.clone(),
+            achievement_progress: achievement_progress.clone(),
             timer_settings: settings.clone(),
             pom_position: *pom_pos,
             inventory: item_stacks,
@@ -118,6 +122,7 @@ fn load_savegame(
     mut tile_query: Query<&mut TileState>,
     mut phase: ResMut<CurrentPhase>,
     mut tracker: ResMut<SessionTracker>,
+    mut achievement_progress: ResMut<AchievementProgress>,
     mut settings: ResMut<TimerSettings>,
     mut pom_query: Query<(&mut GridPosition, &mut Transform), With<Pom>>,
     mut inventory: ResMut<Inventory>,
@@ -134,6 +139,7 @@ fn load_savegame(
                 Ok(save_data) => {
                     *phase = save_data.current_phase;
                     *tracker = save_data.session_tracker;
+                    *achievement_progress = save_data.achievement_progress;
                     *settings = save_data.timer_settings;
 
                     if let Ok((mut pom_pos, mut pom_transform)) = pom_query.single_mut() {
@@ -185,11 +191,13 @@ fn reset_savegame(
     mut tile_query: Query<&mut TileState>,
     mut phase: ResMut<CurrentPhase>,
     mut tracker: ResMut<SessionTracker>,
+    mut achievement_progress: ResMut<AchievementProgress>,
     mut settings: ResMut<TimerSettings>,
     mut pom_query: Query<(&mut GridPosition, &mut Transform), With<Pom>>,
     mut inventory: ResMut<Inventory>,
 ) {
     *tracker = SessionTracker::default();
+    *achievement_progress = AchievementProgress::default();
     *settings = TimerSettings::default();
     *phase = CurrentPhase(Phase::Focus {
         duration: settings.focus_duration as f32,
diff --git a/src/main.rs b/src/main.rs
index 01c3643..af08cac 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -36,6 +36,7 @@ fn main() {
             features::ShopPlugin,
             features::WonderEventPlugin,
             features::NotificationPlugin,
+            features::AchievementPlugin,
         ))
         .insert_resource(config)
         .add_systems(Startup, overwrite_default_font)

From efc69f6be0cec47c4547f819800a17d86430d7dd Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 17:35:00 +0100
Subject: [PATCH 60/71] test: Fix session tests for new session tracker field

---
 tests/session.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/session.rs b/tests/session.rs
index b17efec..323c779 100644
--- a/tests/session.rs
+++ b/tests/session.rs
@@ -15,6 +15,7 @@ fn test_session_tracker_focus_to_short_break() {
     let session_tracker = SessionTracker {
         completed_focus_phases: 1,
         total_berries_earned: 0,
+        total_plants_withered: 0,
     };
 
     next_phase(&mut current_phase, &session_tracker, &timer_settings);
@@ -45,6 +46,7 @@ fn test_session_tracker_focus_to_long_break() {
     let session_tracker = SessionTracker {
         completed_focus_phases: timer_settings.long_break_interval,
         total_berries_earned: 0,
+        total_plants_withered: 0,
     };
 
     next_phase(&mut current_phase, &session_tracker, &timer_settings);
@@ -73,6 +75,7 @@ fn test_session_tracker_break_to_focus() {
     let session_tracker = SessionTracker {
         completed_focus_phases: 1,
         total_berries_earned: 0,
+        total_plants_withered: 0,
     }; // Arbitrary value, should not change
     let timer_settings = TimerSettings::default();
 
@@ -99,6 +102,7 @@ fn test_session_tracker_not_finished_phase_no_change() {
     let session_tracker = SessionTracker {
         completed_focus_phases: 0,
         total_berries_earned: 0,
+        total_plants_withered: 0,
     };
     let timer_settings = TimerSettings::default();
 

From aae0420528d48f9e722cc2eef401b47311a665d5 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 17:35:41 +0100
Subject: [PATCH 61/71] refactor: Remove empty trailing line

---
 tests/session.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/session.rs b/tests/session.rs
index 323c779..e613bef 100644
--- a/tests/session.rs
+++ b/tests/session.rs
@@ -120,4 +120,3 @@ fn test_session_tracker_not_finished_phase_no_change() {
         "Session tracker should not change if phase not Finished"
     );
 }
-

From 63a23ae9a8cc6f009d63574ed756a21e68e530a2 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 17:42:55 +0100
Subject: [PATCH 62/71] test: Add achievement unlock logic test

---
 tests/achievement.rs | 75 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 tests/achievement.rs

diff --git a/tests/achievement.rs b/tests/achievement.rs
new file mode 100644
index 0000000..8f9001c
--- /dev/null
+++ b/tests/achievement.rs
@@ -0,0 +1,75 @@
+use pomomon_garden::features::achievement::AchievementPlugin;
+use pomomon_garden::features::achievement::components::{AchievementId, AchievementProgress};
+use pomomon_garden::features::notification::components::Notifications;
+use pomomon_garden::features::phase::components::SessionTracker;
+use pomomon_garden::prelude::*;
+use strum::IntoEnumIterator;
+
+#[test]
+fn test_achievement_unlock_logic() {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins);
+    app.add_plugins(AchievementPlugin);
+    app.insert_resource(Notifications::default()); // Needs to be present because check_achievements uses it
+
+    // Helper to run systems and get progress
+    let mut run_check = |completed_focus: u32, total_berries: u32, total_withered: u32| {
+        app.insert_resource(SessionTracker {
+            completed_focus_phases: completed_focus,
+            total_berries_earned: total_berries,
+            total_plants_withered: total_withered,
+        });
+        app.update(); // Runs check_achievements
+        app.world().resource::<AchievementProgress>().clone()
+    };
+
+    // --- Initial State ---
+    let progress = run_check(0, 0, 0);
+    for id in AchievementId::iter() {
+        assert!(
+            !progress.is_unlocked(&id),
+            "Achievement {:?} should not be unlocked initially",
+            id
+        );
+    }
+
+    // --- First Steps (1 berry) ---
+    let progress = run_check(0, 1, 0);
+    assert!(progress.is_unlocked(&AchievementId::FirstSteps));
+
+    // --- Getting Started (1 focus phase) ---
+    let progress = run_check(1, 1, 0);
+    assert!(progress.is_unlocked(&AchievementId::GettingStarted));
+
+    // --- Negligent (1 withered plant) ---
+    let progress = run_check(1, 1, 1);
+    assert!(progress.is_unlocked(&AchievementId::Negligent));
+
+    // --- Focus Master (10 focus phases) ---
+    let progress = run_check(10, 1, 1);
+    assert!(progress.is_unlocked(&AchievementId::FocusMaster));
+
+    // --- Master Farmer (100 berries) ---
+    let progress = run_check(10, 100, 1);
+    assert!(progress.is_unlocked(&AchievementId::MasterFarmer));
+
+    // --- Zen Master (50 focus phases) ---
+    let progress = run_check(50, 100, 1);
+    assert!(progress.is_unlocked(&AchievementId::ZenMaster));
+
+    // --- Compost King (10 withered plants) ---
+    let progress = run_check(50, 100, 10);
+    assert!(progress.is_unlocked(&AchievementId::CompostKing));
+
+    // --- Berry Tycoon (1000 berries) ---
+    let progress = run_check(50, 1000, 10);
+    assert!(progress.is_unlocked(&AchievementId::BerryTycoon));
+
+    // --- Test idempotency: already unlocked should stay unlocked ---
+    let initial_progress = progress.clone();
+    let progress = run_check(50, 1000, 10);
+    assert_eq!(progress.unlocked.len(), initial_progress.unlocked.len()); // Same number unlocked
+    for id in AchievementId::iter() {
+        assert_eq!(progress.is_unlocked(&id), initial_progress.is_unlocked(&id));
+    }
+}

From aa705983160512d9c4500bb8301c5d398732cbc6 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 18:47:42 +0100
Subject: [PATCH 63/71] test: Fix achievement integration test setup and system
 visibility (#42)

---
 src/features/achievement/mod.rs |  2 +-
 tests/achievement.rs            | 13 ++++++++++++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/features/achievement/mod.rs b/src/features/achievement/mod.rs
index eaff214..df4d7a5 100644
--- a/src/features/achievement/mod.rs
+++ b/src/features/achievement/mod.rs
@@ -18,7 +18,7 @@ impl Plugin for AchievementPlugin {
     }
 }
 
-fn check_achievements(
+pub fn check_achievements(
     tracker: Res<SessionTracker>,
     mut progress: ResMut<AchievementProgress>,
     mut notifications: ResMut<Notifications>,
diff --git a/tests/achievement.rs b/tests/achievement.rs
index 8f9001c..ee5aae6 100644
--- a/tests/achievement.rs
+++ b/tests/achievement.rs
@@ -1,5 +1,6 @@
 use pomomon_garden::features::achievement::AchievementPlugin;
 use pomomon_garden::features::achievement::components::{AchievementId, AchievementProgress};
+use pomomon_garden::features::core::states::AppState;
 use pomomon_garden::features::notification::components::Notifications;
 use pomomon_garden::features::phase::components::SessionTracker;
 use pomomon_garden::prelude::*;
@@ -9,8 +10,18 @@ use strum::IntoEnumIterator;
 fn test_achievement_unlock_logic() {
     let mut app = App::new();
     app.add_plugins(MinimalPlugins);
+    app.add_plugins(bevy::state::app::StatesPlugin);
     app.add_plugins(AchievementPlugin);
-    app.insert_resource(Notifications::default()); // Needs to be present because check_achievements uses it
+    app.init_state::<AppState>();
+
+    app.insert_resource(Notifications::default());
+    app.insert_resource(SessionTracker::default());
+
+    {
+        let mut next_state = app.world_mut().resource_mut::<NextState<AppState>>();
+        next_state.set(AppState::GameScreen);
+    }
+    app.update();
 
     // Helper to run systems and get progress
     let mut run_check = |completed_focus: u32, total_berries: u32, total_withered: u32| {

From e8af0add0bbadc254b771e907a9a55e64ff9600f Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 19:52:53 +0100
Subject: [PATCH 64/71] feat: Add achievement sprite (#47)

---
 assets/achievement.aseprite | Bin 0 -> 494 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 assets/achievement.aseprite

diff --git a/assets/achievement.aseprite b/assets/achievement.aseprite
new file mode 100644
index 0000000000000000000000000000000000000000..2d1c4137345f0b510065f23bad693e05f994a066
GIT binary patch
literal 494
zcmaFI$iVPmDI<db5GpVLISeU4i~x!Zj37a<JVKOutURFUzdo{oZDj)*D+a{u3ScXd
zEXf73SwOB+1TvHqOk6c=(ku=8!>sQYs@+_W_U`bk-=EB8J`Kp)XJ9@h&pT5;$Xmt8
z#?s!t#2}$5I`3if?Emp+pPat^=l}ozv)68KscX;7%8CpNDs$>uV`OwQJo$R{uKwv>
zUHJz8&l$;sEK^`cvi?7i&CcMHSeaU+U}y|>0<sIa861-{GE>V^b5rw5khB2<4HR$;
z417SWpuhx{`v1QgNV6(10KLP=@E;-w6yXEHiaE&%4bA^ul1e`O|E|9I{|Sa8?TG>o
zm)Xr<|F={Y*{boYq3A`~;WKJW_>Z-{Y~I+pkv~>m@|)p=hxR=NtS6HXTU=TE!nMp=
e&U(YEqmRU+ULN+)c6p&{9@F7>nc=U8K?4A(f^$Xy

literal 0
HcmV?d00001


From d58b23c1b1261243c34751275111e1a24ea9f3c1 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:19:00 +0100
Subject: [PATCH 65/71] feat: Add title and description methods to
 AchievementId (#47)

---
 src/features/achievement/components.rs | 40 +++++++++++++++++++-------
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/src/features/achievement/components.rs b/src/features/achievement/components.rs
index 788daf8..fef5673 100644
--- a/src/features/achievement/components.rs
+++ b/src/features/achievement/components.rs
@@ -19,21 +19,41 @@ pub enum AchievementId {
 }
 
 impl AchievementId {
-    /// Label to be displayed ingame
-    pub fn label(&self) -> String {
+    /// Title to be displayed ingame
+    pub fn title(&self) -> String {
         match self {
-            AchievementId::FirstSteps => "Erste Schritte: Verdiene eine Beere.",
-            AchievementId::MasterFarmer => "Meisterbauer: Verdiene 100 Beeren.",
-            AchievementId::BerryTycoon => "Beeren-Tycoon: Verdiene 1.000 Beeren.",
-            AchievementId::GettingStarted => "Aller Anfang: Schließe deine erste Fokus-Phase ab.",
-            AchievementId::FocusMaster => "Fokus-Meister: Schließe 10 Fokus-Phasen ab.",
-            AchievementId::ZenMaster => "Zen-Meister: Schließe 50 Fokus-Phasen ab.",
-            AchievementId::Negligent => "Nachlässig: Lasse eine Pflanze verdorren.",
-            AchievementId::CompostKing => "Kompost-König: Lasse 10 Pflanzen verdorren.",
+            AchievementId::FirstSteps => "Erste Schritte",
+            AchievementId::MasterFarmer => "Meisterbauer",
+            AchievementId::BerryTycoon => "Beeren-Tycoon",
+            AchievementId::GettingStarted => "Aller Anfang",
+            AchievementId::FocusMaster => "Fokus-Meister",
+            AchievementId::ZenMaster => "Zen-Meister",
+            AchievementId::Negligent => "Nachlässig",
+            AchievementId::CompostKing => "Kompost-König",
         }
         .into()
     }
 
+    /// Description to be displayed ingame
+    pub fn description(&self) -> String {
+        match self {
+            AchievementId::FirstSteps => "Verdiene eine Beere.",
+            AchievementId::MasterFarmer => "Verdiene 100 Beeren.",
+            AchievementId::BerryTycoon => "Verdiene 1.000 Beeren.",
+            AchievementId::GettingStarted => "Schließe deine erste Fokus-Phase ab.",
+            AchievementId::FocusMaster => "Schließe 10 Fokus-Phasen ab.",
+            AchievementId::ZenMaster => "Schließe 50 Fokus-Phasen ab.",
+            AchievementId::Negligent => "Lasse eine Pflanze verdorren.",
+            AchievementId::CompostKing => "Lasse 10 Pflanzen verdorren.",
+        }
+        .into()
+    }
+
+    /// Label to be displayed ingame (Title: Description)
+    pub fn label(&self) -> String {
+        format!("{}: {}", self.title(), self.description())
+    }
+
     /// Checks if an achievement's conditions are met
     pub fn conditions_met(&self, tracker: &SessionTracker) -> bool {
         match self {

From 8c9a27f0df6dd1f1812b963e0673b6028d6e5010 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:20:30 +0100
Subject: [PATCH 66/71] feat: Implement achievement menu UI (#47)

---
 src/features/achievement/mod.rs |  1 +
 src/features/achievement/ui.rs  | 90 +++++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 src/features/achievement/ui.rs

diff --git a/src/features/achievement/mod.rs b/src/features/achievement/mod.rs
index df4d7a5..3d8d7a0 100644
--- a/src/features/achievement/mod.rs
+++ b/src/features/achievement/mod.rs
@@ -5,6 +5,7 @@ use components::{AchievementId, AchievementProgress};
 use strum::IntoEnumIterator;
 
 pub mod components;
+pub mod ui;
 
 pub struct AchievementPlugin;
 
diff --git a/src/features/achievement/ui.rs b/src/features/achievement/ui.rs
new file mode 100644
index 0000000..8dbe75c
--- /dev/null
+++ b/src/features/achievement/ui.rs
@@ -0,0 +1,90 @@
+use crate::features::achievement::components::{AchievementId, AchievementProgress};
+use crate::features::ui::ui::popups::spawn_popup;
+use crate::prelude::*;
+use strum::IntoEnumIterator;
+
+#[derive(Component)]
+pub enum AchievementRootMarker {
+    Menu,
+}
+
+pub fn open_achievements_menu(commands: &mut Commands, progress: &AchievementProgress) {
+    spawn_popup(
+        commands,
+        AchievementRootMarker::Menu,
+        "Erfolge",
+        Node {
+            width: px(700),
+            height: px(500),
+            ..default()
+        },
+        |parent| {
+            // Scrollable Content
+            parent
+                .spawn((Node {
+                    width: percent(100),
+                    height: percent(100),
+                    flex_direction: FlexDirection::Column,
+                    overflow: Overflow::scroll_y(),
+                    padding: UiRect::all(px(10)),
+                    row_gap: px(10),
+                    ..default()
+                },))
+                .with_children(|list| {
+                    for id in AchievementId::iter() {
+                        let unlocked = progress.is_unlocked(&id);
+                        let color = if unlocked {
+                            Color::WHITE
+                        } else {
+                            Color::srgb(0.5, 0.5, 0.5)
+                        };
+
+                        let bg_color = if unlocked {
+                            Color::srgb(0.2, 0.3, 0.2) // Dark Greenish for unlocked
+                        } else {
+                            Color::srgb(0.1, 0.1, 0.1) // Dark Grey for locked
+                        };
+
+                        list.spawn((
+                            Node {
+                                width: percent(100),
+                                padding: UiRect::all(px(10)),
+                                flex_direction: FlexDirection::Column,
+                                row_gap: px(5),
+                                border: UiRect::all(px(2)),
+                                ..default()
+                            },
+                            BackgroundColor(bg_color),
+                            BorderColor::all(if unlocked {
+                                Color::srgb(0.4, 0.8, 0.4)
+                            } else {
+                                Color::BLACK
+                            }),
+                            BorderRadius::all(px(5)),
+                        ))
+                        .with_children(|item| {
+                            // Title
+                            item.spawn(text(id.title(), 20.0, color));
+                            // Description
+                            item.spawn(text(id.description(), 16.0, color));
+                            // Status Text
+                            let status = if unlocked {
+                                "Freigeschaltet"
+                            } else {
+                                "Gesperrt"
+                            };
+                            item.spawn(text(
+                                status,
+                                12.0,
+                                if unlocked {
+                                    Color::srgb(0.6, 1.0, 0.6)
+                                } else {
+                                    Color::srgb(0.7, 0.3, 0.3)
+                                },
+                            ));
+                        });
+                    }
+                });
+        },
+    );
+}

From 52dd300ca0bfb2e9d6ac81b3fc50512142089dc2 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:21:02 +0100
Subject: [PATCH 67/71] feat: Add achievements button to HUD settings (#47)

---
 src/features/hud/components.rs  |  1 +
 src/features/hud/mod.rs         | 11 +++++++++++
 src/features/hud/ui/settings.rs |  6 ++++++
 3 files changed, 18 insertions(+)

diff --git a/src/features/hud/components.rs b/src/features/hud/components.rs
index ccd9a63..449cb5a 100644
--- a/src/features/hud/components.rs
+++ b/src/features/hud/components.rs
@@ -21,6 +21,7 @@ pub enum ButtonType {
     SettingsOpen,
     SettingsExit,
     SettingsSave,
+    SettingsAchievements,
     SettingsTimerChange {
         input: SettingsTimerInput,
         amount: i32,
diff --git a/src/features/hud/mod.rs b/src/features/hud/mod.rs
index f736d89..27fa6fa 100644
--- a/src/features/hud/mod.rs
+++ b/src/features/hud/mod.rs
@@ -1,3 +1,4 @@
+use crate::features::achievement::{components::AchievementProgress, ui::open_achievements_menu};
 use crate::features::phase::components::TimerSettings;
 use crate::features::savegame::messages::SavegameDumpMessage;
 use crate::features::{inventory, shop};
@@ -151,6 +152,8 @@ fn buttons(
     mut next_state: ResMut<NextState<AppState>>,
     mut timer_settings: ResMut<TimerSettings>,
     keys: Res<ButtonInput<KeyCode>>,
+    achievement_progress: Res<AchievementProgress>,
+    root_query: Query<(Entity, &RootMarker)>,
 ) {
     let shift_multiplier = if keys.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]) {
         10
@@ -171,6 +174,14 @@ fn buttons(
                 ButtonType::SettingsSave => {
                     savegame_messages.write(SavegameDumpMessage);
                 }
+                ButtonType::SettingsAchievements => {
+                    open_achievements_menu(&mut commands, &achievement_progress);
+                    for (entity, root) in root_query.iter() {
+                        if let RootMarker::Settings = root {
+                            commands.entity(entity).despawn();
+                        }
+                    }
+                }
                 ButtonType::SettingsTimerChange { input, amount } => match input {
                     SettingsTimerInput::Minutes(timer_type) => {
                         timer_settings.change(timer_type, 60 * amount * shift_multiplier)
diff --git a/src/features/hud/ui/settings.rs b/src/features/hud/ui/settings.rs
index 1ae8962..0d1b70d 100644
--- a/src/features/hud/ui/settings.rs
+++ b/src/features/hud/ui/settings.rs
@@ -27,6 +27,12 @@ pub fn open_settings(commands: &mut Commands) {
                         ButtonVariant::Secondary,
                         Node::from_padding(UiRect::all(px(10))),
                         |color| text("Spiel speichern", 24.0, color)
+                    ),
+                    button(
+                        ButtonType::SettingsAchievements,
+                        ButtonVariant::Secondary,
+                        Node::from_padding(UiRect::all(px(10))),
+                        |color| text("Erfolge", 24.0, color)
                     ),(
                         Node {
                             justify_content: JustifyContent::Center,

From 2857f59a853e8fa6a53e8ea3fc7cc98a533510fe Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:21:46 +0100
Subject: [PATCH 68/71] feat: Show achievement progress in savegame load menu
 (#47)

---
 src/features/savegame/components.rs |  7 ++++++-
 src/features/savegame/ui/load.rs    | 25 ++++++++++++++++++++++++-
 src/features/start_screen/mod.rs    |  3 ++-
 3 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/features/savegame/components.rs b/src/features/savegame/components.rs
index 4ed2aaf..349bed5 100644
--- a/src/features/savegame/components.rs
+++ b/src/features/savegame/components.rs
@@ -1,3 +1,4 @@
+use crate::features::achievement::components::AchievementProgress;
 use crate::prelude::*;
 use std::fs;
 use std::path::PathBuf;
@@ -7,18 +8,20 @@ use std::path::PathBuf;
 pub struct SavegamePath(pub PathBuf);
 
 /// Metadata about a savegame.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SavegameInfo {
     pub path: SavegamePath,
     pub index: u32,
     pub total_berries: u32,
     pub completed_focus: u32,
+    pub achievement_progress: AchievementProgress,
 }
 
 /// Helper for partial JSON deserialization.
 #[derive(Deserialize)]
 struct PartialSaveData {
     session_tracker: PartialSessionTracker,
+    achievement_progress: AchievementProgress,
 }
 
 /// Helper for partial JSON deserialization of session stats.
@@ -87,6 +90,7 @@ impl SavegamePath {
                 index,
                 total_berries: data.session_tracker.total_berries_earned,
                 completed_focus: data.session_tracker.completed_focus_phases,
+                achievement_progress: data.achievement_progress,
             });
         }
 
@@ -113,4 +117,5 @@ pub enum RootMarker {
 pub enum ButtonType {
     SavegameLoad { savegame_path: SavegamePath },
     SavegameDelete { savegame_path: SavegamePath },
+    Achievements { savegame: SavegameInfo },
 }
diff --git a/src/features/savegame/ui/load.rs b/src/features/savegame/ui/load.rs
index 8871061..a03eb7c 100644
--- a/src/features/savegame/ui/load.rs
+++ b/src/features/savegame/ui/load.rs
@@ -1,8 +1,9 @@
 use super::super::components::{ButtonType, RootMarker};
+use crate::features::achievement::ui::open_achievements_menu;
 use crate::{features::savegame::messages::SavegameLoadMessage, prelude::*};
 
 /// Spawns the "Load Game" popup.
-pub fn spawn_load_popup(commands: &mut Commands) {
+pub fn spawn_load_popup(commands: &mut Commands, asset_server: &AssetServer) {
     spawn_popup(
         commands,
         RootMarker::PopupSavegameLoad,
@@ -78,6 +79,25 @@ pub fn spawn_load_popup(commands: &mut Commands) {
                                                 ..default()
                                             },
                                             |color| text("X", 24.0, color)
+                                        ),
+                                        button(
+                                            ButtonType::Achievements {
+                                                savegame: savegame.clone()
+                                            },
+                                            ButtonVariant::Primary,
+                                            Node {
+                                                width: px(40),
+                                                height: px(40),
+                                                ..default()
+                                            },
+                                            |_| (
+                                                ImageNode::default(),
+                                                AseSlice {
+                                                    aseprite: asset_server
+                                                        .load("achievement.aseprite"),
+                                                    name: "Achievement".into()
+                                                }
+                                            )
                                         )
                                     ],
                                 )
@@ -111,6 +131,9 @@ pub fn load_popup_handler(
                             println!("Error while deleting savegame: {:?}", e);
                         }
                     }
+                    ButtonType::Achievements { savegame } => {
+                        open_achievements_menu(&mut commands, &savegame.achievement_progress);
+                    }
                 };
 
                 for (entity, root) in root_query.iter() {
diff --git a/src/features/start_screen/mod.rs b/src/features/start_screen/mod.rs
index 81a833d..3109e67 100644
--- a/src/features/start_screen/mod.rs
+++ b/src/features/start_screen/mod.rs
@@ -80,12 +80,13 @@ fn menu(
     mut commands: Commands,
     mut next_state: ResMut<NextState<AppState>>,
     mut interaction_query: Query<(&Interaction, &ButtonType), (Changed<Interaction>, With<Button>)>,
+    asset_server: Res<AssetServer>,
 ) {
     for (interaction, button_type) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => match button_type {
                 ButtonType::LoadGame => {
-                    spawn_load_popup(&mut commands);
+                    spawn_load_popup(&mut commands, &asset_server);
                 }
                 ButtonType::NewGame => {
                     commands.insert_resource(SavegamePath::next());

From 01067d4770e1945e2068ee959941bd0e687af3b3 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:22:31 +0100
Subject: [PATCH 69/71] fix: Change order of buttons in load save game menu

---
 src/features/savegame/ui/load.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/features/savegame/ui/load.rs b/src/features/savegame/ui/load.rs
index a03eb7c..a9ec630 100644
--- a/src/features/savegame/ui/load.rs
+++ b/src/features/savegame/ui/load.rs
@@ -68,18 +68,6 @@ pub fn spawn_load_popup(commands: &mut Commands, asset_server: &AssetServer) {
                                                 ),
                                             ]
                                         ),
-                                        pill_button(
-                                            ButtonType::SavegameDelete {
-                                                savegame_path: savegame.path.clone()
-                                            },
-                                            ButtonVariant::Destructive,
-                                            Node {
-                                                width: px(40),
-                                                height: px(40),
-                                                ..default()
-                                            },
-                                            |color| text("X", 24.0, color)
-                                        ),
                                         button(
                                             ButtonType::Achievements {
                                                 savegame: savegame.clone()
@@ -98,6 +86,18 @@ pub fn spawn_load_popup(commands: &mut Commands, asset_server: &AssetServer) {
                                                     name: "Achievement".into()
                                                 }
                                             )
+                                        ),
+                                        pill_button(
+                                            ButtonType::SavegameDelete {
+                                                savegame_path: savegame.path.clone()
+                                            },
+                                            ButtonVariant::Destructive,
+                                            Node {
+                                                width: px(40),
+                                                height: px(40),
+                                                ..default()
+                                            },
+                                            |color| text("X", 24.0, color)
                                         )
                                     ],
                                 )

From 526a4657ae4b1065adac76c4a031ffde48f7d3c8 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Thu, 11 Dec 2025 20:24:29 +0100
Subject: [PATCH 70/71] fix: Make save game delete button not rounded

---
 src/features/savegame/ui/load.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/features/savegame/ui/load.rs b/src/features/savegame/ui/load.rs
index a9ec630..0b952a4 100644
--- a/src/features/savegame/ui/load.rs
+++ b/src/features/savegame/ui/load.rs
@@ -87,7 +87,7 @@ pub fn spawn_load_popup(commands: &mut Commands, asset_server: &AssetServer) {
                                                 }
                                             )
                                         ),
-                                        pill_button(
+                                        button(
                                             ButtonType::SavegameDelete {
                                                 savegame_path: savegame.path.clone()
                                             },

From 337444b19d3ea7cee82da49bb2c85920384599c0 Mon Sep 17 00:00:00 2001
From: demenik <dominik.bernroider@icloud.com>
Date: Fri, 12 Dec 2025 14:44:37 +0100
Subject: [PATCH 71/71] fix: Remove debug features from release build

---
 src/features/input/mod.rs     |  6 +++-
 src/features/inventory/mod.rs |  1 +
 src/main.rs                   | 62 +++++++++++++++++++----------------
 3 files changed, 40 insertions(+), 29 deletions(-)

diff --git a/src/features/input/mod.rs b/src/features/input/mod.rs
index a57be0b..d6404df 100644
--- a/src/features/input/mod.rs
+++ b/src/features/input/mod.rs
@@ -42,7 +42,10 @@ impl Plugin for InputPlugin {
         app.add_systems(Update, next_phase.run_if(in_state(AppState::GameScreen)));
 
         app.add_systems(Update, shop_keybind.run_if(in_state(AppState::GameScreen)));
-        app.add_systems(Update, inventory_keybind.run_if(in_state(AppState::GameScreen)));
+        app.add_systems(
+            Update,
+            inventory_keybind.run_if(in_state(AppState::GameScreen)),
+        );
 
         app.add_message::<ClosePopupMessage>();
         app.add_systems(Update, popup_keybind);
@@ -181,6 +184,7 @@ fn interact_click(
     }
 }
 /// Handles debug interactions (shift + left click).
+#[cfg(debug_assertions)]
 fn debug_click(
     mouse_btn: Res<ButtonInput<MouseButton>>,
     keys: Res<ButtonInput<KeyCode>>,
diff --git a/src/features/inventory/mod.rs b/src/features/inventory/mod.rs
index 878fc95..5392aa0 100644
--- a/src/features/inventory/mod.rs
+++ b/src/features/inventory/mod.rs
@@ -1,3 +1,4 @@
+#[cfg(debug_assertions)]
 use crate::features::phase::components::SessionTracker;
 use crate::{features::inventory::ui::open_inventory, prelude::*};
 use components::*;
diff --git a/src/main.rs b/src/main.rs
index af08cac..0933212 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,19 @@
-use bevy_dev_tools::fps_overlay::*;
 use pomomon_garden::prelude::*;
 
 fn main() {
     let config = GameConfig::read_config().unwrap_or(GameConfig::default());
 
-    App::new()
-        .add_plugins((
-            DefaultPlugins.set(ImagePlugin::default_nearest()),
-            AsepriteUltraPlugin,
-        ))
-        .add_plugins((FpsOverlayPlugin {
+    let mut app = App::new();
+
+    app.add_plugins((
+        DefaultPlugins.set(ImagePlugin::default_nearest()),
+        AsepriteUltraPlugin,
+    ));
+
+    #[cfg(debug_assertions)]
+    {
+        use bevy_dev_tools::fps_overlay::*;
+        app.add_plugins(FpsOverlayPlugin {
             config: FpsOverlayConfig {
                 refresh_interval: core::time::Duration::from_millis(100),
                 enabled: true,
@@ -20,27 +24,29 @@ fn main() {
                 },
                 ..default()
             },
-        },))
-        .add_plugins((
-            features::CorePlugin,
-            features::StartScreenPlugin,
-            features::GameScreenPlugin,
-            features::GridPlugin,
-            features::PomPlugin,
-            features::InputPlugin,
-            features::PhasePlugin,
-            features::HudPlugin,
-            features::SavegamePlugin,
-            features::UiPlugin,
-            features::InventoryPlugin,
-            features::ShopPlugin,
-            features::WonderEventPlugin,
-            features::NotificationPlugin,
-            features::AchievementPlugin,
-        ))
-        .insert_resource(config)
-        .add_systems(Startup, overwrite_default_font)
-        .run();
+        });
+    }
+
+    app.add_plugins((
+        features::CorePlugin,
+        features::StartScreenPlugin,
+        features::GameScreenPlugin,
+        features::GridPlugin,
+        features::PomPlugin,
+        features::InputPlugin,
+        features::PhasePlugin,
+        features::HudPlugin,
+        features::SavegamePlugin,
+        features::UiPlugin,
+        features::InventoryPlugin,
+        features::ShopPlugin,
+        features::WonderEventPlugin,
+        features::NotificationPlugin,
+        features::AchievementPlugin,
+    ));
+    app.insert_resource(config);
+    app.add_systems(Startup, overwrite_default_font);
+    app.run();
 }
 
 fn overwrite_default_font(mut fonts: ResMut<Assets<Font>>) {