devpace 1.0.0__tar.gz

devpace-1.0.0/.gitignore

@@ -0,0 +1,3 @@
+.vscode/
+__pycache__/
+*.pyc

devpace-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

devpace-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "devpace"
+version = "1.0.0"
+authors = [
+  { name="Sam Fertig", email="sfertig007@gmail.com" },
+]
+description = "A growing game framework for pygame developement"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/sfertig/GameEngine"
+Issues = "https://github.com/sfertig/GameEngine/issues"

devpace-1.0.0/src/devPace/GlobalDebugger.py

@@ -0,0 +1,53 @@
+def GlobalDebugger(log_queue):
+    """
+    Runs in an isolated process. Must completely rebuild its 
+    own window drivers and pump events immediately to become visible.
+    """
+    import pygame # Import inside the process to ensure clean namespace isolation
+    
+    # RULE 1: Fresh initialization of the sub-process multimedia context
+    pygame.init()
+    
+    # RULE 3: Use traditional display modes for sub-processes to ensure OS hook compatibility
+    # Set window size (e.g., 400x600)
+    screen = pygame.display.set_mode((400, 600))
+    pygame.display.set_caption("Engine Debug Log")
+    
+    font = pygame.font.Font(None, 22)
+    clock = pygame.time.Clock()
+    displayed_logs = ["--- Debugger Online ---"]
+    
+    running = True
+    while running:
+        # RULE 2: Pump events immediately so Windows displays the window framework
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+        
+        # Drain the communication tube 
+        while not log_queue.empty():
+            try:
+                msg = log_queue.get(block=False)
+                displayed_logs.append(msg)
+                if len(displayed_logs) > 25:
+                    displayed_logs.pop(1)
+            except:
+                break
+                
+        # Draw the logs onto the screen
+        screen.fill((15, 15, 15))
+        
+        y = 15
+        for log in displayed_logs:
+            color = (255, 80, 80) if "Error" in log else (220, 220, 220)
+            txt = font.render(log, True, color)
+            screen.blit(txt, (15, y))
+            y += 22
+            
+        # Push the frame buffer onto the screen monitor
+        pygame.display.flip()
+        
+        # Keep frame times light to optimize host CPU execution
+        clock.tick(30)
+        
+    pygame.quit()

devpace-1.0.0/src/devPace/__init__.py

@@ -0,0 +1,39 @@
+"""
+Pygame Engine
+"""
+
+
+__version__ = "1.0.0"
+__author__ = "Sam Fertig"
+
+#____imports____
+from .main import Engine, Scene
+from .basics.camera import Camera
+from .basics.input import Keys, FastMovement
+from .basics.shapes import Rect, Circle
+from .assets.cache import Assets
+from .assets.images import Image
+from .physics.dynamicBody import DynamicBody
+from .physics.KinematicPlatform import KinematicPlatform
+from .assets.tilemap import Tilemap, TILEMAP_COLLISION_GEN
+from .assets.animations import AnimationManager
+from .physics.StateManager import StateManager, AutoStateManager
+
+__all__ = [
+    "Engine",
+    "Scene",
+    "Camera",
+    "Rect",
+    "Keys",
+    "FastMovement",
+    "Circle",
+    "Assets",
+    "Image",
+    "DynamicBody",
+    "KinematicPlatform",
+    "Tilemap",
+    "TILEMAP_COLLISION_GEN",
+    "AnimationManager",
+    "StateManager",
+    "AutoStateManager"
+    ]

devpace-1.0.0/src/devPace/_net.py

@@ -0,0 +1,55 @@
+import pygame
+
+class _global_:
+    def __init__(self):
+        #screen info
+        self.screen: pygame.Surface = None
+        self.display: pygame.Surface = None
+        self.ScreenDim: tuple = (800, 600)
+        self.title: str = "Pygame Window"
+
+        self.FW = 0.0 #diference used for resizing
+        self.FH = 0.0
+
+        #basics
+        self.cam = None
+        self.clock: pygame.time.Clock = None
+        self.bg: str = "black"
+        self.dt: float = 0.0
+        self.events: list[pygame.event.Event] = []
+
+        #assets
+        self.assets = None
+
+        #objects
+        self.objects = {}
+
+        #collisions
+        self.collisions = []
+        self.all_collision_layers = None
+
+        #scenes
+        self.current_scene = None
+        self.scenes = {}
+        self.last_scene = None
+
+        #tilemaps
+        
+        self.tilemaps = {}  #tilemaps: dict[int, list[tilemap]]
+
+    def _add_tilemap(self, layer, map):
+        if layer not in self.tilemaps:
+            self.tilemaps[layer] = []
+        self.tilemaps[layer].append(map)
+
+    def add_object(self, layer: str, obj):
+        if layer not in self.objects:
+            self.objects[layer] = []
+        self.objects[layer].append(obj)
+
+    def remove_object(self, layer: str, obj):
+        if layer in self.objects:
+            self.objects[layer].remove(obj)
+
+Global = _global_()
+

devpace-1.0.0/src/devPace/assets/animations.py

@@ -0,0 +1,111 @@
+import pygame
+from .._net import Global
+from .images import Image
+#from .cache import Assets
+from ..helpers.utils import change_layer
+from ..physics.collisions import CollisionRect
+
+def splitImage(image, width, height, frames):
+    images = []
+    #split image into frames
+    for y in range(image.get_height()//height):
+        for x in range(image.get_width()//width):
+            images.append(image.subsurface(pygame.Rect(x*width, y*height, width, height)))
+    new_images = []
+    #extract each frame
+
+    #if all
+    if frames == "_ALL": return images
+    #else return range
+    for i in range(frames[0], frames[1]+1):
+        new_images.append(images[i])
+    return new_images
+
+class Animation:
+    def __init__(self, name, image, frames, width=16, height=16, x=0, y=0, loop=True, speed=0.3, layer=3, show=True, enableCollision=False):
+        self.name = name
+        self.frames = splitImage(image, width, height, frames)
+        self.frame = 0
+        self.loop = loop
+        self.speed = speed
+        self.layer = layer
+        self.show = show
+        self.time = 0.0
+        self.x = x
+        self.y = y
+
+        Global.add_object(layer, self)
+
+        self.collision = None
+        if enableCollision:
+            self.collision = CollisionRect(x, y, width, height, [layer])
+            self.collision.layers = [layer]
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def update(self):
+        if self.collision is not None:
+            self.collision.x = self.x
+            self.collision.y = self.y
+        #update using Global.dt
+        self.time+=Global.dt
+        if self.time >= self.speed:
+            self.time = 0.0
+            self.frame+=1
+            if self.frame > len(self.frames)-1:
+                if self.loop:
+                    self.frame = 0
+
+    def enableCollision(self):
+        self.collision = CollisionRect(self.x, self.y, self.image.get_width(), self.image.get_height(), [self.layer])
+
+    def get_frame(self):
+        return self.frames[self.frame]
+
+    def render(self):
+        if self.show:
+            Global.screen.blit(self.frames[self.frame], (self.x-Global.cam.x, self.y-Global.cam.y))
+
+class AnimationManager:
+    def __init__(self, name, layer=3, enable_collisions=False, animations={}, current_animation=None):
+        self.name = name
+        self.layer = layer
+        Global.add_object(layer, self)
+        self.animations: dict[str, Animation] = animations
+        self.current_animation = current_animation
+
+        #remove animations from main update loop
+        for animation in self.animations.values():
+            Global.remove_object(animation.layer, animation)
+
+        self.collision = None
+        if enable_collisions:
+            self.collision = CollisionRect(0, 0, 0, 0, [layer])
+            self.collision.layers = [layer]
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def add_animation(self, name, animation):
+        self.animations[name] = animation
+    def remove_animation(self, name):
+        self.animations.pop(name)
+    def play_animation(self, name):
+        self.current_animation = name
+
+    def update(self):
+        if self.collision is not None:
+            self.collision.x = self.x
+            self.collision.y = self.y
+        if self.current_animation is None: return
+        self.animations[self.current_animation].update()
+        self.animations[self.current_animation].x = self.x
+        self.animations[self.current_animation].y = self.y
+
+
+    def render(self):
+        if self.current_animation is None: return
+        self.animations[self.current_animation].render()

devpace-1.0.0/src/devPace/assets/cache.py

@@ -0,0 +1,91 @@
+import pygame
+#from .._net import Global
+from .animations import Animation
+class _Cache:
+    def __init__(self):
+        self.images: dict[str, pygame.surface.Surface] = {}
+        self.animations: dict[str, Animation] = {}
+        self.tilesets: dict[str, dict[tuple[int, int], pygame.surface.Surface]] = {}
+        self._tileset_cache_data: dict[str, tuple[int, int]] = {}
+        self.fonts: dict[str, pygame.font.Font] = {}
+
+    def clear_all(self, _confirm=False):
+        if not _confirm: return
+        self.images.clear()
+        self.animations.clear()
+        self.tilesets.clear()
+        self._tileset_cache_data.clear()
+        self.fonts.clear()
+
+    #########################
+    #CREATION
+    #########################
+
+    def new_image(self, path, name, colorkey=None, scale=1.0) -> bool:
+        if name in self.images:
+            return False
+        self.images[name] = pygame.image.load(path).convert_alpha()
+        if colorkey is not None:
+            self.images[name].set_colorkey(colorkey)
+        if scale != 1.0:
+            self.images[name] = pygame.transform.scale(self.images[name], (int(self.images[name].get_width()*scale), int(self.images[name].get_height()*scale)))
+        return True
+    
+    def new_animation(self, image, name, frames, width=16, height=16, x=0, y=0, loop=True, speed=0.3, layer=3, show=True) -> bool:
+        if name in self.animations:
+            return False
+        self.animations[name] = Animation(name, image, frames, width, height, x, y, loop, speed, layer, show)
+        return True
+    
+    def new_tileset(self, path, name, width=16, height=16, scale=2.0, colorkey=None) -> bool:
+        image = pygame.image.load(path).convert_alpha()
+        if colorkey is not None:
+            image.set_colorkey(colorkey)
+        if scale != 1.0:
+            image = pygame.transform.scale(image, (int(image.get_width()*scale), int(image.get_height()*scale)))
+        data, cache = load_tileset(image, width*scale, height*scale)
+        self.tilesets[name] = data
+        self._tileset_cache_data[name] = cache
+    
+    ########################
+    #REMOVING
+    ########################
+
+    def remove_image(self, name):
+        if name in self.images:
+            del self.images[name]
+
+    def remove_animation(self, name):
+        if name in self.animations:
+            del self.animations[name]
+
+    def remove_tileset(self, name):
+        if name in self.tilesets:
+            del self.tilesets[name]
+
+    ########################
+    #GETTERS
+    ########################
+    
+    def get_image(self, name, copy=False) -> pygame.surface.Surface:
+        if copy: return self.images[name].copy()
+        else: return self.images[name]
+
+    def get_animation(self, name) -> Animation:
+        return self.animations[name]
+    
+    def get_tileset(self, name) -> pygame.surface.Surface:
+        return self.tilesets[name]
+
+Assets = _Cache()
+
+def load_tileset(image, width, height):
+    tileset = {}
+    w, h = image.get_size()
+    w = int(w/width)
+    h = int(h/height)
+    for y in range(int(image.get_height()//height)):
+        for x in range(int(image.get_width()//width)):
+            tileset[(x, y)] = image.subsurface(pygame.Rect(x*width, y*height, width, height))
+    return tileset, (w, h)
+

devpace-1.0.0/src/devPace/assets/images.py

@@ -0,0 +1,48 @@
+import pygame
+
+from .._net import Global
+#from .cache import Assets
+from ..helpers.utils import change_layer
+from ..physics.collisions import CollisionRect
+
+
+
+class Image:
+    def __init__(self, image, colorkey=None, x=0, y=0, scale=1.0, show=True, layer=3, enableCollision=False):
+        self.image = image
+        if scale != 1.0:
+            self.image = pygame.transform.scale(self.image, (int(self.image.get_width()*scale), int(self.image.get_height()*scale)))
+        self.colorkey = colorkey
+        self.x = x
+        self.y = y
+        self.show = show
+        self.layer = layer
+        self.scale = scale
+
+        self.collision: CollisionRect = None
+        if enableCollision:
+            self.collision = CollisionRect(x, y, image.get_width(), image.get_height(), [layer])
+
+        Global.add_object(layer, self)
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def rescale(self, scale):
+        self.image = pygame.transform.scale(self.image, (int(self.image.get_width()*scale), int(self.image.get_height()*scale)))
+        self.scale = scale
+
+    def enableCollision(self):
+        self.collision = CollisionRect(self.x, self.y, self.image.get_width(), self.image.get_height(), [self.layer])
+
+    def update(self):
+        if self.collision is not None:
+            self.collision.x = self.x
+            self.collision.y = self.y
+
+    def render(self, x=None, y=None):
+        if self.show:
+            x, y = x or self.x, y or self.y
+            Global.screen.blit(self.image, (x-Global.cam.x, y-Global.cam.y))
+

devpace-1.0.0/src/devPace/assets/text.py

@@ -0,0 +1,7 @@
+import pygame
+from .._net import Global
+from .cache import Assets
+
+class Text:
+    def __init__(self, text, x, y, size, color, font=None, bold=False, italic=False, underline=False):
+        pass

devpace-1.0.0/src/devPace/assets/tilemap.py

@@ -0,0 +1,88 @@
+import pygame
+import os
+from .._net import Global
+from ..helpers.utils import change_layer
+from ..basics.camera import Camera
+from ..basics.input import Keys
+from ..physics.collisions import CollisionRect
+
+from ..helpers._tilemapEditor import _TileMapEditor
+from ..helpers._tilemap_files import __saveTileMap_json__, __loadTileMap_json__, gen_collision_shapes
+
+#tilemap collision types
+COL_FULL = 1
+COL_HALF_TOP = 2
+COL_HALF_BOTTOM = 3
+COL_HALF_LEFT = 4
+COL_HALF_RIGHT = 5
+
+#collision gen vars
+TILEMAP_COLLISION_GEN = 25
+SEARCH_TIME = TILEMAP_COLLISION_GEN
+
+class Tilemap:
+    def __init__(self, name, tileset, show=True, layer=3, dataFile=None, collisionLayers=None):
+        self.name = name
+        self.tileset: dict[tuple[int, int], pygame.surface.Surface] = tileset
+        self.width = tileset[0, 0].get_width()
+        self.height = tileset[0, 0].get_height()
+        self.show = show
+        self.layer = layer
+
+        if collisionLayers is not None: self.collisionLayers = collisionLayers
+        else: self.collisionLayers = [layer]
+
+        self.dataFile = dataFile
+
+        self.tiles: dict[tuple[int, int ], tuple[int, int]] = {}
+        self.collisions = []
+        self.collDef: dict[tuple[int, int], int] = {}
+
+        Global.add_object(layer, self)
+
+        #fallback for hardcoded tilemaps (no loading from file)
+        self.__gen_self_collision_shapes()
+
+        Global._add_tilemap(layer, self)
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    
+    def __gen_self_collision_shapes(self):
+        gen_collision_shapes(self, COL_FULL, COL_HALF_TOP, COL_HALF_BOTTOM, COL_HALF_LEFT, COL_HALF_RIGHT, SEARCH_TIME)
+
+    def manual_save_json(self, path=None):
+        if path and self.dataFile == None: return
+        if path is None: path = self.dataFile
+        __saveTileMap_json__(path, self.tiles, self.collDef)
+    def manual_load_json(self, path):
+        if path and self.dataFile == None: return
+        if path is None: path = self.dataFile
+        self.tiles, self.collDef = __loadTileMap_json__(path)
+        self.__gen_self_collision_shapes()
+
+    def activateEditor(self, exit_key=Keys.escape, _pin=(0, 0)):
+        x, y = pygame.display.get_window_position()
+        _TileMapEditor(x, y, Global.display.get_width(), Global.display.get_height(), self, exit_key, _pin).run()
+        self.manual_save_json()
+        self.__gen_self_collision_shapes()
+
+    def render(self):
+        if not self.show: return
+        for pos, tile in self.tiles.items():
+            tx = pos[0] * self.width - Global.cam.x
+            ty = pos[1] * self.height - Global.cam.y
+            if tx > -self.width and tx < Global.screen.get_width()+self.width and ty > -self.height and ty < Global.screen.get_height()+self.height:
+                image = self.tileset[tile]
+                Global.screen.blit(image, (tx, ty))
+
+def tile_beside(pos, _pos):
+    if _pos[0] == pos[0]+1: return True
+    elif _pos[0] == pos[0]-1: return True
+    return False
+def tile_above(pos, _pos):
+    if _pos[1] == pos[1]+1: return True
+    elif _pos[1] == pos[1]-1: return True
+    return False

devpace-1.0.0/src/devPace/basics/camera.py

@@ -0,0 +1,32 @@
+import pygame
+from .._net import Global
+
+class Camera:
+    def __init__(self, x=0, y=0, vx=0.0, vy=0.0, zoom=1.0):
+        self.x = x
+        self.y = y
+        self.vx = vx
+        self.vy = vy
+        self.zoom = zoom
+
+        self.follow_target = None
+        self.offset = None
+        self.speed = 0.0
+
+
+        if Global.cam is None:
+            Global.cam = self
+
+    def update(self):
+        self.x+=self.vx*Global.dt
+        self.y+=self.vy*Global.dt
+
+        if self.follow_target is not None:
+            self.x = (self.x+(self.follow_target.x+self.offset[0]-self.x)*self.speed)
+            self.y = (self.y+(self.follow_target.y+self.offset[1]-self.y)*self.speed)
+
+    def set_follow_target(self, target, speed=0.2):
+        self.follow_target = target
+        self.speed = speed
+        self.offset = (self.x - target.x, self.y - target.y)
+