feather-engine 26.8.2__tar.gz

feather_engine-26.8.2/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: feather-engine
+Version: 26.8.2
+Summary: A pygame utility module
+Author: TheCodingChihuahua
+License-Expression: GPL-3.0-only
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: pygame>=2.5
+
+# Feather Engine
+
+Feather is a small Pygame utility module for beginner-friendly 2D games.
+
+## Example
+
+```python
+import feather
+
+player = None
+
+
+def init():
+    global player
+    player = feather.Sprite("assets/player.png")
+
+
+def update():
+    if feather.key_pressed("ENTER"):
+        player.image = "assets/playerdance.png"
+    if feather.key_pressed("BACKSPACE"):
+        player.image = "assets/playercry.png"
+    if feather.key_pressed("ESCAPE"):
+        feather.end()
+
+
+feather.run(init, update)
+```
+
+`update` runs once per frame at up to 60 frames per second. Image paths are resolved relative to the game's current working directory.
+
+## Installation
+
+```powershell
+python -m pip install feather-engine
+```
+
+Then import it in your game with:
+
+```python
+import feather
+```

feather_engine-26.8.2/README.md

@@ -0,0 +1,42 @@
+# Feather Engine
+
+Feather is a small Pygame utility module for beginner-friendly 2D games.
+
+## Example
+
+```python
+import feather
+
+player = None
+
+
+def init():
+    global player
+    player = feather.Sprite("assets/player.png")
+
+
+def update():
+    if feather.key_pressed("ENTER"):
+        player.image = "assets/playerdance.png"
+    if feather.key_pressed("BACKSPACE"):
+        player.image = "assets/playercry.png"
+    if feather.key_pressed("ESCAPE"):
+        feather.end()
+
+
+feather.run(init, update)
+```
+
+`update` runs once per frame at up to 60 frames per second. Image paths are resolved relative to the game's current working directory.
+
+## Installation
+
+```powershell
+python -m pip install feather-engine
+```
+
+Then import it in your game with:
+
+```python
+import feather
+```

feather_engine-26.8.2/feather.py

@@ -0,0 +1,399 @@
+import os
+import pygame
+
+_running = True
+_objects = []
+_background_color = (0, 0, 0)
+
+
+def _normalize_layer(value):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _sort_objects():
+    _objects.sort(key=lambda obj: _normalize_layer(getattr(obj, 'layer', 0)), reverse=True)
+
+_keys_down = set()
+_key_aliases = {
+    'ENTER': 'RETURN',
+    'ESC': 'ESCAPE',
+    'CTRL': 'CONTROL',
+    'CMD': 'GUI',
+}
+
+framerate: int = 60
+def setWindowTitle(title): pygame.display.set_caption(title)
+def setWindowSize(width, height): pygame.display.set_mode((width, height), pygame.RESIZABLE)
+def setBackgroundColor(color):
+    global _background_color
+    if isinstance(color, str):
+        color = pygame.Color(color)
+    _background_color = color
+    surface = pygame.display.get_surface()
+    if surface is not None:
+        surface.fill(color)
+
+def _key_name(key):
+    name = str(key).upper()
+    return _key_aliases.get(name, name)
+
+
+def run(_init, _update):
+    global _running
+    _running = True
+
+    if not pygame.get_init():
+        pygame.init()
+
+    if pygame.display.get_surface() is None:
+        pygame.display.set_mode((800, 600), pygame.RESIZABLE)
+
+    clock = pygame.time.Clock()
+
+    if _init is not None:
+        _init()
+
+    while _running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                end()
+            elif event.type == pygame.KEYDOWN:
+                _keys_down.add(_key_name(pygame.key.name(event.key)))
+            elif event.type == pygame.KEYUP:
+                _keys_down.discard(_key_name(pygame.key.name(event.key)))
+
+        screen = pygame.display.get_surface()
+        screen.fill(_background_color)
+        _update()
+
+        for obj in _objects:
+            if isinstance(obj, Sprite):
+                screen.blit(obj.image, obj.rect)
+            elif isinstance(obj, Label):
+                screen.blit(obj.image, obj.rect)
+            elif isinstance(obj, Rectangle):
+                pygame.draw.rect(screen, obj.color, obj.rect)
+
+        pygame.display.flip()
+        clock.tick(framerate)
+
+
+def end():
+    global _running
+    _running = False
+
+def key_pressed(key):
+    return _key_name(key) in _keys_down
+
+def add_sprite(sprite):
+    if sprite not in _objects:
+        _objects.append(sprite)
+        _sort_objects()
+
+def add_rect(rect):
+    if rect not in _objects:
+        _objects.append(rect)
+        _sort_objects()
+
+def add_label(label):
+    if label not in _objects:
+        _objects.append(label)
+        _sort_objects()
+
+
+class Sprite:
+    def __init__(self, image_path, x=0, y=0, width=None, height=None, layer=0, flip_x=False, flip_y=False):
+        file_extension = os.path.splitext(image_path)[1].lower().lstrip('.')
+
+        if file_extension in {'png', 'svg'}:
+            self.image = pygame.image.load(image_path).convert_alpha()
+        elif file_extension in {'jpg', 'jpeg'}:
+            self.image = pygame.image.load(image_path).convert()
+        else:
+            raise ValueError("Unsupported image format: {}".format(file_extension))
+
+        self.rect = self.image.get_rect(topleft=(x, y))
+
+        if width is not None or height is not None:
+            target_width = self.rect.width if width is None else width
+            target_height = self.rect.height if height is None else height
+            self._resize(target_width, target_height)
+
+        self._layer = _normalize_layer(layer)
+        self._flip_x = False
+        self._flip_y = False
+        self.flip_x = flip_x
+        self.flip_y = flip_y
+        add_sprite(self)
+
+    @property
+    def x(self):
+        return self.rect.x
+
+    @x.setter
+    def x(self, value):
+        self.rect.x = value
+
+    @property
+    def y(self):
+        return self.rect.y
+
+    @y.setter
+    def y(self, value):
+        self.rect.y = value
+
+    @property
+    def width(self):
+        return self.rect.width
+
+    @width.setter
+    def width(self, value):
+        self._resize(value, self.height)
+
+    @property
+    def height(self):
+        return self.rect.height
+
+    @height.setter
+    def height(self, value):
+        self._resize(self.width, value)
+    
+    @property
+    def layer(self):
+        return self._layer
+    
+    @layer.setter
+    def layer(self, value):
+        self._layer = _normalize_layer(value)
+        _sort_objects()
+
+    def _resize(self, width, height):
+        width = max(1, min(int(width), 8192))
+        height = max(1, min(int(height), 8192))
+        position = self.rect.topleft
+        self.image = pygame.transform.scale(self.image, (width, height))
+        self.rect = self.image.get_rect(topleft=position)
+
+    @property
+    def flip_x(self):
+        return self._flip_x
+
+    @flip_x.setter
+    def flip_x(self, value):
+        value = bool(value)
+        if value != self._flip_x:
+            self.image = pygame.transform.flip(self.image, True, False)
+            self._flip_x = value
+
+    @property
+    def flip_y(self):
+        return self._flip_y
+
+    @flip_y.setter
+    def flip_y(self, value):
+        value = bool(value)
+        if value != self._flip_y:
+            self.image = pygame.transform.flip(self.image, False, True)
+            self._flip_y = value
+
+    @property
+    def image(self):
+        return self._image
+
+    @image.setter
+    def image(self, value):
+        preserve_size = isinstance(value, str) and hasattr(self, 'rect')
+        position = self.rect.topleft if hasattr(self, 'rect') else (0, 0)
+
+        if isinstance(value, str):
+            file_extension = os.path.splitext(value)[1].lower().lstrip('.')
+
+            if file_extension in {'png', 'svg'}:
+                loaded_image = pygame.image.load(value).convert_alpha()
+            elif file_extension in {'jpg', 'jpeg'}:
+                loaded_image = pygame.image.load(value).convert()
+            else:
+                raise ValueError("Unsupported image format: {}".format(file_extension))
+        elif isinstance(value, pygame.Surface):
+            loaded_image = value
+        else:
+            raise ValueError("Unsupported image type: {}".format(type(value)))
+
+        if preserve_size:
+            loaded_image = pygame.transform.scale(loaded_image, self.rect.size)
+            loaded_image = pygame.transform.flip(
+                loaded_image,
+                getattr(self, '_flip_x', False),
+                getattr(self, '_flip_y', False),
+            )
+
+        self._image = loaded_image
+        self.rect = self.image.get_rect(topleft=position)
+
+class Label:
+    def __init__(self, text='', x=0, y=0, layer=0, size=36, color=('black'), font_name=None, rounded=True):
+        self._x = x
+        self._y = y
+        self._text = str(text)
+        self._layer = _normalize_layer(layer)
+        self._size = size
+        self._color = color
+        self._font_name = font_name
+        self._rounded = rounded
+        self.font = pygame.font.Font(self._font_name, self._size)
+        self._render()
+        add_label(self)
+
+    def _render(self):
+        self.image = self.font.render(self._text, self._rounded, self._color)
+        self.rect = self.image.get_rect(topleft=(self._x, self._y))
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = value
+        if hasattr(self, 'rect'):
+            self.rect.x = value
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y = value
+        if hasattr(self, 'rect'):
+            self.rect.y = value
+
+    @property
+    def layer(self):
+        return self._layer
+
+    @layer.setter
+    def layer(self, value):
+        self._layer = _normalize_layer(value)
+        _sort_objects()
+    
+    @property
+    def text(self):
+        return self._text
+
+    @text.setter
+    def text(self, value):
+        self._text = str(value)
+        self._render()
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, value):
+        self._size = value
+        self.font = pygame.font.Font(self._font_name, self._size)
+        self._render()
+
+    @property
+    def color(self):
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = value
+        self._render()
+
+    @property
+    def font_name(self):
+        return self._font_name
+
+    @font_name.setter
+    def font_name(self, value):
+        self._font_name = value
+        self.font = pygame.font.Font(self._font_name, self._size)
+        self._render()
+
+    @property
+    def rounded(self):
+        return self._rounded
+
+    @rounded.setter
+    def rounded(self, value):
+        self._rounded = value
+        self._render()
+
+class Rectangle:
+    def __init__(self, x=0, y=0, width=30, height=30, color=(255, 255, 255), layer=0):
+        self._x = x
+        self._y = y
+        self._width = width
+        self._height = height
+        self.rect = pygame.Rect(x, y, width, height)
+        self.color = color
+        self._layer = _normalize_layer(layer)
+        add_rect(self)
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = value
+        if hasattr(self, 'rect'):
+            self.rect.x = value
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y = value
+        if hasattr(self, 'rect'):
+            self.rect.y = value
+
+    @property
+    def width(self):
+        return self._width
+
+    @width.setter
+    def width(self, value):
+        self._width = value
+        if hasattr(self, 'rect'):
+            self.rect.width = value
+
+    @property
+    def height(self):
+        return self._height
+
+    @height.setter
+    def height(self, value):
+        self._height = value
+        if hasattr(self, 'rect'):
+            self.rect.height = value
+    
+    @property
+    def color(self):
+        return self._color
+    
+    @color.setter
+    def color(self, value):
+        self._color = value
+    
+    @property
+    def layer(self):
+        return self._layer
+    
+    @layer.setter
+    def layer(self, value):
+        try:
+            self._layer = int(value)
+        except (TypeError, ValueError):
+            self._layer = 0
+        _sort_objects()

feather_engine-26.8.2/feather_engine.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: feather-engine
+Version: 26.8.2
+Summary: A pygame utility module
+Author: TheCodingChihuahua
+License-Expression: GPL-3.0-only
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: pygame>=2.5
+
+# Feather Engine
+
+Feather is a small Pygame utility module for beginner-friendly 2D games.
+
+## Example
+
+```python
+import feather
+
+player = None
+
+
+def init():
+    global player
+    player = feather.Sprite("assets/player.png")
+
+
+def update():
+    if feather.key_pressed("ENTER"):
+        player.image = "assets/playerdance.png"
+    if feather.key_pressed("BACKSPACE"):
+        player.image = "assets/playercry.png"
+    if feather.key_pressed("ESCAPE"):
+        feather.end()
+
+
+feather.run(init, update)
+```
+
+`update` runs once per frame at up to 60 frames per second. Image paths are resolved relative to the game's current working directory.
+
+## Installation
+
+```powershell
+python -m pip install feather-engine
+```
+
+Then import it in your game with:
+
+```python
+import feather
+```

feather_engine-26.8.2/feather_engine.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+feather.py
+pyproject.toml
+feather_engine.egg-info/PKG-INFO
+feather_engine.egg-info/SOURCES.txt
+feather_engine.egg-info/dependency_links.txt
+feather_engine.egg-info/requires.txt
+feather_engine.egg-info/top_level.txt

feather_engine-26.8.2/feather_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

feather_engine-26.8.2/feather_engine.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame>=2.5

feather_engine-26.8.2/feather_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+feather

feather_engine-26.8.2/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "feather-engine"
+version = "26.8.2"
+description = "A pygame utility module"
+readme = "README.md"
+requires-python = ">=3.14"
+authors = [{ name = "TheCodingChihuahua" }]
+license = "GPL-3.0-only"
+dependencies = ["pygame>=2.5"]
+
+[tool.setuptools]
+py-modules = ["feather"]

feather_engine-26.8.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+