devpace 1.0.0__py3-none-any.whl

devPace/main.py

@@ -0,0 +1,184 @@
+import pygame
+import sys
+import os
+import multiprocessing
+from ._net import Global, _global_
+from .basics.input import Keys
+from .physics.collisions import CollisionRect
+from .assets.cache import Assets
+
+from .GlobalDebugger import GlobalDebugger
+
+
+MIN_LAYER = -5
+MAX_LAYER = 10
+ALL_COLLISION_LAYERS = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+class Engine:
+    def __init__(self, bg="black", title="Pygame Win", width=800, height=600, EXPERIMENTAL_RESIZABLE=False, TARGET_FPS=60, EXPERIMENTAL_DEBUG=False):
+        if EXPERIMENTAL_RESIZABLE: self._display = pygame.display.set_mode((width, height), flags=pygame.RESIZABLE)
+        else: self._display = pygame.display.set_mode((width, height))
+        pygame.display.set_caption(title)
+
+        if EXPERIMENTAL_DEBUG:
+            print("Starting GlobalDebugger...")
+            self.log_queue = multiprocessing.Queue()
+            self.debug_prossess = multiprocessing.Process(target=GlobalDebugger, args=(self.log_queue,)).start()
+
+
+        self.screen_dim = (width, height)
+        self.width = width
+        self.height = height
+        self.RESIZABLE = EXPERIMENTAL_RESIZABLE
+
+        self.screen = pygame.surface.Surface((width, height))
+        self.bg = bg
+        self.title = title
+
+        self.clock = pygame.time.Clock()
+        self.FPS = TARGET_FPS
+
+        #update global
+        Global.display = self._display
+        Global.screen = self.screen
+        Global.bg = self.bg
+        Global.title = self.title
+        Global.clock = self.clock
+        Global.assets = Assets
+        Global.all_collision_layers = ALL_COLLISION_LAYERS
+
+    def Tick(self):
+        self.update()
+        self.render()
+
+    def update(self):
+        #dt
+        Global.dt = self.clock.tick(self.FPS) / 1000.0
+        #events
+        Global.events = pygame.event.get()
+        for event in Global.events:
+            if event.type == pygame.QUIT:
+                self.exit()
+            if event.type == pygame.VIDEORESIZE and self.RESIZABLE:
+                self._auto_resize(event)
+        #updates
+
+        #keys
+        Keys.update()
+
+        #cam
+        Global.cam.update()
+        #objects
+        layer=MIN_LAYER
+        while layer<=MAX_LAYER:
+            if layer in Global.objects:
+                i = Global.objects[layer]
+                for obj in i:
+                    try:
+                        obj.update()
+                    except AttributeError:
+                        pass
+            layer+=1
+        
+
+    def render(self):
+        self.screen.fill(self.bg)
+        #render to screen
+        layer=MIN_LAYER
+        while layer<=MAX_LAYER:
+            if layer in Global.objects:
+                i = Global.objects[layer]
+                for obj in i:
+                    try:
+                        obj.render()
+                    except AttributeError:
+                        pass
+            layer+=1
+        
+
+        #update screen(display)
+        self._display.fill(self.bg)
+        self._display.blit(pygame.transform.scale(self.screen, self.screen_dim), (0, 0))
+        pygame.display.flip()
+
+    def exit(self):
+        os.system("cls")
+        pygame.quit()
+        sys.exit()
+
+    def _auto_resize(self, event):
+        w, h = event.size
+        self._display = pygame.display.set_mode((w, h), flags=pygame.RESIZABLE)
+        self.screen_dim = (w, h)
+        Global.FW = w / self.screen_dim[0]
+        Global.FH = h / self.screen_dim[1]
+    def all_colision_layers(self):
+        return ALL_COLLISION_LAYERS
+
+    def manual_resize(self, width, height):
+        self._display = pygame.display.set_mode((width, height), flags=pygame.RESIZABLE)
+        self.screen_dim = (width, height)
+        Global.FW = width / self.screen_dim[0]
+        Global.FH = height / self.screen_dim[1]
+
+    def create_aroundScreen_bounds(self):
+        CollisionRect(0, -5, self.screen_dim[0], 5, ALL_COLLISION_LAYERS)
+        CollisionRect(-5, 0, 5, self.screen_dim[1], ALL_COLLISION_LAYERS)
+        CollisionRect(self.screen_dim[0], 0, 5, self.screen_dim[1], ALL_COLLISION_LAYERS)
+        CollisionRect(0, self.screen_dim[1], self.screen_dim[0], 5, ALL_COLLISION_LAYERS)
+
+    def _func_get_global_(self) -> _global_:
+        print("<Engine> Global accsesed")
+        return Global
+    
+    def get_current_fps(self):
+        return self.clock.get_fps()
+    
+    def change_title(self, title):
+        Global.title = title
+        pygame.display.set_caption(title)
+        self.title = title
+
+    #scene logic
+    def new_scene(self, name, scene):
+        Global.scenes[name] = scene
+    def change_scene(self, name, resetCam=True, resetObjects=True):
+        if resetCam: Global.cam = None
+        if resetObjects: 
+            Global.tilemaps = {}
+            Global.objects = {}
+        if name in Global.scenes:
+            if Global.current_scene is not None:
+                Global.last_scene = Global.current_scene
+                Global.current_scene.on_end()
+            Global.current_scene = Global.scenes[name]
+            Global.current_scene.on_end()
+            Global.current_scene.on_start()
+            Global.current_scene.run()
+
+    def reload_scene(self, resetCam=True, resetObjects=True, end=True, start=True):
+        if Global.current_scene is not None:
+            if resetCam: 
+                Global.tilemaps = {}
+                Global.cam = None
+            if resetObjects: Global.objects = {}
+            if end: Global.current_scene.on_end()
+            if start: Global.current_scene.on_start()
+            Global.current_scene.run()
+
+    def back_scene(self):
+        if Global.last_scene is not None:
+            self.change_scene(Global.last_scene)
+
+    def remove_scene(self, name):
+        if name in Global.scenes:
+            del Global.scenes[name]
+class Scene:
+    def __init__(self):
+        pass
+    def run(self):
+        pass
+    def on_start(self):
+        pass
+    def on_end(self):
+        pass

devPace/physics/KinematicPlatform.py

@@ -0,0 +1,87 @@
+import pygame
+
+from .._net import Global
+
+
+import pygame
+from .._net import Global
+from ..helpers.utils import change_layer
+from .collisions import CollisionRect
+class KinematicPlatform:
+    def __init__(self, x, y, width, height, speed, show=True, layer=3, waypoints=[], loop=True, snapDist = 5):
+        self.x = x
+        self.y = y
+        self.vx = 0.0
+        self.vy = 0.0
+        self.width = width
+        self.height = height
+        self.show = show
+        self.layer = layer
+
+        self.waypoints = waypoints
+        self.currentWaypoint = 0
+        self.speed = speed
+        self.loop = loop
+        self.snapDist = snapDist
+
+        self.collision = CollisionRect(x, y, width, height)
+        self.collision.layers = [layer]
+
+        Global.add_object(layer, self)
+
+        self.shape = None
+        self.image = None
+        self.animation = None
+        self.animationManager = None
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def update(self):
+        self.vx = 0.0
+        self.vy = 0.0
+        #move toward current waypoint
+        if self.currentWaypoint < len(self.waypoints):
+            if self.x > self.waypoints[self.currentWaypoint][0]:
+                self.vx = -self.speed
+            elif self.x < self.waypoints[self.currentWaypoint][0]:
+                self.vx = self.speed
+            if self.y > self.waypoints[self.currentWaypoint][1]:
+                self.vy = -self.speed
+            elif self.y < self.waypoints[self.currentWaypoint][1]:
+                self.vy = self.speed
+
+            #if at waypoint,or snapdist, move to next waypoint
+            if abs(self.x - self.waypoints[self.currentWaypoint][0]) < self.snapDist and abs(self.y - self.waypoints[self.currentWaypoint][1]) < self.snapDist:
+                self.currentWaypoint+=1
+                if self.currentWaypoint >= len(self.waypoints):
+                    if self.loop:
+                        self.currentWaypoint = 0
+
+            
+
+        #x movement
+        self.x+=self.vx*Global.dt
+        self.collision.x = self.x
+        self.y+=self.vy*Global.dt
+        self.collision.y = self.y
+
+        #update any other positions now
+        if self.shape is not None:
+            self.shape.x = self.x
+            self.shape.y = self.y
+
+        if self.image is not None:
+            self.image.x = self.x
+            self.image.y = self.y
+
+        if self.animation is not None:
+            self.animation.x = self.x
+            self.animation.y = self.y
+
+        if self.animationManager is not None:
+            self.animationManager.x = self.x
+            self.animationManager.y = self.y
+
+

devPace/physics/StateManager.py

@@ -0,0 +1,87 @@
+import pygame
+
+from .._net import Global
+from ..assets.animations import AnimationManager
+
+class _constraints_:
+    def __init__(self):
+        #define dir <>^_#o
+        self.dir_up = 'V^'
+        self.dir_down = 'Vv'
+        self.dir_left = 'V<'
+        self.dir_right = 'V>'
+        self.dir_any = 'V#'
+        self.dir_none = 'Vo'
+
+Constraints = _constraints_()
+
+class AutoStateManager:
+    def __init__(self, manager: AnimationManager = None, obj=None):
+        Global.add_object(1, self)
+        self.manager = manager
+        self.state = None
+        self.states: dict[list[str], str] = {}
+        self.weights: dict[str, int] = {}
+        self.obj = obj
+
+    def set_obj(self, obj):
+        self.obj = obj
+
+    def add_state(self, constraints: list[str], state: str, weight=0):
+        self.states[tuple(constraints)] = state
+        self.weights[state] = weight
+    def remove_state(self, state: str):
+        self.states.remove(state)
+    def set_state(self, name):
+        self.current_state = name
+        if self.manager is not None and name in self.manager.animations:
+            self.manager.play_animation(name)
+
+    def update(self):
+        if self.obj is None: return
+        if self.manager is None: return
+        #eval all states and pick wining num
+        states: dict[str, int] ={}
+        for constraints, state in self.states.items():
+            #velocity tests
+            states = self._eval_velocity(constraints, state, states)
+            states[state] += self.weights[state]
+        #pick the highest state
+        self.state = max(states, key=states.get)
+        if self.manager is not None and self.state in self.manager.animations:
+            self.manager.play_animation(self.state)
+
+
+    def _eval_velocity(self, conditions, state, _end):
+        if len(conditions) == 0: _end[state] += 0
+        #up, down, left, right, all, none
+        if not hasattr(self.obj, 'vx') and hasattr(self.obj, 'vy'): return _end
+        #else do checks
+        if 'V^' in conditions and self.obj.vy < 0: _end[state] += 1
+        if 'Vv' in conditions and self.obj.vy > 0: _end[state] += 1
+        if 'V<' in conditions and self.obj.vx < 0: _end[state] += 1
+        if 'V>' in conditions and self.obj.vx > 0: _end[state] += 1
+        if 'V#' in conditions and self.obj.vx != 0 and self.obj.vy != 0: _end[state] += 1
+        if 'Vo' in conditions and self.obj.vx == 0 and self.obj.vy == 0: _end[state] += 1
+        return _end
+        
+
+class StateManager:
+    def __init__(self, manager: AnimationManager = None, states=[]):
+        #Global.add_object(1, self)
+        self.manager = manager
+        self.state = None
+        self.states: list[str] = states
+
+    def add_state(self, constraints: list[str], state: str):
+        if state not in self.states:
+            self.states.append(state)
+        
+    def remove_state(self, state):
+        if state in self.states:
+            self.states.remove(state)
+
+    def set_state(self, name):
+        self.current_state = name
+        if self.manager is not None and name in self.manager.animations:
+            self.manager.play_animation(name)

devPace/physics/collisions.py

@@ -0,0 +1,40 @@
+import pygame
+import random
+from .._net import Global
+
+
+class CollisionRect:
+    def __init__(self, x, y, width, height, layers=[]):
+        self.x, self.y, self.width, self.height = x, y, width, height
+        self.layers = layers
+        Global.collisions.append(self)
+        self.active = True
+        
+        self.color = (random.randint(0, 255), 0, random.randint(0, 255))
+
+    def rect(self):
+        return pygame.Rect(self.x, self.y, self.width, self.height)
+    
+    def Del(self):
+        if self not in Global.collisions: return
+        Global.collisions.remove(self)
+    
+    def isColliding(self):
+        if not self.active: return False
+        for obj in Global.collisions:
+            if obj == self: continue
+            for layer in self.layers:
+                if layer in obj.layers:
+                    if obj.rect().colliderect(self.rect()):
+                        return True
+
+        return False
+
+    def copy(self):
+        return CollisionRect(self.x, self.y, self.width, self.height, self.layers)
+    
+    def render(self):
+        rect = self.rect()
+        rect.x = self.x-Global.cam.x
+        rect.y = self.y-Global.cam.y
+        pygame.draw.rect(Global.screen, self.color, rect)

devPace/physics/dynamicBody.py

@@ -0,0 +1,135 @@
+import pygame
+from .._net import Global
+from ..helpers.utils import change_layer
+from .collisions import CollisionRect
+class DynamicBody:
+    def __init__(self, x, y, width, height, vx=0.0, vy=0.0, show=True, layer=3, gravity=0.0, smartCollisions=True, smartCollisionDist=1):
+        self.x = x
+        self.y = y
+        self.vx = vx
+        self.vy = vy
+        self.width = width
+        self.height = height
+        self.show = show
+        self.layer = layer
+        self.gravity = gravity
+
+        self.collision = CollisionRect(x, y, width, height)
+        self.collision.layers = [layer]
+
+        Global.add_object(layer, self)
+
+        self.shape = None
+        self.image = None
+        self.animation = None
+        self.animationManager = None
+
+        #collision checks
+        self.smartCollisions = smartCollisions
+        self.smartCollisionDist = smartCollisionDist
+
+        self.is_on_floor = False
+        self.is_on_ceiling = False
+        self.is_on_left = False
+        self.is_on_right = False
+        self.is_on_wall = False
+
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+
+    def update(self):  
+
+        #collision checks
+        self.is_on_floor = False
+        self.is_on_ceiling = False
+        self.is_on_left = False
+        self.is_on_right = False
+        self.is_on_wall = False
+
+        #x movement
+        self.x+=self.vx*Global.dt
+        #if collisions, back up
+        self.collision.x = self.x
+        if self.collision.isColliding():
+            self.x-=self.vx*Global.dt
+            #colisions info
+            self.is_on_wall = True
+            if self.vx > 0.0:
+                self.is_on_right = True
+            elif self.vx < 0.0:
+                self.is_on_left = True
+            self.vx = 0
+
+        if self.smartCollisions:
+            if not self.is_on_left:
+                self.collision.x = self.x - self.smartCollisionDist
+                if self.collision.isColliding():
+                    self.is_on_left = True
+                    self.vx = 0.0
+                self.collision.x = self.x
+
+            if not self.is_on_right:
+                self.collision.x = self.x + self.smartCollisionDist
+                if self.collision.isColliding():
+                    self.is_on_right = True
+                    self.vx = 0.0
+                self.collision.x = self.x
+
+        #y movement
+        self.y += self.vy*Global.dt
+        #if collisions, back up
+        self.collision.y = self.y
+        if self.collision.isColliding():
+            self.y-=self.vy*Global.dt
+
+            #collision info
+            if self.vy > 0.0:
+                self.is_on_floor = True
+            if self.vy < 0.0:
+                self.is_on_ceiling = True
+
+            self.vy = 0
+
+        if self.smartCollisions:
+            if not self.is_on_floor:
+                self.collision.y = self.y + self.smartCollisionDist
+                if self.collision.isColliding():
+                    self.is_on_floor = True
+                    self.vy = 0.0
+                self.collision.y = self.y
+
+            if not self.is_on_ceiling:
+                self.collision.y = self.y - self.smartCollisionDist
+                if self.collision.isColliding():
+                    self.is_on_ceiling = True
+                    self.vy = 0.0
+                self.collision.y = self.y
+
+        #gravity
+        if not self.is_on_floor:
+            self.vy += self.gravity*Global.dt
+
+
+        self.collision.x = self.x
+        self.collision.y = self.y
+
+        #update any other positions now
+        if self.shape is not None:
+            self.shape.x = self.x
+            self.shape.y = self.y
+
+        if self.image is not None:
+            self.image.x = self.x
+            self.image.y = self.y
+
+        if self.animation is not None:
+            self.animation.x = self.x
+            self.animation.y = self.y
+
+        if self.animationManager is not None:
+            self.animationManager.x = self.x
+            self.animationManager.y = self.y
+

devPace/tracker.txt

@@ -0,0 +1,13 @@
+This file is for tracking progress on certain parts of the project
+
+TILEMAP:
+    v1
+    basic tiles laoding and saving with simple rendering
+
+TILEMAP EDITOR:
+    v1
+    opens window for placing and removing tiles, with arrow key tile switching
+
+TILEMAP COLLISION GEN:
+    v1
+    Generates seperate collisionRects for each tile.

devpace-1.0.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+devPace/GlobalDebugger.py,sha256=hU1XRDzDyJkpQJ_irfIodb8Rl2ZrGX8nggZJo69_4hQ,1885
+devPace/__init__.py,sha256=QDMjEYV2vTbQqNVSD2jVoH1QLELX1lUMH2ySNseiwao,918
+devPace/_net.py,sha256=XnYRxk6FQVPlHnWVWy6EMzB0Vm8H852dCsFol0CH0UM,1417
+devPace/main.py,sha256=5ztNSXlIbYVKmssCdOXmZo0W8eTvwnnR9fXJ_87Ke5U,6107
+devPace/tracker.txt,sha256=Rniz3J4YQqW_qXGxXixbgegvW9sN1GQEPdDebFbqZu0,341
+devPace/assets/animations.py,sha256=BqngXzJ2r0Ibx9GwyVY_7vFOExmR1J8LB3ONIx0XsRY,3840
+devPace/assets/cache.py,sha256=6gATAWKBiQN5okCmqkXVdLiAGqttHZa_V-HvZXDuMPo,3355
+devPace/assets/images.py,sha256=sCCl0v6O5wkr-8KVyh788RrPN54kC0R1EmuDsqZj49U,1655
+devPace/assets/text.py,sha256=NH8oLzgRNn5iF_MBQ-KpFiO_9z6iNDrr8Adcm4VmrVg,202
+devPace/assets/tilemap.py,sha256=eYONRe7UWAPDL99_FtWVXd-_ATfVJHJiw88kYVWHfrU,3247
+devPace/basics/camera.py,sha256=Gn8dPm4JkcCBcquFDOCEzG_J0QqMAS7Bd10pg5bHZLM,887
+devPace/basics/input.py,sha256=9CjiSkVL7qLEkYq9Q5fuNK2sMPhYtEH2NZKG3Z9vWOk,4121
+devPace/basics/shapes.py,sha256=C0aaw7I8MhNtWDv5RqHFu1mDZpR9Dy_kY_-T8FR8-UM,2512
+devPace/helpers/_tilemapEditor.py,sha256=zXCggIKnQjGyLndk37-2PCWrQOgh2BJhYBO2OiDQhdY,15041
+devPace/helpers/_tilemap_files.py,sha256=tvWhIXUX5lytX7aDoJo-qQVYxL-JX9ZcN9ILooJX1Sg,6458
+devPace/helpers/utils.py,sha256=ugli4wZxy2QW9R4c2amR2t2pym1h3YyA1AGJgAernu8,265
+devPace/physics/KinematicPlatform.py,sha256=Ioo5pYekJvWH_BSRTz2uqj73zCuDeAk2sDP5pQFwFvA,2770
+devPace/physics/StateManager.py,sha256=NmVApPmGKCVrB63M4apYni_gWYQ6Rf4fqg2no-VS_uc,3201
+devPace/physics/collisions.py,sha256=ysAnUQ_Ks2eBsxHwWFNjZ3_7cqEKv09DXKbiAW-ukc4,1255
+devPace/physics/dynamicBody.py,sha256=_HZCbAWW0M-2paU0xeDQofgQbXWl4NJE7FdnwGOkz6g,4187
+devpace-1.0.0.dist-info/METADATA,sha256=PlOnBIc_tZweODB0G_I1gYbM0eBfv4nge7BeZBpgN9s,544
+devpace-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+devpace-1.0.0.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+devpace-1.0.0.dist-info/RECORD,,

devpace-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

devpace-1.0.0.dist-info/licenses/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.