GameBox 0.9.1__tar.gz → 0.10.0.dev1__tar.gz

{gamebox-0.9.1 → gamebox-0.10.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameBox
-Version: 0.9.1
+Version: 0.10.0.dev1
 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

{gamebox-0.9.1 → gamebox-0.10.0.dev1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["hatchling >= 1.26"]
 build-backend = "hatchling.build"
 [project]
 name = "GameBox"
-version = "0.9.1"
+version = "0.10.0.dev1"
 authors = [
   { name="Sam Fertig", email="sfertig007@gmail.com" },
 ]

gamebox-0.10.0.dev1/src/GameBox/Game.py

@@ -0,0 +1,68 @@
+import pygame
+
+from .basics.Net import Global
+from .basics.Shapes import Rect
+
+class Game:
+    def __init__(self, width: int, height: int, bg_color = "black", title = "Game", resizable: bool = False):
+        pygame.init()
+        flags = pygame.RESIZABLE if resizable else 0
+        self.flags = flags
+        self.screen = pygame.Surface((width, height))
+        self.width, self.height = width, height
+        self.display = pygame.display.set_mode((width, height), flags)
+        self.clock = pygame.time.Clock()
+        self.running = True
+        self.bg_color = bg_color
+        self.title = title
+        
+        #set global
+        Global.screen = self.screen
+        Global.screenDim = pygame.Vector2(width, height)
+        Global.bg_color = bg_color
+        Global.winTitle = title
+        Global.clock = self.clock
+
+    def update(self, events, render = True, fps=60):
+        Global.collision = []
+        #update cam
+        Global.cam.update()
+
+        self.screen.fill(Global.bg_color)
+        Global.events = events
+        Global.dt = self.clock.tick(fps)/1000.0
+        
+        #collect all collision rects first
+        for key in range(5, -1, -1):
+            for obj in Global.objs[str(key)]:
+                if hasattr(obj, '_addCollision'):
+                    obj._addCollision()
+        
+        #then update all objects
+        for key in range(5, -1, -1):
+            for obj in Global.objs[str(key)]:
+                if hasattr(obj, 'update'):
+                    obj.update()
+        
+        if render: 
+            self.display.blit(pygame.transform.scale(self.screen, (self.width, self.height)), (0, 0))
+            pygame.display.update()
+
+    def get_screen(self): return self.screen
+
+    def rescale(self, event):
+        self.width = event.w
+        self.height = event.h
+        self.display = pygame.display.set_mode((self.width, self.height), self.flags)
+    
+    def quit(self):
+        return
+        #for tilemap in Global.tilemaps:
+        #    tilemap._quit()
+
+    def generate_bounds(self, width, height, color="black", show=False):
+        Rect(pygame.Vector2(0, -10), pygame.Vector2(width, 10), color, show)
+        Rect(pygame.Vector2(-10, 0), pygame.Vector2(10, height), color, show)
+        Rect(pygame.Vector2(width, 0), pygame.Vector2(10, height), color, show)
+        Rect(pygame.Vector2(0, height), pygame.Vector2(width, 10), color, show)
+

gamebox-0.10.0.dev1/src/GameBox/__init__.py

@@ -0,0 +1,39 @@
+"""
+GameBox - A beginner-friendly Python 2D game development library.
+--------------------------------------------------------------
+GameBox makes it easy to build 2D games with graphics, sound, and UI in just a few lines of code.
+"""
+
+
+__version__ = "0.10.0"
+__author__ = "Sam Fertig"
+
+#____imports____
+from .Game import Game
+from .basics.Cammera import Cammera
+from .basics.Shapes import Rect, Circle
+from .helpers.Input import Keys
+from .player.Player import Player
+from .basics.utils import clamp
+from .basics.ui import Image, Text
+from .basics.sound import Sound
+from .tilemap.Tilemap import Tilemap
+
+__all__ = [
+    "Game", 
+    "Cammera",
+    "Rect",
+    "Circle",
+    "Keys",
+    "Player",
+    "clamp",
+    "Image",
+    "Text",
+    "Sound",
+    "Tilemap"
+    
+    ]
+
+
+
+

gamebox-0.10.0.dev1/src/GameBox/basics/Cammera.py

@@ -0,0 +1,43 @@
+import pygame
+from random import randint as Ri
+
+from .Net import Global
+
+
+class Cammera:
+    def __init__(self, scale: float = 1.0, smooth: float = 1.0):
+
+        Global.cam = self
+
+        self.pos = pygame.Vector2(0, 0)
+        self.smooth = smooth
+        self.zoom = scale
+
+        self.shakeinfo = [False, 0, 0, False]  # [active, duration, power, returnPos]
+
+        #movement
+        self.target = None
+        self.offset = None
+
+    def update(self):
+        #addon
+        addon = pygame.Vector2(0, 0)
+        if self.shakeinfo[0]: 
+            addon = pygame.Vector2(Ri(-1, 1), Ri(-1, 1)) * self.shakeinfo[2]
+            self.shakeinfo[1]-=1
+            if self.shakeinfo[1]<=0: 
+                self.shakeinfo[0] = False
+                if self.shakeinfo[3]: self.pos = pygame.Vector2(self.shakeinfo[3])
+
+        if self.target and hasattr(self.target, "pos"):
+            target_pos = self.target.pos
+            self.pos = (self.pos + (target_pos + self.offset - self.pos) * self.smooth)
+
+        self.pos+=addon
+
+    def set_target(self, target):
+        self.target = target
+        self.offset = self.pos - target.pos
+
+    def shake(self, dur, power, returnPos=False):
+        self.shakeinfo = [True, dur, power, returnPos]

gamebox-0.10.0.dev1/src/GameBox/basics/Net.py

@@ -0,0 +1,28 @@
+import pygame
+import numpy as np
+
+
+class _global_:
+    def __init__(self):
+        #screen info
+        self.screen: pygame.Surface
+        self.screenDim: np.array
+        self.bg_color: np.array
+        self.winTitle: str
+
+        self.player = None
+
+        #time info
+        self.clock: pygame.time.Clock
+        self.dt: float
+
+        #game info and data
+        #objs in layers 1-5
+        self.objs = {"0":[], "1":[], "2":[], "3":[], "4":[], "5":[]}
+        self.collision = []
+        self.events = None
+        self.cam = None
+
+        
+Global = _global_()
+

gamebox-0.10.0.dev1/src/GameBox/basics/Shapes.py

@@ -0,0 +1,80 @@
+import pygame
+
+from .Net import Global
+
+class shape:
+    def __init__(self, pos, dim, color, show):
+        self.pos = pygame.Vector2(pos)
+        self.dim = pygame.Vector2(dim)
+        self.color = color
+        self.show = show
+
+    def move_to(self, x, y):
+        self.pos = pygame.Vector2(x, y)
+    def move_by(self, x, y):
+        self.pos += pygame.Vector2(x, y)
+    
+    def scale(self, factor):
+        self.dim *= factor
+    def set_dim(self, width, height):
+        self.dim = pygame.Vector2(width, height)
+    def change_dim(self, width, height):
+        self.dim += pygame.Vector2(width, height)
+    def set_color(self, color):
+        self.color = color
+
+    def collide(self, obj):
+        rect = pygame.Rect(self.pos, self.dim)
+        if hasattr(obj, 'pos') and hasattr(obj, 'dim'):
+            obj_rect = pygame.Rect(obj.pos, obj.dim)
+            return rect.colliderect(obj_rect)
+        print(f"<GameBox> Error: Object {obj} does not have pos and dim attributes and can't be collided with")
+        return False
+
+class Rect(shape):
+    def __init__(self, pos, dim, color, show=True, collision=True, layer=3):
+        super().__init__(pos, dim, color, show)
+        self.collision = collision
+        self.layer = layer
+
+        Global.objs[str(layer)].append(self)
+
+    def update(self):
+        if self.show: self.draw()
+
+    def _addCollision(self):
+        if self.collision:
+            rect = pygame.Rect(self.pos, self.dim)
+            Global.collision.append(rect)
+
+    def draw(self):
+        sp = (self.pos - Global.cam.pos) * Global.cam.zoom
+        ss = self.dim * Global.cam.zoom
+        pygame.draw.rect(Global.screen, self.color, (sp, ss))
+
+    def delete(self):
+        Global.objs[str(self.layer)].remove(self)
+
+class Circle(shape):
+    def __init__(self, pos, radius, color, show=True, layer=3):
+        super().__init__(pos, pygame.Vector2(radius, radius), color)
+        self.collision = False
+        self.layer = layer
+        Global.objs[str(layer)].append(self)
+
+    def update(self):
+        if self.show: self.draw()
+
+    def _addCollision(self):
+        if self.collision:
+            rect = pygame.Rect(self.pos, self.dim)
+            Global.collision.append(rect)
+
+    def draw(self):
+        sp = (self.pos - Global.cam.pos) * Global.cam.zoom
+        ss = self.dim * Global.cam.zoom
+        pygame.draw.circle(Global.screen, self.color, (sp), ss[0]//2)
+
+    def delete(self):
+        Global.objs[str(self.layer)].remove(self)
+

gamebox-0.10.0.dev1/src/GameBox/basics/sound.py

@@ -0,0 +1,16 @@
+import pygame
+
+class Sound:
+    def __init__(self, path: str, volume: float = 1.0):
+        self.sound = pygame.mixer.Sound(path)
+        self.volume = volume
+
+    def play(self, loops: int = 0, maxtime: int = 0, fade_ms: int = 0):
+        self.sound.play(loops, maxtime, fade_ms)
+
+    def stop(self):
+        self.sound.stop()
+
+    def set_volume(self, volume: float):
+        self.volume = volume
+        self.sound.set_volume(volume)

gamebox-0.10.0.dev1/src/GameBox/basics/ui.py

@@ -0,0 +1,70 @@
+import pygame
+
+from .Net import Global
+
+class _image:
+    def __init__(self, pos, image, scale, show):
+        self.pos = pygame.Vector2(pos)
+        self.image = pygame.transform.scale(image, (int(image.get_width() * scale), int(image.get_height() * scale)))
+        self.scale = scale
+        self.show=show
+
+    def move_to(self, pos):
+        self.pos = pygame.Vector2(pos)
+    def move_by(self, x, y):
+        self.pos.x += x
+        self.pos.y += y
+
+    def change_scale(self, amount):
+        self.scale += amount
+        self.image = pygame.transform.scale(self.image, (int(self.image.get_width() * self.scale), int(self.image.get_height() * self.scale)))
+
+def load_image(image) -> pygame.Surface:
+    if type(image) == str:
+        return pygame.image.load(image)
+    return image
+
+class Image(_image):
+    def __init__(self, pos, image, scale, show=True, layer=0):
+        super().__init__(pos, load_image(image), scale, show)
+        self.layer = layer
+        Global.objs[str(self.layer)].append(self)
+
+    def update(self):
+        if self.show: self.draw()
+
+    def draw(self):
+        if Global.cam.zoom != 0:
+            image = pygame.transform.scale(self.image, (int(self.image.get_width() * Global.cam.zoom), int(self.image.get_height() * Global.cam.zoom)))
+            Global.screen.blit(image, self.pos - Global.cam.pos)
+        else:
+            Global.screen.blit(self.image, self.pos)
+
+class Text:
+    def __init__(self, pos, text, font, color, show=True, ui=True, layer=0):
+        self.pos = pygame.Vector2(pos)
+        self.text = text
+        self.font = font
+        self.color = color
+        self.layer = layer
+        self.ui = ui
+        Global.objs[str(self.layer)].append(self)
+        self.show = show
+
+    def change(self, text):
+        self.text = text
+
+    def update(self):
+        if self.show: self.draw()
+
+    def draw(self):
+        text = self.font.render(self.text, True, self.color)
+        #scale if needed
+        if Global.cam.zoom != 1.0: text = pygame.transform.scale_by(text, Global.cam.zoom)
+
+        if self.ui: Global.screen.blit(text, self.pos)
+        else:
+            sp = self.pos - Global.cam.pos
+            Global.screen.blit(text, sp)
+        
+        

{gamebox-0.9.1 → gamebox-0.10.0.dev1}/src/GameBox/basics/utils.py

@@ -4,6 +4,7 @@ import numpy as np
 
 def clamp(value, min_value, max_value):
     return max(min(value, max_value), min_value)
+    
 def moveTward(value, target, speed):
     if value < target:
         value += speed
@@ -14,4 +15,4 @@ def moveTward(value, target, speed):
 def zeroOut(value, max):
     if value < 0 and value > -max: value = 0
     if value > 0 and value < max: value = 0
-    return value
+    return value

gamebox-0.9.1/src/GameBox/helpers/_input.py → gamebox-0.10.0.dev1/src/GameBox/helpers/Input.py

@@ -1,6 +1,6 @@
 import pygame
 
-from ..basics._net import Global
+from ..basics.Net import Global
 
 
 class _keys:
@@ -61,14 +61,19 @@ class _keys:
 
         #mouse
         self.mouse_x, self.mouse_y = 0, 0
-    def init(self): Global.game.objs.append(self)
+    def init(self): Global.objs[str(5)].append(self)
 
     def is_pressed(self, key): 
-        for event in Global.event:
+        if Global.events is None: return False
+        for event in Global.events:
             if event.type == pygame.KEYDOWN:
                 if event.key == key: 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()
 
 

gamebox-0.10.0.dev1/src/GameBox/helpers/_collisions.py

@@ -0,0 +1,78 @@
+import pygame
+
+from ..basics.Net import Global
+
+
+def CollisionLogic(vel, pos, dim, sample):
+    x, y = pos
+    vx, vy = vel
+
+    x, y, vx, vy = _Collisions(x, y, vx, vy, dim, Global.collision)
+    #x, y, vx, vy = _tilemapCollisions(x, y, vx, vy, dim, sample)
+
+    pos = pygame.Vector2(x, y)
+    vel = pygame.Vector2(vx, vy)
+
+    return pos, vel
+
+
+def _Collisions(x, y, vx, vy, dim, shapes):
+    # Apply movement
+    x += vx
+    y += vy
+
+    rect = pygame.Rect(x, y, dim.x, dim.y)
+
+    for collision in shapes:
+        if not rect.colliderect(collision):
+            continue
+
+        # Calculate overlap on each side
+        overlap_left   = rect.right - collision.left
+        overlap_right  = collision.right - rect.left
+        overlap_top    = rect.bottom - collision.top
+        overlap_bottom = collision.bottom - rect.top
+
+        # Find smallest overlap
+        min_x = min(overlap_left, overlap_right)
+        min_y = min(overlap_top, overlap_bottom)
+
+        # Resolve on the axis with least penetration
+        if min_x < min_y:
+            if overlap_left < overlap_right:
+                rect.right = collision.left
+            else:
+                rect.left = collision.right
+            vx = 0
+        else:
+            if overlap_top < overlap_bottom:
+                rect.bottom = collision.top
+            else:
+                rect.top = collision.bottom
+            vy = 0
+
+    return rect.x, rect.y, vx, vy
+
+
+def _tilemapCollisions(x, y, vx, vy, dim, sampleSize):
+    for map in Global.tilemaps:
+        #get player tilemap pos
+        tx = x//map.tileDim[0]
+        ty = y//map.tileDim[1]
+        #get tiles around player
+        collisions = []
+        for yIndex in range(-sampleSize, sampleSize):
+            for xIndex in range(-sampleSize, sampleSize):
+                #if point not on map, skip
+                if tx+xIndex < 0 or tx+xIndex >= map.mapDim[0] or ty+yIndex < 0 or ty+yIndex >= map.mapDim[1]: continue
+                #get shape
+                tile = str(map.map[int(ty+yIndex)][int(tx+xIndex)])
+                if tile not in map.collisionDict: continue
+                shape = map.collisionDict[str(tile)]
+                rect = getattr(map.collisionShapes, shape).copy()
+                rect.x += (tx+xIndex)*map.tileDim[0]
+                rect.y += (ty+yIndex)*map.tileDim[1]
+                collisions.append(rect)
+        #collision math
+        x, y, vx, vy = _Collisions(x, y, vx, vy, dim, collisions)
+    return x, y, vx, vy

gamebox-0.10.0.dev1/src/GameBox/player/Player.py

@@ -0,0 +1,45 @@
+import pygame
+
+from ..basics.Net import Global
+from ._playerPhysics import playerPhysics
+from ._playerControler import playerController
+
+
+class Player:
+    def __init__(self, pos, dim, color, show=True, layer=3):
+        self.pos = pygame.Vector2(pos)
+        self.dim = pygame.Vector2(dim)
+        self.vel = pygame.Vector2(0, 0)
+        self.color = color
+
+        self.physics = None
+        self.move = playerController(self)
+        self.show = show
+
+        self.sampleSize = 5
+        self.layer = layer
+        
+        Global.objs[str(layer)].append(self)
+        #Global.player = self
+
+
+    def copy(self):
+        p = Player(self.pos, self.dim, self.color, self.show, self.layer)
+        p.add_physics(self.physics.speed, self.physics.gravity, self.physics.jumpForce, self.physics.maxV, self.physics.friction)
+        return p
+
+    def add_physics(self, speed: float = 7.0, gravity: float = 5.5, jumpForce: float = 10.0, maxV: tuple = (25, 25), friction: tuple = (0.8, 0.8)):
+        self.physics = playerPhysics(self, speed, gravity, jumpForce, pygame.Vector2(maxV), pygame.Vector2(friction))
+        
+    def update(self):
+        if self.physics: self.physics.update()
+        if self.show: self.draw()
+
+    #--debug func--
+    def draw(self):
+        sp = (self.pos - Global.cam.pos) * Global.cam.zoom
+        ss = self.dim * Global.cam.zoom
+        pygame.draw.rect(Global.screen, self.color, [sp, ss])
+
+    def set_sample_size(self, size):
+        self.sampleSize = size

gamebox-0.10.0.dev1/src/GameBox/player/_playerControler.py

@@ -0,0 +1,29 @@
+import pygame
+
+from ..helpers.Input import Keys
+
+class playerController:
+    def __init__(self, player):
+        self.p = player
+
+    def by_WSAD(self, speed):
+        if Keys.is_held(Keys.w): self.p.vel.y -= speed
+        if Keys.is_held(Keys.s): self.p.vel.y += speed
+        if Keys.is_held(Keys.a): self.p.vel.x -= speed
+        if Keys.is_held(Keys.d): self.p.vel.x += speed
+
+    def by_arrows(self, speed):
+        if Keys.is_held(Keys.up): self.p.vel.y -= speed
+        if Keys.is_held(Keys.down): self.p.vel.y += speed
+        if Keys.is_held(Keys.left): self.p.vel.x -= speed
+        if Keys.is_held(Keys.right): self.p.vel.x += speed
+
+    def platformor_by_WSAD(self, speed):
+        if Keys.is_pressed(Keys.w): self.p.vel.y -= speed
+        if Keys.is_held(Keys.a): self.p.vel.x -= speed
+        if Keys.is_held(Keys.d): self.p.vel.x += speed
+
+    def platformor_by_arrows(self, speed):
+        if Keys.is_pressed(Keys.up): self.p.vel.y -= speed
+        if Keys.is_held(Keys.left): self.p.vel.x -= speed
+        if Keys.is_held(Keys.right): self.p.vel.x += speed

gamebox-0.10.0.dev1/src/GameBox/player/_playerPhysics.py

@@ -0,0 +1,35 @@
+import pygame
+
+from ..basics.Net import Global
+from ..basics.utils import clamp, zeroOut
+
+from ..helpers._collisions import CollisionLogic
+
+class playerPhysics:
+    def __init__(self, player, speed, gravity, jumpForce, maxV, friction):
+        self.player = player
+        self.speed = speed
+        self.gravity = gravity
+        self.jumpForce = jumpForce
+        self.maxV = maxV
+        self.friction = friction
+        
+    def update(self):
+        #clamp velocities
+        self.player.vel.x = clamp(self.player.vel.x, -self.maxV.x, self.maxV.x)
+        self.player.vel.y = clamp(self.player.vel.y, -self.maxV.y, self.maxV.y)
+        
+        #apply gravity
+        self.player.vel.y += self.gravity
+        
+        #apply friction
+        self.player.vel.x *= self.friction.x
+        self.player.vel.y *= self.friction.y
+        
+        #zero out very small velocities to prevent drift
+        self.player.vel.x = zeroOut(self.player.vel.x, 0.01)
+        self.player.vel.y = zeroOut(self.player.vel.y, 0.01)
+        
+        #update position
+        self.player.pos, self.player.vel = CollisionLogic(self.player.vel, self.player.pos, self.player.dim, self.player.sampleSize)
+               

gamebox-0.10.0.dev1/src/GameBox/tilemap/Tilemap.py

@@ -0,0 +1,46 @@
+import pygame
+import numpy as np
+
+from ..basics.Net import Global
+from ..basics.ui import load_image
+
+class Tilemap:
+    def __init__(self, tilesetImage, tileDim, scale, layer=4, show=True):
+        self.tilemap = load_image(tilesetImage)
+
+        self.tileDim = pygame.Vector2(tileDim)
+        self.scaleDim = pygame.Vector2(tileDim) * scale
+        self.scale = scale
+        self.mapDim = mapDim
+
+        self.fill = fill
+        self.layer = layer
+        self.show = show
+        Global.objs[str(self.layer)].append(self)
+
+        #load images and create basic tilemap 
+        self.map = {}
+        self.tiles: Dict[int, pygame.Surface] = {}
+        self.images: Dict[int, pygame.Surface] = {}
+        tile = 1
+        #split image into tiles
+        for y in range(mapDim[1]):
+            for x in range(mapDim[0]):
+                try:
+                    self.images[tile] = self.tilemap.subsurface(pygame.Rect(x * self.tileDim.x, y * self.tileDim.y, self.tileDim.x, self.tileDim.y))
+                    self.tiles[tile] = pygame.transform.scale_by(self.images[tile], self.scale)
+                except:
+                    pass
+                tile += 1
+
+    def update(self):
+        if self.show: self.draw()
+
+    def draw(self):
+        for key in self.map:
+            tile = self.map[key]
+            image = self.tiles[tile['type']]
+            pos = tile['pos']
+            
+            
+