GameBox 0.0.5__py3-none-any.whl → 0.1.0__py3-none-any.whl

GameBox/tilemap/editor.py

@@ -1,267 +0,0 @@
-import pygame
-import math
-from ..basics.Functions import DisplayText
-from ..basics.Functions import getTilePosInGrid as getTilePos
-
-class Editor:
-    def __init__(self, tilesize, file, winDim, fileDim, imageDict, layers, size, currentLayer, C_tiles, C_Data):
-        print("""====INGAME EDITOR ENABLED, PRESS "e" TO USE====""")
-        self.Tsize = tilesize
-        self.image = file
-        self.width = winDim[0]
-        self.height = winDim[1]
-        self.fileDim = fileDim
-        self.images = imageDict
-        self.layers = layers
-        self.currentLayer = currentLayer
-
-        self.active = False
-        self.Constdis = {
-            "title" : "TileMap Editor",
-            "T_color" : "white",
-            "T_size" : 50,
-            "T_pos" : (self.width-(self.width/4)+40, self.height-(self.height/6)+40)
-        }
-
-        self.state = "standby"
-        self.selectedTile = (0, 0)
-        self.SelTileDict = [0, 0]
-        self.DictPos = (0, 0)
-        self.imageSize = size
-        self.collision = C_tiles
-        self.Cdata = C_Data
-        self.Col = {
-            "state" : "standby",
-            "selected": "none",
-            "exit": False
-        }
-
-        #self.space_pressed_last = False
-
-    def update(self, cam):
-        keys = pygame.key.get_pressed()
-        
-        if keys[pygame.K_e] and not self.e_pressed_last:
-            self.active = not self.active
-        self.e_pressed_last = keys[pygame.K_e]
-        if self.active:
-            self.key_toggles(keys)
-        else:
-            self.resetStates()
-        #erase tiles
-        if pygame.mouse.get_pressed(3)[2] and self.active:
-            mx, my = pygame.mouse.get_pos()
-            # Convert mouse to world coordinates
-            world_x = mx + cam.pos[0]
-            world_y = my + cam.pos[1]
-            # Snap to grid
-            x, y = getTilePos((world_x, world_y), self.Tsize)
-            # Remove any tile at that world grid position
-            tiles = self.layers[self.currentLayer]
-            tiles = [tile for tile in tiles if tile[1] != [x, y]]
-            self.layers[self.currentLayer] = tiles
-
-
-    def display(self, screen, cam):
-        if self.active:
-            self.basicUI(screen)
-            if self.state == "picking":
-                self.Picking(screen)
-            if self.state == "paint":
-                self.Paint(screen, cam)
-            if self.state == "collisionEditing":
-                self.collision_editing(screen)
-
-    def collision_editing(self, screen):
-        screen.fill("black")
-        screen.blit(self.image, (0, 0))
-        self.collision_Base_ui(screen)
-        self.collisionOverlay(screen)
-        if self.Col["state"] == "painting":
-            if pygame.mouse.get_pos()[1] > self.height - self.height//6 and self.Col["exit"]:
-                self.Col["exit"] = False
-                self.Col["state"] = "standby"
-            data = self.Cdata[self.Col['selected']]
-            #tile to follow mouse
-            x, y = pygame.mouse.get_pos()
-            pos = (getTilePos((x, y), self.imageSize))
-            pygame.draw.rect(screen, "yellow", pygame.Rect((pos[0]*self.imageSize+data[0][0], pos[1]*self.imageSize+data[0][1]), data[1]))
-            if pygame.mouse.get_pressed(3)[0] and self.Col["exit"]:
-                #get index
-                index = getTilePos(pygame.mouse.get_pos(), self.imageSize)
-                x, y = index
-                if x<self.fileDim[0] and y<self.fileDim[1] and x>=0 and y>=0:
-                    self.collision[str([x, y])] = self.Col["selected"]
-
-
-    def collisionOverlay(self, screen):
-        x, y = 0, self.fileDim[1]*self.imageSize+25
-        screen.blit(self.image, (0, y))
-        rect = pygame.Rect(x, y, self.fileDim[0]*self.imageSize, self.fileDim[1]*self.imageSize)
-        pygame.draw.rect(screen, "white", rect, 2)
-        for value in self.collision.values():
-            data = self.Cdata[value]
-            if value != "none":
-                pygame.draw.rect(screen, "yellow", pygame.Rect((data[0][0]+x, data[0][1]+y), data[1]))
-            x+=self.imageSize
-            if x>=self.fileDim[0]*self.imageSize:
-                y+=self.imageSize
-                x=0
-            
-
-    def collision_Base_ui(self, screen):
-        pygame.draw.rect(screen, "gray", pygame.Rect((0, self.height-self.height//6), (self.width, self.height-self.height//6)))
-        self.basicUI(screen)
-        #display tileset
-        #display collision paintable tiles
-        x = 0
-        y = (self.height - self.height//6)
-        for tile in self.Cdata:
-            data = self.Cdata[tile]
-            if tile!="none":
-                pygame.draw.rect(screen, "yellow", pygame.Rect(data[0][0]+x, data[0][1]+y, data[1][0], data[1][1]))
-            else:
-                pygame.draw.rect(screen, "green", pygame.Rect(data[0][0]+x, data[0][1]+y, data[1][0], data[1][1]), 7)
-            x+=self.Tsize
-        if pygame.mouse.get_pos()[1] < self.height - self.height//6:
-            self.collisionPointer_paint(screen)
-        else:
-            self.collisionPointer_change(screen)
-
-        if pygame.mouse.get_pos()[1] < self.height - self.height//6:
-                self.Col["exit"] = True
-
-        if pygame.mouse.get_pressed(3)[0] and pygame.mouse.get_pos()[1] >= self.height - self.height//6:
-            self.Col["exit"] = False
-            #get sellected tile position
-            x, y = pygame.mouse.get_pos()
-            nx, ny = (getTilePos((x, y), self.imageSize))
-            additive = 0
-            for i in range(nx):
-                additive+=self.imageSize/4
-            pos = nx, self.height - self.height//6
-            x, y = nx*self.imageSize, self.height//6
-            #divide to get tile index numbers
-            nx = x/self.imageSize
-            if nx%2 == 0:
-                self.Col["state"] = "painting"
-                data = list(self.Cdata.items())[int(nx//2)]
-                self.Col["selected"] = data[0]
-
-
-    def collisionPointer_change(self, screen):
-        x, y = pygame.mouse.get_pos()
-        nx, ny = (getTilePos((x, y), self.imageSize))
-        additive = 0
-        for i in range(nx):
-            additive+=self.imageSize/4
-        pos = nx, self.height - self.height//6
-        pygame.draw.rect(screen, "white", pygame.Rect((pos[0]*self.imageSize, pos[1]), (self.imageSize, self.imageSize)), 2)
-
-    def collisionPointer_paint(self, screen):
-        x, y = pygame.mouse.get_pos()
-        pos = (getTilePos((x, y), self.imageSize))
-        pygame.draw.rect(screen, "white", pygame.Rect((pos[0]*self.imageSize, pos[1]*self.imageSize), (self.imageSize, self.imageSize)), 2)
-        
-
-
-    def Paint(self, screen, cam):
-        mx, my = pygame.mouse.get_pos()
-        # 1. Convert screen pos → world pos
-        world_x = mx + cam.pos[0]
-        world_y = my + cam.pos[1]
-        # 2. Snap world pos → grid
-        x, y = getTilePos((world_x, world_y), self.Tsize)
-        # 3. Draw highlight (subtract camera for screen-space display)
-        pygame.draw.rect(
-            screen, "white",
-            pygame.Rect(x*self.Tsize - cam.pos[0], y*self.Tsize - cam.pos[1], self.Tsize, self.Tsize),
-            5
-        )
-        # 4. Place tile in world grid space
-        if pygame.mouse.get_pressed(3)[0]:
-            tiles = self.layers[self.currentLayer]
-            tiles = [tile for tile in tiles if tile[1] != [x, y]]
-            tiles.append([self.SelTileDict, [x, y]])
-            self.layers[self.currentLayer] = tiles
-
-
-    def Picking(self, screen):
-        #display tileset / tile follow mouse
-        screen.blit(self.image, (10, 10))
-        x, y = pygame.mouse.get_pos()
-        pos = getTilePos((int(x), int(y)), self.imageSize)   # (grid_x, grid_y)
-        x = ((pos[0]) * self.imageSize)+10
-        y = ((pos[1]) * self.imageSize)+10
-        pygame.draw.rect(screen, "white", pygame.Rect((x, y), (self.imageSize, self.imageSize)), 2)
-        #wait for selection
-        X = int(pos[0])
-        Y = int(pos[1])
-        if pygame.mouse.get_pressed(3)[0] and X<self.fileDim[0] and Y<self.fileDim[1]:
-            self.state = "paint"
-            #get sellected tile
-            self.selectedTile = self.images[str([X,Y])]
-            self.SelTileDict = [X, Y]
-        self.DF_DictPos(screen,pos[0], pos[1])
-
-    def DF_DictPos(self, screen, x, y):
-        DisplayText(str((x, y)), "green", 35, (self.width//2, self.height//2), screen)
-        DisplayText(str(self.imageSize), "green", 35, (self.width//2, self.height//2-50), screen)
-
-    def key_toggles(self, keys):
-        #toggle
-        if keys[pygame.K_TAB] and self.active:
-            #pick tile
-            self.state = "picking"
-        if keys[pygame.K_ESCAPE] and self.state == "picking":
-            self.state = "standby"
-        elif keys[pygame.K_ESCAPE] and self.state == "paint":
-            self.state = "picking"
-        elif keys[pygame.K_c]:
-            self.state = "collisionEditing"
-        self.switchLayers(keys)
-
-    def switchLayers(self, keys):
-        if keys[pygame.K_SPACE] and not self.space_pressed_last:
-            layer_names = list(self.layers.keys())
-            idx = layer_names.index(self.currentLayer)
-            self.currentLayer = layer_names[(idx + 1) % len(layer_names)]
-        self.space_pressed_last = keys[pygame.K_SPACE]
-
-    def resetStates(self):
-        self.state = "standby"
-
-    def basicUI(self, screen):
-        # Panel size scales with window
-        panel_w = int(self.width * 0.25)   # 25% of screen width
-        panel_h = int(self.height * 0.2)   # 20% of screen height
-        panel_x = self.width - panel_w
-        panel_y = self.height - panel_h
-        panel_rect = pygame.Rect(panel_x, panel_y, panel_w, panel_h)
-
-        # Draw background
-        pygame.draw.rect(screen, (136, 148, 150), panel_rect)
-
-        # Dynamic font sizes based on panel height
-        title_size = max(20, panel_h // 6)   # min 20 to avoid being too small
-        text_size  = max(15, panel_h // 8)
-
-        margin = 20
-
-        # Title
-        DisplayText(self.Constdis["title"], self.Constdis["T_color"], title_size,
-                    (panel_x + margin, panel_y + margin), screen)
-
-        # State & Layer
-        DisplayText(f"State: {self.state}", "white", text_size,
-                    (panel_x + margin, panel_y + margin + text_size + 5), screen)
-
-        DisplayText(f"Layer: {self.currentLayer}", "white", text_size,
-                    (panel_x + margin, panel_y + margin + 2 * (text_size + 5)), screen)
-
-        # Selected tile preview (anchored bottom-right inside panel)
-        if self.state == "paint":
-            tile_x = panel_x + panel_w - self.Tsize - margin
-            tile_y = panel_y + panel_h - self.Tsize - margin
-            screen.blit(self.selectedTile, (tile_x, tile_y))
-

GameBox/tilemap/tilemap.py

@@ -1,146 +0,0 @@
-import pygame
-import json
-from .editor import Editor
-from ..basics._core import GLOBAL
-from ..basics.Functions import IsWithinBounds
-from ..game import Game
-
-class Tilemap:
-    def __init__(self, tileSize, fileDim, image, camera, scale=1):
-        # Scale tile size
-        self.size = int(tileSize * scale)
-
-        self.fileDim = fileDim
-        self.images = {}
-        self.currentLayer = "ground"
-        self.layers = {
-            "ground": []
-        }
-        self.Crect = []
-        self.collisions = {}
-        self.camera = camera
-        self.loadedImage = image
-        self.isEditor = False
-        self.scale = scale
-        self.Tsize = tileSize
-        self.createCollisionData()
-        self.screen = GLOBAL.screen
-
-        self.optim = IsWithinBounds(GLOBAL.BaseInfo["screenDim"], self.size)
-
-        # Load images (crop each tile)
-        for y in range(fileDim[1]):
-            for x in range(fileDim[0]):
-                # Create a fresh surface for this tile
-                surface = pygame.Surface((tileSize, tileSize), pygame.SRCALPHA)
-                # Define the rectangle area on the sheet
-                rect = pygame.Rect(
-                    x * tileSize,
-                    y * tileSize,
-                    tileSize,
-                    tileSize
-                )
-                # Copy the correct tile into the new surface
-                surface.blit(image, (0, 0), rect)
-                # Store it in the images dictionary
-                self.images[str([x, y])] = pygame.transform.scale(surface, (self.size, self.size))
-
-        for tileID in self.images:
-            self.collisions[tileID] = "none"
-
-    def Add_layer(self, name):
-        self.layers[name] = []
-
-    def display(self, dt):
-        self.draw_tiles()
-        if self.isEditor:
-            self.editor.update(self.camera)
-            self.editor.display(self.screen, self.camera)
-
-
-    def draw_tiles(self):
-        if self.isEditor:
-            self.layers = self.editor.layers
-            self.collisions = self.editor.collision
-            GLOBAL.collisions = self.Crect
-            #update rects
-            self.createCollisionRects()
-        for layer in self.layers:
-            for item in self.layers[layer]:
-                tile, pos = item
-                x = pos[0]*self.size
-                x -= self.camera.pos[0]
-                y = pos[1]*self.size
-                y -= self.camera.pos[1]
-                if self.optim.checkPos((x, y)):
-                    self.screen.blit(self.images[str(tile)], (x, y))
-
-
-
-    def createCollisionRects(self):
-        self.Crect.clear()
-        for layer in self.layers:
-            for tile in self.layers[layer]:
-                tx, ty = tile[0]
-                x, y = tile[1]
-                tile_type = self.collisions[str([tx, ty])]
-                type = self.RealCollisionTiles[tile_type]
-                if tile_type != "none":
-                    x = (x*self.size)
-                    y = (y*self.size)
-                    x+=type[0][0] - self.camera.pos[0]
-                    y+=type[0][1] - self.camera.pos[1]
-                    width = type[1][0]
-                    height = type[1][1]
-                    self.Crect.append(pygame.Rect((x, y), (width, height)))
-
-
-    def createCollisionData(self):
-        size = self.Tsize
-        self.CollisionTiles = {
-            "none": ((0, 0), (size, size)),
-            "full": ((0, 0), (size, size)),
-            "half1": ((0, 0), (size, size//2)),
-            "half2": ((0, size/2), (size, size/2)),
-            "half3": ((0, 0), (size/2, size)),
-            "half4": ((size/2, 0), (size/2, size)),
-            "center": ((size/4, size/4), (size/2, size/2))
-        }
-        #real tile sizes
-        size = self.size
-        self.RealCollisionTiles = {
-            "none": ((0, 0), (size, size)),
-            "full": ((0, 0), (size, size)),
-            "half1": ((0, 0), (size, size//2)),
-            "half2": ((0, size/2), (size, size/2)),
-            "half3": ((0, 0), (size/2, size)),
-            "half4": ((size/2, 0), (size/2, size)),
-            "center": ((size/4, size/4), (size/2, size/2))
-        }
-
-            
-
-    def enable_editor(self, scren_width, screen_height):
-        self.isEditor = True
-        self.editor = Editor(self.size, self.loadedImage, (scren_width, screen_height), self.fileDim, self.images, self.layers, self.Tsize, self.currentLayer, self.collisions, self.CollisionTiles)
-
-
-    def save_map(self, filepath):
-        with open(filepath, "w") as file:
-            data = {
-                "TileData" : self.layers,
-                "CollisionData": self.collisions
-            }
-            json.dump(data, file)
-
-    def load_map(self, filepath):
-        with open(filepath, "r") as file:
-            data = dict(json.load(file))
-            self.layers = dict(data["TileData"])
-            self.collisions = dict(data["CollisionData"])
-            self.currentLayer = "ground"
-
-    def get_editor_status(self):
-        return self.editor.active
-
-        

gamebox-0.0.5.dist-info/METADATA

@@ -1,40 +0,0 @@
-Metadata-Version: 2.4
-Name: GameBox
-Version: 0.0.5
-Summary: GameBox is a beginner-friendly Python package built on top of pygame, designed to make 2D game development faster and easier. It provides ready-to-use modules, utilities, and abstractions that let new developers create polished games without needing advanced coding knowledge—while still offering the flexibility for experienced coders to customize and extend.
-Author-email: Sam Fertig <sfertig007@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-# GameBox 🎮  
-*A beginner-friendly game framework built on top of pygame.*  
-
-## Overview  
-GameBox is a Python package designed to make **2D game design simple, fast, and fun**.  
-It extends **pygame** with pre-built modules, utilities, and helpers that allow beginners to build advanced-looking games without needing to write tons of boilerplate code.  
-
-Whether you’re just starting out or you’re an experienced developer who wants to prototype quickly, GameBox has you covered.  
-
-👉 **Docs & Examples:** [GameBox Documentation](https://sites.google.com/view/pythonpackagegamebox/)  
-
----
-
-## Features ✨  
-- Built on top of **pygame** for reliability and performance  
-- Easy-to-use modules for sprites, input handling, collisions, animations, and more  
-- Reduces boilerplate: get a game loop running in just a few lines  
-- Beginner-friendly design with advanced flexibility  
-- Helps you focus on *gameplay* instead of low-level setup  
-
----
-
-## Installation  
-GameBox requires Python 3.8+ and pygame.  
-You can install it using pip:  
-
-```bash
-pip install GameBox

gamebox-0.0.5.dist-info/RECORD

@@ -1,19 +0,0 @@
-GameBox/__init__.py,sha256=8JdqatB1jiY958yMAz_5_XY6YIbeHvvFKMfkmRIK9sI,902
-GameBox/game.py,sha256=UjMcqrJGVQLCyuUF8TLLnas53TKjaCx8ZWbep-oOIsM,864
-GameBox/basics/Defaults.json,sha256=3l-bNEPWnUb-tmFrqwgSO2As35PplgkzauzT_IJGSlo,222
-GameBox/basics/Functions.py,sha256=gjoB8GVsMR4eYAk-VTni9MCw7M6T533xj-GcgE87re0,1103
-GameBox/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameBox/basics/_core.py,sha256=fB6KRFp3p_wD_td2uc9ZRzo0qHgUQNJ8veCaH1_eIRc,1157
-GameBox/basics/camera.py,sha256=HwHITLEf-V4DUs-qW1lQ6uzaIaFg7kQqcGWou2IbqUY,377
-GameBox/basics/player.py,sha256=FBo-4HfqcLtbqg_JlYcs_ohZ0RRE19k8l-PjXdDGuCQ,9483
-GameBox/basics/shapes.py,sha256=XRVy_xbh1iPefC8IVlrZLq83zhj3d64tTF8JqJ9EcHM,932
-GameBox/entities/basicNPCs.py,sha256=kyatewGfEGUZjf1l58Xooza5qxuo3cYEXsZBj5R9_Cg,645
-GameBox/entities/basicTypes.py,sha256=H6Yn2duRK9P1WWRnq812g3JWBW71dBq3fINdllWW260,2714
-GameBox/inputs/BasicInput.py,sha256=6iBwl9l9V5dZYnihxtY0MV61Rq7uUYs1Ss4ezFcKCBo,324
-GameBox/sound/BasicSound.py,sha256=vZP62UipUzz0gZMLSHJkMyzmnnWbMaySbRfZLS-E_m0,1760
-GameBox/tilemap/editor.py,sha256=GvHFxkybq_vbG3LAFyJWgbKvtV3fniqFdC2ByBFANC0,11008
-GameBox/tilemap/tilemap.py,sha256=6V_gxmecrmjruhj12HMMwxZTKHeVbhTnqsrvjbAdKSE,5154
-gamebox-0.0.5.dist-info/METADATA,sha256=BQFXRtUbFMTHpoYrgbMyRbkuuml9v_g-nV_FqB1f2VM,1759
-gamebox-0.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gamebox-0.0.5.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
-gamebox-0.0.5.dist-info/RECORD,,