mini-arcade-native-backend 0.3.3__tar.gz → 0.4.1__tar.gz

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/.github/workflows/release-publish.yml

@@ -17,8 +17,9 @@ jobs:
     with:
       release_branch: ${{ inputs.release_branch }}
       version_file: "pyproject.toml"
-      apt-deps: "libsdl2-dev"
+      apt-deps: "libsdl2-dev libsdl2-ttf-dev"
       poetry-build-args: "-f sdist"
+      build_wheels: true
     secrets:
       PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
       SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/CHANGELOG.md

@@ -6,6 +6,30 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.1] - 2025-12-15
+
+### Added
+- extend event handling with additional mouse and window events in engine and bindings
+- enhance font handling by returning font ID and updating draw_text signature
+
+### Fixed
+- update mini-arcade-core dependency version to ensure compatibility
+
+### Other
+- Merge release/0.3 into develop
+
+## [0.4.0] - 2025-12-15
+
+### Added
+- extend event handling with additional mouse and window events in engine and bindings
+- enhance font handling by returning font ID and updating draw_text signature
+
+### Fixed
+- update mini-arcade-core dependency version to ensure compatibility
+
+### Other
+- Merge release/0.3 into develop
+
 ## [0.3.3] - 2025-12-05
 
 ### Other

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.3.3
+Version: 0.4.1
 Summary: Native SDL2 backend for mini-arcade-core using SDL2 + pybind11.
 Author-Email: Santiago Rincon <rincores@gmail.com>
 License: Copyright (c) 2025 Santiago Rincón
@@ -24,7 +24,7 @@ License: Copyright (c) 2025 Santiago Rincón
            SOFTWARE.
          
 Requires-Python: <3.12,>=3.9
-Requires-Dist: mini-arcade-core>=0.2.3
+Requires-Dist: mini-arcade-core~=0.9
 Provides-Extra: dev
 Requires-Dist: pytest~=8.3; extra == "dev"
 Requires-Dist: pytest-cov~=6.0; extra == "dev"

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/cpp/bindings.cpp

@@ -14,12 +14,31 @@ PYBIND11_MODULE(_native, m) {
         .value("Quit", mini::EventType::Quit)
         .value("KeyDown", mini::EventType::KeyDown)
         .value("KeyUp", mini::EventType::KeyUp)
+        .value("MouseMotion", mini::EventType::MouseMotion)
+        .value("MouseButtonDown", mini::EventType::MouseButtonDown)
+        .value("MouseButtonUp", mini::EventType::MouseButtonUp)
+        .value("MouseWheel", mini::EventType::MouseWheel)
+        .value("WindowResized", mini::EventType::WindowResized)
+        .value("TextInput", mini::EventType::TextInput)
         .export_values();
 
     // Bind the Event struct
     py::class_<mini::Event>(m, "Event")
         .def_readonly("type", &mini::Event::type)
-        .def_readonly("key", &mini::Event::key);
+        .def_readonly("key", &mini::Event::key)
+        .def_readonly("scancode", &mini::Event::scancode)
+        .def_readonly("mod", &mini::Event::mod)
+        .def_readonly("repeat", &mini::Event::repeat)
+        .def_readonly("x", &mini::Event::x)
+        .def_readonly("y", &mini::Event::y)
+        .def_readonly("dx", &mini::Event::dx)
+        .def_readonly("dy", &mini::Event::dy)
+        .def_readonly("button", &mini::Event::button)
+        .def_readonly("wheel_x", &mini::Event::wheel_x)
+        .def_readonly("wheel_y", &mini::Event::wheel_y)
+        .def_readonly("width", &mini::Event::width)
+        .def_readonly("height", &mini::Event::height)
+        .def_readonly("text", &mini::Event::text);
 
     // Bind the Engine class
     py::class_<mini::Engine>(m, "Engine")
@@ -58,7 +77,8 @@ PYBIND11_MODULE(_native, m) {
                 py::arg("y"),
                 py::arg("r"),
                 py::arg("g"),
-                py::arg("b")
+                py::arg("b"),
+                py::arg("font_id") = -1
         )
         .def("poll_events", &mini::Engine::poll_events)
 

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/cpp/engine.cpp

@@ -10,7 +10,8 @@ namespace mini {
             renderer_(nullptr),
             initialized_(false),
             font_(nullptr),
-            clear_color_{0, 0, 0, 255}
+            clear_color_{0, 0, 0, 255},
+            default_font_id_(-1)
     {
     }
 
@@ -87,6 +88,8 @@ namespace mini {
         // Enable alpha blending for RGBA drawing
         SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 
+        SDL_StartTextInput();   // <--- needed for SDL_TEXTINPUT
+
         initialized_ = true;
     }
 
@@ -161,40 +164,47 @@ namespace mini {
     }
 
     // Load a TTF font from file at specified point size.
-    void Engine::load_font(const char* path, int pt_size)
+    int Engine::load_font(const char* path, int pt_size)
     {
         if (!initialized_) {
             throw std::runtime_error("Engine::init must be called before load_font");
         }
 
-        if (font_ != nullptr) {
-            TTF_CloseFont(font_);
-            font_ = nullptr;
+        TTF_Font* f = TTF_OpenFont(path, pt_size);
+        if (!f) {
+            throw std::runtime_error(std::string("TTF_OpenFont Error: ") + TTF_GetError());
         }
 
-        font_ = TTF_OpenFont(path, pt_size);
-        if (!font_) {
-            std::string msg = std::string("TTF_OpenFont Error: ") + TTF_GetError();
-            throw std::runtime_error(msg);
+        fonts_.push_back(f);
+        int id = static_cast<int>(fonts_.size() - 1);
+
+        // first loaded font becomes default (good default behavior)
+        if (default_font_id_ < 0) {
+            default_font_id_ = id;
         }
+
+        return id;
     }
 
     // Draw text at specified position.
-    void Engine::draw_text(const char* text, int x, int y, int r, int g, int b)
+    void Engine::draw_text(const char* text, int x, int y, int r, int g, int b, int font_id)
     {
-        if (!initialized_ || renderer_ == nullptr || font_ == nullptr) {
-            return;
-        }
+        if (!initialized_ || renderer_ == nullptr) return;
+
+        int idx = (font_id >= 0) ? font_id : default_font_id_;
+        if (idx < 0 || idx >= (int)fonts_.size() || fonts_[idx] == nullptr) return;
+
+        TTF_Font* font = fonts_[idx];
 
-        // clamp a bit to be safe
         auto clamp = [](int v) {
             if (v < 0) return 0;
             if (v > 255) return 255;
             return v;
         };
 
-        SDL_Color color = { (Uint8)clamp(r), (Uint8)clamp(g), (Uint8)clamp(b), 255 }; // white text
-        SDL_Surface* surface = TTF_RenderUTF8_Blended(font_, text, color);
+        SDL_Color color = { (Uint8)clamp(r), (Uint8)clamp(g), (Uint8)clamp(b), 255 };
+
+        SDL_Surface* surface = TTF_RenderUTF8_Blended(font, text, color);
         if (!surface) {
             std::cerr << "TTF_RenderUTF8_Blended Error: " << TTF_GetError() << std::endl;
             return;
@@ -207,12 +217,7 @@ namespace mini {
             return;
         }
 
-        SDL_Rect dstRect;
-        dstRect.x = x;
-        dstRect.y = y;
-        dstRect.w = surface->w;
-        dstRect.h = surface->h;
-
+        SDL_Rect dstRect{ x, y, surface->w, surface->h };
         SDL_FreeSurface(surface);
 
         SDL_RenderCopy(renderer_, texture, nullptr, &dstRect);
@@ -243,7 +248,6 @@ namespace mini {
         SDL_RenderFillRect(renderer_, &rect);
     }
 
-
     bool Engine::capture_frame(const char* path)
     {
         if (!initialized_ || renderer_ == nullptr) {
@@ -303,8 +307,6 @@ namespace mini {
 
         while (SDL_PollEvent(&sdl_event)) {
             Event ev;
-            ev.type = EventType::Unknown;
-            ev.key = 0;
 
             switch (sdl_event.type) {
             case SDL_QUIT:
@@ -314,11 +316,63 @@ namespace mini {
             case SDL_KEYDOWN:
                 ev.type = EventType::KeyDown;
                 ev.key = sdl_event.key.keysym.sym;
+                ev.scancode = (int)sdl_event.key.keysym.scancode;
+                ev.mod = (int)sdl_event.key.keysym.mod;
+                ev.repeat = (int)sdl_event.key.repeat;
                 break;
 
             case SDL_KEYUP:
                 ev.type = EventType::KeyUp;
                 ev.key = sdl_event.key.keysym.sym;
+                ev.scancode = (int)sdl_event.key.keysym.scancode;
+                ev.mod = (int)sdl_event.key.keysym.mod;
+                ev.repeat = 0;
+                break;
+
+            case SDL_MOUSEMOTION:
+                ev.type = EventType::MouseMotion;
+                ev.x = sdl_event.motion.x;
+                ev.y = sdl_event.motion.y;
+                ev.dx = sdl_event.motion.xrel;
+                ev.dy = sdl_event.motion.yrel;
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                ev.type = EventType::MouseButtonDown;
+                ev.button = (int)sdl_event.button.button;
+                ev.x = sdl_event.button.x;
+                ev.y = sdl_event.button.y;
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                ev.type = EventType::MouseButtonUp;
+                ev.button = (int)sdl_event.button.button;
+                ev.x = sdl_event.button.x;
+                ev.y = sdl_event.button.y;
+                break;
+
+            case SDL_MOUSEWHEEL:
+                ev.type = EventType::MouseWheel;
+                ev.wheel_x = sdl_event.wheel.x;
+                ev.wheel_y = sdl_event.wheel.y;
+                // If you want "natural" direction handling, you can flip based on sdl_event.wheel.direction
+                break;
+
+            case SDL_TEXTINPUT:
+                ev.type = EventType::TextInput;
+                ev.text = sdl_event.text.text; // UTF-8
+                break;
+
+            case SDL_WINDOWEVENT:
+                if (sdl_event.window.event == SDL_WINDOWEVENT_RESIZED ||
+                    sdl_event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+                {
+                    ev.type = EventType::WindowResized;
+                    ev.width = sdl_event.window.data1;
+                    ev.height = sdl_event.window.data2;
+                } else {
+                    continue; // ignore other window events
+                }
                 break;
 
             default:
@@ -326,7 +380,7 @@ namespace mini {
                 break;
             }
 
-            events.push_back(ev);
+            events.push_back(std::move(ev));
         }
 
         return events;

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/cpp/engine.h

@@ -3,6 +3,7 @@
 #include <SDL.h>
 #include <SDL_ttf.h>
 #include <vector>
+#include <string>
 
 // A minimal 2D graphics engine binding for Python using SDL.
 namespace mini {
@@ -11,14 +12,44 @@ namespace mini {
     enum class EventType {
         Unknown = 0,
         Quit,
+
         KeyDown,
-        KeyUp
+        KeyUp,
+
+        MouseMotion,
+        MouseButtonDown,
+        MouseButtonUp,
+        MouseWheel,
+
+        WindowResized,
+        TextInput
     };
 
     // A simple event structure to pass events to Python.
     struct Event {
-        EventType type;
-        int key;  // SDL key code (e.g., 27 for ESC). 0 if not applicable.
+        EventType type = EventType::Unknown;
+
+        // Keyboard
+        int key = 0;       // SDL_Keycode
+        int scancode = 0;  // SDL_Scancode
+        int mod = 0;       // SDL_Keymod bitmask
+        int repeat = 0;    // 1 if key repeat, else 0
+
+        // Mouse
+        int x = 0;
+        int y = 0;
+        int dx = 0;        // motion relative
+        int dy = 0;
+        int button = 0;    // SDL_BUTTON_LEFT etc.
+        int wheel_x = 0;
+        int wheel_y = 0;
+
+        // Window
+        int width = 0;
+        int height = 0;
+
+        // Text input
+        std::string text;
     };
 
     // The main engine class that wraps SDL functionality.
@@ -49,10 +80,10 @@ namespace mini {
         std::vector<Event> poll_events();
         
         // Load a TTF font from file at specified point size.
-        void load_font(const char* path, int pt_size);
+        int load_font(const char* path, int pt_size);
 
         // Draw text at specified position.
-        void draw_text(const char* text, int x, int y, int r, int g, int b);
+        void draw_text(const char* text, int x, int y, int r, int g, int b, int font_id = -1);
 
         // Capture the current frame into an image file (BMP for now).
         // Returns true on success, false on failure.
@@ -62,11 +93,13 @@ namespace mini {
         void draw_rect_rgba(int x, int y, int w, int h, int r, int g, int b, int a);
 
     private:
-        SDL_Window* window_;
-        SDL_Renderer* renderer_;
-        bool initialized_;
-        TTF_Font* font_;
-        SDL_Color clear_color_;
+        SDL_Window* window_; // The main application window.
+        SDL_Renderer* renderer_; // The renderer for drawing.
+        bool initialized_; // Whether the engine has been initialized.
+        TTF_Font* font_; // The current font for text rendering.
+        SDL_Color clear_color_; // The clear color for the screen.
+        std::vector<TTF_Font*> fonts_; // Loaded fonts.
+        int default_font_id_; // Default font index.
     };
 
 } // namespace mini

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "mini-arcade-native-backend"
-version = "0.3.3"
+version = "0.4.1"
 description = "Native SDL2 backend for mini-arcade-core using SDL2 + pybind11."
 authors = [
   { name = "Santiago Rincon", email = "rincores@gmail.com" },
@@ -17,7 +17,7 @@ readme = "README.md"
 requires-python = ">=3.9,<3.12"
 license = { file = "LICENSE" }
 dependencies = [
-  "mini-arcade-core>=0.2.3",
+  "mini-arcade-core~=0.9",
 ]
 
 [project.optional-dependencies]

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/src/mini_arcade_native_backend/__init__.py

@@ -6,17 +6,31 @@ from __future__ import annotations
 
 import os
 import sys
+from pathlib import Path
 
 # --- 1) Make sure Windows can find SDL2.dll when using vcpkg ------------------
 
 if sys.platform == "win32":
+    # a) If running as a frozen PyInstaller exe (e.g. DejaBounce.exe),
+    #    SDL2.dll will live next to the executable. Add that dir.
+    if getattr(sys, "frozen", False):
+        exe_dir = Path(sys.executable).resolve().parent
+        try:
+            os.add_dll_directory(str(exe_dir))
+        except (FileNotFoundError, OSError):
+            # If this somehow fails, we still try other fallbacks.
+            pass
+
+    # b) Dev / vcpkg fallback: use VCPKG_ROOT if available.
     vcpkg_root = os.environ.get("VCPKG_ROOT")
     if vcpkg_root:
         # Typical vcpkg layout: <VCPKG_ROOT>/installed/x64-windows/bin/SDL2.dll
         sdl_bin = os.path.join(vcpkg_root, "installed", "x64-windows", "bin")
         if os.path.isdir(sdl_bin):
-            # Python 3.8+ – add DLL search path before importing the extension
-            os.add_dll_directory(sdl_bin)
+            try:
+                os.add_dll_directory(sdl_bin)
+            except (FileNotFoundError, OSError):
+                pass
 
 # --- 2) Now import native extension and core types ----------------------------
 
@@ -39,6 +53,12 @@ _NATIVE_TO_CORE = {
     native.EventType.Quit: EventType.QUIT,
     native.EventType.KeyDown: EventType.KEYDOWN,
     native.EventType.KeyUp: EventType.KEYUP,
+    native.EventType.MouseMotion: EventType.MOUSEMOTION,
+    native.EventType.MouseButtonDown: EventType.MOUSEBUTTONDOWN,
+    native.EventType.MouseButtonUp: EventType.MOUSEBUTTONUP,
+    native.EventType.MouseWheel: EventType.MOUSEWHEEL,
+    native.EventType.WindowResized: EventType.WINDOWRESIZED,
+    native.EventType.TextInput: EventType.TEXTINPUT,
 }
 
 
@@ -56,6 +76,7 @@ class NativeBackend(Backend):
         self._engine = native.Engine()
         self._font_path = font_path
         self._font_size = font_size
+        self._default_font_id: int | None = None
 
     def init(self, width: int, height: int, title: str):
         """
@@ -74,7 +95,9 @@ class NativeBackend(Backend):
 
         # Load font if provided
         if self._font_path is not None:
-            self._engine.load_font(self._font_path, self._font_size)
+            self._default_font_id = self._engine.load_font(
+                self._font_path, self._font_size
+            )
 
     def set_clear_color(self, r: int, g: int, b: int):
         """
@@ -91,6 +114,8 @@ class NativeBackend(Backend):
         """
         self._engine.set_clear_color(int(r), int(g), int(b))
 
+    # Justification: Many local variables needed for event mapping
+    # pylint: disable=too-many-locals
     def poll_events(self) -> list[Event]:
         """
         Poll for events from the backend and return them as a list of Event objects.
@@ -98,12 +123,54 @@ class NativeBackend(Backend):
         :return: List of Event objects representing the polled events.
         :rtype: list[Event]
         """
-        events: list[Event] = []
+        out: list[Event] = []
         for ev in self._engine.poll_events():
-            core_type = _NATIVE_TO_CORE.get(ev.type, EventType.UNKNOWN)
+            etype = _NATIVE_TO_CORE.get(ev.type, EventType.UNKNOWN)
+
+            # "0 means not present" convention from C++ side
             key = ev.key if getattr(ev, "key", 0) != 0 else None
-            events.append(Event(type=core_type, key=key))
-        return events
+
+            x = getattr(ev, "x", 0) or None
+            y = getattr(ev, "y", 0) or None
+            dx = getattr(ev, "dx", 0) or None
+            dy = getattr(ev, "dy", 0) or None
+            button = getattr(ev, "button", 0) or None
+
+            wheel_x = getattr(ev, "wheel_x", 0)
+            wheel_y = getattr(ev, "wheel_y", 0)
+            wheel = (wheel_x, wheel_y) if (wheel_x or wheel_y) else None
+
+            w = getattr(ev, "width", 0)
+            h = getattr(ev, "height", 0)
+            size = (w, h) if (w and h) else None
+
+            text = getattr(ev, "text", "") or None
+
+            scancode = getattr(ev, "scancode", 0) or None
+            mod = getattr(ev, "mod", 0) or None
+            repeat_raw = getattr(ev, "repeat", 0)
+            repeat = bool(repeat_raw) if repeat_raw else None
+
+            out.append(
+                Event(
+                    type=etype,
+                    key=key,
+                    x=x,
+                    y=y,
+                    dx=dx,
+                    dy=dy,
+                    button=button,
+                    wheel=wheel,
+                    size=size,
+                    text=text,
+                    scancode=scancode,
+                    mod=mod,
+                    repeat=repeat,
+                )
+            )
+        return out
+
+    # pylint: enable=too-many-locals
 
     def begin_frame(self):
         """Begin a new frame for rendering."""
@@ -178,7 +245,10 @@ class NativeBackend(Backend):
         """
         # We rely on C++ side to no-op if font is missing
         r, g, b = color
-        self._engine.draw_text(text, x, y, int(r), int(g), int(b))
+        font_id = (
+            self._default_font_id if self._default_font_id is not None else -1
+        )
+        self._engine.draw_text(text, x, y, int(r), int(g), int(b), font_id)
 
     def capture_frame(self, path: str | None = None) -> bool:
         """

{mini_arcade_native_backend-0.3.3 → mini_arcade_native_backend-0.4.1}/tests/test_init.py

@@ -18,18 +18,33 @@ def setup_fake_core_and_native(monkeypatch):
     class FakeBackend:
         """Minimal base class just to satisfy inheritance."""
 
-        pass
-
     class FakeCoreEventType:
         UNKNOWN = "core_unknown"
         QUIT = "core_quit"
         KEYDOWN = "core_keydown"
         KEYUP = "core_keyup"
+        MOUSEMOTION = "core_mousemotion"
+        MOUSEBUTTONDOWN = "core_mousebuttondown"
+        MOUSEBUTTONUP = "core_mousebuttonup"
+        MOUSEWHEEL = "core_mousewheel"
+        WINDOWRESIZED = "core_windowresized"
+        TEXTINPUT = "core_textinput"
 
     @dataclass
     class FakeEvent:
         type: object
         key: object = None
+        x: object = None
+        y: object = None
+        dx: object = None
+        dy: object = None
+        button: object = None
+        wheel: object = None
+        size: object = None
+        text: object = None
+        scancode: object = None
+        mod: object = None
+        repeat: object = None
 
     fake_core.Backend = FakeBackend
     fake_core.Event = FakeEvent
@@ -45,6 +60,12 @@ def setup_fake_core_and_native(monkeypatch):
         Quit = "native_quit"
         KeyDown = "native_keydown"
         KeyUp = "native_keyup"
+        MouseMotion = "native_mousemotion"
+        MouseButtonDown = "native_mousebuttondown"
+        MouseButtonUp = "native_mousebuttonup"
+        MouseWheel = "native_mousewheel"
+        WindowResized = "native_windowresized"
+        TextInput = "native_textinput"
 
     class FakeEngine:
         def __init__(self):
@@ -226,36 +247,84 @@ def test_poll_events_maps_native_events_to_core_events_and_keys(
     backend_module,
 ):
     pkg, fake_core, fake_native = backend_module
-
     backend = pkg.NativeBackend()
 
-    # Create fake native events
     @dataclass
     class FakeNativeEvent:
         type: object
         key: int = 0
+        x: int = 0
+        y: int = 0
+        dx: int = 0
+        dy: int = 0
+        button: int = 0
+        wheel_x: int = 0
+        wheel_y: int = 0
+        width: int = 0
+        height: int = 0
+        text: str = ""
+        scancode: int = 0
+        mod: int = 0
+        repeat: int = 0
 
     engine = backend._engine
     engine._events_to_return = [
-        FakeNativeEvent(fake_native.EventType.Quit, 0),  # -> QUIT, key=None
+        FakeNativeEvent(fake_native.EventType.Quit),  # -> QUIT
         FakeNativeEvent(
-            fake_native.EventType.KeyDown, 32
+            fake_native.EventType.KeyDown, key=32
         ),  # -> KEYDOWN, key=32
-        FakeNativeEvent("something_unknown", 10),  # -> UNKNOWN, key=10
+        FakeNativeEvent(
+            fake_native.EventType.MouseMotion, x=10, y=20, dx=1, dy=-2
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.MouseButtonDown, x=5, y=6, button=1
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.MouseWheel, wheel_x=0, wheel_y=-1
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.WindowResized, width=800, height=600
+        ),
+        FakeNativeEvent(fake_native.EventType.TextInput, text="á"),
+        FakeNativeEvent("something_unknown", key=10),  # -> UNKNOWN, key=10
     ]
 
     events = backend.poll_events()
+    assert len(events) == 8
 
-    assert len(events) == 3
-
-    # 1) Quit event, key==0 -> key should become None
+    # Quit: key 0 -> None
     assert events[0].type == fake_core.EventType.QUIT
     assert events[0].key is None
 
-    # 2) KeyDown, key!=0 passes through
+    # KeyDown: key passes through
     assert events[1].type == fake_core.EventType.KEYDOWN
     assert events[1].key == 32
 
-    # 3) Unknown type -> UNKNOWN
-    assert events[2].type == fake_core.EventType.UNKNOWN
-    assert events[2].key == 10
+    # MouseMotion: x/y/dx/dy mapped (0 becomes None; here non-zero)
+    assert events[2].type == fake_core.EventType.MOUSEMOTION
+    assert events[2].x == 10
+    assert events[2].y == 20
+    assert events[2].dx == 1
+    assert events[2].dy == -2
+
+    # MouseButtonDown
+    assert events[3].type == fake_core.EventType.MOUSEBUTTONDOWN
+    assert events[3].x == 5
+    assert events[3].y == 6
+    assert events[3].button == 1
+
+    # MouseWheel -> wheel tuple
+    assert events[4].type == fake_core.EventType.MOUSEWHEEL
+    assert events[4].wheel == (0, -1)
+
+    # WindowResized -> size tuple
+    assert events[5].type == fake_core.EventType.WINDOWRESIZED
+    assert events[5].size == (800, 600)
+
+    # TextInput -> text
+    assert events[6].type == fake_core.EventType.TEXTINPUT
+    assert events[6].text == "á"
+
+    # Unknown
+    assert events[7].type == fake_core.EventType.UNKNOWN
+    assert events[7].key == 10

mini_arcade_native_backend-0.3.3/.changelog_section

@@ -1,6 +0,0 @@
-## [0.3.3] - 2025-12-05
-
-### Other
-- docs: improve docstring formatting for capture_frame method in NativeBackend
-- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
-

mini_arcade_native_backend-0.3.3/.version_to_tag

@@ -1 +0,0 @@
-0.3.3