GameBox 0.9.2__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,165 +1,78 @@
 import pygame
-import numpy as np
 
-from ..basics._net import Global
+from ..basics.Net import Global
 
 
-def CheckCollisions(x, y, vx, vy, dim, sample, obj):
-        x, y = x + vx, y + vy
+def CollisionLogic(vel, pos, dim, sample):
+    x, y = pos
+    vx, vy = vel
 
-        #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)
+    x, y, vx, vy = _Collisions(x, y, vx, vy, dim, Global.collision)
+    #x, y, vx, vy = _tilemapCollisions(x, y, vx, vy, dim, sample)
 
-        return x, y, vx, vy
-    
-def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
-    offset = 0
+    pos = pygame.Vector2(x, y)
+    vel = pygame.Vector2(vx, vy)
 
-    prev_rect = pygame.Rect(x - vx, y - vy, dim[0], dim[1])
-    rect = pygame.Rect(x, y, dim[0], dim[1])
+    return pos, vel
 
-    # =====================
-    # Y AXIS COLLISION
-    # =====================
-    y_hit = None
 
-    for collision in collisions:
-        if Global._debug:
-            pygame.draw.rect(Global.screen, "yellow", collision, 2)
+def _Collisions(x, y, vx, vy, dim, shapes):
+    # Apply movement
+    x += vx
+    y += vy
 
-        if collision.colliderect(rect):
-            if vy > 0 and prev_rect.bottom <= collision.top:
-                if y_hit is None or collision.top < y_hit.top:
-                    y_hit = collision
-            elif vy < 0 and prev_rect.top >= collision.bottom:
-                if y_hit is None or collision.bottom > y_hit.bottom:
-                    y_hit = collision
+    rect = pygame.Rect(x, y, dim.x, dim.y)
 
-    if y_hit:
-        if vy > 0:
-            y = y_hit.top - dim[1] - offset
-        else:
-            y = y_hit.bottom + offset
-        vy = 0
-
-    # update rect after Y resolution
-    rect.y = y
-
-    # =====================
-    # X AXIS COLLISION
-    # =====================
-    x_hit = None
-
-    for collision in collisions:
-        if collision.colliderect(rect):
+    for collision in shapes:
+        if not rect.colliderect(collision):
+            continue
 
-            # ONLY resolve X if we were NOT overlapping horizontally last frame
-            if prev_rect.right <= collision.left and vx > 0:
-                if x_hit is None or collision.left < x_hit.left:
-                    x_hit = collision
+        # 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
 
-            elif prev_rect.left >= collision.right and vx < 0:
-                if x_hit is None or collision.right > x_hit.right:
-                    x_hit = collision
+        # Find smallest overlap
+        min_x = min(overlap_left, overlap_right)
+        min_y = min(overlap_top, overlap_bottom)
 
-    if x_hit:
-        if vx > 0:
-            x = x_hit.left - dim[0] - offset
-        else:
-            x = x_hit.right + offset
-        vx = 0
-
-    if Global._debug:
-        pygame.draw.rect(
-            Global.screen,
-            "green",
-            rect,
-            2
-        )
-        pygame.draw.rect(
-            Global.screen,
-            "red",
-            prev_rect,
-            1
-        )
-        pygame.draw.rect(
-            Global.screen,
-            "blue",
-            (x, y, dim[0], dim[1]),
-            2
-        )
-
-    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])
+        # 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
+                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)
-
-        #check collisions
-        x, y, vx, vy = _mainCollisionLogic(collisions, x, y, vx, vy, dim)
-
-        return x, y, vx, vy
-
+        #collision math
+        x, y, vx, vy = _Collisions(x, y, vx, vy, dim, collisions)
+    return x, y, vx, vy