pygame-foundation 0.1.0__tar.gz

pygame_foundation-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

pygame_foundation-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pygame-foundation
+Version: 0.1.0
+Summary: A modern wrapper around Pygame.
+Author: Arad Rezakhani
+License: MIT
+Keywords: pygame,game,gamedev,engine,framework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.6
+Requires-Dist: termcolor>=3.1
+Dynamic: license-file
+
+# pygame-foundation
+
+A foundation for building Pygame projects and games.
+
+pygame-foundation is currently in active development. Version 0.1.0 is the initial public release, and additional features are planned for future versions.
+
+## Installation
+
+pip install pygame-foundation
+
+## Features
+
+- Game class
+- World class
+- Entity class
+- Layered rendering
+- Update priorities
+- Tag management
+- Visibility control
+- Active/paused states
+- Update intervals
+
+## Quick Start
+
+```python
+from pygame_foundation import Game, World, Entity
+
+game = Game()
+world = game.world
+
+player = Entity(
+    x=100,
+    y=100,
+    size=(50, 50)
+)
+
+world.add(player)
+
+game.run()
+```
+
+## Roadmap
+
+- Scene system
+- Camera
+- Input manager
+- Asset manager
+- Animation system
+- Timer system
+
+
+## License
+
+This project is licensed under the MIT License.
+

pygame_foundation-0.1.0/README.md

@@ -0,0 +1,55 @@
+# pygame-foundation
+
+A foundation for building Pygame projects and games.
+
+pygame-foundation is currently in active development. Version 0.1.0 is the initial public release, and additional features are planned for future versions.
+
+## Installation
+
+pip install pygame-foundation
+
+## Features
+
+- Game class
+- World class
+- Entity class
+- Layered rendering
+- Update priorities
+- Tag management
+- Visibility control
+- Active/paused states
+- Update intervals
+
+## Quick Start
+
+```python
+from pygame_foundation import Game, World, Entity
+
+game = Game()
+world = game.world
+
+player = Entity(
+    x=100,
+    y=100,
+    size=(50, 50)
+)
+
+world.add(player)
+
+game.run()
+```
+
+## Roadmap
+
+- Scene system
+- Camera
+- Input manager
+- Asset manager
+- Animation system
+- Timer system
+
+
+## License
+
+This project is licensed under the MIT License.
+

pygame_foundation-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pygame-foundation"
+version = "0.1.0"
+description = "A modern wrapper around Pygame."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+authors = [
+    { name = "Arad Rezakhani" }
+]
+
+dependencies = [
+    "pygame>=2.6",
+    "termcolor>=3.1"
+]
+
+keywords = [
+    "pygame",
+    "game",
+    "gamedev",
+    "engine",
+    "framework"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

pygame_foundation-0.1.0/setup.cfg

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

pygame_foundation-0.1.0/src/pygame_foundation/__init__.py

@@ -0,0 +1,8 @@
+"""Foundational helpers for Pygame projects."""
+
+__version__ = "0.1.0"
+
+'''
+pygame
+termcolor
+'''

pygame_foundation-0.1.0/src/pygame_foundation/core/__int__.py

@@ -0,0 +1,11 @@
+''' 
+Core of pygame-foundation library.
+Contains most useful code.
+'''
+
+__all__ = [
+    'Game',
+    'UpdatablesManager',
+    'debug_and_log',
+    'Entity'
+]

pygame_foundation-0.1.0/src/pygame_foundation/core/constants.py

@@ -0,0 +1,7 @@
+# Colors
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+GREEN = (0, 255, 0)
+
+# Readability
+UPDATE_EVERY_FRAME = None

pygame_foundation-0.1.0/src/pygame_foundation/core/debug.py

@@ -0,0 +1,48 @@
+from functools import wraps
+from termcolor import colored
+from datetime import datetime
+
+def debug_and_log(messages:dict, expected_errors=[Exception], end='\n'):
+    ''' 
+    A decorator that checks for errors and log the data to the terminal
+    
+    NOTE:
+        Leave expected_errors as empty list to catch no errors
+        and leave it as default to catch all errors
+    '''
+    if expected_errors is None:
+        expected_errors = (Exception,)
+    else:
+        expected_errors = tuple(expected_errors)
+
+    def get_error_message(error):
+        error_messages = messages.get("errors", {})
+
+        for error_type in type(error).__mro__:
+            if error_type in error_messages:
+                return error_messages[error_type]
+
+        return messages["error"]
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # For instance methods, args[0] is normally `self`.
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            current_time = f"[{colored(timestamp, 'yellow')}]"
+
+            try:
+                result = func(*args, **kwargs)
+
+            except expected_errors as error:
+                message = colored(get_error_message(error), "red")
+                print(f"{current_time}: {message}: {error}", end=end)
+                return None
+
+            success = colored(messages["success"], "green")
+            print(f"{current_time}: {success}", end=end)
+
+            return result
+
+        return wrapper
+    return decorator

pygame_foundation-0.1.0/src/pygame_foundation/core/entities.py

@@ -0,0 +1,125 @@
+from .constants import WHITE, UPDATE_EVERY_FRAME
+from .debug import debug_and_log
+import pygame 
+
+class Entity(pygame.sprite.Sprite):
+    ''' A super class to be used to create subclasses  '''
+    def __init__(self,
+                x,
+                y,
+                imagepath=None, 
+                size=(0, 0), 
+                color=WHITE, 
+                visible:bool=True,
+                paused:bool=False,
+                active:bool=True,
+                priority:int=0,
+                layer:int=0,
+                update_interval:float=UPDATE_EVERY_FRAME,
+                tags:set=None,
+                name='NONE'):
+        ''' Initializes the Entity Class '''
+        super().__init__()
+        if imagepath:
+            self.image = pygame.image.load(imagepath)
+            self.rect = self.image.get_rect(topleft=(x, y))
+
+        else:
+            self.image = None
+            self.rect = pygame.Rect(x, y, *size)
+            self.color = color
+
+        self._world = None
+
+        self.visible = visible
+        self.paused = paused
+        self.active = active
+        self._priority = priority
+        self._layer = layer
+        self.update_interval = update_interval
+        self._elapsed = 0.0
+        self._tags = set() if tags is None else set(tags)
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def world(self):
+        return self._world
+
+    @property
+    def tags(self): 
+        return frozenset(self._tags)
+    
+    @property
+    def layer(self):
+        return self._layer
+
+    @layer.setter
+    def layer(self, value):
+        if self._layer == value:
+            return
+
+        old_layer = self._layer
+        self._layer = value
+
+        if self._world is not None:
+            self._world._move_layer(self, old_layer, value)
+
+    @property
+    def priority(self):
+        return self._priority
+
+    @priority.setter
+    def priority(self, value):
+        if self._priority == value:
+            return
+
+        old_priority = self._priority
+        self._priority = value
+
+        if self._world is not None:
+            self._world._move_priority(self, old_priority, value)
+
+    def update(self, dt):
+       '''Override in subclasses'''
+       pass
+
+    def draw(self, surface):
+        ''' Draw or blit self to screen '''
+        if self.visible:
+            if self.image:
+                surface.blit(self.image, self.rect)
+
+            else:
+                pygame.draw.rect(surface, self.color, self.rect)
+
+    @debug_and_log({
+        'success':'Succussfully added tag.',
+        'error':'Tag Addition Error',
+    })
+    def add_tag(self, tag):
+        if tag in self._tags:
+            return
+
+        self._tags.add(tag)
+
+        if self._world is not None:
+            self._world._add_tag(self, tag)
+
+    @debug_and_log({
+        'success':'Succussfully removed tag.',
+        'error':'Tag Removal Error',
+    })
+    def remove_tag(self, tag):
+        if tag not in self._tags:
+            return
+
+        self._tags.remove(tag)
+
+        if self._world is not None:
+            self._world._remove_tag(self, tag)
+
+    def has_tag(self, tag):
+        return tag in self._tags

pygame_foundation-0.1.0/src/pygame_foundation/core/game.py

@@ -0,0 +1,50 @@
+from .debug import debug_and_log
+from .constants import *
+from .world import World
+import pygame
+
+class Game:
+    ''' A class that acts as a manager for all events in the game '''
+    def __init__(self, window_width, window_height, caption, fps):
+        ''' Initialize the Game class and pygame '''
+        pygame.init()
+
+        self.window_width = window_width
+        self.window_height = window_height
+        self.fps = fps
+
+        self.surface = pygame.display.set_mode((window_width, window_height))
+        pygame.display.set_caption(caption)
+
+        self.clock = pygame.time.Clock()
+
+        self.world = World()
+
+    def update(self, dt):
+        ''' Update the Game '''
+        self.world.update(dt)
+
+        pygame.display.update()
+
+    def draw(self):
+        ''' Draw and blit Objects to the screen '''
+        self.world.draw(self.surface)
+
+    @debug_and_log({
+        'success':'Successfully closed game',
+        'error':'Error has occured during game',
+    })
+    def run(self):
+        ''' Run the Game '''
+        self.running = True
+        while self.running:
+            dt = self.clock.tick(self.fps) / 1000.0
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    self.running = False
+
+            self.surface.fill((0, 12, 12))
+            self.draw()
+
+            self.update(dt)
+        pygame.quit()

pygame_foundation-0.1.0/src/pygame_foundation/core/world.py

@@ -0,0 +1,284 @@
+from .constants import UPDATE_EVERY_FRAME, WHITE, BLACK, GREEN
+from .debug import debug_and_log
+from termcolor import colored
+import pygame
+import random
+
+class World(pygame.sprite.Group):
+    """An enhanced Sprite Group used to manage game entities."""
+
+    def __init__(self):
+        super().__init__()
+        print(colored('Info:', 'blue'), 'The Message above is normal even when no obj is added to the world')
+
+        self._layers = {}
+        self._priorities = {}
+        self._tags = {}
+
+    @debug_and_log(
+        {
+            'success':'Succussfully added obj/objs to World',
+            'error':'World Obj Addition Error'
+        }
+    )
+    def add(self, *sprites: pygame.sprite.Sprite) -> None:
+        super().add(*sprites)
+
+        for sprite in sprites:
+            sprite._world = self
+
+        self._update_layers(*sprites)
+        self._update_priorities(*sprites)
+        self._update_tags(*sprites)
+
+    @debug_and_log(
+        {
+            'success':'Succussfully removed obj/objs from World',
+            'error':'World Obj Removal Error'
+        }
+    )
+    def remove(self, *sprites):
+        super().remove(*sprites)
+
+        for sprite in sprites:
+
+            self._layers[sprite.layer].remove(sprite)
+            self._priorities[sprite.priority].remove(sprite)
+
+            if not self._layers[sprite.layer]:
+                del self._layers[sprite.layer]
+
+            if not self._priorities[sprite.priority]:
+                del self._priorities[sprite.priority]
+
+            for tag in sprite.tags:
+                self._tags[tag].remove(sprite)
+            
+                if not self._tags[tag]:
+                    del self._tags[tag]
+
+            sprite._world = None
+
+    def _update_tags(self, *sprites):
+        for sprite in sprites:
+            for tag in sprite.tags:
+                self._tags.setdefault(tag, []).append(sprite)
+
+    def _add_tag(self, sprite, tag):
+        self._tags.setdefault(tag, []).append(sprite)
+
+    def _remove_tag(self, sprite, tag):
+        if tag in self._tags:
+            self._tags[tag].remove(sprite)
+
+            if not self._tags[tag]:
+                del self._tags[tag]
+
+    def _update_priorities(self, *sprites):
+        for sprite in sprites:
+            if sprite.priority in self._priorities:
+                self._priorities[sprite.priority].append(sprite)
+
+            else:
+                self._priorities[sprite.priority] = [sprite]
+
+    def _move_priority(self, sprite, old_priority, new_priority):
+        self._priorities[old_priority].remove(sprite)
+
+        if not self._priorities[old_priority]:
+            del self._priorities[old_priority]
+
+        self._priorities.setdefault(new_priority, []).append(sprite)
+
+    def _update_layers(self, *sprites):
+        for sprite in sprites:
+            if sprite.layer in self._layers:
+                self._layers[sprite.layer].append(sprite)
+
+            else:
+                self._layers[sprite.layer] = [sprite]
+
+    def _move_layer(self, sprite, old_layer, new_layer):
+        # Remove from old layer
+        self._layers[old_layer].remove(sprite)
+
+        # Delete empty layer
+        if not self._layers[old_layer]:
+            del self._layers[old_layer]
+
+        # Add to new layer
+        self._layers.setdefault(new_layer, []).append(sprite)
+
+    def _find_tags(self, *tags, match_all=False):
+        sprites = []
+        matcher = all if match_all else any
+
+        for sprite in self.sprites():
+            if matcher(tag in sprite._tags for tag in tags):
+                sprites.append(sprite)
+
+        return sprites
+
+    def draw(self, surface):
+        for layer in sorted(self._layers):
+            for sprite in self._layers[layer]:
+                if not sprite.active:
+                    continue
+
+                sprite.draw(surface)
+
+    def update(self, dt):
+        ''' Updates the objects in the world according to their update_interval and priority. '''
+        for priority in sorted(self._priorities):
+            for sprite in self._priorities[priority]:
+                if not sprite.active or sprite.paused:
+                    continue
+
+                sprite._elapsed += dt
+
+                if sprite.update_interval is UPDATE_EVERY_FRAME:
+                    sprite.update(dt)
+
+                elif sprite._elapsed >= sprite.update_interval:
+                    sprite.update(dt)
+                    sprite._elapsed -= sprite.update_interval
+
+    @debug_and_log({
+            'success':'Succussfully found sprites by tags',
+            'error':'Sprites Search by Tags Error'
+        }
+    )
+    def find_by_tags(self, *tags) -> list:
+        ''' 
+        Gets all the sprites that contains the specified tags.
+        This function gets all the sprites that contain any of the tags
+        not filter them by tags.
+        '''
+        sprites = []
+
+        for tag in tags:
+            for sprite in self._tags.get(tag, []):
+                if sprite not in sprites:
+                    sprites.append(sprite)
+
+        return sprites
+
+    @debug_and_log({
+            'success':'Succussfully found sprites by tags',
+            'error':'Sprites Search by Tags(Match All) Error'
+        }
+    )
+    def find_by_tags_all(self, *tags) -> list:
+        ''' 
+        Gets all the sprites that contains the specified tags.
+        This function filters and gets all the sprites that have all the tags
+        not only one.
+        '''
+        sprites = set(self._tags.get(tags[0], []))
+        for tag in tags[1:]:
+            sprites &= set(self._tags.get(tag, []))
+
+        return list(sprites)
+
+    @debug_and_log(
+        {
+            'success':'Succussfully paused sprites by tags',
+            'error':'Sprites Pause by Tags Error'
+        }
+    )
+    def pause_tags(self, *tags) -> list:
+        ''' 
+        Pauses the sprites that contains the specified tags.
+        It does this by changing the paused attribute on the entity to True.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.paused = True
+
+        return sprites
+
+    @debug_and_log(
+        {
+            'success':'Succussfully resumed sprites by tags',
+            'error':'Sprites Resume by Tags Error'
+        }
+    )
+    def resume_tags(self, *tags) -> list:
+        ''' 
+        Resumes the sprites that contains the specified tags.
+        It does this by changing the paused attribute on the entity to False.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.paused = False
+
+        return sprites
+
+    @debug_and_log(
+        {
+            'success':'Succussfully hid sprites by tags',
+            'error':'Sprites Hide by Tags Error'
+        }
+    )
+    def hide_tags(self, *tags) -> list:
+        ''' 
+        Hides the sprites that contains the specified tags.
+        It does this by changing the visible attribute on the entity to False.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.visible = False
+        
+        return sprites
+
+    @debug_and_log(
+        {
+            'success':'Succussfully shown sprites by tags',
+            'error':'Sprites Show by Tags Error'
+        }
+    )
+    def show_tags(self, *tags) -> list:
+        ''' 
+        Show the hidden sprites that contains the specified tags.
+        It does this by changing the visible attribute on the entity to True.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.visible = True
+        
+        return sprites
+
+    @debug_and_log(
+        {
+            'success':'Succussfully activated sprites by tags',
+            'error':'Sprites Activation by Tags Error'
+        }
+    )
+    def activate_tags(self, *tags) -> list:
+        ''' 
+        Activate the sprites that contains the specified tags.
+        It does this by changing the active attribute on the entity to True.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.active = True
+        
+        return sprites
+
+    @debug_and_log(
+        {
+            'success':'Succussfully deactivated sprites by tags',
+            'error':'Sprites Deactivation by Tags Error'
+        }
+    )
+    def deactivate_tags(self, *tags) -> list:
+        ''' 
+        Deactivate the sprites that contains the specified tags.
+        It does this by changing the active attribute on the entity to False.
+        '''
+        sprites = self._find_tags(*tags)
+        for sprite in sprites:
+            sprite.active = False
+
+        return sprites
+        

pygame_foundation-0.1.0/src/pygame_foundation.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pygame-foundation
+Version: 0.1.0
+Summary: A modern wrapper around Pygame.
+Author: Arad Rezakhani
+License: MIT
+Keywords: pygame,game,gamedev,engine,framework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.6
+Requires-Dist: termcolor>=3.1
+Dynamic: license-file
+
+# pygame-foundation
+
+A foundation for building Pygame projects and games.
+
+pygame-foundation is currently in active development. Version 0.1.0 is the initial public release, and additional features are planned for future versions.
+
+## Installation
+
+pip install pygame-foundation
+
+## Features
+
+- Game class
+- World class
+- Entity class
+- Layered rendering
+- Update priorities
+- Tag management
+- Visibility control
+- Active/paused states
+- Update intervals
+
+## Quick Start
+
+```python
+from pygame_foundation import Game, World, Entity
+
+game = Game()
+world = game.world
+
+player = Entity(
+    x=100,
+    y=100,
+    size=(50, 50)
+)
+
+world.add(player)
+
+game.run()
+```
+
+## Roadmap
+
+- Scene system
+- Camera
+- Input manager
+- Asset manager
+- Animation system
+- Timer system
+
+
+## License
+
+This project is licensed under the MIT License.
+

pygame_foundation-0.1.0/src/pygame_foundation.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/pygame_foundation/__init__.py
+src/pygame_foundation.egg-info/PKG-INFO
+src/pygame_foundation.egg-info/SOURCES.txt
+src/pygame_foundation.egg-info/dependency_links.txt
+src/pygame_foundation.egg-info/requires.txt
+src/pygame_foundation.egg-info/top_level.txt
+src/pygame_foundation/core/__int__.py
+src/pygame_foundation/core/constants.py
+src/pygame_foundation/core/debug.py
+src/pygame_foundation/core/entities.py
+src/pygame_foundation/core/game.py
+src/pygame_foundation/core/world.py

pygame_foundation-0.1.0/src/pygame_foundation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pygame_foundation-0.1.0/src/pygame_foundation.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pygame>=2.6
+termcolor>=3.1

pygame_foundation-0.1.0/src/pygame_foundation.egg-info/top_level.txt

@@ -0,0 +1 @@
+pygame_foundation