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

GameBox/__init__.py

@@ -9,29 +9,20 @@ __version__ = "0.0.3"
 __author__ = "Sam Fertig"
 
 #____imports____
-from .game import Game
-from .basics.camera import Camera
-from .basics.shapes import Rect, Text
-from .basics.player import Player, Animation
-from .tilemap.tilemap import Tilemap
-from .inputs.BasicInput import Input
-from .sound.BasicSound import Sound
-from .basics.Functions import State_conditions
-from .entities.basicTypes import Static_enemy, Dynamic_enemy
+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
 
 
 __all__ = [
     "Game",
-    "Camera",
+    "Cammera",
     "Rect",
     "Player",
-    "Tilemap",
-    "Input",
-    "Sound",
-    "Text",
-    "Animation",
-    "State_conditions",
-    "Static_enemy",
-    "Dynamic_enemy",
+    "clamp",
+    "moveTward",
+    "zeroOut"
 ]
 

GameBox/_game.py

@@ -0,0 +1,38 @@
+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.
+
+        ParameArters:
+        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 = []
+
+    def update(self, frame_rate=60):
+        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()
+        pygame.display.update()

GameBox/basics/_net.py

@@ -0,0 +1,29 @@
+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
+        #-collisions
+        self.collisions: list[pygame.Rect] = []
+
+        #objects
+        self.player = self._player()
+
+    class _player:
+        def __init__(self):
+            self.pos: tuple = None
+
+
+
+Global = _global_()

GameBox/basics/_shapes.py

@@ -0,0 +1,23 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+
+class Rect:
+    def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), collision: bool = True):
+        self.x, self.y = pos
+        self.width, self.height = size
+        self.color = color
+        Global.game.objs.append(self)
+        self.collision = collision
+
+    def update(self):
+        rect = pygame.Rect(self.x - Global.cam.x
+                           , self.y - Global.cam.y
+                           , self.width, self.height)
+        if self.collision: Global.collisions.append(rect)
+        pygame.draw.rect(Global.screen, self.color, rect)
+
+    def move(self, x, y):
+        self.x += x
+        self.y += y

GameBox/basics/cammera.py

@@ -0,0 +1,30 @@
+import pygame
+import numpy as np
+
+from ._net import Global
+
+from ..basics.utils import moveTward
+
+class Cammera:
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        Global.game.objs.append(self)
+        Global.cam = self
+        self.follow = None
+        self.diff = (0, 0)
+
+    def move(self, x, y):
+        self.x += x
+        self.y += y
+
+    def update(self):
+        return
+        if self.follow is not None:
+            self.x = (self.follow.x - self.diff[0])
+            self.y = (self.follow.y - self.diff[1])
+
+    def set_follow_target(self, target: object):
+        self.follow = target
+        print(target)
+        self.diff = (target.x - self.x, target.y - self.y)

GameBox/basics/utils.py

@@ -0,0 +1,17 @@
+import pygame
+import math
+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
+    elif value > target:
+        value -= speed
+    return value
+
+def zeroOut(value, max):
+    if value < 0 and value > -max: value = 0
+    if value > 0 and value < max: value = 0
+    return value

GameBox/player/_player.py

@@ -0,0 +1,35 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+
+from ..player._playerPhysics import _playerPhysics
+
+class Player:
+    def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), gravity: bool = False):
+        self.x, self.y = pos
+        self.screenPos = pos
+        self.dim = size
+        self.color = color
+
+        self.gravity = gravity
+        
+        Global.game.objs.append(self)
+        Global.player.pos = pos
+
+
+    def add_physics(self, speed: float = 1.0, gravity: float = 0.0, jump: float = 10.0, maxV: float = 10.0, airRes: float = 0.2):
+        self.physics = _playerPhysics(self, speed, gravity, jump, maxV, airRes)
+
+    def update(self):
+        self.physics.update()
+        #debug rect
+        rect = pygame.Rect(self.x, self.y, self.dim[0], self.dim[1])
+        pygame.draw.rect(Global.screen, "green", rect)
+
+    #movement
+    def top_down_movement(self):
+        self.physics.top_down_movement()
+
+    def platforming_movement(self):
+        self.physics.platforming_movement()

GameBox/player/_playerControler.py

@@ -0,0 +1,54 @@
+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
+

GameBox/player/_playerPhysics.py

@@ -0,0 +1,105 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+from ..basics.utils import clamp, moveTward, 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):
+        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.maxV = maxV
+        self.airRes = airRes
+        self.onGround = False
+        self.canJump = False
+
+        self.vx, self.vy = 0, 0
+
+    def update(self):
+        self.ckeck_is_on_ground()
+        self.fixVelocities()
+        x, y = self.check_collisions()
+        if type(Global.cam.follow) != type(self.player):
+            self.player.x = x
+            self.player.y = y
+        elif type(Global.cam.follow) == type(self.player):
+            dx = -(self.player.x - x)
+            dy = -(self.player.y - y)
+            Global.cam.move(self.vx, self.vy)
+            
+
+
+    def check_collisions(self):
+        x, y = self.player.x + self.vx, self.player.y + self.vy
+
+        # X-axis collisions
+        new_rect = pygame.Rect((x, self.player.y), self.player.dim)
+        for collision in Global.collisions:
+            if collision.colliderect(new_rect):
+                if self.vx > 0:
+                    x = collision.left - self.player.dim[0]
+                elif self.vx < 0:
+                    x = collision.right
+                self.vx = 0
+
+        # Y-axis collisions
+        new_rect = pygame.Rect((x, y), self.player.dim)
+        for collision in Global.collisions:
+            if collision.colliderect(new_rect):
+                if self.vy > 0:  # falling
+                    y = collision.top - self.player.dim[1]
+                    self.vy = 0
+                elif self.vy < 0:  # jumping
+                    y = collision.bottom
+                    self.vy = 0
+
+        return x, y
+    
+    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

gamebox-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: GameBox
+Version: 0.1.0
+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 is a lightweight 2D game framework built on pygame.
+This is an early technical preview of a full engine rewrite.
+APIs may change frequently.
+
+Versioning
+GameBox follows a modified semantic versioning scheme.
+Versions starting with 0.x.x are experimental and may change without notice.
+Stable, marketed releases will begin at 1.0.0.

gamebox-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+GameBox/__init__.py,sha256=ZGp_MWKpBN5yyxOqNg2XamrccMDJtsg9eLoejEYe72E,625
+GameBox/_game.py,sha256=CB8GzTAheE-UvF4-emRsKZm3kmSC-gkpSn46K8D6Vqc,1222
+GameBox/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameBox/basics/_net.py,sha256=Mdxa8-V3Xm0Gvhb-2lkGj3DfhM0MnREI_nLsccR14xc,658
+GameBox/basics/_shapes.py,sha256=zlRxwSakcKgrtIM75hnfnmlks6rQdxP2Ie9U4s4imCk,730
+GameBox/basics/cammera.py,sha256=r5veuC6T3PUHM_9O-d-kjsNEDQv0k5-8_AKke2XGn0E,728
+GameBox/basics/utils.py,sha256=w6H34MhxcNoX58iQtlvbT5-4GXefy3RIMTxZGP9fSxA,432
+GameBox/player/_player.py,sha256=A1a281ToYM_kbMMaTZT3OLFXPDpqZpnAfMNd4WxwWfI,1066
+GameBox/player/_playerControler.py,sha256=XEb87RFlgLFoXnXqxIS4lpzHN0wywMNCX5y-NIhw0cs,1715
+GameBox/player/_playerPhysics.py,sha256=1DWjWk8J4eH5YpGCTHaJQVHOWExjJdPZArJVNKrfliA,3685
+gamebox-0.1.0.dist-info/METADATA,sha256=DnUktpoPqNzEJ6Ru0dceEy3xUSHjJ0dNNsvsNvFzTis,1015
+gamebox-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gamebox-0.1.0.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
+gamebox-0.1.0.dist-info/RECORD,,

{gamebox-0.0.5.dist-info → gamebox-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

GameBox/basics/Defaults.json

@@ -1,12 +0,0 @@
-{
-
-  "tilemap": {
-    "tile_size": 32,
-    "highlight_color": [0, 255, 0],
-    "collision_color": [255, 0, 0],
-    "grid_line_color": [100, 100, 100],
-    "layer_opacity": 0.8,
-    "snap_to_grid": true
-  }
- 
-}

GameBox/basics/Functions.py

@@ -1,43 +0,0 @@
-import pygame
-
-def DisplayText(text, color, size, pos, screen):
-    font = pygame.font.Font(None, size)
-    textSurf = font.render(text, False, color)
-    screen.blit(textSurf, pos)
-
-def getTilePosInGrid(pos,  grid_size):
-    x, y = pos
-    return (x // grid_size, y // grid_size)
-
-class IsWithinBounds:
-    def __init__(self, dim, offset):
-        self.offset = offset
-        self.dim = dim
-
-    def checkPos(self, pos):
-        x, y = pos
-        w, h = self.dim
-        w+=self.offset
-        h+=self.offset
-        if x > w or y > h:
-            return False
-        w=-self.offset
-        h=-self.offset
-        if x < w or y < h:
-            return False
-        return True
-
-class State_conditions:
-    def __init__(self):
-        self.top = "C^"
-        self.bottom = "C_"
-        self.left = "C<"
-        self.right = "C>"
-        self.any = "C#"
-        self.none = "CN"
-        self.move_up = "M^"
-        self.move_down = "M_"
-        self.move_left = "m<"
-        self.move_right = "M>"
-        self.move_any = "M#"
-        self.move_none = "MN"

GameBox/basics/_core.py

@@ -1,41 +0,0 @@
-import json
-import os
-
-class _GLOBALNETWORK:
-    def __init__(self):
-        self.collisions = []
-        self.playerPosition = None
-        self.BaseInfo = {}
-        self.screen  = None
-
-class _CONFIG:
-    def __init__(self, path="Defaults.json"):
-        self.data = {}
-        self.load(path)
-
-    def load(self, path):
-        """Load JSON data with fallback defaults."""
-        if not os.path.exists(path):
-            print("[GameBox] No Default.json found — using override settings.")
-            return
-        
-        with open(path, "r") as f:
-            try:
-                self.data = json.load(f)
-                print("[GameBox] Config loaded successfully.")
-            except json.JSONDecodeError:
-                print("[GameBox] Error: Invalid JSON format.")
-
-    def get(self, *keys, default=None):
-        """Nested key access: config.get('player', 'speed')"""
-        ref = self.data
-        for key in keys:
-            if isinstance(ref, dict) and key in ref:
-                ref = ref[key]
-            else:
-                return default
-        return ref
-
-
-
-GLOBAL = _GLOBALNETWORK()

GameBox/basics/camera.py

@@ -1,14 +0,0 @@
-import pygame
-
-class Camera:
-    def __init__(self, width, height, type = "dynamic"):
-        """Camera type can be fixed or dynamic depending on your needs. Defaults to dynamic."""
-        self.type = type
-        self.dim = width, height
-        self.pos = 0, 0
-
-    def move(self, x, y):
-        X, Y = self.pos
-        X+=x
-        Y+=y
-        self.pos = X, Y