mini-arcade-core 0.9.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

mini_arcade_core/utils/logging.py

@@ -0,0 +1,174 @@
+"""
+Logging utilities for Mini Arcade Core.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from typing import Optional
+
+
+def _classname_from_locals(locals_: dict) -> Optional[str]:
+    self_obj = locals_.get("self")
+    if self_obj is not None:
+        return type(self_obj).__name__
+    cls_obj = locals_.get("cls")
+    if isinstance(cls_obj, type):
+        return cls_obj.__name__
+    return None
+
+
+class EnsureClassName(logging.Filter):
+    """
+    Populate record.classname by finding the *emitting* frame:
+    match by (pathname, funcName) and read self/cls from its locals.
+    Falls back to "-" when not in a class context.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        # record_factory ensures classname exists, but allow explicit override
+        if getattr(record, "classname", None) not in (None, "-"):
+            return True
+
+        target_path = record.pathname
+        target_func = record.funcName
+
+        # Justification: Seems pretty obvious here.
+        # pylint: disable=protected-access
+        f = sys._getframe()
+        # pylint: enable=protected-access
+
+        for _ in range(200):
+            if f is None:
+                break
+            code = f.f_code
+            if code.co_filename == target_path and code.co_name == target_func:
+                record.classname = _classname_from_locals(f.f_locals) or "-"
+                return True
+            f = f.f_back
+
+        record.classname = "-"
+        return True
+
+
+class ConsoleColorFormatter(logging.Formatter):
+    """
+    Console formatter with ANSI colors by log level.
+    """
+
+    COLORS = {
+        logging.DEBUG: "\033[96m",  # Cyan
+        logging.INFO: "\033[92m",  # Green
+        logging.WARNING: "\033[93m",  # Yellow
+        logging.ERROR: "\033[91m",  # Red
+        logging.CRITICAL: "\033[95m",  # Magenta
+        "RESET": "\033[0m",
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        color = self.COLORS.get(record.levelno, self.COLORS["RESET"])
+        msg = super().format(record)
+        return f"{color}{msg}{self.COLORS['RESET']}"
+
+
+# --------------------------------------------------------------------------------------
+# Global logging setup (single source of truth)
+# --------------------------------------------------------------------------------------
+
+LOGGER_FORMAT = (
+    "%(asctime)s [%(levelname)-8.8s] [%(name)s] "
+    "%(module)s.%(classname)s.%(funcName)s: "
+    "%(message)s (%(filename)s:%(lineno)d)"
+)
+
+
+def _enable_windows_ansi():
+    """
+    Best-effort enable ANSI escape sequences on Windows terminals.
+    Newer Windows 10/11 terminals usually support this already.
+    """
+    if os.name != "nt":
+        return
+    try:
+        # Enables VT100 sequences in some consoles; harmless if unsupported
+        # Justification: Importing ctypes only on Windows is acceptable.
+        # pylint: disable=import-outside-toplevel
+        import ctypes
+
+        # pylint: enable=import-outside-toplevel
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+        handle = kernel32.GetStdHandle(-11)  # STD_OUTPUT_HANDLE = -11
+        mode = ctypes.c_uint32()
+        if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            # ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)
+    # Justification: We want to catch all exceptions here.
+    # pylint: disable=broad-exception-caught
+    except Exception:
+        # If it fails, we just keep going without breaking logging.
+        pass
+    # pylint: enable=broad-exception-caught
+
+
+def _install_record_factory_defaults():
+    """
+    Ensure every LogRecord has `classname` so formatters never crash.
+    Safe to call multiple times; we keep the current factory chain.
+    """
+    old_factory = logging.getLogRecordFactory()
+
+    def record_factory(*args, **kwargs):
+        record = old_factory(*args, **kwargs)
+        if not hasattr(record, "classname"):
+            record.classname = "-"
+        return record
+
+    logging.setLogRecordFactory(record_factory)
+
+
+def configure_logging(level: int = logging.DEBUG):
+    """
+    Configure logging once for the whole app (root logger).
+    Call this early (app entrypoint). Safe to call multiple times.
+    """
+    _enable_windows_ansi()
+    _install_record_factory_defaults()
+
+    root = logging.getLogger()
+    root.setLevel(level)
+
+    # Avoid duplicate handlers if reloaded/imported multiple times
+    # We tag our handler so we can find it reliably.
+    handler_tag = "_mini_arcade_core_console_handler"
+
+    for h in list(root.handlers):
+        if getattr(h, handler_tag, False):
+            # Already configured
+            return
+
+    console = logging.StreamHandler(stream=sys.stdout)
+    setattr(console, handler_tag, True)
+
+    console.setFormatter(ConsoleColorFormatter(LOGGER_FORMAT))
+    console.addFilter(EnsureClassName())
+
+    # Important: don’t leave any basicConfig handlers around if someone called it earlier
+    # We remove only the plain StreamHandlers that don't have our tag.
+    for h in list(root.handlers):
+        if isinstance(h, logging.StreamHandler) and not getattr(
+            h, handler_tag, False
+        ):
+            root.removeHandler(h)
+
+    root.addHandler(console)
+
+
+# --------------------------------------------------------------------------------------
+# Public logger for DejaBounce
+# --------------------------------------------------------------------------------------
+
+configure_logging()
+logger = logging.getLogger("mini-arcade-core")

{mini_arcade_core-0.9.9.dist-info → mini_arcade_core-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-arcade-core
-Version: 0.9.9
+Version: 1.0.0
 Summary: Tiny scene-based game loop core for small arcade games.
 License: Copyright (c) 2025 Santiago Rincón
            

mini_arcade_core-1.0.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+mini_arcade_core/__init__.py,sha256=Cyp7bCkNW018_AlhUGXRH29iPytyW03dE5cvetezxLg,3441
+mini_arcade_core/backend/__init__.py,sha256=J1wZBHX-aqmBP3zh_ey9PK2b_gnWp72zxMfKcs3iwSw,274
+mini_arcade_core/backend/backend.py,sha256=9CYcI7llbUhyO1p3Rjl-jmsw2c3KsQUtPAx0ys-WnW4,4237
+mini_arcade_core/backend/events.py,sha256=5Ohve3CQ6n2CztiOhbCoz6yFDY4z0j4v4R9FBKRDRjc,2929
+mini_arcade_core/backend/keys.py,sha256=LTg20SwLBI3kpPIiTNpq2yBft_QUGj-iNFSNm9M-Fus,3010
+mini_arcade_core/backend/sdl_map.py,sha256=_yBRtvaFUcQKy1kcoIf-SPhbbKEW7dzvzBcI6TLmKjc,2060
+mini_arcade_core/backend/types.py,sha256=SuiwXGNmXCZxfPsww6zj3V_NK7k4jpoCuzMn19afS-g,175
+mini_arcade_core/bus.py,sha256=2Etpoa-UWhk33xJjqDlY5YslPDJEjxNoIEVtF3C73vs,1558
+mini_arcade_core/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/commands.py,sha256=1g7XBWmiVYxe2IUggPpUs5uaZP9PHZKfr6cQuhez8eg,4044
+mini_arcade_core/engine/game.py,sha256=ovfSCNczMN8Tu-rj83reHKl32OKEa649PwMbshlLpac,11479
+mini_arcade_core/engine/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/render/packet.py,sha256=OiAPwGoVHo04OcUWMAoA_N1AFPUMyf8yxNgJthGj4-c,1440
+mini_arcade_core/engine/render/pipeline.py,sha256=4Pdwwt-fo4dK3uqPb3M_IiRIDxymilAK8fOaiojsl10,891
+mini_arcade_core/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/managers/cheats.py,sha256=jMx2a8YnaNCkCG5MPmIzz4uHuS7-_aYf0J45cv2-3v0,5569
+mini_arcade_core/managers/inputs.py,sha256=LL0Q_QYUF3K1orpLIrmYXOadBUascyJVpd2KYvpTNDU,8605
+mini_arcade_core/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/audio/audio_adapter.py,sha256=CEMYbAhCT1MoIsH6PTqu2kE6iOCcB7SwnFjBqk3hLlc,286
+mini_arcade_core/runtime/audio/audio_port.py,sha256=idUxRIr_qga46gL31_GMwQ3j-zfNyuyYC-Ygkl_tIO4,338
+mini_arcade_core/runtime/capture/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/capture/capture_adapter.py,sha256=qJ2JiOLJHbP00IesbAyyPGPBxSaxwPJRTMaMjMU4bXs,4660
+mini_arcade_core/runtime/capture/capture_port.py,sha256=lZme02Cs9aeb_qpZnAz3sClZieG-lFc05wbFPCyB4_I,704
+mini_arcade_core/runtime/context.py,sha256=IQpAhtbN0ZqJVXG6KXFq3FPk0sIGyPmyNgBYviqZl7A,1632
+mini_arcade_core/runtime/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/file/file_adapter.py,sha256=09q7G9Qijml9d4AAjo6HLC1yuoVTjE_7xaT8apT4mk0,523
+mini_arcade_core/runtime/file/file_port.py,sha256=p1MouCSHXZw--rWNMw3aYBLU-of8mXaT_suopczPtM8,608
+mini_arcade_core/runtime/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/input/input_adapter.py,sha256=vExQiwFIWTI3zYD8lmnD9TvoQPZvJfI6IINPJUqAdQ0,1467
+mini_arcade_core/runtime/input/input_port.py,sha256=d4ptftwf92_LJdyaUMFxIsLHXBINzQyJACHn4laNyxQ,746
+mini_arcade_core/runtime/input_frame.py,sha256=34-RAfOD-YScVLyRQrarpm7byFTHjsWM77lIH0JsmT8,2384
+mini_arcade_core/runtime/scene/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/scene/scene_adapter.py,sha256=dYkqFWN3FcRmf9tsZ5wz1QZX67CUntndiNMOWrO578U,2523
+mini_arcade_core/runtime/scene/scene_port.py,sha256=uDFrN7fudIldNkivEkagQd9-b1HVI71BpTpSv5Oh6JI,3854
+mini_arcade_core/runtime/services.py,sha256=9LX7O-AYFTxKgBDewzu0B_D01EJ41WVAdl8U1ZcvEYg,1061
+mini_arcade_core/runtime/window/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/window/window_adapter.py,sha256=EMSWE72aWWzCN0uRuVJvry3g2PQTBmEa_zEfgK6weKY,637
+mini_arcade_core/runtime/window/window_port.py,sha256=HwY8ilhZLLK5cZbEA93R5crjOA4i8Gn2MB8y4BbI4o4,988
+mini_arcade_core/scenes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/scenes/autoreg.py,sha256=wsuY7YUSZFmDyToKHFriAG78OU48-7J4BfL_X6T5GBg,1037
+mini_arcade_core/scenes/registry.py,sha256=EF5qaAgoLwJa3IV_3wclvjHpE3jZt-KHB3GOJS9lQy8,3390
+mini_arcade_core/scenes/sim_scene.py,sha256=b2JsOvPFkHCdCf8pMLJZ90qB0JJ6B8Ka3o5QK4cVshI,1055
+mini_arcade_core/scenes/systems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/scenes/systems/base_system.py,sha256=GfMrXsO8ynW3xOxWeav7Ug5XUbRnbF0vo8VzmG7gpec,1075
+mini_arcade_core/scenes/systems/system_pipeline.py,sha256=Cy9y1DclbMLZZ-yx7OKYe34ORoGLNa6dReQfOdiO8SY,1642
+mini_arcade_core/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/sim/protocols.py,sha256=b7d2WAKRokTNbteNhUaWdGx9vc9Fnccxb-5rPwozDaA,1099
+mini_arcade_core/sim/runner.py,sha256=ZF-BZJw-NcaFrg4zsUu1zOUUBZwZbRYflqcdF1jDcmM,7446
+mini_arcade_core/spaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/spaces/d2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/spaces/d2/boundaries2d.py,sha256=H1HkCR1422MkQIEve2DFKvnav4RpvtLx-qTMxzmdDMQ,2610
+mini_arcade_core/spaces/d2/collision2d.py,sha256=5IvgLnyVb8i0uzzZuum1noWsNhoxcvHOLaHkmrTMTxQ,1710
+mini_arcade_core/spaces/d2/geometry2d.py,sha256=FuYzef-XdOyb1aeGLJbxINxr0WJHnqFFBgtbPi1WonY,1716
+mini_arcade_core/spaces/d2/kinematics2d.py,sha256=AJ3DhPXNgm6wZYwCljMIE4_2BYx3E2rPcwhXTgQALkU,2030
+mini_arcade_core/spaces/d2/physics2d.py,sha256=OQT7r-zMtmoKD2aWCSNmRAdI0OGIpxGX-pLR8LcAMbQ,1854
+mini_arcade_core/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/ui/menu.py,sha256=94W9lFI0qVB-v-f0b5U05p-MTmzaa5H1RGxy-1S01go,24345
+mini_arcade_core/utils/__init__.py,sha256=3Q9r6bTyqImYix8BnOGwWjAz25nbTQezGcRq3m5KEYE,189
+mini_arcade_core/utils/deprecated_decorator.py,sha256=yrrW2ZqPskK-4MUTyIrMb465Wc54X2poV53ZQutZWqc,1140
+mini_arcade_core/utils/logging.py,sha256=IqkM1C5yezb3qnmqlftROlHO6mBCW0iWQmyIR9mwd-4,5576
+mini_arcade_core-1.0.0.dist-info/METADATA,sha256=hMAIBh7Kk29GpAzrP4LziqDT3fzHc0SoiNmhz8A70YY,8188
+mini_arcade_core-1.0.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+mini_arcade_core-1.0.0.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
+mini_arcade_core-1.0.0.dist-info/RECORD,,

{mini_arcade_core-0.9.9.dist-info → mini_arcade_core-1.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.0
 Root-Is-Purelib: true
 Tag: py3-none-any

mini_arcade_core/cheats.py

@@ -1,235 +0,0 @@
-"""
-Cheats module for Mini Arcade Core.
-Provides cheat codes and related functionality.
-"""
-
-from __future__ import annotations
-
-from collections import deque
-from dataclasses import dataclass
-from enum import Enum
-from typing import Callable, Deque, Dict, Optional, Sequence, TypeVar
-
-# Justification: We want to keep the type variable name simple here.
-# pylint: disable=invalid-name
-TContext = TypeVar("TContext")
-# pylint: enable=invalid-name
-
-CheatCallback = Callable[[TContext], None]
-
-
-@dataclass(frozen=True)
-class CheatCode:
-    """
-    Represents a registered cheat code.
-
-    :ivar name (str): Unique name of the cheat code.
-    :ivar sequence (tuple[str, ...]): Sequence of key strings that trigger the cheat.
-    :ivar callback (CheatCallback): Function to call when the cheat is activated.
-    :ivar clear_buffer_on_match (bool): Whether to clear the input buffer after a match.
-    :ivar enabled (bool): Whether the cheat code is enabled.
-    """
-
-    name: str
-    sequence: tuple[str, ...]
-    callback: CheatCallback
-    clear_buffer_on_match: bool = False
-    enabled: bool = True
-
-
-class CheatManager:
-    """
-    Reusable cheat code matcher.
-    Keeps a rolling buffer of recent keys and triggers callbacks on sequence match.
-    """
-
-    def __init__(
-        self,
-        buffer_size: int = 16,
-        *,
-        enabled: bool = True,
-        normalize: Optional[Callable[[str], str]] = None,
-        key_getter: Optional[Callable[[object], Optional[str]]] = None,
-    ):
-        """
-        :param buffer_size: Maximum size of the input buffer.
-        :type buffer_size: int
-
-        :param enabled: Whether the cheat manager is enabled.
-        :type enabled: bool
-
-        :param normalize: Optional function to normalize key strings.
-        :type normalize: Callable[[str], str] | None
-
-        :param key_getter: Optional function to extract key string from event object.
-        :type key_getter: Callable[[object], Optional[str]] | None
-        """
-        self.enabled = enabled
-        self._buffer: Deque[str] = deque(maxlen=buffer_size)
-        self._codes: Dict[str, CheatCode] = {}
-
-        self._normalize = normalize or (lambda s: s.strip().upper())
-        # key_getter: how to extract a key from an engine/backend event object
-        self._key_getter = key_getter or self._default_key_getter
-
-    # Justification: We want to keep the number of arguments manageable here.
-    # pylint: disable=too-many-arguments
-    def register_code(
-        self,
-        name: str,
-        sequence: Sequence[str],
-        callback: CheatCallback,
-        *,
-        clear_buffer_on_match: bool = False,
-        enabled: bool = True,
-    ):
-        """
-        Register a new cheat code.
-
-        :param name: Unique name for the cheat code.
-        :type name: str
-
-        :param sequence: Sequence of key strings that trigger the cheat.
-        :type sequence: Sequence[str]
-
-        :param callback: Function to call when the cheat is activated.
-        :type callback: CheatCallback
-
-        :param clear_buffer_on_match: Whether to clear the input buffer after a match.
-        :type clear_buffer_on_match: bool
-
-        :param enabled: Whether the cheat code is enabled.
-        :type enabled: bool
-        """
-        if not name:
-            raise ValueError("Cheat code name must be non-empty.")
-        if not sequence:
-            raise ValueError(
-                f"Cheat code '{name}' sequence must be non-empty."
-            )
-
-        norm_seq = tuple(self._normalize(k) for k in sequence)
-        self._codes[name] = CheatCode(
-            name=name,
-            sequence=norm_seq,
-            callback=callback,
-            clear_buffer_on_match=clear_buffer_on_match,
-            enabled=enabled,
-        )
-
-    # pylint: enable=too-many-arguments
-
-    def unregister_code(self, name: str):
-        """
-        Unregister a cheat code by name.
-
-        :param name: Name of the cheat code to unregister.
-        :type name: str
-        """
-        self._codes.pop(name, None)
-
-    def clear_buffer(self):
-        """Clear the input buffer."""
-        self._buffer.clear()
-
-    def process_event(self, event: object, context: TContext) -> list[str]:
-        """
-        Call from Scene when a key is pressed.
-        Returns list of cheat names matched (often 0 or 1).
-
-        :param event: The event object from the backend/engine.
-        :type event: object
-
-        :param context: Context object passed to cheat callbacks.
-        :type context: TContext
-        """
-        if not self.enabled:
-            return []
-        key = self._key_getter(event)
-        if not key:
-            return []
-        return self.process_key(key, context)
-
-    def process_key(self, key: str, context: TContext) -> list[str]:
-        """
-        Pure method for tests: feed a key string directly.
-
-        :param key: The key string to process.
-        :type key: str
-
-        :param context: Context object passed to cheat callbacks.
-        :type context: TContext
-
-        :return: List of cheat names matched.
-        :rtype: list[str]
-        """
-        if not self.enabled:
-            return []
-
-        k = self._normalize(key)
-        if not k:
-            return []
-
-        self._buffer.append(k)
-        buf = tuple(self._buffer)
-
-        matched: list[str] = []
-        # Check if buffer ends with any cheat sequence
-        for code in self._codes.values():
-            if not code.enabled:
-                continue
-            seq = code.sequence
-            if len(seq) > len(buf):
-                continue
-            if buf[-len(seq) :] == seq:
-                code.callback(context)
-                matched.append(code.name)
-                if code.clear_buffer_on_match:
-                    self.clear_buffer()
-                    break  # buffer changed; stop early
-
-        return matched
-
-    @staticmethod
-    def _default_key_getter(event: object) -> Optional[str]:
-        """
-        Best-effort extraction:
-        - event.key
-        - event.key_code
-        - event.code
-        - event.scancode
-        - dict-like {"key": "..."}
-        Adjust/override with key_getter in your engine if needed.
-
-        :param event: The event object.
-        :type event: object
-
-        :return: Extracted key string, or None if not found.
-        :rtype: Optional[str]
-        """
-        if event is None:
-            return None
-
-        # dict-like
-        if isinstance(event, dict):
-            v = (
-                event.get("key")
-                or event.get("key_code")
-                or event.get("code")
-                or event.get("scancode")
-            )
-            if isinstance(v, Enum):
-                return v.name
-            return str(v) if v is not None else None
-
-        # object-like
-        for attr in ("key", "key_code", "code", "scancode"):
-            if hasattr(event, attr):
-                v = getattr(event, attr)
-                if v is None:
-                    continue
-                if isinstance(v, Enum):
-                    return v.name  # <-- THIS is the important bit
-                return str(v)
-
-        return None

mini_arcade_core/entity.py

@@ -1,71 +0,0 @@
-"""
-Entity base classes for mini_arcade_core.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from mini_arcade_core.two_d import (
-    KinematicData,
-    Position2D,
-    RectCollider,
-    Size2D,
-)
-
-
-class Entity:
-    """Entity base class for game objects."""
-
-    def update(self, dt: float):
-        """
-        Advance the entity state by ``dt`` seconds.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-
-    def draw(self, surface: Any):
-        """
-        Render the entity to the given surface.
-
-        :param surface: The surface to draw on.
-        :type surface: Any
-        """
-
-
-class SpriteEntity(Entity):
-    """Entity with position and size."""
-
-    def __init__(self, position: Position2D, size: Size2D):
-        """
-        :param position: Top-left position of the entity.
-        :type position: Position2D
-
-        :param size: Size of the entity.
-        :type size: Size2D
-        """
-        self.position = Position2D(float(position.x), float(position.y))
-        self.size = Size2D(int(size.width), int(size.height))
-        self.collider = RectCollider(self.position, self.size)
-
-
-class KinematicEntity(SpriteEntity):
-    """SpriteEntity with velocity-based movement."""
-
-    def __init__(self, kinematic_data: KinematicData):
-        """
-        :param kinematic_data: Kinematic data for the entity.
-        :type kinematic_data: KinematicData
-        """
-        super().__init__(
-            position=kinematic_data.position,
-            size=kinematic_data.size,
-        )
-
-        self.velocity = kinematic_data.velocity
-
-    def update(self, dt: float):
-        self.position.x, self.position.y = self.velocity.advance(
-            self.position.x, self.position.y, dt
-        )