devpace 1.0.0__py3-none-any.whl

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/__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/_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/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/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/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/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/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/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)
+

devPace/basics/input.py

@@ -0,0 +1,135 @@
+import pygame
+
+from .._net import Global
+
+
+class _keys:
+    def __init__(self):
+
+        #alphabet
+        self.a = pygame.K_a
+        self.b = pygame.K_b
+        self.c = pygame.K_c
+        self.d = pygame.K_d
+        self.e = pygame.K_e
+        self.f = pygame.K_f
+        self.g = pygame.K_g
+        self.h = pygame.K_h
+        self.i = pygame.K_i
+        self.j = pygame.K_j
+        self.k = pygame.K_k
+        self.l = pygame.K_l
+        self.m = pygame.K_m
+        self.n = pygame.K_n
+        self.o = pygame.K_o
+        self.p = pygame.K_p
+        self.q = pygame.K_q
+        self.r = pygame.K_r
+        self.s = pygame.K_s
+        self.t = pygame.K_t
+        self.u = pygame.K_u
+        self.v = pygame.K_v
+        self.w = pygame.K_w
+        self.x = pygame.K_x
+        self.y = pygame.K_y
+        self.z = pygame.K_z
+
+        #numbers
+        self.n0 = pygame.K_0
+        self.n1 = pygame.K_1
+        self.n2 = pygame.K_2
+        self.n3 = pygame.K_3
+        self.n4 = pygame.K_4
+        self.n5 = pygame.K_5
+        self.n6 = pygame.K_6
+        self.n7 = pygame.K_7
+        self.n8 = pygame.K_8
+        self.n9 = pygame.K_9
+
+        #special keys
+        self.enter = pygame.K_RETURN
+        self.escape = pygame.K_ESCAPE
+        self.space = pygame.K_SPACE
+        self.backspace = pygame.K_BACKSPACE
+        self.tab = pygame.K_TAB
+        self.shift = pygame.K_LSHIFT
+
+        #arrow keys
+        self.up = pygame.K_UP
+        self.down = pygame.K_DOWN
+        self.left = pygame.K_LEFT
+        self.right = pygame.K_RIGHT
+
+
+        #mouse
+        self.mouse_x, self.mouse_y = 0, 0
+
+    def is_pressed(self, keys): 
+        if type(keys) != list: keys = [keys]
+        if Global.events is None: return False
+        for event in Global.events:
+            if event.type == pygame.KEYDOWN:
+                if event.key in keys: return True
+        return False
+
+    def is_held(self, key):
+        keys = pygame.key.get_pressed()
+        return keys[key]
+
+    def update(self): self.mouse_x, self.mouse_y = pygame.mouse.get_pos()
+
+Keys = _keys()
+
+class FastMovement:
+    def __init__(self, obj, speed, reset_x=True, reset_y=True, WSAD=True, ARROWS=True, move_x=True, move_y=True, jump=False, jumpForce=0.0, jumpKeys=[Keys.space]):
+        self.obj = obj
+        self.speed = speed
+        self.reset_x = reset_x
+        self.reset_y = reset_y
+
+        self.jump = jump
+        self.jumpForce = jumpForce
+        self.jumpKeys = jumpKeys
+
+        self.WSAD = WSAD
+        self.ARROWS = ARROWS
+
+        self.move_x = move_x
+        self.move_y = move_y
+
+        if hasattr(self.obj, 'vx') and hasattr(self.obj, 'vy'): self.safe = True
+        else: self.safe = False
+        if hasattr(self.obj, 'is_on_floor'): self.safeJump = True
+        else: self.safeJump = False
+
+        Global.add_object(0, self)
+
+    def update(self):
+        if not self.safe: return
+
+        if self.reset_x: self.obj.vx = 0.0
+        if self.reset_y: self.obj.vy = 0.0
+
+        if self.WSAD:
+            if self.move_x:
+                if Keys.is_held(Keys.a): self.obj.vx = -self.speed
+                if Keys.is_held(Keys.d): self.obj.vx = self.speed
+            if self.move_y:
+                if Keys.is_held(Keys.w): self.obj.vy = -self.speed
+                if Keys.is_held(Keys.s): self.obj.vy = self.speed
+
+            if self.safeJump and self.jump:
+                if Keys.is_pressed(self.jumpKeys) and self.obj.is_on_floor: 
+                    self.obj.vy = -self.jumpForce
+
+        if self.ARROWS:
+            if self.move_x:
+                if Keys.is_held(Keys.left): self.obj.vx = -self.speed
+                if Keys.is_held(Keys.right): self.obj.vx = self.speed
+            if self.move_y:
+                if Keys.is_held(Keys.up): self.obj.vy = -self.speed
+                if Keys.is_held(Keys.down): self.obj.vy = self.speed
+
+            if self.safeJump and self.jump:
+                if Keys.is_pressed(self.jumpKeys) and self.obj.is_on_floor: self.obj.vy = -self.jumpForce
+