pgfe 0.1.0__tar.gz

pgfe-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.3
+Name: pgfe
+Version: 0.1.0
+Requires-Dist: pygame-ce
+Requires-Python: >=3.14

pgfe-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "pgfe"
+version = "0.1.0"
+requires-python = ">=3.14"
+dependencies = ["pygame-ce"]
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13"]
+build-backend = "uv_build"

pgfe-0.1.0/pyproject.toml.orig

@@ -0,0 +1,11 @@
+[project]
+name = "pgfe"
+version = "0.1.0"
+requires-python = ">=3.14"
+dependencies = [
+    "pygame-ce",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13"]
+build-backend = "uv_build"

pgfe-0.1.0/src/pgfe/Enum.py

@@ -0,0 +1,6 @@
+
+import enum
+
+class Axis(enum.Enum):
+    X = enum.auto()
+    Y = enum.auto()

pgfe-0.1.0/src/pgfe/__init__.py

@@ -0,0 +1,6 @@
+
+import pgfe.entity
+import pgfe.game
+import pgfe.scene
+import pgfe.Enum
+import pgfe.events_manager

pgfe-0.1.0/src/pgfe/entity/AbstractEntity.py

@@ -0,0 +1,29 @@
+
+import abc
+import pygame as pg
+
+from pgfe.entity.entity_controllers.AbstractController import AbstractController
+
+
+class AbstractEntity(pg.sprite.Sprite, abc.ABC):
+
+    def __init__(self, *groups, x: int, y: int, image: pg.Surface) -> None:
+        pg.sprite.Sprite.__init__(self, *groups)
+        self.controller: AbstractController|None = None
+
+        self.image = image
+        self.rect = self.image.get_rect()
+        self.rect.x = x
+        self.rect.y = y
+
+        self.velocity: pg.Vector2 = pg.Vector2()
+
+    def update_velocity(self, x: float = 0.0, y: float = 0.0) -> None:
+        self.velocity.x += x
+        self.velocity.y += y
+
+    def move_x(self):
+        self.rect.x += self.velocity.x
+
+    def move_y(self):
+        self.rect.y += self.velocity.y

pgfe-0.1.0/src/pgfe/entity/entity_components/AbstractComponent.py

@@ -0,0 +1,9 @@
+
+import abc
+import pygame as pg
+
+
+class AbstractComponent(abc.ABC):
+    def __init__(self):
+        self.rect: pg.FRect|Pg.Rect = None
+        self.velocity: pg.Vector2|None = None

pgfe-0.1.0/src/pgfe/entity/entity_components/CollisionExceptions.py

@@ -0,0 +1,37 @@
+
+
+
+import dataclasses, typing
+
+from pgfe.entity.entity_components.AbstractComponent import AbstractComponent
+
+if typing.TYPE_CHECKING:
+    from rampant.world.tiles.Tile import Tile
+
+
+@dataclasses.dataclass
+class CollisionExceptions(AbstractComponent):
+    def __init__(self):
+        super().__init__()
+        self.unconditional: CollisionRules.Unconditional = self.Unconditional()
+        self.conditional: CollisionRules.Conditional = self.Conditional()
+
+    class Unconditional(list):
+        def add(self, tile: "type[Tile]"):
+            self.append(tile)
+
+        def remove(self, tile: "type[Tile]"):
+            super().remove(tile)
+
+        def get_rules(self):
+            return [i for i in self]
+
+    class Conditional(dict):
+        def add(self, tile: "type[Tile]", condition: "typing.Callable[[Tile], Tile|None]"):
+            self[tile] = condition
+
+        def remove(self, tile: "type[Tile]"):
+            super().pop(self, tile)
+
+        def get_rules(self):
+            return {(t, c) for t, c in self.items()}

pgfe-0.1.0/src/pgfe/entity/entity_components/colliders/AABBCollider.py

@@ -0,0 +1,37 @@
+
+import abc
+
+from pgfe import Enum
+from pgfe.entity.entity_components.colliders.AbstractCollider import AbstractCollider
+
+
+class AABBCollider(AbstractCollider, abc.ABC):
+    def __init__(self):
+        super().__init__()
+
+    def collide(self, sprite, axis) -> tuple[bool, bool]:
+        if axis == Enum.Axis.X:
+            to_return = [False, False]
+            if self.velocity.x > 0:
+                self.rect.right = sprite.rect.left
+                self.velocity.x = 0
+                to_return[0] = True
+            if self.velocity.x < 0:
+                self.rect.left = sprite.rect.right
+                self.velocity.x = 0
+                to_return[1] = True
+            return tuple(to_return)
+
+        if axis == Enum.Axis.Y:
+            to_return = [False, False]
+            if self.velocity.y > 0:
+                self.rect.bottom = sprite.rect.top
+                self.velocity.y = 0
+                to_return[1] = True
+            if self.velocity.y < 0:
+                self.rect.top = sprite.rect.bottom
+                self.velocity.y = 0
+                to_return[0] = True
+            return tuple(to_return)
+
+        return False, False

pgfe-0.1.0/src/pgfe/entity/entity_components/colliders/AbstractCollider.py

@@ -0,0 +1,57 @@
+
+import abc
+import pygame as pg
+
+from pgfe import Enum
+from pgfe.entity.entity_components.AbstractComponent import AbstractComponent
+from pgfe.entity.entity_components.CollisionExceptions import CollisionExceptions
+
+
+class AbstractCollider(AbstractComponent, abc.ABC):
+    def __init__(self):
+        super().__init__()
+
+        self.collision_exceptions = CollisionExceptions()
+
+    def get_collides(self, sprite_group):
+        for sprite in sprite_group.sprites():
+            if sprite != self and self.rect.colliderect(sprite.rect):
+                yield sprite
+
+    @abc.abstractmethod
+    def collide(self, sprite: pg.sprite.Sprite, axis: Enum.Axis) -> tuple[bool, bool]:
+        pass
+
+    def collides(self, sprite_group):
+        directions = {"top": False, "left": False, "bottom": False, "right": False}
+
+        # Remove unwanted sprites
+        for sprite in sprite_group.sprites():
+            if sprite != self and type(sprite) in self.collision_exceptions.unconditional:
+                sprite_group.remove(sprite)
+
+        self.move_x()
+        for sprite in self.get_collides(sprite_group):
+            right, left = self.collide(sprite, Enum.Axis.X)
+            directions.update({
+                "left": left,
+                "right": right
+            })
+
+        self.move_y()
+        for sprite in self.get_collides(sprite_group):
+            top, bottom = self.collide(sprite, Enum.Axis.Y)
+            directions.update({
+                "top": top,
+                "bottom": bottom
+            })
+
+        return directions
+
+    @abc.abstractmethod
+    def move_x(self):
+        pass
+
+    @abc.abstractmethod
+    def move_y(self):
+        pass

pgfe-0.1.0/src/pgfe/entity/entity_controllers/AbstractController.py

@@ -0,0 +1,11 @@
+
+import abc
+
+
+class AbstractController(abc.ABC):
+    def __init__(self):
+        pass
+
+    @abc.abstractmethod
+    def return_movement(self):
+        pass

pgfe-0.1.0/src/pgfe/entity/entity_controllers/WASDController.py

@@ -0,0 +1,38 @@
+
+import pygame as pg
+
+from pgfe.entity.entity_controllers.AbstractController import AbstractController
+
+
+class WASDController(AbstractController):
+    def __init__(self):
+        super().__init__()
+
+    def return_wasd(self) -> dict[str, float]:
+        pressed = pg.key.get_pressed()
+
+        return {
+            "w": pressed[pg.K_w],
+            "a": pressed[pg.K_a],
+            "s": pressed[pg.K_s],
+            "d": pressed[pg.K_d]
+        }
+
+    def return_movement(self) -> pg.Vector2:
+        vector = pg.math.Vector2()
+        wasd = self.return_wasd()
+
+        if wasd["w"]:
+            vector.x = 0
+            vector.y -= 1
+        if wasd["a"]:
+            vector.y = 0
+            vector.x -= 1
+        if wasd["s"]:
+            vector.x = 0
+            vector.y += 1
+        if wasd["d"]:
+            vector.y = 0
+            vector.x += 1
+
+        return vector

pgfe-0.1.0/src/pgfe/events_manager.py

@@ -0,0 +1,33 @@
+
+import pygame as pg
+import typing
+
+
+events: dict[int, list[typing.Callable]] = {}
+
+
+def add(hook: int, event: typing.Callable[[int], None]):
+    global events
+
+    event_list = events.get(hook)
+    if event_list:
+        events[hook].append(event)
+    else:
+        events[hook] = [event]
+
+def remove(hook: int, event: typing.Callable):
+    global events
+    events[hook].remove(event)
+
+def clear(hook: int):
+    global events
+    events[hook] = []
+
+def update_events():
+    global events
+
+    for event in pg.event.get():
+        if event.type in events:
+            for called in events[event.type]:
+                called(event)
+

pgfe-0.1.0/src/pgfe/game/AbstractGame.py

@@ -0,0 +1,53 @@
+
+import abc
+import pygame as pg
+
+from pgfe.scene.AbstractScene import AbstractScene
+from pgfe import events_manager
+
+
+def quit(event: int):
+    pg.quit()
+    raise SystemExit
+
+
+class AbstractGame(abc.ABC):
+
+    def __init__(self, framerate: int = 60, tickrate: int = 60, **window_args):
+        self.window: pg.Window = pg.Window(**window_args)
+        self.window.get_surface()
+
+        self.clock: pg.time.Clock = pg.time.Clock()
+
+        self.framerate: int = framerate
+        self.tickrate: int = tickrate
+
+        self.dt: float = 0
+        self.frame_dt: float = 0
+
+        self.scene: AbstractScene|None = None
+
+        events_manager.add(pg.QUIT, quit)
+
+    def set_scene(self, scene: AbstractScene):
+        self.scene = scene
+        self.scene.load()
+
+    def tick(self):
+        self.dt = self.clock.tick(self.tickrate) / 1000
+        self.frame_dt = self.dt * self.framerate
+
+    def update_idle_tasks(self):
+        self.scene.render(self.window.get_surface())
+        events_manager.update_events()
+        self.window.flip()
+
+    def play(self):
+        while True:
+            self.tick()
+
+            self.window.get_surface().fill(self.scene.colors.BG)
+
+            self.scene.update()
+
+            self.update_idle_tasks()

pgfe-0.1.0/src/pgfe/scene/AbstractScene.py

@@ -0,0 +1,54 @@
+
+from __future__ import annotations
+
+import abc
+import typing
+import dataclasses
+import pygame as pg
+
+if typing.TYPE_CHECKING:
+    from pgfe.game.AbstractGame import AbstractGame
+
+
+@dataclasses.dataclass
+class SceneColors:
+
+    BG: pg.Color = dataclasses.field(
+        default_factory=lambda: pg.Color("black")
+    )
+
+    FG: pg.Color = dataclasses.field(
+        default_factory=lambda: pg.Color("grey")
+    )
+
+    extra: dict[str, pg.Color] = dataclasses.field(default_factory=dict)
+
+    def add_color(self, name: str, color: pg.Color):
+        self.extra[name] = color
+
+
+class AbstractScene(abc.ABC):
+
+    def __init__(self, game: AbstractGame, colors: SceneColors = SceneColors(), **groups: pg.sprite.Group):
+
+        self.game: AbstractGame = game
+
+        self.colors: SceneColors = colors
+
+        self.groups: dict[str, pg.sprite.Group] = groups
+
+    @abc.abstractmethod
+    def load(self):
+        pass
+
+    def reset(self):
+        for group in self.groups.values():
+            group.empty()
+
+    def update(self, *args, **kwargs):
+        for group in self.groups.values():
+            group.update(*args, **kwargs)
+
+    def render(self, surface: pg.Surface):
+        for group in self.groups.values():
+            group.draw(surface)