arepy 0.1.1__tar.gz

arepy-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Abrahan Gil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arepy-0.1.1/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: arepy
+Version: 0.1.1
+Summary: An ECS python game engine with Raylib
+Author-email: Abrahan Gil <scr44gr@protonmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Abrahan Gil
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: ecs,game-engine,python-game-engine
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bitarray==2.9.2
+Requires-Dist: raylib==5.5.0.2
+Provides-Extra: imgui
+Requires-Dist: imgui-bundle==1.6.0; extra == "imgui"
+Requires-Dist: moderngl==5.12.0; extra == "imgui"
+
+# Arepy 🎮
+[![Upload Python Package](https://github.com/Scr44gr/arepy/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Scr44gr/arepy/actions/workflows/python-publish.yml)
+
+An ECS game engine created in python with raylib and imgui integration :)
+## Installation 📖
+```bash
+pip install git+https://github.com/Scr44gr/arepy.git
+```
+
+## Usage 📝
+
+### Basic usage example 
+
+#### Creating a simple system to move entities
+
+```python
+from arepy.bundle.components.rigidbody_component import RigidBody2D
+from arepy.bundle.components.transform_component import Transform
+from arepy.ecs.entities import Entities
+from arepy.ecs.query import Query, With
+from arepy.engine.renderer.renderer_2d import Renderer2D
+
+def movement_system(
+    query: Query[Entities, With[Transform, RigidBody2D]], renderer: Renderer2D
+):
+    delta_time = renderer.get_delta_time()
+    entities = query.get_entities()
+    for entity in entities:
+        transform = entity.get_component(Transform)
+        velocity = entity.get_component(RigidBody2D).velocity
+
+        transform.position.x += velocity.x * delta_time
+        transform.position.y += velocity.y * delta_time
+```
+
+TODO!: create a nice README.md

arepy-0.1.1/README.md

@@ -0,0 +1,36 @@
+# Arepy 🎮
+[![Upload Python Package](https://github.com/Scr44gr/arepy/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Scr44gr/arepy/actions/workflows/python-publish.yml)
+
+An ECS game engine created in python with raylib and imgui integration :)
+## Installation 📖
+```bash
+pip install git+https://github.com/Scr44gr/arepy.git
+```
+
+## Usage 📝
+
+### Basic usage example 
+
+#### Creating a simple system to move entities
+
+```python
+from arepy.bundle.components.rigidbody_component import RigidBody2D
+from arepy.bundle.components.transform_component import Transform
+from arepy.ecs.entities import Entities
+from arepy.ecs.query import Query, With
+from arepy.engine.renderer.renderer_2d import Renderer2D
+
+def movement_system(
+    query: Query[Entities, With[Transform, RigidBody2D]], renderer: Renderer2D
+):
+    delta_time = renderer.get_delta_time()
+    entities = query.get_entities()
+    for entity in entities:
+        transform = entity.get_component(Transform)
+        velocity = entity.get_component(RigidBody2D).velocity
+
+        transform.position.x += velocity.x * delta_time
+        transform.position.y += velocity.y * delta_time
+```
+
+TODO!: create a nice README.md

arepy-0.1.1/arepy/__init__.py

@@ -0,0 +1,4 @@
+from .engine import ArepyEngine
+
+__all__ = ["ArepyEngine"]
+__version__ = "0.1.1"

arepy-0.1.1/arepy/arepy_imgui/imgui_repository.py

@@ -0,0 +1,432 @@
+from dataclasses import dataclass
+from typing import Any, Optional, Protocol
+
+
+class ImGuiRendererRepository(Protocol):
+    def __init__(self, window: int): ...
+    def render(self, data: Any): ...
+    def process_inputs(self): ...
+
+
+@dataclass(frozen=True)
+class Default:
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def __getattr__(self, item):
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return False
+
+
+class ImGui(Protocol):
+    """A helper class to interact with the ImGui library"""
+
+    def get_draw_data(self) -> Any:
+        """Get the draw data"""
+        ...
+
+    def create_context(self):
+        """Create a new ImGui Context"""
+        ...
+
+    def render(self):
+        """Render the ImGui frame"""
+        ...
+
+    def shutdown(self):
+        """Shutdown the ImGui context"""
+        ...
+
+    def get_io(self):
+        """Get the ImGui IO object"""
+        ...
+
+    def image(
+        self,
+        texture_id: int,
+        size: tuple[int, int],
+        uv0: tuple[float, float],
+        uv1: tuple[float, float],
+        tint_col: Optional[tuple[float, float, float, float]],
+        border_col: Optional[tuple[float, float, float, float]],
+    ):
+        """Create an image
+
+        Args:
+            texture_id: The id of the texture
+            width: The width of the image
+            height: The height of the image
+        """
+        ...
+
+    def accept_drag_drop_payload(self, type: str, flags: int):
+        """Accept a drag and drop payload
+
+        Args:
+            type: The type of the payload
+            flags: The flags of the payload
+        """
+        ...
+
+    def align_text_to_frame_padding(self):
+        """Align text to the frame padding"""
+        ...
+
+    def arrow_button(self, label: str, direction: int) -> bool:
+        """Create an arrow button
+
+        Args:
+            label: The label of the button
+            direction: The direction of the arrow
+
+        Returns:
+            bool: True if the button was clicked
+        """
+        ...
+
+    def begin_child(
+        self, id: str, width: float, height: float, border: bool, flags: int
+    ):
+        """Begin a new child window
+
+        Args:
+            id: The id of the child window
+            width: The width of the child window
+            height: The height of the child window
+            border: Whether the child window has a border
+            flags: The flags of the child window
+        """
+        ...
+
+    def end_child(self):
+        """End the current child window"""
+        ...
+
+    def begin_combo(self, label: str, preview_value: str, flags: int):
+        """Begin a new combo box
+
+        Args:
+            label: The label of the combo box
+            preview_value: The preview value of the combo box
+            flags: The flags of the combo box
+        """
+        ...
+
+    def begin_drag_drop_source(self, flags: int):
+        """Begin a new drag and drop source
+
+        Set the current item as a drag and drop source. If dragging is True, you can call set_drag_drop_payload() and end_drag_drop_source().
+        Use with with to automatically call end_drag_drop_source() if necessary.
+
+        Args:
+            flags: The flags of the drag and drop source
+        """
+        ...
+
+    def begin_tab_item(self, label: str, open: bool, flags: int) -> Default:
+        """Begin a new tab item
+
+        Args:
+            label: The label of the tab item
+            open: Whether the tab item is open
+            flags: The flags of the tab item
+        """
+        ...
+
+    def begin_tab_bar(self, id: str, flags: int) -> Default:
+        """Begin a new tab bar
+
+        Args:
+            id: The id of the tab bar
+            flags: The flags of the tab bar
+        """
+        ...
+
+    def begin_main_menu_bar(self):
+        """Begin a new main menu bar"""
+        ...
+
+    def begin_menu(self, label: str, enabled: bool) -> bool:
+        """Begin a new menu
+
+        Args:
+            label: The label of the menu
+            enabled: Whether the menu is enabled
+
+        Returns:
+            bool: True if the menu was clicked
+        """
+        ...
+
+    def get_window_draw_list(self) -> Default:
+        """Get the window draw list"""
+        ...
+
+    def get_content_region_available(self) -> tuple[float, float]:
+        """Get the content region available"""
+        ...
+
+    def same_line(self, offset_from_start_x: float = 0.0, spacing: float = -1.0):
+        """Move the cursor to the same line
+
+        Args:
+            offset_from_start_x: The offset from the start x
+            spacing: The spacing
+        """
+        ...
+
+    def new_frame(self):
+        """Start a new ImGui frame"""
+        ...
+
+    def end_frame(self):
+        """End the current ImGui frame"""
+        ...
+
+    def button(self, label: str) -> bool:
+        """Create a button
+
+        Args:
+            label: The label of the button
+
+        Returns:
+            bool: True if the button was clicked
+        """
+        ...
+
+    def text(self, text: str):
+        """Print text
+
+        Args:
+            text: The text to print
+        """
+        ...
+
+    def begin(self, name: str, open: bool = True, flags: int = 0):
+        """Begin a new window
+
+        Args:
+            name: The name of the window
+            open: Whether the window is open
+        """
+        ...
+
+    def end(self):
+        """End the current window"""
+        ...
+
+    def end_tab_item(self):
+        """End the current tab item"""
+        ...
+
+    def end_tab_bar(self):
+        """End the current tab bar"""
+        ...
+
+    def end_main_menu_bar(self):
+        """End the current main menu bar"""
+        ...
+
+    def end_menu(self):
+        """End the current menu"""
+        ...
+
+    def open_popup(self, id: str):
+        """Open a popup
+
+        Args:
+            id: The id of the popup
+        """
+        ...
+
+    def begin_popup(self, id: str):
+        """Begin a new popup
+
+        Args:
+            id: The id of the popup
+        """
+        ...
+
+    def end_popup(self):
+        """End the current popup"""
+        ...
+
+    def input_text(self, label: str, value: str, buffer_length: int):
+        """Create an input text field
+
+        Args:
+            label: The label of the input field
+            value: The value of the input field
+            buffer_length: The length of the buffer
+        """
+        ...
+
+    def input_text_multiline(
+        self,
+        label: str,
+        value: str,
+        buffer_length: int,
+        width: float,
+        height: float,
+        flags: int = 0,
+        callback: Optional[Default] = None,
+    ):
+        """Create a multiline input text field
+
+        Args:
+            label: The label of the input field
+            value: The value of the input field
+            buffer_length: The length of the buffer
+            width: The width of the input field
+            height: The height of the input field
+            flags: The flags of the input field
+            callback: The callback of the input field
+        """
+        ...
+
+    def input_float(self, label: str, value: float, step: float, step_fast: float):
+        """Create a float input field
+
+        Args:
+            label: The label of the input field
+            value: The value of the input field
+            step: The step of the input field
+            step_fast: The fast step of the input field
+        """
+        ...
+
+    def get_cursor_screen_pos(self) -> tuple[float, float]:
+        """Get the cursor screen position"""
+        ...
+
+    def slider_int(
+        self, label: str, value: int, min_value: int, max_value: int, format: str
+    ):
+        """Create an integer slider
+
+        Args:
+            label: The label of the slider
+            value: The value of the slider
+            min_value: The minimum value of the slider
+            max_value: The maximum value of the slider
+            format: The format of the slider
+        """
+        ...
+
+    def slider_float(
+        self,
+        label: str,
+        value: float,
+        min_value: float,
+        max_value: float,
+        format: str,
+        power: float,
+    ):
+        """Create a float slider
+
+        Args:
+            label: The label of the slider
+            value: The value of the slider
+            min_value: The minimum value of the slider
+            max_value: The maximum value of the slider
+            format: The format of the slider
+            power: The power of the slider
+        """
+        ...
+
+    def menu_item(
+        self, label: str, shortcut: str, selected: bool, enabled: bool
+    ) -> tuple[bool, bool]:
+        """Create a menu item
+
+        Args:
+            label: The label of the menu item
+            shortcut: The shortcut of the menu item
+            selected: Whether the menu item is selected
+            enabled: Whether the menu item is enabled
+
+        Returns:
+            bool: True if the menu item was clicked
+        """
+        ...
+
+    def checkbox(self, label: str, state: bool):
+        """Create a checkbox
+
+        Args:
+            label: The label of the checkbox
+            value: The value of the checkbox
+        """
+        ...
+
+    def radio_button(self, label: str, active: bool):
+        """Create a radio button
+
+        Args:
+            label: The label of the radio button
+            active: Whether the radio button is active
+        """
+        ...
+
+    def set_next_window_size(self, width: int, height: int):
+        """Set the size of the next window
+
+        Args:
+            width: The width of the window
+            height: The height of the window
+        """
+        ...
+
+    def set_next_window_position(self, x: int, y: int):
+        """Set the position of the next window
+
+        Args:
+            x: The x position of the window
+            y: The y position of the window
+        """
+        ...
+
+    def set_next_window_size_constraints(
+        self, min_width: int, min_height: int, max_width: int, max_height: int
+    ):
+        """Set the size constraints of the next window
+
+        Args:
+            min_width: The minimum width of the window
+            min_height: The minimum height of the window
+            max_width: The maximum width of the window
+            max_height: The maximum height of the window
+        """
+        ...
+
+    def set_next_window_content_size(self, width: int, height: int):
+        """Set the content size of the next window
+
+        Args:
+            width: The width of the content
+            height: The height of the content
+        """
+        ...
+
+    def set_next_window_collapsed(self, collapsed: bool, cond: int):
+        """Set the collapsed state of the next window
+
+        Args:
+            collapsed: Whether the window is collapsed
+            cond: The condition to set the collapsed state
+        """
+        ...
+
+    def set_next_window_focus(self):
+        """Set the focus of the next window"""
+        ...
+
+    def set_next_window_bg_alpha(self, alpha: float):
+        """Set the background alpha of the next window
+
+        Args:
+            alpha: The alpha value of the background
+        """
+        ...

arepy-0.1.1/arepy/asset_store/__init__.py

@@ -0,0 +1 @@
+from .asset_store import AssetStore

arepy-0.1.1/arepy/asset_store/asset_store.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from os.path import exists
+from pathlib import Path
+from typing import Any, Dict
+
+from ..engine.renderer import ArepyTexture
+from ..engine.renderer.renderer_2d import Renderer2D
+
+
+class TextureFilter(Enum):
+    NEAREST = 0
+    LINEAR = 1
+
+
+@dataclass(frozen=True, slots=True)
+class AssetStore:
+    textures: Dict[str, ArepyTexture] = field(default_factory=dict)
+    fonts: Dict[str, Any] = field(default_factory=dict)
+
+    def create_render_texture(
+        self,
+        renderer: Renderer2D,
+        name: str,
+        width: int,
+        height: int,
+    ) -> ArepyTexture:
+        texture = renderer.create_render_texture(width, height)
+        self.textures[name] = texture
+        return texture
+
+    def load_texture(
+        self,
+        renderer: Renderer2D,
+        name: str,
+        path: str,
+    ) -> None:
+        if not exists(path):
+            raise FileNotFoundError(f"Texture file not found: {path}")
+
+        self.textures[name] = renderer.create_texture(path=Path(path))
+
+    def load_font(self, name: str, path: str, size: int) -> None: ...
+    def get_texture(self, name: str) -> ArepyTexture:
+        return self.textures[name]
+
+    def get_font(self, name: str) -> Any:
+        return self.fonts[name]
+
+    def unload_texture(self, renderer: Renderer2D, name: str) -> None:
+
+        texture = self.textures.pop(name)
+        renderer.unload_texture(texture)

arepy-0.1.1/arepy/builders.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from .ecs.components import Component
+from .ecs.registry import Entity, Registry
+
+
+class EntityBuilder:
+    """A builder for entities.
+
+    This is a wrapped class for the entity class.
+    It allows for the creation of entities with components without having to touch the ecs registry.
+    """
+
+    _registry: Registry
+
+    def __init__(self, entity: Entity, registry: Registry):
+        self._entity = entity
+        self._components: List[Component] = list()
+        self._registry = registry
+
+    def with_component(self, component: Component) -> "EntityBuilder":
+        """Add a component to the entity.
+
+        Returns:
+            A component builder.
+        """
+        if not isinstance(component, Component):
+            raise TypeError(
+                f"Component must be of type Component, not {type(component)}."
+            )
+
+        for _component in self._components:
+            if type(_component) == type(component):
+                raise TypeError(
+                    f"Component {type(component)} already exists in entity."
+                )
+
+        self._components.append(component)
+        return self
+
+    def build(self) -> Entity:
+        """Build the entity with the components, the components are built and added to the registry."""
+        for component in self._components:
+            self._registry.add_component(
+                self._entity,
+                type(component),
+                component,
+            )
+
+        return self._entity

arepy-0.1.1/arepy/bundle/components/__init__.py

@@ -0,0 +1,6 @@
+from .camera_component import Camera2D, Camera3D
+from .rigidbody_component import RigidBody2D
+from .sprite_component import Sprite
+from .transform_component import Transform
+
+__all__ = ["RigidBody2D", "Sprite", "Transform", "Camera2D", "Camera3D"]