mini-arcade-native-backend 0.5.0__tar.gz → 0.6.0__tar.gz

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     with:
       project-name: "mini-arcade-native-backend"
       lint-path: "src/mini_arcade_native_backend"
-      apt-deps: "libsdl2-dev libsdl2-ttf-dev"
+      apt-deps: "libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev"
     secrets:
       SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
       SLACK_CHANNEL_ID: ${{ secrets.SLACK_CHANNEL_ID }}

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/.github/workflows/release-publish.yml

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

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/CHANGELOG.md

@@ -6,6 +6,42 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-01-23
+
+### Added
+- add draw_line method to Engine and bind it in Python
+
+### Other
+- Merge release/0.5 into develop
+
+## [0.5.3] - 2026-01-23
+
+- Internal changes only.
+
+## [0.5.2] - 2026-01-23
+
+### Added
+- add window resizing and clipping functions to Engine and update bindings
+- add audio management functions to Engine and integrate with NativeBackend
+
+### Fixed
+- update apt dependencies to include libsdl2-mixer-dev for CI and release workflows
+
+### Changed
+- add TODO for backend interface refactoring to improve structure
+
+## [0.5.1] - 2026-01-23
+
+### Added
+- add window resizing and clipping functions to Engine and update bindings
+- add audio management functions to Engine and integrate with NativeBackend
+
+### Fixed
+- update apt dependencies to include libsdl2-mixer-dev for CI and release workflows
+
+### Changed
+- add TODO for backend interface refactoring to improve structure
+
 ## [0.5.0] - 2026-01-21
 
 ### Added

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/CMakeLists.txt

@@ -10,6 +10,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 find_package(pybind11 CONFIG REQUIRED)
 find_package(SDL2 CONFIG REQUIRED)
 find_package(SDL2_ttf CONFIG REQUIRED)
+find_package(SDL2_mixer CONFIG REQUIRED) 
 
 set(TARGET_NAME _native)
 
@@ -19,7 +20,7 @@ pybind11_add_module(${TARGET_NAME}
     cpp/engine.cpp
 )
 
-target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2 SDL2_ttf::SDL2_ttf)
+target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2 SDL2_ttf::SDL2_ttf SDL2_mixer::SDL2_mixer)
 
 # Install the compiled extension into the Python package directory
 # so it ends up as mini_arcade_native_backend/_native.*.pyd

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.5.0
+Version: 0.6.0
 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~=1.0
+Requires-Dist: mini-arcade-core~=1.1
 Provides-Extra: dev
 Requires-Dist: pytest~=8.3; extra == "dev"
 Requires-Dist: pytest-cov~=6.0; extra == "dev"

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/cpp/bindings.cpp

@@ -89,5 +89,43 @@ PYBIND11_MODULE(_native, m) {
                         &mini::Engine::measure_text,
                         py::arg("text"),
                         py::arg("font_id") = -1
-                );
+                )
+
+                .def("init_audio", &mini::Engine::init_audio,
+                        py::arg("frequency") = 44100,
+                        py::arg("channels") = 2,
+                        py::arg("chunk_size") = 2048)
+
+                .def("shutdown_audio", &mini::Engine::shutdown_audio) 
+
+                .def("load_sound", &mini::Engine::load_sound,
+                        py::arg("sound_id"),
+                        py::arg("path"))
+
+                .def("play_sound", &mini::Engine::play_sound,
+                        py::arg("sound_id"),
+                        py::arg("loops") = 0)
+
+                .def("set_master_volume", &mini::Engine::set_master_volume,
+                        py::arg("volume"))
+
+                .def("set_sound_volume", &mini::Engine::set_sound_volume,
+                        py::arg("sound_id"),
+                        py::arg("volume"))
+
+                .def("stop_all_sounds", &mini::Engine::stop_all_sounds)
+                .def("resize_window", &mini::Engine::resize_window,
+                        py::arg("width"),
+                        py::arg("height"))
+                .def("set_clip_rect", &mini::Engine::set_clip_rect,
+                        py::arg("x"),
+                        py::arg("y"),
+                        py::arg("w"),
+                        py::arg("h"))
+                .def("clear_clip_rect", &mini::Engine::clear_clip_rect)
+                .def("draw_line", &mini::Engine::draw_line,
+                        py::arg("x1"), py::arg("y1"),
+                        py::arg("x2"), py::arg("y2"),
+                        py::arg("r"), py::arg("g"), py::arg("b"), py::arg("a"));
+
 }

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/cpp/engine.cpp

@@ -11,7 +11,6 @@ namespace mini {
         : window_(nullptr),
             renderer_(nullptr),
             initialized_(false),
-            font_(nullptr),
             clear_color_{0, 0, 0, 255},
             default_font_id_(-1),
             default_alpha_(255)
@@ -20,10 +19,12 @@ namespace mini {
 
     Engine::~Engine()
     {
-        if (font_ != nullptr) {
-            TTF_CloseFont(font_);
-            font_ = nullptr;
+        shutdown_audio();
+
+        for (TTF_Font* f : fonts_) {
+            if (f) TTF_CloseFont(f);
         }
+        fonts_.clear();
 
         if (renderer_ != nullptr) {
             SDL_DestroyRenderer(renderer_);
@@ -35,19 +36,14 @@ namespace mini {
             window_ = nullptr;
         }
 
+        SDL_StopTextInput();
+
         if (initialized_) {
+            TTF_Quit();
             SDL_Quit();
             initialized_ = false;
         }
 
-        for (TTF_Font* f : fonts_) {
-            if (f) TTF_CloseFont(f);
-        }
-        fonts_.clear();
-
-        TTF_Quit();
-        SDL_StopTextInput();
-
     }
 
     void Engine::init(int width, int height, const char* title)
@@ -72,7 +68,7 @@ namespace mini {
             SDL_WINDOWPOS_CENTERED,
             width,
             height,
-            SDL_WINDOW_SHOWN
+            SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE
         );
 
         if (window_ == nullptr) {
@@ -87,6 +83,7 @@ namespace mini {
             -1,
             SDL_RENDERER_ACCELERATED
         );
+        // SDL_RenderSetLogicalSize(renderer_, width, height);
 
         if (renderer_ == nullptr) {
             std::string msg = std::string("SDL_CreateRenderer Error: ") + SDL_GetError();
@@ -105,7 +102,6 @@ namespace mini {
         initialized_ = true;
     }
 
-    
     void Engine::set_window_title(const char* title)
     {
         if (!initialized_ || !window_) return;
@@ -309,6 +305,21 @@ namespace mini {
         std::vector<Event> events;
         SDL_Event sdl_event;
 
+        auto scale_mouse = [&](int &x, int &y, int &dx, int &dy) {
+            int ww=0, wh=0, rw=0, rh=0;
+            SDL_GetWindowSize(window_, &ww, &wh);
+            SDL_GetRendererOutputSize(renderer_, &rw, &rh);
+
+            if (ww > 0 && wh > 0) {
+                float sx = (float)rw / (float)ww;
+                float sy = (float)rh / (float)wh;
+                x  = (int)lroundf(x  * sx);
+                y  = (int)lroundf(y  * sy);
+                dx = (int)lroundf(dx * sx);
+                dy = (int)lroundf(dy * sy);
+            }
+        };
+
         while (SDL_PollEvent(&sdl_event)) {
             Event ev;
 
@@ -339,6 +350,7 @@ namespace mini {
                 ev.y = sdl_event.motion.y;
                 ev.dx = sdl_event.motion.xrel;
                 ev.dy = sdl_event.motion.yrel;
+                scale_mouse(ev.x, ev.y, ev.dx, ev.dy);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
@@ -353,6 +365,7 @@ namespace mini {
                 ev.button = (int)sdl_event.button.button;
                 ev.x = sdl_event.button.x;
                 ev.y = sdl_event.button.y;
+                scale_mouse(ev.x, ev.y, ev.dx, ev.dy);
                 break;
 
             case SDL_MOUSEWHEEL:
@@ -372,8 +385,14 @@ namespace mini {
                     sdl_event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
                 {
                     ev.type = EventType::WindowResized;
-                    ev.width = sdl_event.window.data1;
-                    ev.height = sdl_event.window.data2;
+                    int rw=0, rh=0;
+                    if (renderer_ && SDL_GetRendererOutputSize(renderer_, &rw, &rh) == 0) {
+                        ev.width = rw;
+                        ev.height = rh;
+                    } else {
+                        ev.width = sdl_event.window.data1;
+                        ev.height = sdl_event.window.data2;
+                    }
                 } else {
                     continue; // ignore other window events
                 }
@@ -412,4 +431,166 @@ namespace mini {
         return {w, h};
     }
 
+    void Engine::init_audio(int frequency, int channels, int chunk_size)
+    {
+        if (audio_initialized_) return;
+
+        // Make sure SDL audio subsystem is enabled
+        if ((SDL_WasInit(SDL_INIT_AUDIO) & SDL_INIT_AUDIO) == 0) {
+            if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
+                throw std::runtime_error(std::string("SDL_InitSubSystem(AUDIO) Error: ") + SDL_GetError());
+            }
+        }
+
+        if (Mix_OpenAudio(frequency, MIX_DEFAULT_FORMAT, channels, chunk_size) != 0) {
+            throw std::runtime_error(std::string("Mix_OpenAudio Error: ") + Mix_GetError());
+        }
+
+        // Optional: allow OGG/MP3 decoding if you want
+        // Mix_Init(MIX_INIT_OGG | MIX_INIT_MP3);
+
+        Mix_AllocateChannels(16);           // plenty for pong
+        Mix_Volume(-1, master_volume_);     // -1 = all channels
+
+        audio_initialized_ = true;
+    }
+
+    void Engine::shutdown_audio()
+    {
+        if (!audio_initialized_) return;
+
+        stop_all_sounds();
+
+        for (auto& kv : sounds_) {
+            if (kv.second) {
+                Mix_FreeChunk(kv.second);
+            }
+        }
+        sounds_.clear();
+
+        Mix_CloseAudio();
+        // Mix_Quit(); // if you used Mix_Init
+
+        audio_initialized_ = false;
+    }
+
+    void Engine::load_sound(const std::string& sound_id, const std::string& path)
+    {
+        if (!audio_initialized_) {
+            // auto-init so Python doesn't need to care
+            init_audio();
+        }
+
+        if (sound_id.empty()) {
+            throw std::runtime_error("load_sound: sound_id is empty");
+        }
+
+        // If already loaded, free it first (support hot reload)
+        auto it = sounds_.find(sound_id);
+        if (it != sounds_.end() && it->second) {
+            Mix_FreeChunk(it->second);
+            it->second = nullptr;
+        }
+
+        Mix_Chunk* chunk = Mix_LoadWAV(path.c_str());
+        if (!chunk) {
+            throw std::runtime_error(std::string("Mix_LoadWAV Error: ") + Mix_GetError());
+        }
+
+        sounds_[sound_id] = chunk;
+    }
+
+    void Engine::play_sound(const std::string& sound_id, int loops)
+    {
+        if (!audio_initialized_) {
+            init_audio();
+        }
+
+        auto it = sounds_.find(sound_id);
+        if (it == sounds_.end() || it->second == nullptr) {
+            // be forgiving: if not preloaded, just do nothing
+            // (or throw if you want strict behavior)
+            return;
+        }
+
+        Mix_Chunk* chunk = it->second;
+
+        // -1 channel = pick first free channel
+        Mix_PlayChannel(-1, chunk, loops);
+    }
+
+    void Engine::set_master_volume(int volume)
+    {
+        if (volume < 0) volume = 0;
+        if (volume > MIX_MAX_VOLUME) volume = MIX_MAX_VOLUME;
+
+        master_volume_ = volume;
+        Mix_Volume(-1, master_volume_); // all channels
+    }
+
+    void Engine::set_sound_volume(const std::string& sound_id, int volume)
+    {
+        if (volume < 0) volume = 0;
+        if (volume > MIX_MAX_VOLUME) volume = MIX_MAX_VOLUME;
+
+        auto it = sounds_.find(sound_id);
+        if (it == sounds_.end() || it->second == nullptr) return;
+
+        Mix_VolumeChunk(it->second, volume);
+    }
+
+    void Engine::stop_all_sounds()
+    {
+        Mix_HaltChannel(-1);
+    }
+
+    void Engine::resize_window(int width, int height)
+    {
+        if (!initialized_ || !window_) return;
+        SDL_SetWindowSize(window_, width, height);
+
+        // if (renderer_) {
+        //     SDL_RenderSetLogicalSize(renderer_, width, height);
+        // }
+    }
+
+    void Engine::set_clip_rect(int x, int y, int w, int h)
+    {
+        if (!initialized_ || renderer_ == nullptr) return;
+        SDL_Rect r{ x, y, w, h };
+        SDL_RenderSetClipRect(renderer_, &r);
+    }
+
+    void Engine::clear_clip_rect()
+    {
+        if (!initialized_ || renderer_ == nullptr) return;
+        SDL_RenderSetClipRect(renderer_, nullptr);
+    }
+
+    void Engine::draw_line(int x1, int y1, int x2, int y2, int r, int g, int b, int a)
+    {
+        if (!initialized_ || renderer_ == nullptr) {
+            return;
+        }
+
+        auto clamp = [](int v) {
+            if (v < 0) return 0;
+            if (v > 255) return 255;
+            return v;
+        };
+
+        // alpha or default alpha
+        a = (a < 0) ? default_alpha_ : a;
+
+        SDL_SetRenderDrawColor(
+            renderer_,
+            static_cast<Uint8>(clamp(r)),
+            static_cast<Uint8>(clamp(g)),
+            static_cast<Uint8>(clamp(b)),
+            static_cast<Uint8>(clamp(a))
+        );
+
+        SDL_RenderDrawLine(renderer_, x1, y1, x2, y2);
+    }
+
 } // namespace mini

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/cpp/engine.h

@@ -2,6 +2,8 @@
 
 #include <SDL.h>
 #include <SDL_ttf.h>
+#include <SDL_mixer.h>
+#include <unordered_map>
 #include <vector>
 #include <string>
 #include <utility>
@@ -97,15 +99,44 @@ namespace mini {
         // Returns (width, height) in pixels. Returns (0,0) if no valid font or error.
         std::pair<int, int> measure_text(const char* text, int font_id = -1);
 
+        // --- Audio ---
+        // Initialize audio subsystem.
+        void init_audio(int frequency = 44100, int channels = 2, int chunk_size = 2048);
+        // Shutdown audio subsystem.
+        void shutdown_audio();
+
+        // Load, play, and manage sounds.
+        void load_sound(const std::string& sound_id, const std::string& path);
+        // Play a loaded sound by its ID.
+        void play_sound(const std::string& sound_id, int loops = 0);
+        // Set the volume for a specific sound (0..128).
+        void set_sound_volume(const std::string& sound_id, int volume); // 0..128
+        // Set the master volume for all sounds (0..128).
+        void set_master_volume(int volume); // 0..128
+        // Stop all currently playing sounds.
+        void stop_all_sounds();
+
+        // Resize the application window.
+        void resize_window(int width, int height);
+        // Set clipping rectangle for rendering.
+        void set_clip_rect(int x, int y, int w, int h);
+        // Clear clipping rectangle (disable clipping).
+        void clear_clip_rect();
+
+        // Draw a line from (x1, y1) to (x2, y2) with specified color.
+        void draw_line(int x1, int y1, int x2, int y2, int r, int g, int b, int a);
+
     private:
         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.
         int default_alpha_; // Default alpha value for drawing.
+        bool audio_initialized_ = false; // Whether audio subsystem is initialized.
+        int master_volume_ = MIX_MAX_VOLUME; // 128 is max volume
+        std::unordered_map<std::string, Mix_Chunk*> sounds_; // Audio data
     };
 
 } // namespace mini

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/poetry.lock

@@ -516,14 +516,14 @@ files = [
 
 [[package]]
 name = "mini-arcade-core"
-version = "1.0.0"
+version = "1.1.1"
 description = "Tiny scene-based game loop core for small arcade games."
 optional = false
 python-versions = "<3.12,>=3.9"
 groups = ["main"]
 files = [
-    {file = "mini_arcade_core-1.0.0-py3-none-any.whl", hash = "sha256:16ec8b11e6c6c7c6fc414d872d03934f2f7df01b5ffaf8515af98ab081507b07"},
-    {file = "mini_arcade_core-1.0.0.tar.gz", hash = "sha256:3565073c6f3896a9a23b347745d33ddb374b2cb19b6a4001c31a31f66690923e"},
+    {file = "mini_arcade_core-1.1.1-py3-none-any.whl", hash = "sha256:cd487278b33ba77e80acfdc895a77a76cc1d07f5c800a26b7537e18aaa97f00e"},
+    {file = "mini_arcade_core-1.1.1.tar.gz", hash = "sha256:b3b81a3adefaaf2b5438bc773ed364a5cf997e7f00a67ef3fc8be9d40bdbc61f"},
 ]
 
 [package.dependencies]
@@ -1001,4 +1001,4 @@ dev = ["black", "isort", "mypy", "pylint", "pytest", "pytest-cov"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.9,<3.12"
-content-hash = "36a9b75ca1c71a10eb85ee901a0df5f279b1433575e1f797b11d5c7efb875e7b"
+content-hash = "049cf6813d766ae9a7c9ab36a2ef36d24fce8da7a19ffa70200461aef112012d"

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "mini-arcade-native-backend"
-version = "0.5.0"
+version = "0.6.0"
 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~=1.0",
+  "mini-arcade-core~=1.1",
 ]
 
 [project.optional-dependencies]

{mini_arcade_native_backend-0.5.0 → mini_arcade_native_backend-0.6.0}/src/mini_arcade_native_backend/__init__.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import os
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, Union
 
@@ -42,6 +43,7 @@ if sys.platform == "win32":
 # pylint: disable=import-error
 from mini_arcade_core.backend import (  # pyright: ignore[reportMissingImports]
     Backend,
+    WindowSettings,
 )
 from mini_arcade_core.backend.events import (  # pyright: ignore[reportMissingImports]
     Event,
@@ -79,23 +81,49 @@ _NATIVE_TO_CORE = {
 }
 
 
+@dataclass
+class BackendSettings:
+    """
+    Settings for the NativeBackend.
+
+    :ivar font_path (Optional[str]): Optional path to a TTF font file to load.
+    :ivar font_size (int): Font size in points to use when loading the font.
+    :ivar sounds (Optional[dict[str, str]]): Optional dictionary mapping sound IDs to file paths.
+    """
+
+    font_path: Optional[str] = None
+    font_size: int = 24
+    sounds: Optional[dict[str, str]] = None  # sound_id -> path
+
+
+# TODO: Refactor backend interface into smaller protocols?
+# Justification: Many public methods needed for backend interface
+# pylint: disable=too-many-public-methods,too-many-instance-attributes
 class NativeBackend(Backend):
     """Adapter that makes the C++ Engine usable as a mini-arcade backend."""
 
-    def __init__(self, font_path: str | None = None, font_size: int = 24):
+    def __init__(self, backend_settings: BackendSettings | None = None):
         """
-        :param font_path: Optional path to a TTF font file to load.
-        :type font_path: str | None
-
-        :param font_size: Font size in points to use when loading the font.
-        :type font_size: int
+        :param backend_settings: Optional settings for the backend.
+        :type backend_settings: BackendSettings | None
         """
         self._engine = native.Engine()
-        self._font_path = font_path
-        self._font_size = font_size
+
+        self._font_path = (
+            backend_settings.font_path if backend_settings else None
+        )
+        self._font_size = (
+            backend_settings.font_size if backend_settings else 24
+        )
         self._default_font_id: int | None = None
         self._fonts_by_size: dict[int, int] = {}
 
+        self._sounds = backend_settings.sounds if backend_settings else None
+
+        self._vp_offset_x = 0
+        self._vp_offset_y = 0
+        self._vp_scale = 1.0
+
     def _get_font_id(self, font_size: int | None) -> int:
         # No font loaded -> keep current “no-op” behavior
         if self._font_path is None:
@@ -122,22 +150,15 @@ class NativeBackend(Backend):
         self._fonts_by_size[font_size] = font_id
         return font_id
 
-    def init(self, width: int, height: int, title: Optional[str] = None):
+    def init(self, window_settings: WindowSettings):
         """
         Initialize the backend with a window of given width, height, and title.
 
-        :param width: Width of the window in pixels.
-        :type width: int
-
-        :param height: Height of the window in pixels.
-        :type height: int
-
-        :param title: Title of the window.
-        :type title: Optional[str]
+        :param window_settings: Settings for the backend window.
+        :type window_settings: WindowSettings
         """
-        if title is None:
-            title = ""
-        self._engine.init(width, height, title)
+        title = ""
+        self._engine.init(window_settings.width, window_settings.height, title)
 
         # Load font if provided
         if self._font_path is not None:
@@ -146,6 +167,11 @@ class NativeBackend(Backend):
             )
             self._fonts_by_size[self._font_size] = self._default_font_id
 
+        # Load sounds if provided
+        if self._sounds is not None:
+            for sound_id, path in self._sounds.items():
+                self.load_sound(sound_id, path)
+
     def set_window_title(self, title: str):
         """
         Set the window title.
@@ -273,12 +299,18 @@ class NativeBackend(Backend):
         if isinstance(alpha, bool):
             raise TypeError("alpha must be a float in [0,1], not bool")
 
-        a = float(alpha)
+        # If it's an int-like value, treat as 0..255
+        if isinstance(alpha, int):
+            if alpha < 0 or alpha > 255:
+                raise ValueError(
+                    f"int alpha must be in [0, 255], got {alpha!r}"
+                )
+            return int(alpha)
 
-        # Enforce “percentage only”
+        # Otherwise treat as float 0..1
+        a = float(alpha)
         if a < 0.0 or a > 1.0:
-            raise ValueError(f"alpha must be in [0, 1], got {alpha!r}")
-
+            raise ValueError(f"float alpha must be in [0, 1], got {alpha!r}")
         return int(round(a * 255))
 
     @staticmethod
@@ -328,7 +360,12 @@ class NativeBackend(Backend):
         :type color: tuple[int, ...]
         """
         r, g, b, a = self._get_color_values(color)
-        self._engine.draw_rect(x, y, w, h, r, g, b, a)
+        sx = int(round(self._vp_offset_x + x * self._vp_scale))  # top-left x
+        sy = int(round(self._vp_offset_y + y * self._vp_scale))  # top-left y
+        sw = int(round(w * self._vp_scale))  # width
+        sh = int(round(h * self._vp_scale))  # height
+        self._engine.draw_rect(sx, sy, sw, sh, r, g, b, a)
+        # self._engine.draw_rect(x, y, w, h, r, g, b, a)
 
     def draw_text(
         self,
@@ -356,9 +393,22 @@ class NativeBackend(Backend):
         """
         r, g, b, a = self._get_color_values(color)
         font_id = self._get_font_id(font_size)
+        sx = int(round(self._vp_offset_x + x * self._vp_scale))
+        sy = int(round(self._vp_offset_y + y * self._vp_scale))
+
+        # optional but recommended: scale font size too
+        if font_size is not None:
+            scaled = max(8, int(round(font_size * self._vp_scale)))
+        else:
+            scaled = None
+
+        font_id = self._get_font_id(scaled)
         self._engine.draw_text(
-            text, x, y, int(r), int(g), int(b), int(a), font_id
+            text, sx, sy, int(r), int(g), int(b), int(a), font_id
         )
+        # self._engine.draw_text(
+        #     text, x, y, int(r), int(g), int(b), int(a), font_id
+        # )
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments
 
@@ -388,3 +438,97 @@ class NativeBackend(Backend):
         font_id = self._get_font_id(font_size)
         w, h = self._engine.measure_text(text, font_id)
         return int(w), int(h)
+
+    def init_audio(
+        self, frequency: int = 44100, channels: int = 2, chunk_size: int = 2048
+    ):
+        """Initialize SDL_mixer audio."""
+        self._engine.init_audio(int(frequency), int(channels), int(chunk_size))
+
+    def shutdown_audio(self):
+        """Shutdown SDL_mixer audio and free loaded sounds."""
+        self._engine.shutdown_audio()
+
+    def load_sound(self, sound_id: str, path: str):
+        """
+        Load a WAV sound and store it by ID.
+        Example: backend.load_sound("hit", "assets/sfx/hit.wav")
+        """
+        if not sound_id:
+            raise ValueError("sound_id cannot be empty")
+
+        p = Path(path)
+        if not p.exists():
+            raise FileNotFoundError(f"Sound file not found: {p}")
+
+        self._engine.load_sound(sound_id, str(p))
+
+    def play_sound(self, sound_id: str, loops: int = 0):
+        """
+        Play a loaded sound.
+        loops=0 => play once
+        loops=-1 => infinite loop
+        loops=1 => play twice (SDL convention)
+        """
+        self._engine.play_sound(sound_id, int(loops))
+
+    def set_master_volume(self, volume: int):
+        """
+        Master volume: 0..128
+        """
+        self._engine.set_master_volume(int(volume))
+
+    def set_sound_volume(self, sound_id: str, volume: int):
+        """
+        Per-sound volume: 0..128
+        """
+        self._engine.set_sound_volume(sound_id, int(volume))
+
+    def stop_all_sounds(self):
+        """Stop all channels."""
+        self._engine.stop_all_sounds()
+
+    def set_viewport_transform(
+        self, offset_x: int, offset_y: int, scale: float
+    ) -> None:
+        self._vp_offset_x = int(offset_x)
+        self._vp_offset_y = int(offset_y)
+        self._vp_scale = float(scale)
+
+    def clear_viewport_transform(self) -> None:
+        self._vp_offset_x = 0
+        self._vp_offset_y = 0
+        self._vp_scale = 1.0
+
+    def resize_window(self, width: int, height: int) -> None:
+        self._engine.resize_window(int(width), int(height))
+
+    def set_clip_rect(self, x: int, y: int, w: int, h: int) -> None:
+        self._engine.set_clip_rect(int(x), int(y), int(w), int(h))
+
+    def clear_clip_rect(self) -> None:
+        self._engine.clear_clip_rect()
+
+    # Justification: Many arguments needed for line drawing
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def draw_line(
+        self,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        color: tuple[int, ...] = (255, 255, 255),
+    ) -> None:
+        r, g, b, a = self._get_color_values(color)
+
+        sx1 = int(round(self._vp_offset_x + x1 * self._vp_scale))
+        sy1 = int(round(self._vp_offset_y + y1 * self._vp_scale))
+        sx2 = int(round(self._vp_offset_x + x2 * self._vp_scale))
+        sy2 = int(round(self._vp_offset_y + y2 * self._vp_scale))
+
+        self._engine.draw_line(
+            sx1, sy1, sx2, sy2, int(r), int(g), int(b), int(a)
+        )
+
+
+# pylint: enable=too-many-arguments,too-many-positional-arguments