GameBox 0.0.6__tar.gz → 0.1.1__tar.gz

gamebox-0.1.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: GameBox
+Version: 0.1.1
+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.1/README.md

@@ -0,0 +1,8 @@
+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.0.6 → gamebox-0.1.1}/pyproject.toml

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

gamebox-0.1.1/src/GameBox/__init__.py

@@ -0,0 +1,28 @@
+"""
+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.0.3"
+__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
+
+
+__all__ = [
+    "Game",
+    "Cammera",
+    "Rect",
+    "Player",
+    "clamp",
+    "moveTward",
+    "zeroOut"
+]
+

gamebox-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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-0.1.1/src/GameBox/player/_playerPhysics.py

@@ -0,0 +1,104 @@
+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()
+        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.1/tests/basicScreen.py

@@ -0,0 +1,31 @@
+from src.GameBox import *
+import pygame
+
+width, height = 1400, 800
+game = Game(width, height, (124, 204, 201))
+
+cam = Cammera()
+
+player = Player((width / 2, 500), (50, 50), (0, 255, 0), True)
+
+player.add_physics(1.0, 3.0, 16, 7.0, 0.5)
+
+rect = Rect((0, 700), (width*20, 100), (255, 0, 0), True)
+      
+cam.set_follow_target(player)
+
+running = True
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    player.platforming_movement()
+
+    game.update()
+    
+
+
+pygame.quit()
+quit()

gamebox-0.0.6/PKG-INFO

@@ -1,40 +0,0 @@
-Metadata-Version: 2.4
-Name: GameBox
-Version: 0.0.6
-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 🎮  
-*A beginner-friendly game framework built on top of pygame.*  
-
-## Overview  
-GameBox is a Python package designed to make **2D game design simple, fast, and fun**.  
-It extends **pygame** with pre-built modules, utilities, and helpers that allow beginners to build advanced-looking games without needing to write tons of boilerplate code.  
-
-Whether you’re just starting out or you’re an experienced developer who wants to prototype quickly, GameBox has you covered.  
-
-👉 **Docs & Examples:** [GameBox Documentation](https://sites.google.com/view/pythonpackagegamebox/)  
-
----
-
-## Features ✨  
-- Built on top of **pygame** for reliability and performance  
-- Easy-to-use modules for sprites, input handling, collisions, animations, and more  
-- Reduces boilerplate: get a game loop running in just a few lines  
-- Beginner-friendly design with advanced flexibility  
-- Helps you focus on *gameplay* instead of low-level setup  
-
----
-
-## Installation  
-GameBox requires Python 3.8+ and pygame.  
-You can install it using pip:  
-
-```bash
-pip install GameBox

gamebox-0.0.6/README.md

@@ -1,28 +0,0 @@
-# GameBox 🎮  
-*A beginner-friendly game framework built on top of pygame.*  
-
-## Overview  
-GameBox is a Python package designed to make **2D game design simple, fast, and fun**.  
-It extends **pygame** with pre-built modules, utilities, and helpers that allow beginners to build advanced-looking games without needing to write tons of boilerplate code.  
-
-Whether you’re just starting out or you’re an experienced developer who wants to prototype quickly, GameBox has you covered.  
-
-👉 **Docs & Examples:** [GameBox Documentation](https://sites.google.com/view/pythonpackagegamebox/)  
-
----
-
-## Features ✨  
-- Built on top of **pygame** for reliability and performance  
-- Easy-to-use modules for sprites, input handling, collisions, animations, and more  
-- Reduces boilerplate: get a game loop running in just a few lines  
-- Beginner-friendly design with advanced flexibility  
-- Helps you focus on *gameplay* instead of low-level setup  
-
----
-
-## Installation  
-GameBox requires Python 3.8+ and pygame.  
-You can install it using pip:  
-
-```bash
-pip install GameBox

gamebox-0.0.6/src/GameBox/__init__.py

@@ -1,37 +0,0 @@
-"""
-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.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
-
-
-__all__ = [
-    "Game",
-    "Camera",
-    "Rect",
-    "Player",
-    "Tilemap",
-    "Input",
-    "Sound",
-    "Text",
-    "Animation",
-    "State_conditions",
-    "Static_enemy",
-    "Dynamic_enemy",
-]
-

gamebox-0.0.6/src/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-0.0.6/src/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-0.0.6/src/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-0.0.6/src/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