GameBox 0.9.1__py3-none-any.whl → 0.10.0.dev1__py3-none-any.whl

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/__init__.py

@@ -5,38 +5,35 @@ GameBox makes it easy to build 2D games with graphics, sound, and UI in just a f
 """
 
 
-__version__ = "0.3.0"
+__version__ = "0.10.0"
 __author__ = "Sam Fertig"
 
 #____imports____
-from ._game import Game
-from .basics.cammera import Cammera
-from .basics._shapes import Rect
-from .player._player import Player
-from .basics.utils import clamp, moveTward, zeroOut
-from .tilemap._tilemap import TileMap
-from.helpers._input import Keys
-from .ui._basicUI import Image
-
-from .GameLevel_ui._sprites import Sprite_2d, Animated_Sprite2D, AnimationPlayer2D, split_image
-from.helpers._Conditions import Conditions
-
+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",
+    "Game", 
     "Cammera",
     "Rect",
+    "Circle",
+    "Keys",
     "Player",
     "clamp",
-    "moveTward",
-    "zeroOut",
-    "TileMap",
-    "Keys",
     "Image",
-    "Sprite_2d",
-    "Animated_Sprite2D",
-    "AnimationPlayer2D",
-    "split_image",
-    "Conditions",
-]
+    "Text",
+    "Sound",
+    "Tilemap"
+    
+    ]
+
+
+
 

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/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/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/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/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/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/helpers/{_input.py → 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/helpers/_collisions.py

@@ -1,114 +1,78 @@
 import pygame
-import numpy as np
-
-from ..basics._net import Global
-
-
-def CheckCollisions(x, y, vx, vy, dim, sample, obj):
-        x, y = x + vx, y + vy
-
-        #basic object collisions
-        x, y, vx, vy = _mainCollisionLogic(Global.collisions, x, y, vx, vy, dim)
-        x, y, vx, vy = _checkTilemapCollisions(x, y, vx, vy, dim, sample, obj)
-
-        return x, y, vx, vy
-    
-def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
-    # Y-axis collisions
-    py = y
-    new_rect = pygame.Rect((x, y), dim)
-    if Global._debug:
-        pygame.draw.rect(Global.screen, "green", new_rect, 5)
-    for collision in collisions:
-        if Global._debug:
-            pygame.draw.rect(Global.screen, "yellow", collision, 5)
-        if collision.colliderect(new_rect):
-            if vy > 0:  # falling
-                y = collision.top - dim[1]
-                vy = 0
-            elif vy < 0:  # jumping
-                y = collision.bottom
-                vy = 0
-                
-    new_rect = pygame.Rect((x, py), dim)
-    for collision in collisions:
-        if Global._debug:
-            pygame.draw.rect(Global.screen, "yellow", collision, 5)
-        if collision.colliderect(new_rect):
-            if vx > 0:
-                x = collision.left - dim[0]
-            elif vx < 0:
-                x = collision.right
-            vx = 0
 
-    return x, y, vx, vy
-    
-def _checkTilemapCollisions(x, y, vx, vy, dim, sample, obj):
-    if len(Global.tilemap) == 0:
-        return x, y, vx, vy
-    
-    for tilemap in Global.tilemap:
-    
-        #get player reletive tilemap  pos
-        prect = pygame.Rect(x, y, dim[0], dim[1])
-        prx, pry = prect.center
-        if Global.cam.follow != obj:
-            if Global.cam.x != 0 or Global.cam.y != 0:
-                px = int((prx) - Global.cam.x)
-                py = int((pry) - Global.cam.y) 
-                px = int(px  // tilemap.tileDim[0])
-                py = int(py  // tilemap.tileDim[1])
+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:
-                px = int((x) / tilemap.tileDim[0])
-                py = int((y ) / tilemap.tileDim[1])
+                rect.left = collision.right
+            vx = 0
         else:
-            if Global.cam.x != 0 or Global.cam.y != 0:
-                px = int(((prx + Global.cam.x)) // tilemap.tileDim[0])
-                py = int(((pry + Global.cam.y)) // tilemap.tileDim[1])
+            if overlap_top < overlap_bottom:
+                rect.bottom = collision.top
             else:
-                px = int((x) / tilemap.tileDim[0])
-                py = int((y) / tilemap.tileDim[1])
-
-
-        #check if player is on tilemap
-        if px < 0 or px >= tilemap.mapDim[0] or py < 0 or py >= tilemap.mapDim[1]:
-            return x, y, vx, vy
-        #get collision rects around player
-        collisions: list[pygame.Rect] = []
-        for tx in range(px - sample, px + sample):
-            for ty in range(py - sample, py + sample):
-                nx = int(px + tx)
-                ny = int(py + ty)
-                #if tile is on map
-                if nx < 0 or nx >= tilemap.mapDim[0] or ny < 0 or ny >= tilemap.mapDim[1]:
-                    continue
-                #if tile has defined collision shape
-                tile = str(tilemap.map[ny][nx])
-                if tile not in tilemap.collisionDict: continue
-
-                #get collision shape 
-                rectshape = tilemap.collisionDict[str(tile)]
-                rect = getattr(tilemap.collisionShapes, rectshape).copy()
-
-                # Position rect correctly in the world
-                if Global.cam.follow != obj:
-                    if Global.cam.x != 0 or Global.cam.y != 0:
-                        rect.x = ((nx * tilemap.tileDim[0])) - Global.cam.x
-                        rect.y = ((ny * tilemap.tileDim[1])) - Global.cam.y
-                    else:
-                        rect.x += (nx * tilemap.tileDim[0]) - Global.cam.x
-                        rect.y += (ny * tilemap.tileDim[1]) - Global.cam.y
-                else:
-                    if Global.cam.x != 0 or Global.cam.y != 0:
-                        rect.x += ((nx * tilemap.tileDim[0])) - Global.cam.x
-                        rect.y += ((ny * tilemap.tileDim[1])) - Global.cam.y
-                    else:
-                        rect.x += (nx * tilemap.tileDim[0]) - Global.cam.x
-                        rect.y += (ny * tilemap.tileDim[1]) - Global.cam.y
-                collisions.append(rect)
+                rect.top = collision.bottom
+            vy = 0
 
-        #check collisions
-        x, y, vx, vy = _mainCollisionLogic(collisions, x, y, vx, vy, dim)
+    return rect.x, rect.y, vx, vy
 
-        return x, 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/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