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

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/player/_playerControler.py

@@ -1,54 +1,29 @@
 import pygame
-import numpy as np
-
-from ..basics._net import Global
-from ..basics.utils import clamp, moveTward, zeroOut
-
-class _playerControler:
-    def __init__(self, player: object, speed: float = 1.0, gravity: float = 0.0, jump: float = 0.0, maxV: float = 10.0, airRes: float = 0.2):
-        self.speed = speed
-        self.gravity = gravity
-        self.jump = jump
-        self.player = player
-        self.maxV = maxV
-        self.airRes = airRes
-
-    def update(self):
-        self.player.vx = clamp(self.player.vx, -self.maxV, self.maxV)
-        #self.player.vy = clamp(self.player.vy, -self.maxV, self.maxV)
-
-        self.player.vx = moveTward(self.player.vx, 0, self.airRes)
-        self.player.vy = moveTward(self.player.vy, 0, self.airRes)
-
-        self.player.vx = zeroOut(self.player.vx, 0.3)
-        self.player.vy = zeroOut(self.player.vy, 0.3)
-
-        if self.player.gravity and not self.player.onGround: self.player.vy += self.gravity
-
-
-
-
-    def move(self, x, y):
-        self.player.vx += x * self.speed
-        self.player.vy += y * self.speed
-
-    def top_down_movement(self):
-        keys = pygame.key.get_pressed()
-        if keys[pygame.K_a]:
-            self.move(-1, 0)
-        if keys[pygame.K_d]:
-            self.move(1, 0)
-        if keys[pygame.K_w]:
-            self.move(0, -1)
-        if keys[pygame.K_s]:
-            self.move(0, 1)
-
-    def platforming_movement(self):
-        keys = pygame.key.get_pressed()
-        if keys[pygame.K_a]:
-            self.move(-1, 0)
-        if keys[pygame.K_d]:
-            self.move(1, 0)
-        if keys[pygame.K_SPACE] and self.player.onGround:
-            self.player.vy = -self.jump
 
+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/player/_playerPhysics.py

@@ -1,84 +1,35 @@
 import pygame
-import numpy as np
 
-from ..basics._net import Global
-from ..basics.utils import clamp, moveTward, zeroOut
-from ..helpers._collisions import CheckCollisions
+from ..basics.Net import Global
+from ..basics.utils import clamp, zeroOut
 
-class _playerPhysics:
-    def __init__(self, player, speed: float = 1.0, gravity: float = 0.0, jump: float = 0.0, maxV: float = 10.0, airRes: float = 0.2):
+from ..helpers._collisions import CollisionLogic
+
+class playerPhysics:
+    def __init__(self, player, speed, gravity, jumpForce, maxV, friction):
         self.player = player
-        self.rect = pygame.Rect(self.player.x, self.player.y, self.player.dim[0], self.player.dim[1])
-        
         self.speed = speed
         self.gravity = gravity
-        self.jump = jump
-        self.player = player
+        self.jumpForce = jumpForce
         self.maxV = maxV
-        self.airRes = airRes
-        self.onGround = False
-        self.canJump = False
-
-        self.sample = 25
-
-        self.vx, self.vy = 0, 0
-
+        self.friction = friction
+        
     def update(self):
-        self.ckeck_is_on_ground()
-        x, y, self.vx, self.vy = CheckCollisions(self.player.x, self.player.y, 
-                               self.vx, self.vy, self.player.dim, 
-                               self.sample,self.player)
-        if (Global.cam.follow) != (self.player):
-            self.player.x = x
-            self.player.y = y
-        elif (Global.cam.follow) == (self.player):
-            dx = -(self.player.x - x)
-            dy = -(self.player.y - y)
-            Global.cam._move(self.vx, self.vy)
-
-
-
-    
-    def ckeck_is_on_ground(self):
-        self.canJump = False
-        rect = pygame.Rect(self.player.x, self.player.y + self.player.dim[1], self.player.dim[0], 10)
-        for collision in Global.collisions:
-            if collision.colliderect(rect):
-                self.canJump = True
-
-
-    def move(self, x, y):
-        self.vx += x * self.speed
-        self.vy += y * self.speed
-
-    def top_down_movement(self):
-        keys = pygame.key.get_pressed()
-        if keys[pygame.K_a]:
-            self.move(-1, 0)
-        if keys[pygame.K_d]:
-            self.move(1, 0)
-        if keys[pygame.K_w]:
-            self.move(0, -1)
-        if keys[pygame.K_s]:
-            self.move(0, 1)
-        #limit velocity
-        self.vx = clamp(self.vx, -self.maxV, self.maxV)
-        self.vy = clamp(self.vy, -self.maxV, self.maxV)
-        self.vx = moveTward(self.vx, 0, self.airRes)
-        self.vy = moveTward(self.vy, 0, self.airRes)
-        self.vx = zeroOut(self.vx, 0.3)
-        self.vy = zeroOut(self.vy, 0.3)
-
-    def platforming_movement(self):
-        keys = pygame.key.get_pressed()
-        if keys[pygame.K_a]:
-            self.move(-1, 0)
-        if keys[pygame.K_d]:
-            self.move(1, 0)
-        if keys[pygame.K_w] and self.canJump:
-            self.vy -= self.jump
-        #limit velocity
-        self.vx = clamp(self.vx, -self.maxV, self.maxV)
-        self.vx = moveTward(self.vx, 0, self.airRes)
-        self.vx = zeroOut(self.vx, 0.3)
-        if self.player.gravity and not self.onGround: self.vy += self.gravity
+        #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/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']
+            
+            
+

{gamebox-0.9.2.dist-info → gamebox-0.10.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameBox
-Version: 0.9.2
+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.10.0.dev1.dist-info/RECORD

@@ -0,0 +1,18 @@
+GameBox/Game.py,sha256=WpuQh_zyyEaRwCH1LIoPPb1c9ouCdeA__j_L8UiMlLE,2465
+GameBox/__init__.py,sha256=mM7TXJro8t3fmEpeWX8zgJc9THrYufTl9YJv5Q9ydR0,817
+GameBox/basics/Cammera.py,sha256=91uhSOb0S1M_Sm5G4Ryen9bVygvVWENgLYXZ3JUplT0,1284
+GameBox/basics/Net.py,sha256=YNbcIrTOt7NHckWUJIyWor1DVYfOk6KPxMprRbLjYm0,597
+GameBox/basics/Shapes.py,sha256=uFSI7HijdkAhelI7wRP1nWVbsu0CHg9NTj52Oy8ato4,2556
+GameBox/basics/sound.py,sha256=SnkCvp0sNV_EoDA9Ocg4D9Ve3gKMBwgfLm_QxmIY4Vk,453
+GameBox/basics/ui.py,sha256=XozEs_C_RM4mPDPRbq9F3qhQrXzIXf_cLMCa07RMu_c,2289
+GameBox/basics/utils.py,sha256=mVYXumz0s1pvn4H_BEQIOI3C7uq3PsfGAMAMVui2cKU,436
+GameBox/helpers/Input.py,sha256=aTbe_fpM_KXyOR5AYxCHwhiQW1uidh9EpJ0gtRqWyGk,2112
+GameBox/helpers/_collisions.py,sha256=9sCEqqX0J_znk4DKMXdhSLJh8hsZeFLbu2a1Uz5s9NM,2555
+GameBox/player/Player.py,sha256=J-Nn5Rv8KLbA6RE4HXWx40Tf-kCcDa2HHRdN3fmAvV0,1533
+GameBox/player/_playerControler.py,sha256=MNhqYBd10z1y9CQdQeZWbyZZyNcluTGtPCHsYreCqKw,1103
+GameBox/player/_playerPhysics.py,sha256=AebFiV9ue-lIODI6zPI2R9vnEMj2PMvgXS5_cpQgDeI,1236
+GameBox/tilemap/Tilemap.py,sha256=r2aVV0l2idkNC6m_rGGq0w3JyKO8FkU_yyHCYl97BXg,1452
+gamebox-0.10.0.dev1.dist-info/METADATA,sha256=WI3XbRWfD4fgRFRZZxAsaeMFm72nB05EjIWXk3PAs10,1065
+gamebox-0.10.0.dev1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gamebox-0.10.0.dev1.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
+gamebox-0.10.0.dev1.dist-info/RECORD,,

GameBox/GameLevel_ui/_Animations.py

@@ -1,39 +0,0 @@
-import pygame
-import numpy as np
-
-from ..basics._net import Global
-
-class Animation:
-    def __init__(self, image, tileDim, startPos, frames, dur):
-        if type(image) == str:
-            image = pygame.image.load(image)
-
-        #others
-        self.dur = dur
-        self.currentFrame = 0
-        self.currentDur = 0
-
-        #get frames from image
-        self.frames = []
-        x, y = startPos
-        x *= tileDim[0]
-        y *= tileDim[1]
-        for i in range(frames):
-            self.frames.append(image.subsurface(x, y, tileDim[0], tileDim[1]))
-            x += tileDim[0]
-            if x >= image.get_width():
-                x = 0
-                y += tileDim[1]
-
-    def update(self, dt):
-        self.currentDur += dt
-        if self.currentDur >= self.dur:
-            self.currentDur = 0
-            self.currentFrame += 1
-            if self.currentFrame >= len(self.frames):
-                self.currentFrame = 0
-
-    def getFrame(self):
-        return self.frames[self.currentFrame]
-
-

GameBox/GameLevel_ui/_sprites.py

@@ -1,185 +0,0 @@
-import pygame
-import numpy as np
-
-from ..basics._net import Global
-from ._Animations import Animation
-
-class Sprite_2d:
-    def __init__(self, pos: tuple, image, scale: float = 1.0, collision = True, dirrection: int = 1):
-        """
-        Initialize a 2D sprite.
-        
-        Args:
-            pos: Tuple (x, y) for the sprite position
-            image: Either a file path (str) or pygame.Surface object
-            scale: Scale factor for the sprite (default: 1.0)
-        """
-        #add to game
-        Global.game.objs.append(self)
-        self.collision = collision
-        self.__worldPos__ = True
-        self.dir = dirrection
-
-        self.pos = pos
-        if type(image) == str:
-            self.image = pygame.image.load(image)
-        else:
-            self.image = image
-        
-        #scale image
-        print(self.image)
-        self.image = pygame.transform.scale_by(self.image, scale)
-        #flip image
-        if self.dir == -1:
-            self.image = pygame.transform.flip(self.image, True, False)
-
-    def update(self):
-        #world space
-        x, y = self.pos
-        if self.__worldPos__:
-            x = x - Global.cam.x
-            y = y - Global.cam.y
-        Global.screen.blit(self.image, (x, y))
-        if self.collision:
-            rect = self.image.get_rect()
-            rect.x = x
-            rect.y = y
-            Global.collisions.append(rect)
-
-    def switch_dirrection(self):
-        self.image = pygame.transform.flip(self.image, True, False)
-        
-
-    def move_by(self, x: int, y: int):
-        self.pos = (self.pos[0] + x, self.pos[1] + y)
-
-    def move_to(self, x: int, y: int):
-        self.pos = (x, y)
-
-    def get_pos(self):
-        return self.pos
-
-    def rescale(self, scale: float):
-        self.image = pygame.transform.scale_by(self.image, scale)
-
-    def __remove__(self):
-        Global.game.objs.remove(self)
-
-def split_image(image, tileDim, startPos):
-    if type(image) == str:
-        image = pygame.image.load(image)
-    else:
-        image = image
-
-    #return image split
-    x = startPos[0] * tileDim[0]
-    y = startPos[1] * tileDim[1]
-    return image.subsurface((x, y, tileDim[0], tileDim[1]))
-
-class Animated_Sprite2D:
-    def __init__(self, pos, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = True, dirrection = 1):
-        self.animation = Animation(image, tileDim, (0, 0), frames, speed)
-        self.collision = collision
-        self.dir = dirrection
-        self.pos = pos
-
-        self.scale = scale
-        self.image = pygame.transform.scale_by(self.animation.getFrame(), scale)
-        if self.dir == -1:
-            self.image = pygame.transform.flip(self.image, True, False)
-
-        self.__worldPos__ = True
-
-        #add to game
-        Global.game.objs.append(self)
-
-    def update(self):
-        self.animation.update(Global.dt)
-        self.image = pygame.transform.scale_by(self.animation.getFrame(), self.scale)
-        if self.dir == -1:
-            self.image = pygame.transform.flip(self.image, True, False)
-        
-        #world space
-        x, y = self.pos
-        if self.__worldPos__:
-            x = x - Global.cam.x
-            y = y - Global.cam.y
-        Global.screen.blit(self.image, (x, y))
-        if self.collision:
-            rect = self.image.get_rect()
-            rect.x = x
-            rect.y = y
-            Global.collisions.append(rect)
-
-    def __remove__(self):
-        Global.game.objs.remove(self)
-
-    def switch_dirrection(self):
-        self.image = pygame.transform.flip(self.image, True, False)
-
-    def move_by(self, x: int, y: int):
-        self.pos = (self.pos[0] + x, self.pos[1] + y)
-
-    def move_to(self, x: int, y: int):
-        self.pos = (x, y)
-
-    def get_pos(self):
-        return self.pos
-
-    def rescale(self, scale: float):
-        self.image = pygame.transform.scale_by(self.image, scale)
-
-class AnimationPlayer2D:
-    def __init__(self, pos, scale):
-        self.pos = pos
-        self.scale = scale
-        self.anims = {}
-        self.currentAnim = None
-
-        self.__worldPos__ = True
-
-        #add to game
-        Global.game.objs.append(self)
-
-    def update(self):
-        if self.currentAnim is not None:
-            self.anims[self.currentAnim].update()
-
-    def add_animation(self, name, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = True, dirrection = 1):
-        self.anims[name] = Animated_Sprite2D(self.pos, image, imageDim, tileDim, frames, speed, scale, collision, dirrection)
-        self.currentAnim = name
-        self.anims[self.currentAnim].__remove__()
-
-    def remove_animation(self, name: str):
-        self.anims[name].__remove__()
-        del self.anims[name]
-
-    def set_worldPos(self, worldPos: bool):
-        for anim in self.anims:
-            self.anims[anim].__worldPos__ = worldPos
-
-    def __remove__(self):
-        if self in Global.game.objs:
-            Global.game.objs.remove(self)\
-
-    def set_scale(self, scale: float):
-        for anim in self.anims:
-            self.anims[anim].rescale(scale)
-
-    def set_animation(self, anim: str):
-        self.currentAnim = anim
-
-    def move_by(self, x: int, y: int):
-        self.pos = (self.pos[0] + x, self.pos[1] + y)
-        for anim in self.anims:
-            self.anims[anim].move_by(x, y)
-
-    def move_to(self, x: int, y: int):
-        self.pos = (x, y)
-        for anim in self.anims:
-            self.anims[anim].move_to(x, y)
-
-    def get_pos(self):
-        return self.pos
-
-

GameBox/_game.py

@@ -1,81 +0,0 @@
-import pygame
-import numpy as np
-
-
-from .basics._net import Global
-from .player._player import Player
-
-class Game:
-    def __init__(self, width, height, bg_color, WinTitle="GameBox"):
-        """
-        Initialize the Game object.
-
-        Parameters:
-        width (int): The width of the game window.
-        height (int): The height of the game window.
-        bg_color (tuple): The background color of the game window.
-        WinTitle (str): The title of the game window.
-
-        Returns:
-        None
-        """
-        Global.screenDim = (width, height)
-        Global.screen = pygame.display.set_mode(Global.screenDim)
-        pygame.display.set_caption(WinTitle)
-        Global.bgColor = bg_color
-        Global.clock = pygame.time.Clock()
-        Global.game = self
-        self.objs = []
-        self.ui_objs = []
-
-
-    def update(self, event: pygame.event,frame_rate=60):
-        Global.event = event
-        #clear collisions
-        Global.collisions.clear()
-
-        Global.dt = Global.clock.tick(frame_rate) / 1000.0
-        Global.screen.fill(Global.bgColor)
-        player = None
-        for obj in self.objs:
-            if type(obj) == Player: player = obj
-            else: obj.update()
-        if player != None: player.update()
-        
-        #update ui
-        for obj in self.ui_objs:
-            obj.update()
-        
-        pygame.display.update()
-
-    def get_screen(self):
-        return Global.screen
-    
-    def quit(self):
-        #will save files later
-        for obj in self.objs:
-            if hasattr(obj, "_quit") and callable(obj._quit):
-                obj._quit()
-
-    def _set_debug(self, debug: bool):
-        """
-        Set the debug mode for the game. This will show / hide debuging information 
-        like collisions. Note: This feture is for development and testing purposes only.
-        
-        Parameters:
-        debug (bool): The debug mode.
-        
-        Returns:
-        None
-        """
-        Global._debug = debug
-    def _get_debug_state(self):
-        """
-        Get the debug mode for the game.
-        
-        Returns:
-        bool: The debug mode.
-        """
-        return Global._debug
-
-

GameBox/basics/_net.py

@@ -1,36 +0,0 @@
-import pygame
-import numpy as np
-
-class _global_:
-    def __init__(self):
-        #screen info and win data
-        self.screen: pygame.Surface = None
-        self.dt: float = 0
-        self.screenDim: tuple = None
-        self.bgColor: tuple = None
-        self.clock: pygame.time.Clock = None
-
-        #basics
-        #--game and cam
-        self.game: object = None
-        self.cam: object = None
-        self.event: pygame.event = None
-        #-collisions
-        self.collisions: list[pygame.Rect] = []
-
-        self.cond: object = None
-
-        self._debug: bool = False
-
-        #objects
-        self.player = self._player()
-        self.tilemap = []
-
-    class _player:
-        def __init__(self):
-            self.pos: tuple = None
-            self.player: object = None
-
-
-
-Global = _global_()