devpace 1.0.0__py3-none-any.whl

devPace/basics/shapes.py

@@ -0,0 +1,74 @@
+import pygame
+from .._net import Global
+from ..physics.collisions import CollisionRect
+from ..helpers.utils import change_layer
+
+class _Shape:
+    def __init__(self, x, y, vx, vy, show):
+        self.x = x
+        self.y = y
+        self.vx = vx
+        self.vy = vy
+        self.show = show
+
+        self.collision: CollisionRect = None
+
+    def update(self):
+        self.x+=self.vx*Global.dt
+        self.y+=self.vy*Global.dt
+        if self.collision is not None:
+            self.collision.x = self.x
+            self.collision.y = self.y
+
+class Rect(_Shape):
+    def __init__(self, x, y, width, height, color, _width=0, vx=0.0, vy=0.0, show=True, layer=3, enableCollision=False):
+        super().__init__(x, y, vx, vy, show)
+        self.layer = layer
+        self.width=width
+        self.height = height
+        self.color = color
+        self._width=_width
+        Global.add_object(layer, self)
+        if enableCollision:
+            self.collision: CollisionRect = CollisionRect(x, y, width, height, [layer])
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def rect(self):
+        return pygame.Rect(self.x, self.y, self.width, self.height)
+    
+    def enableCollision(self):
+        self.collision = CollisionRect(self.x, self.y, self.width, self.height, [self.layer])
+
+    def render(self):
+        if self.show:
+            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, self._width)
+
+class Circle(_Shape):
+    def __init__(self, x, y, radius, color, _width=0, vx=0.0, vy=0.0, show=True, layer=3, enableCollision=False):
+        super().__init__(x, y, vx, vy, show)
+        self.layer = layer
+        self.r = radius
+        self.color = color
+        self._width=_width
+        Global.add_object(layer, self)
+
+        if enableCollision:
+            self.collision = CollisionRect(x, y, radius*2, radius*2, [layer])
+
+    def change_layer(self, new_layer):
+        change_layer(self, new_layer, self.layer)
+        self.layer = new_layer
+
+    def enableCollision(self):
+        self.collision = CollisionRect(self.x, self.y, self.r*2, self.r*2, [self.layer])
+
+    def render(self):
+        if self.show:
+            pygame.draw.circle(Global.screen, self.color, (self.x-Global.cam.x, self.y-Global.cam.y), self.r, self._width)
+

devPace/helpers/_tilemapEditor.py

@@ -0,0 +1,340 @@
+import pygame
+
+from ..basics.camera import Camera
+from ..basics.input import Keys
+from .._net import Global
+
+def gen_collision_rects(width, height):
+    return {
+        1: pygame.Rect(0, 0, width, height),
+        2: pygame.Rect(0, 0, width, height//2),
+        3: pygame.Rect(0, height//2, width, height//2),
+        4: pygame.Rect(0, 0, width//2, height),
+        5: pygame.Rect(width//2, 0, width//2, height)
+    }
+
+class _TileMapEditor:
+    def __init__(self, x, y, width, height, map, exit_key, pin=(0, 0)):
+        self.width, self.height = width, height
+        self.map = map
+        self.running = True
+        self.exit_key = exit_key
+        self._pin = pin
+
+        self.mode = "painting"
+        self.cooldown = False
+
+        self.cam = Camera(-width/2, -height/2)
+        self.cam_speed = 275
+
+        self.win = pygame.Window("Tilemap Editor", (width, height), (x, y))
+        self.screen = self.win.get_surface()
+
+        self.clock = pygame.time.Clock()
+        self.FPS = 60
+        self.dt = 0.0
+
+        self.selected_tile = (0, 0)
+        #get the dim of the original tileset
+        self.setDim = Global.assets._tileset_cache_data[self.map.name]
+        self.setDim = (self.setDim[0]-1, self.setDim[1]-1)
+        self.colTypes = gen_collision_rects(self.map.width, self.map.height)
+        self.current_col_type = 1
+        self.mapColType = 5        
+
+        #keys
+        self.key_picking = Keys.tab
+        self.key_picking_exit = False
+        self.save_cam_pos = (0, 0)
+        self.can_click = True
+        self.key_collision = Keys.c
+        self.key_collision_exit = False
+
+    def run(self):
+        pygame.mouse.set_visible(False)
+        while self.running:
+            self.update()
+            if not self.running: break
+            self.render()
+        pygame.mouse.set_visible(True)
+
+    def update(self):
+        #if need to exit
+        if Keys.is_pressed(self.exit_key) and self.cooldown:
+            self.running = False
+            return
+        else: self.cooldown = True
+
+        self.change_title(self.mode)
+        #win updates
+        self.dt = self.clock.tick(self.FPS) / 1000
+        Global.events = pygame.event.get()
+        for event in Global.events:
+            if event.type == pygame.QUIT:
+                self.win.close()
+                self.running = False
+            if event.type == pygame.WINDOWCLOSE:
+                try:
+                    event.window.destroy()
+                    self.running = False
+                except:
+                    pass
+        #other updates
+        if self.mode == "painting":
+            self.cam_movement()
+            self.tile_placing()
+            self.basic_tile_selecting()
+            if Keys.is_pressed(self.key_picking):
+                self.mode = "picking"
+                self.save_cam_pos = (self.cam.x, self.cam.y)
+                self.cam.x, self.cam.y = 0, 0
+            elif Keys.is_pressed(self.key_collision):
+                self.mode = "collision"
+                self.save_cam_pos = (self.cam.x, self.cam.y)
+                self.cam.x, self.cam.y = 0, 0
+        elif self.mode == "picking":
+            if Keys.is_pressed(self.key_picking) and self.key_picking_exit:
+                self.mode = "painting"
+                self.cam.x, self.cam.y = self.save_cam_pos
+                self.key_picking_exit = False
+            else: self.key_picking_exit = True
+            if Keys.is_pressed(self.key_collision):
+                self.mode = "collision"
+                self.save_cam_pos = (self.cam.x, self.cam.y)
+                self.cam.x, self.cam.y = 0, 0
+            #update logic
+            self.cam_movement()
+            self.picking_logic()
+            self.basic_tile_selecting()
+        elif self.mode == "collision":
+            if Keys.is_pressed(self.key_collision) and self.key_collision_exit:
+                self.mode = "painting"
+                self.key_collision_exit = False
+                self.cam.x, self.cam.y = self.save_cam_pos
+            else: self.key_collision_exit = True
+            self.cam_movement()
+            self.collision_logic()
+
+    def render(self):
+        self.screen.fill("black")
+        #render
+        if self.mode == "painting":
+            self.render_otherTilemaps()
+            self.render_tiles()
+        elif self.mode == "picking":
+            self.render_picking()
+        elif self.mode == "collision":
+            self.render_collision()
+
+        #update
+        self.win.flip()
+
+    def collision_logic(self):
+        #change col type based on mouse wheel
+        for event in Global.events:
+            if event.type == pygame.MOUSEWHEEL:
+                if event.y > 0: self.current_col_type += 1
+                else: self.current_col_type -= 1
+                #wrap around
+                if self.current_col_type < 1: self.current_col_type = 5
+                elif self.current_col_type > 5: self.current_col_type = 1
+                break
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                mpos = pygame.mouse.get_pos()
+                tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+                if event.button == 1:
+                    self.map.collDef[tpos] = self.current_col_type
+                elif event.button == 3:
+                    self.map.collDef.pop(tpos, None)
+    def render_collision(self):
+        #render tileset
+        for pos, image in self.map.tileset.items():
+            tx = pos[0] * self.map.width
+            ty = pos[1] * self.map.height
+            self.screen.blit(image, (tx-self.cam.x, ty-self.cam.y))
+        #render existing collisions on tiles
+        for pos, num in self.map.collDef.items():
+            rect = self.colTypes[num].copy()
+            rect.x += pos[0] * self.map.width - self.cam.x
+            rect.y += pos[1] * self.map.height - self.cam.y
+            pygame.draw.rect(self.screen, "red", rect, 2)
+        #render col rect on mouse
+        #draw square around mouse
+        mpos = pygame.mouse.get_pos()
+        tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+        rect = self.colTypes[self.current_col_type].copy()
+        rect.x += tpos[0] * self.map.width - self.cam.x
+        rect.y += tpos[1] * self.map.height - self.cam.y
+        pygame.draw.rect(self.screen, "green", rect)
+        pygame.draw.rect(self.screen, "white", (tpos[0]*self.map.width-self.cam.x, tpos[1]*self.map.height-self.cam.y, self.map.width, self.map.height), 1)
+
+    def picking_logic(self):
+        if pygame.mouse.get_pressed()[0]:
+            mpos = pygame.mouse.get_pos()
+            tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+            self.selected_tile = tpos
+            self.mode = "painting"
+            self.cam.x, self.cam.y = self.save_cam_pos
+            self.key_picking_exit = False
+            self.can_click = False
+        elif Keys.is_pressed(Keys.enter):
+            self.mode = "painting"
+            self.cam.x, self.cam.y = self.save_cam_pos
+            self.key_picking_exit = False
+            self.can_click = False
+
+    def render_picking(self):
+        #render tileset
+        for pos, image in self.map.tileset.items():
+            tx = pos[0] * self.map.width
+            ty = pos[1] * self.map.height
+            self.screen.blit(image, (tx-self.cam.x, ty-self.cam.y))
+        #render box around selected tile
+        tx = self.selected_tile[0] * self.map.width - self.cam.x
+        ty = self.selected_tile[1] * self.map.height - self.cam.y
+        pygame.draw.rect(self.screen, "yellow", (tx, ty, self.map.width, self.map.height), 2)
+        #draw square around mouse
+        mpos = pygame.mouse.get_pos()
+        tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+        pygame.draw.rect(self.screen, "white", (tpos[0]*self.map.width-self.cam.x, tpos[1]*self.map.height-self.cam.y, self.map.width, self.map.height), 1)
+
+    def render_tiles(self):
+        #draw orgin
+        point = (self._pin[0]-self.cam.x, self._pin[1]-self.cam.y)
+        if point[0] > 0 and point[0] < self.width and point[1] > 0 and point[1] < self.height:
+            pygame.draw.circle(self.screen, "white", point, 5)
+
+        #render tiles
+        for pos, tile in self.map.tiles.items():
+            tx = pos[0] * self.map.width - self.cam.x
+            ty = pos[1] * self.map.height - self.cam.y
+            if tx > -self.map.width and tx < self.width+self.map.width and ty > -self.map.height and ty < self.height+self.map.height:
+                image = self.map.tileset[tile]
+                self.screen.blit(image, (tx, ty))
+
+        #draw box around mouse and selected tile
+        mpos = pygame.mouse.get_pos()
+        tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+        self.screen.blit(self.map.tileset[self.selected_tile], (tpos[0]*self.map.width-self.cam.x, tpos[1]*self.map.height-self.cam.y))
+        pygame.draw.rect(self.screen, "white", (tpos[0]*self.map.width-self.cam.x, tpos[1]*self.map.height-self.cam.y, self.map.width, self.map.height), 1)
+
+    def tile_placing(self):
+        #placing tile logic
+        if pygame.mouse.get_pressed()[0] and self.can_click and not Keys.is_held(Keys.f):
+            mpos = pygame.mouse.get_pos()
+            tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+            self.map.tiles[tpos] = self.selected_tile
+        elif not pygame.mouse.get_pressed()[0]: self.can_click = True
+        elif pygame.mouse.get_pressed()[0] and self.can_click and Keys.is_held(Keys.f):
+            #fill area logic
+            self.fillBrushLogic()
+        #erasing logic
+        if pygame.mouse.get_pressed()[2]:
+            mpos = pygame.mouse.get_pos()
+            tpos = point_world_to_tilemap(mpos[0]+self.cam.x, mpos[1]+self.cam.y, self.map.width, self.map.height)
+            self.map.tiles.pop(tpos, None)
+
+    def fillBrushLogic(self):
+        # 1. Get the mouse position in World Pixels
+        mpos = pygame.mouse.get_pos()
+        world_x = mpos[0] + self.cam.x
+        world_y = mpos[1] + self.cam.y
+        
+        # 2. Convert to Grid/Tile coordinates (e.g., 0, 1, 2... NOT pixels like 32, 64)
+        start_tile = point_world_to_tilemap(world_x, world_y, self.map.width, self.map.height)
+        
+        # If the starting tile is already occupied, don't fill anything
+        if start_tile in self.map.tiles:
+            return
+
+        # 3. Setup our Queue and Tracker sets
+        queue = [start_tile]
+        used = set([start_tile])
+        tiles_to_place = []
+        
+        # Safety limit to prevent freezing if filling an unbounded open screen
+        MAX_FILL_TILES = 1000 
+
+        # 4. The Flood Fill Loop
+        while len(queue) > 0:
+            if len(tiles_to_place) > MAX_FILL_TILES:
+                return # Cancel completely to avoid a system freeze
+                
+            # Pop the first tile coordinate out of the front of our queue
+            current_tile = queue.pop(0)
+            tiles_to_place.append(current_tile)
+            
+            # 5. Define 4-directional neighbors in Grid Space
+            cx, cy = current_tile
+            neighbors = [
+                (cx + 1, cy), # Right
+                (cx - 1, cy), # Left
+                (cx, cy + 1), # Down
+                (cx, cy - 1)  # Up
+            ]
+            
+            for n in neighbors:
+                # Skip if we already evaluated or queued this tile position
+                if n in used:
+                    continue
+                    
+                # Skip if there is an existing tile acting as a boundary wall
+                if n in self.map.tiles:
+                    continue
+                    
+                # It's an open, unvisited tile! Mark it used and queue it up
+                used.add(n)
+                queue.append(n)
+
+        # 6. Execution Phase
+        # Commit all computed tiles straight to the engine map matrix array
+        for tile_pos in tiles_to_place:
+            # Matches your engine style: storing directly via grid tuples
+            self.map.tiles[tile_pos] = self.selected_tile
+
+
+    def basic_tile_selecting(self):
+        #changing tile logic
+        if Keys.is_pressed(Keys.up): self.selected_tile = (self.selected_tile[0], self.selected_tile[1]-1)
+        if Keys.is_pressed(Keys.down): self.selected_tile = (self.selected_tile[0], self.selected_tile[1]+1)
+        if Keys.is_pressed(Keys.left): self.selected_tile = (self.selected_tile[0]-1, self.selected_tile[1])
+        if Keys.is_pressed(Keys.right): self.selected_tile = (self.selected_tile[0]+1, self.selected_tile[1])
+        #wrap around
+        if self.selected_tile[0]<0: self.selected_tile = (self.setDim[0]-1, self.selected_tile[1])
+        if self.selected_tile[0]>self.setDim[0]: self.selected_tile = (0, self.selected_tile[1])
+        if self.selected_tile[1]<0: self.selected_tile = (self.selected_tile[0], self.setDim[1])
+        if self.selected_tile[1]>self.setDim[1]: self.selected_tile = (self.selected_tile[0], 0)
+    def cam_movement(self):
+        #cam movement
+        if Keys.is_held(Keys.a): self.cam.x -= self.cam_speed*self.dt
+        if Keys.is_held(Keys.d): self.cam.x += self.cam_speed*self.dt
+        if Keys.is_held(Keys.w): self.cam.y -= self.cam_speed*self.dt
+        if Keys.is_held(Keys.s): self.cam.y += self.cam_speed*self.dt
+        self.cam.update()
+
+    def render_otherTilemaps(self):
+        #render tilemaps from Global with respective layers
+        layer = -5
+        max_layer = 10
+        while layer <= max_layer:
+            if layer in Global.tilemaps and layer != self.map.layer:
+                for map in Global.tilemaps[layer]:
+                    for pos, tile in map.tiles.items():
+                        tx = pos[0] * map.width - self.cam.x
+                        ty = pos[1] * map.height - self.cam.y
+                        if tx > -map.width and tx < self.width+map.width and ty > -map.height and ty < self.height+map.height:
+                            image = map.tileset[tile]
+                            self.screen.blit(image, (tx, ty))
+            layer += 1
+
+    def change_title(self, mode):
+        self.win.title = f"Tilemap Editor - {mode.capitalize()} Mode"
+
+def point_world_to_tilemap(x, y, width, height):
+    return (int(x//width), int(y//height))
+
+def around(pos):
+    return [(pos[0]-1, pos[1]), (pos[0]+1, pos[1]), (pos[0], pos[1]-1), (pos[0], pos[1]+1), (pos[0]-1, pos[1]-1), (pos[0]-1, pos[1]+1), (pos[0]+1, pos[1]-1), (pos[0]+1, pos[1]+1)]
+
+
+            

devPace/helpers/_tilemap_files.py

@@ -0,0 +1,154 @@
+import pygame
+import json
+import os
+
+from .._net import Global
+from ..physics.collisions import CollisionRect
+
+
+def __saveTileMap_json__(path, data:dict[tuple[int, int ], tuple[int, int]], collisions:dict[tuple[int, int], int]):
+    new_data = {}
+    #covert data into json arrays
+    for key, value in data.items():
+        new_data[str(key)] = [value[0], value[1]]
+    new_collisions = {}
+    for key, value in collisions.items():
+        new_collisions[str(key)] = value
+    #save file
+    with open(path, "w") as f:
+        json.dump({"map": new_data, "coll": new_collisions}, f)
+
+def __loadTileMap_json__(path):
+    with open(path, "r") as f:
+        i = json.load(f)
+        data = i["map"]
+        coll = i["coll"]
+    info = {}
+    for key, value in data.items():
+        info[extract_tuple_from_str(key)] = tuple(value)
+    collisions = {}
+    for key, value in coll.items():
+        collisions[extract_tuple_from_str(key)] = value
+    return info, collisions
+
+def extract_tuple_from_str(str):
+    return tuple(float(x) for x in str[1:-1].split(","))
+
+
+def gen_collision_shapes(self, COL_FULL, COL_HALF_TOP, COL_HALF_BOTTOM, COL_HALF_LEFT, COL_HALF_RIGHT, SEARCH_TIME):
+    [t.Del() for t in self.collisions]
+    self.collisions.clear()
+    
+    # Separate tiles into shapes
+    full = []
+    half_top = []
+    half_bottom = []
+    half_left = []
+    half_right = []
+    
+    for key, value in self.tiles.items():
+        if value not in self.collDef: 
+            continue
+        # CORRECTION: Appending 'key' (grid pos) instead of 'value' (tile type)
+        if self.collDef[value] == COL_FULL: full.append(key)
+        elif self.collDef[value] == COL_HALF_TOP: half_top.append(key)
+        elif self.collDef[value] == COL_HALF_BOTTOM: half_bottom.append(key)
+        elif self.collDef[value] == COL_HALF_LEFT: half_left.append(key)
+        elif self.collDef[value] == COL_HALF_RIGHT: half_right.append(key)
+
+
+    # Gen collision shapes
+    _tiles = []
+    used = []
+    rows: list[CollisionRect] = _gen_tiles_left_right([], used, full, self, SEARCH_TIME, CollisionRect(0, 0, self.width, self.height, self.collisionLayers))
+    #join rows to form rects
+    for shape in rows:
+        if shape in used: continue
+        #else this is current shape to attempt and match
+        #used.append(shape)
+        _tiles.append(shape)
+        for i in range(SEARCH_TIME):
+            for other_shape in rows:
+                if other_shape in used: continue
+                #elif above, and width is the same, and x is the same
+                if other_shape.y == shape.y-other_shape.height and other_shape.width == shape.width and other_shape.x == shape.x:
+                    shape.y -= other_shape.height
+                    shape.height += other_shape.height
+                    other_shape.Del()
+                    used.append(other_shape)
+                #elif below, and width is the same, and x is the same
+                if other_shape.y == shape.y+shape.height and other_shape.width == shape.width and other_shape.x == shape.x:
+                    shape.height += other_shape.height
+                    other_shape.Del()
+                    used.append(other_shape)
+        
+    #half top tiles
+    _tiles = _gen_tiles_left_right(_tiles, used, half_top, self, SEARCH_TIME, CollisionRect(0, 0, self.width, self.height//2, self.collisionLayers))
+    #half bottom tiles
+    _tiles = _gen_tiles_left_right(_tiles, used, half_bottom, self, SEARCH_TIME, CollisionRect(0, self.height//2, self.width, self.height//2, self.collisionLayers))
+    #half left tiles
+    _tiles = _gen_tiles_top_bottom(_tiles, used, half_left, self, SEARCH_TIME, CollisionRect(0, 0, self.width//2, self.height, self.collisionLayers))
+    #half right tiles
+    _tiles = _gen_tiles_top_bottom(_tiles, used, half_right, self, SEARCH_TIME, CollisionRect(self.width//2, 0, self.width//2, self.height, self.collisionLayers))
+        
+    # CORRECTION: Make sure generated rectangles are actually added to your active collisions list
+    for i in _tiles:
+        self.collisions.append(i)
+    #print(len(self.collisions))
+    #print(len(Global.collisions))
+
+def _gen_tiles_left_right(_tiles: list[CollisionRect], used: list, _pos_list: list[tuple], self, SEARCH_TIME: int, shape: CollisionRect):
+    used.clear()
+    for pos in _pos_list:
+        if pos in used: continue
+        col = shape.copy()
+        #move shape to correct position
+        col.x += pos[0]*self.width
+        col.y += pos[1]*self.height
+        _tiles.append(col)
+        used.append(pos)
+        #run search through tiles
+        for i in range(SEARCH_TIME):
+            for tile in _pos_list:
+                if tile in used: continue
+                #else check left then right
+                if tile[0] == (col.x//self.width)-1 and tile[1] == pos[1]:
+                    col.x -= self.width
+                    col.width += self.width
+                    used.append(tile)
+                elif tile[0] == (col.x+col.width)//self.width and tile[1] == pos[1]:
+                    col.width += self.width
+                    used.append(tile)
+                #else leave it be
+    #clear collisions shape used as template
+    shape.Del()
+    return _tiles
+
+def _gen_tiles_top_bottom(_tiles: list[CollisionRect], used: list, _pos_list: list[tuple], self, SEARCH_TIME: int, shape: CollisionRect):
+    used.clear()
+    for pos in _pos_list:
+        if pos in used: continue
+        col = CollisionRect.copy(shape)
+        #move shape to correct position
+        col.x += pos[0]*self.width
+        col.y += pos[1]*self.height
+        _tiles.append(col)
+        used.append(pos)
+        #run search through tiles
+        for i in range(SEARCH_TIME):
+            for tile in _pos_list:
+                if tile in used: continue
+                #else check left then right
+                if tile[1] == (col.y//self.height)-1 and tile[0] == pos[0]:
+                    col.y -= self.height
+                    col.height += self.height
+                    used.append(tile)
+                elif tile[1] == (col.y+col.height)//self.height and tile[0] == pos[0]:
+                    col.height += self.height
+                    used.append(tile)
+                #else leave it be
+    #clear collisions shape used as template
+    shape.Del()
+    return _tiles
+
+

devPace/helpers/utils.py

@@ -0,0 +1,9 @@
+import pygame
+from .._net import Global
+
+def change_layer(self, new_layer, layer):
+        Global.remove_object(layer, self)
+        Global.add_object(new_layer, self)
+
+def clamp(value, min_value, max_value):
+    return max(min(value, max_value), min_value)