pygkit 1.2.1__tar.gz → 2.1.0__tar.gz

{pygkit-1.2.1 → pygkit-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygkit
-Version: 1.2.1
+Version: 2.1.0
 Summary: General-purpose Pygame CE runtime kit: UI widgets, audio, timers, interpolation, and more.
 Author: pygkit contributors
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -700,8 +700,9 @@ Provides-Extra: animation
 Provides-Extra: lighting
 Provides-Extra: transitions
 Provides-Extra: inventory
+Provides-Extra: parallax
 Provides-Extra: all
-Requires-Dist: pygkit[animation,audio,inventory,lighting,transitions,ui]; extra == "all"
+Requires-Dist: pygkit[animation,audio,inventory,lighting,parallax,transitions,ui]; extra == "all"
 Dynamic: license-file
 
 # pygkit
@@ -720,7 +721,7 @@ import pygkit
 - **Animation**: Multi-state `AnimationPlayer` where every state owns its own spritesheet — mixed image sizes and grids (e.g. `idle_spritesheet.png` vs `run_spritesheet.png`) in one player; pure image API, no JSON
 - **Dialog**: Typewriter effect with customizable speeds, speaker names, and progress indicators
 - **Inventory**: Grid-based item management with stacking, weight tracking, events, and serialization
-- **Audio**: SoundManager with channel pools and explicit targeting
+- **Audio**: SoundManager with channel pools, kind/key addressing, volume buses, fades
 - **Lighting**: low-resolution light map pipeline (`LightMap`), point lights
   with flicker, wind-reactive `DynamicLight` flames, and cone `Spotlight` —
   full RGB/RGBA blend modes, allocation-free per frame
@@ -736,5 +737,7 @@ pip install "pygkit[all]"     # everything
 ```
 
 Available extras: `ui`, `audio`, `animation`, `lighting`,
-`transitions`, `inventory`, `all`. `import pygkit` alone loads
+`transitions`, `inventory`, `parallax`, `all`. `import pygkit` alone loads
 core only; subsystems load lazily on first use.
+
+> Extra: lightning idea was extended version of [https://www.youtube.com/watch?v=LN7u20H7zK4](https://www.youtube.com/watch?v=LN7u20H7zK4) which was my first attempt of making lightning after learning blend modes.

{pygkit-1.2.1 → pygkit-2.1.0}/README.md

@@ -14,7 +14,7 @@ import pygkit
 - **Animation**: Multi-state `AnimationPlayer` where every state owns its own spritesheet — mixed image sizes and grids (e.g. `idle_spritesheet.png` vs `run_spritesheet.png`) in one player; pure image API, no JSON
 - **Dialog**: Typewriter effect with customizable speeds, speaker names, and progress indicators
 - **Inventory**: Grid-based item management with stacking, weight tracking, events, and serialization
-- **Audio**: SoundManager with channel pools and explicit targeting
+- **Audio**: SoundManager with channel pools, kind/key addressing, volume buses, fades
 - **Lighting**: low-resolution light map pipeline (`LightMap`), point lights
   with flicker, wind-reactive `DynamicLight` flames, and cone `Spotlight` —
   full RGB/RGBA blend modes, allocation-free per frame
@@ -30,5 +30,7 @@ pip install "pygkit[all]"     # everything
 ```
 
 Available extras: `ui`, `audio`, `animation`, `lighting`,
-`transitions`, `inventory`, `all`. `import pygkit` alone loads
+`transitions`, `inventory`, `parallax`, `all`. `import pygkit` alone loads
 core only; subsystems load lazily on first use.
+
+> Extra: lightning idea was extended version of [https://www.youtube.com/watch?v=LN7u20H7zK4](https://www.youtube.com/watch?v=LN7u20H7zK4) which was my first attempt of making lightning after learning blend modes.

{pygkit-1.2.1 → pygkit-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygkit"
-version = "1.2.1"
+version = "2.1.0"
 description = "General-purpose Pygame CE runtime kit: UI widgets, audio, timers, interpolation, and more."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -37,8 +37,9 @@ animation = []
 lighting = []
 transitions = []
 inventory = []
+parallax = []
 all = [
-  "pygkit[ui, audio, animation, lighting, transitions, inventory]",
+  "pygkit[ui, audio, animation, lighting, transitions, inventory, parallax]",
 ]
 
 [project.urls]

{pygkit-1.2.1 → pygkit-2.1.0}/src/pygkit/__init__.py

@@ -34,6 +34,10 @@ from .utils import (
 _LAZY_ATTRS: dict[str, str] = {
     "SoundManager": "audio",
     "SFX_CHANNELS": "audio",
+    "DEFAULT_SFX_CHANNELS": "audio",
+    "ParallaxBackground": "parallax",
+    "ParallaxLayer": "parallax",
+    "Camera2D": "parallax",
     "AnimationPlayer": "animation",
     "AnimationSheet": "animation",
     "PackOptions": "animation",
@@ -111,6 +115,10 @@ _LAZY_ATTRS: dict[str, str] = {
 __all__ = [
     "SoundManager",
     "SFX_CHANNELS",
+    "DEFAULT_SFX_CHANNELS",
+    "ParallaxBackground",
+    "ParallaxLayer",
+    "Camera2D",
     "AnimationPlayer",
     "AnimationSheet",
     "PackOptions",

{pygkit-1.2.1 → pygkit-2.1.0}/src/pygkit/animation/player.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass
 from typing import Callable
 
 from .sheet import AnimationSheet
 
+_UNSET: object = object()
+
 
 @dataclass
 class _State:
@@ -19,7 +22,7 @@ class AnimationPlayer:
 
     States are registered lazily via :meth:`play`; sheets may differ freely in
     pixel size and grid layout between states. Playback is time-based: feed
-    ``update(dt_ms)`` each frame and blit ``image``.
+    ``update(dt)`` each frame with delta time in seconds and blit ``image``.
     """
 
     __slots__ = (
@@ -89,13 +92,15 @@ class AnimationPlayer:
         *,
         fps: float | None = None,
         loop: bool | None = None,
-        on_finish: Callable[[], None] | None = None,
+        on_finish: Callable[[], None] | None | object = _UNSET,
+        restart: bool = False,
     ) -> None:
         """Switch to *name*, registering the state on first use.
 
         Registration requires *sheet*; omitted options fall back to the
         player defaults given at construction. Calling ``play`` for the state
-        already playing does not restart it — use :meth:`reset`.
+        already playing does not restart it unless ``restart`` is true.
+        Pass ``on_finish=None`` explicitly to clear a default callback.
         """
         if name not in self._states:
             if sheet is None:
@@ -106,37 +111,37 @@ class AnimationPlayer:
                 sheet=sheet,
                 fps=float(resolved_fps),
                 loop=self._default_loop if loop is None else bool(loop),
-                on_finish=self._default_on_finish if on_finish is None else on_finish,
+                on_finish=self._default_on_finish if on_finish is _UNSET else on_finish,
             )
 
-        if name == self._state_name:
+        if name == self._state_name and not restart:
             return
         self._state_name = name
         self.reset()
 
-    def update(self, dt_ms: float) -> None:
-        """Advance playback by *dt_ms* milliseconds of wall time."""
+    def update(self, dt: float) -> None:
+        """Advance playback by *dt* seconds."""
         if self._paused or self._state_name is None or self._finished:
             return
+        if not math.isfinite(dt) or dt < 0:
+            dt = 0.0
         state = self._states[self._state_name]
         frame_count = state.sheet.frame_count
-        frame_duration = 1000.0 / state.fps
-        self._elapsed_in_frame += max(0.0, dt_ms)
-        while self._elapsed_in_frame >= frame_duration:
-            self._elapsed_in_frame -= frame_duration
-            next_index = self._frame_index + 1
-            if next_index < frame_count:
-                self._frame_index = next_index
-                continue
-            if state.loop:
-                self._frame_index = 0
-            else:
-                self._frame_index = frame_count - 1
-                self._elapsed_in_frame = 0.0
-                self._finished = True
-                if state.on_finish is not None:
-                    state.on_finish()
-                break
+        frame_duration = 1.0 / state.fps
+        steps, self._elapsed_in_frame = divmod(self._elapsed_in_frame + dt, frame_duration)
+        steps = int(steps)
+        if steps <= 0:
+            return
+        if state.loop:
+            self._frame_index = (self._frame_index + steps) % frame_count
+        elif self._frame_index + steps >= frame_count:
+            self._frame_index = frame_count - 1
+            self._elapsed_in_frame = 0.0
+            self._finished = True
+            if state.on_finish is not None:
+                state.on_finish()
+        else:
+            self._frame_index += steps
 
     def pause(self) -> None:
         self._paused = True

pygkit-2.1.0/src/pygkit/audio/__init__.py

@@ -0,0 +1,7 @@
+from .soundmanager import DEFAULT_SFX_CHANNELS, SFX_CHANNELS, SoundManager
+
+__all__ = [
+    "SoundManager",
+    "SFX_CHANNELS",
+    "DEFAULT_SFX_CHANNELS",
+]

pygkit-2.1.0/src/pygkit/audio/soundmanager.py

@@ -0,0 +1,262 @@
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Tuple
+
+import pygame
+from pygame import Channel, Sound
+
+DEFAULT_SFX_CHANNELS = 6
+SFX_CHANNELS = DEFAULT_SFX_CHANNELS
+
+
+def _clamp(value: float) -> float:
+    return max(0.0, min(1.0, float(value)))
+
+
+class SoundManager:
+    def __init__(self, num_channels: int = 8, main_channels: int = 2) -> None:
+        if pygame.mixer.get_init() is None:
+            raise RuntimeError("pygame.mixer not initialized")
+        if num_channels < 1:
+            raise ValueError(f"num_channels must be >= 1, got {num_channels!r}")
+        if not 0 <= main_channels <= num_channels:
+            raise ValueError(f"main_channels must be 0..num_channels, got {main_channels!r}")
+
+        if num_channels - main_channels < DEFAULT_SFX_CHANNELS:
+            num_channels = main_channels + DEFAULT_SFX_CHANNELS
+
+        if pygame.mixer.get_num_channels() < num_channels:
+            pygame.mixer.set_num_channels(num_channels)
+
+        self._main: Dict[str, Sound] = {}
+        self._sfx: Dict[str, Sound] = {}
+
+        self._num_channels = num_channels
+        self._main_count = main_channels
+        self._channels = tuple(pygame.Channel(i) for i in range(num_channels))
+        self._next_sfx = main_channels
+        self._next_main = 0
+
+        self._master = 1.0
+        self._kind_vol: Dict[str, float] = {"main": 1.0, "sfx": 1.0}
+        self._vol: Dict[Tuple[str, str], float] = {}
+
+    @property
+    def sfx_channels(self) -> int:
+        return self._num_channels - self._main_count
+
+    def add_sound(
+        self, path: str | Path, key: str, kind: Literal["main", "sfx"] = "sfx",
+        volume: float = 1.0,
+    ) -> bool:
+        try:
+            scope = self._scope(kind)
+        except ValueError:
+            return False
+        registry = self._main if scope == "main" else self._sfx
+        try:
+            registry[key] = pygame.Sound(str(path))
+            self._vol[(scope, key)] = _clamp(volume)
+            return True
+        except (FileNotFoundError, TypeError, pygame.error):
+            return False
+
+    def _scope(self, kind: str) -> str:
+        if kind == "main":
+            return "main"
+        if kind == "sfx":
+            return "sfx"
+        raise ValueError(f"kind must be 'main' or 'sfx', got {kind!r}")
+
+    def _pool(self, kind: str):
+        scope = self._scope(kind)
+        start = 0 if scope == "main" else self._main_count
+        stop = self._main_count if scope == "main" else self._num_channels
+        for idx in range(start, stop):
+            yield idx, self._channels[idx]
+
+    def _check_channel_id(self, channel_id: int) -> Channel:
+        if not isinstance(channel_id, int) or isinstance(channel_id, bool):
+            raise ValueError(f"channel_id must be an int, got {channel_id!r}")
+        if not 0 <= channel_id < self._num_channels:
+            raise ValueError(f"channel_id out of range 0..{self._num_channels - 1}")
+        return self._channels[channel_id]
+
+    def _effective(self, kind: str, key: str) -> float:
+        scope = self._scope(kind)
+        return _clamp(self._master * self._kind_vol[scope] * self._vol.get((scope, key), 1.0))
+
+    def _locate(self, channel: Channel) -> Optional[Tuple[str, str]]:
+        if not channel.get_busy():
+            return None
+        sound = channel.get_sound() if hasattr(channel, "get_sound") else None
+        if sound is None:
+            return None
+        for scope, registry in (("main", self._main), ("sfx", self._sfx)):
+            for key, owned in registry.items():
+                if owned is sound:
+                    return (scope, key)
+        return None
+
+    def play(
+        self,
+        key: str,
+        kind: Literal["main", "sfx"] = "sfx",
+        channel_id: int | None = None,
+        loops: int | None = None,
+        volume: float | None = None,
+        fade_ms: int = 0,
+    ) -> Channel:
+        scope = self._scope(kind)
+        registry = self._main if scope == "main" else self._sfx
+        sound = registry.get(key)
+        if sound is None:
+            raise KeyError(f"Unknown sound '{key}'")
+
+        if loops is None:
+            loops = -1 if scope == "main" else 0
+
+        if volume is not None:
+            self._vol[(scope, key)] = _clamp(volume)
+
+        fade_ms = max(0, int(fade_ms))
+        if channel_id is not None:
+            channel = self._check_channel_id(channel_id)
+            channel.stop()
+            channel.play(sound, loops, 0, fade_ms)
+            channel.set_volume(self._effective(scope, key))
+            return channel
+
+        channel = self._assign(scope)
+        channel.play(sound, loops, 0, fade_ms)
+        channel.set_volume(self._effective(scope, key))
+        return channel
+
+    def channels_for(self, key: str, kind: Literal["main", "sfx"] = "sfx") -> List[Channel]:
+        scope = self._scope(kind)
+        registry = self._main if scope == "main" else self._sfx
+        sound = registry.get(key)
+        if sound is None:
+            raise KeyError(f"Unknown sound '{key}'")
+        return [
+            channel
+            for _, channel in self._pool(scope)
+            if channel.get_busy() and channel.get_sound() is sound
+        ]
+
+    def playing(self, key: str, kind: Literal["main", "sfx"] = "sfx") -> bool:
+        return len(self.channels_for(key, kind)) > 0
+
+    def channel_for(self, key: str, kind: Literal["main", "sfx"] = "sfx") -> Optional[Channel]:
+        found = self.channels_for(key, kind)
+        return found[0] if found else None
+
+    def stop(self, kind: Literal["main", "sfx"] | None = None, key: str | None = None) -> None:
+        if kind is None and key is None:
+            raise ValueError("stop() needs a kind or use stop_all()")
+        if key is not None:
+            if kind is None:
+                raise ValueError("stop(key=...) needs kind=...")
+            for channel in self.channels_for(key, kind):
+                channel.stop()
+            return
+        scope = self._scope(kind)
+        for _, channel in self._pool(scope):
+            channel.stop()
+
+    def stop_all(self) -> None:
+        for ch in self._channels:
+            ch.stop()
+
+    def stop_channel(self, channel_id: int) -> None:
+        self._check_channel_id(channel_id).stop()
+
+    def fadeout(
+        self, time_ms: int, kind: Literal["main", "sfx"] | None = None, key: str | None = None
+    ) -> None:
+        time_ms = max(0, int(time_ms))
+        if key is not None:
+            if kind is None:
+                raise ValueError("fadeout(key=...) needs kind=...")
+            for channel in self.channels_for(key, kind):
+                channel.fadeout(time_ms)
+            return
+        if kind is None:
+            for ch in self._channels:
+                if ch.get_busy():
+                    ch.fadeout(time_ms)
+            return
+        for _, channel in self._pool(self._scope(kind)):
+            if channel.get_busy():
+                channel.fadeout(time_ms)
+
+    def set_volume(
+        self, value: float, kind: Literal["main", "sfx"] | None = None, key: str | None = None
+    ) -> None:
+        value = _clamp(value)
+        if key is not None:
+            if kind is None:
+                raise ValueError("set_volume(key=...) needs kind=...")
+            scope = self._scope(kind)
+            registry = self._main if scope == "main" else self._sfx
+            if key not in registry:
+                raise KeyError(f"Unknown sound '{key}'")
+            self._vol[(scope, key)] = value
+            for channel in self.channels_for(key, scope):
+                channel.set_volume(self._effective(scope, key))
+            return
+        if kind is None:
+            self._master = value
+            for ch in self._channels:
+                located = self._locate(ch)
+                if located is not None:
+                    ch.set_volume(self._effective(*located))
+            return
+        scope = self._scope(kind)
+        self._kind_vol[scope] = value
+        for _, channel in self._pool(scope):
+            located = self._locate(channel)
+            if located is not None:
+                channel.set_volume(self._effective(*located))
+
+    def get_volume(
+        self, kind: Literal["main", "sfx"] | None = None, key: str | None = None
+    ) -> float:
+        if key is not None:
+            if kind is None:
+                raise ValueError("get_volume(key=...) needs kind=...")
+            scope = self._scope(kind)
+            registry = self._main if scope == "main" else self._sfx
+            if key not in registry:
+                raise KeyError(f"Unknown sound '{key}'")
+            return self._vol.get((scope, key), 1.0)
+        if kind is None:
+            return self._master
+        return self._kind_vol[self._scope(kind)]
+
+    def get_channel(self, channel_id: int) -> Channel:
+        return self._check_channel_id(channel_id)
+
+    def _assign(self, kind: Literal["main", "sfx"]) -> Channel:
+        if kind == "main":
+            for idx in range(self._main_count):
+                ch = self._channels[idx]
+                if not ch.get_busy():
+                    return ch
+            if self._main_count == 0:
+                raise RuntimeError("no main channels allocated")
+            ch = self._channels[self._next_main % self._main_count]
+            self._next_main += 1
+            ch.stop()
+            return ch
+
+        for idx in range(self._main_count, self._num_channels):
+            ch = self._channels[idx]
+            if not ch.get_busy():
+                return ch
+
+        ch = self._channels[self._next_sfx]
+        ch.stop()
+        self._next_sfx += 1
+        if self._next_sfx >= self._num_channels:
+            self._next_sfx = self._main_count
+        return ch

{pygkit-1.2.1 → pygkit-2.1.0}/src/pygkit/inventory/core.py

@@ -334,7 +334,7 @@ class Inventory:
             )
         else:
             stack.remove_quantity(quantity)
-            removed_stack = ItemStack(data=stack.data, quantity=quantity)
+            removed_stack = ItemStack(data=dict(stack.data), quantity=quantity)
             self._emit_event(
                 InventoryEvent(
                     event_type="item_removed",
@@ -410,7 +410,7 @@ class Inventory:
                 )
 
                 self._update_weight()
-                return source_stack.is_empty()
+                return True
 
             return False
 
@@ -462,6 +462,7 @@ class Inventory:
         self,
         slot_index: int,
         quantity: int,
+        target_slot: Optional[int] = None,
     ) -> Optional[ItemStack]:
         """
         Split a stack, moving part to an empty slot.
@@ -469,6 +470,8 @@ class Inventory:
         Args:
             slot_index: Slot containing the stack to split
             quantity: Amount to move to new slot
+            target_slot: Preferred destination (must be empty); falls back
+                to the first empty slot when None
 
         Returns:
             The new stack created, or None if split failed
@@ -483,12 +486,19 @@ class Inventory:
         if quantity <= 0 or quantity >= source_stack.quantity:
             return None
 
-        empty_slot = self.find_empty_slot()
-        if empty_slot == -1:
-            return None
+        if target_slot is not None:
+            if not 0 <= target_slot < self.total_slots:
+                return None
+            if target_slot == slot_index or self._slots[target_slot] is not None:
+                return None
+            empty_slot = target_slot
+        else:
+            empty_slot = self.find_empty_slot()
+            if empty_slot == -1:
+                return None
 
         new_stack = ItemStack(
-            data=source_stack.data,
+            data=dict(source_stack.data),
             quantity=quantity,
         )
         source_stack.remove_quantity(quantity)

{pygkit-1.2.1 → pygkit-2.1.0}/src/pygkit/inventory/ui.py

@@ -7,7 +7,6 @@ drag-and-drop support, tooltips, and visual feedback.
 
 from __future__ import annotations
 
-import time
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import pygame
@@ -181,7 +180,7 @@ class DragDropState:
 
         if split and stack.quantity > 1:
             half_qty = (stack.quantity + 1) // 2
-            self.dragged_stack = ItemStack(data=stack.data, quantity=half_qty)
+            self.dragged_stack = ItemStack(data=dict(stack.data), quantity=half_qty)
         else:
             self.dragged_stack = stack.copy()
 
@@ -238,6 +237,7 @@ class InventoryWidget:
         self.inventory = inventory
         self.position = position
         self.config = {**DEFAULT_INVENTORY_CONFIG, **(config or {})}
+        self.visible = True
 
         self.rows = inventory.rows
         self.cols = inventory.cols
@@ -328,6 +328,8 @@ class InventoryWidget:
 
     def handle_events(self, events: List[pygame.event.Event]) -> None:
         """Process pygame events for inventory interaction."""
+        if not self.visible:
+            return
         mouse_pos = pygame.mouse.get_pos()
 
         for event in events:
@@ -438,12 +440,8 @@ class InventoryWidget:
             if self._drag_state.split_mode:
                 to_move = min(dragged_stack.quantity, space)
                 if to_move > 0:
-                    target_stack.add_quantity(to_move)
+                    self.inventory.move_item(source_slot, target_slot, to_move)
                     dragged_stack.remove_quantity(to_move)
-
-                    if dragged_stack.quantity <= 0:
-                        self.inventory.remove_from_slot(source_slot)
-
                     return True
             else:
                 to_move = min(dragged_stack.quantity, space)
@@ -452,14 +450,13 @@ class InventoryWidget:
                         self.inventory.move_item(source_slot, target_slot)
                         return True
                     else:
-                        target_stack.add_quantity(to_move)
+                        self.inventory.move_item(source_slot, target_slot, to_move)
                         dragged_stack.remove_quantity(to_move)
-                        self.inventory.remove_from_slot(source_slot, dragged_stack.quantity)
                         return True
 
         elif target_stack is None:
             if self._drag_state.split_mode:
-                new_stack = self.inventory.split_stack(source_slot, dragged_stack.quantity)
+                new_stack = self.inventory.split_stack(source_slot, dragged_stack.quantity, target_slot)
                 return new_stack is not None
             else:
                 return self.inventory.move_item(source_slot, target_slot)
@@ -469,8 +466,10 @@ class InventoryWidget:
 
         return False
 
-    def update(self, dt: float) -> None:
+    def update(self, dt: float = 0.0) -> None:
         """Update inventory state (tooltip timing, etc.)."""
+        if not self.visible:
+            return
         if self._hovered_slot is not None and not self._drag_state.is_dragging:
             stack = self.inventory.get_slot(self._hovered_slot)
             if stack:
@@ -488,6 +487,8 @@ class InventoryWidget:
 
     def render(self, screen: Surface) -> None:
         """Render the inventory UI to the screen."""
+        if not self.visible:
+            return
 
         bg_color = self.config.get("background_color", (40, 40, 45, 230))
         border_color = self.config.get("border_color", (100, 100, 110, 255))
@@ -604,9 +605,16 @@ class InventoryWidget:
         """Move the inventory widget to a new position."""
         self.position = pos
 
+    def _reset_interaction_state(self) -> None:
+        self._drag_state.end_drag()
+        self._hovered_slot = None
+        self._tooltip.hide()
+        self._tooltip_timer = 0.0
+
     def toggle_visibility(self) -> None:
-        """Toggle inventory visibility (to be handled by parent manager)."""
-        pass
+        self.visible = not self.visible
+        if not self.visible:
+            self._reset_interaction_state()
 
 
 class InventoryManager:
@@ -646,12 +654,17 @@ class InventoryManager:
         """Close/hide an inventory."""
         if inventory_id in self._active_inventories:
             self._active_inventories.remove(inventory_id)
+        widget = self._inventories.get(inventory_id)
+        if widget is not None:
+            widget._reset_interaction_state()
 
         if not self._active_inventories:
             self._visible = False
 
     def close_all(self) -> None:
         """Close all open inventories."""
+        for widget in self._inventories.values():
+            widget._reset_interaction_state()
         self._active_inventories.clear()
         self._visible = False
 
@@ -675,7 +688,7 @@ class InventoryManager:
             if inv_id in self._inventories:
                 self._inventories[inv_id].handle_events(events)
 
-    def update(self, dt: float) -> None:
+    def update(self, dt: float = 0.0) -> None:
         """Update all active inventories."""
         if not self._visible:
             return