GameBox 0.2.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

GameBox/GameLevel_ui/_Animations.py

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

@@ -0,0 +1,243 @@
+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:
+    """
+    A class for animated 2D sprites.
+
+    Args:
+        pos (tuple): The position of the sprite in world space.
+        image (str or pygame.Surface): The image of the sprite.
+        imageDim (tuple): The dimensions of the image.
+        tileDim (tuple): The dimensions of the tiles in the image.
+        frames (int): The number of frames in the animation.
+        speed (float): The speed of the animation.
+        scale (float): The scale of the sprite.
+        collision (bool): Whether the sprite has collision.
+        dirrection (int): The direction of the sprite.
+
+    Attributes:
+        animation (Animation): The animation of the sprite.
+        collision (bool): Whether the sprite has collision.
+        dir (int): The direction of the sprite.
+        pos (tuple): The position of the sprite in world space.
+        scale (float): The scale of the sprite.
+        image (pygame.Surface): The current frame of the animation.
+        __worldPos__ (bool): Whether the sprite is in world space.
+
+    Methods:
+        update (None): Updates the sprite.
+        __remove__ (None): Removes the sprite from the game.
+        switch_dirrection (None): Switches the direction of the sprite.
+        move_by (x, y): Moves the sprite by (x, y) in world space.
+        move_to (x, y): Moves the sprite to (x, y) in world space.
+        get_pos (None): Returns the position of the sprite in world space.
+        rescale (scale): Rescales the sprite by the given scale.
+    """
+
+    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:
+    """
+    Class for playing animations in a 2D game.
+
+    Attributes:
+        pos (tuple): Position of the AnimationPlayer2D.
+        scale (float): Scale of the AnimationPlayer2D.
+        anims (dict): Dictionary of animations that can be played, where the key is the name of the animation and the value is an instance of Animated_Sprite2D.
+        currentAnim (str): The name of the currently playing animation.
+
+    Methods:
+        update (None): Updates the currently playing animation.
+        add_animation (name, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = True, dirrection = 1): Adds an animation to the AnimationPlayer2D.
+        remove_animation (name: str): Removes an animation from the AnimationPlayer2D.
+        set_worldPos (worldPos: bool): Sets the world position of all animations in the AnimationPlayer2D.
+        __remove__ (None): Removes the AnimationPlayer2D from the game.
+        set_scale (scale: float): Sets the scale of all animations in the AnimationPlayer2D.
+        set_animation (anim: str): Sets the currently playing animation.
+        move_by (x, y): Moves the AnimationPlayer2D by (x, y) in world space.
+        move_to (x, y): Moves the AnimationPlayer2D to (x, y) in world space.
+        get_pos (None): Returns the position of the AnimationPlayer2D in world space.
+    """
+    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/__init__.py

@@ -5,7 +5,7 @@ GameBox makes it easy to build 2D games with graphics, sound, and UI in just a f
 """
 
 
-__version__ = "0.1.3"
+__version__ = "0.3.0"
 __author__ = "Sam Fertig"
 
 #____imports____
@@ -16,6 +16,10 @@ 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
 
 
 __all__ = [
@@ -28,5 +32,11 @@ __all__ = [
     "zeroOut",
     "TileMap",
     "Keys",
+    "Image",
+    "Sprite_2d",
+    "Animated_Sprite2D",
+    "AnimationPlayer2D",
+    "split_image",
+    "Conditions",
 ]
 

GameBox/_game.py

@@ -26,6 +26,7 @@ class Game:
         Global.clock = pygame.time.Clock()
         Global.game = self
         self.objs = []
+        self.ui_objs = []
 
 
     def update(self, event: pygame.event,frame_rate=60):
@@ -40,6 +41,11 @@ class Game:
             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):

GameBox/basics/_net.py

@@ -18,6 +18,8 @@ class _global_:
         #-collisions
         self.collisions: list[pygame.Rect] = []
 
+        self.cond: object = None
+
         #objects
         self.player = self._player()
         self.tilemap = []

GameBox/basics/_shapes.py

@@ -4,7 +4,26 @@ import numpy as np
 from ..basics._net import Global
 
 class Rect:
+    """
+    A rectangle shape used for rendering and collision detection.
+
+    Args:
+        pos (tuple): The position of the rectangle.
+        size (tuple): The size of the rectangle.
+        color (tuple, optional): The color of the rectangle. Defaults to (0,0,0).
+        collision (bool, optional): Whether the rectangle should be used for collision detection. Defaults to True.
+    """
+
     def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), collision: bool = True):
+        """
+        Initialize the rectangle object.
+
+        Args:
+            pos (tuple): The position of the rectangle.
+            size (tuple): The size of the rectangle.
+            color (tuple, optional): The color of the rectangle. Defaults to (0,0,0).
+            collision (bool, optional): Whether the rectangle should be used for collision detection. Defaults to True.
+        """
         self.x, self.y = pos
         self.width, self.height = size
         self.color = color
@@ -12,6 +31,12 @@ class Rect:
         self.collision = collision
 
     def update(self):
+        """
+        Update the rectangle object.
+
+        This method updates the position and size of the rectangle based on the camera's position and scale.
+        It then renders the rectangle to the screen and adds it to the collision detection list if necessary.
+        """
         width = self.width * Global.cam.scale
         height = self.height * Global.cam.scale
         if (Global.cam.follow) != (self):
@@ -21,13 +46,43 @@ class Rect:
             x = self.x
             y = self.y
 
-        rect = pygame.Rect(x, y, width ,height)
+        rect = pygame.Rect(x, y, width, height)
         if self.collision: Global.collisions.append(rect)
         pygame.draw.rect(Global.screen, self.color, rect)
 
     def move(self, x, y):
+        """
+        Move the rectangle object.
+
+        Args:
+            x (int): The x-coordinate to move the rectangle by.
+            y (int): The y-coordinate to move the rectangle by.
+        """
         if (Global.cam.follow) != (self):
             self.x += x
             self.y += y
         else:
-            Global.cam.move(x, y)
+            Global.cam._move(x, y)
+            
+    def move_to(self, x, y):
+        """
+        Move the rectangle object to a specific position.
+
+        Args:
+            x (int): The x-coordinate to move the rectangle to.
+            y (int): The y-coordinate to move the rectangle to.
+        """
+        if (Global.cam.follow) != (self):
+            self.x = x
+            self.y = y
+        else:
+            Global.cam.x = x
+            Global.cam.y = y
+
+    def __remove__(self):
+        """
+        Remove the rectangle object from the game.
+
+        This method removes the rectangle object from the game's object list.
+        """
+        Global.game.objs.remove(self)

GameBox/basics/cammera.py

@@ -6,7 +6,17 @@ from ._net import Global
 from ..basics.utils import moveTward
 
 class Cammera:
+    """
+    A class for the camera object.
+    """
+
     def __init__(self, scale: float = 1.0):
+        """
+        Initialize the camera object.
+
+        Args:
+            scale (float): The scale of the camera (default: 1.0)
+        """
         self.x = 0
         self.y = 0
         Global.game.objs.append(self)
@@ -15,22 +25,51 @@ class Cammera:
         self.diff = (0, 0)
         self.scale = scale
 
-    def move(self, x, y):
+    def _move(self, x: int, y: int):
+        """
+        Move the camera by (x, y).
+
+        Args:
+            x (int): The x component of the movement
+            y (int): The y component of the movement
+        """
         self.x += x
         self.y += y
 
     def update(self):
+        """
+        Update the camera position based on the follow target.
+        """
         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):
+        """
+        Set the follow target for the camera.
+
+        Args:
+            target (object): The object to follow
+        """
         self.follow = target
         print(target)
         self.diff = (target.x - self.x, target.y - self.y)
 
     def set_scale(self, scale: float = 1.0):
+        """
+        Set the scale of the camera.
+
+        Args:
+            scale (float): The scale of the camera (default: 1.0)
+        """
         self.scale = scale
+
     def change_scale(self, scale: float = 1.0):
+        """
+        Change the scale of the camera by the given amount.
+
+        Args:
+            scale (float): The amount to change the scale by (default: 1.0)
+        """
         self.scale += scale

GameBox/helpers/_Conditions.py

@@ -0,0 +1,65 @@
+import pygame
+import numpy as np
+
+from ..basics.utils import zeroOut
+from ..basics._net import Global
+
+class _Conditions:
+    """
+    Class containing the predefined conditions for the game.
+    Conditions are in the format of 'C' followed by the command ('v' for velocity), and dir (^ up, _ down, < left, > right, # none, ~ any)
+    """
+
+    def __init__(self):
+        """
+        Initialize the conditions.
+        """
+        # conditions start with 'C' and then command ('v' for velocity), and dir (^ up, _ down, < left, > right, # none, ~ any)
+        self.velocity_up = 'CV^'  # velocity up
+        self.velocity_down = 'CV_'  # velocity down
+        self.velocity_left = 'CV<'  # velocity left
+        self.velocity_right = 'CV>'  # velocity right
+        self.velocity_none = 'CV#'  # velocity none
+        self.velocity_any = 'CV~'  # velocity any
+
+Conditions = _Conditions()
+Global.cond = Conditions
+
+class Condition_check:
+    def __init__(self, stateTree: dict[str, dict[_Conditions, str]], currentState: str):
+        self.stateTree = stateTree
+        self.currentState = currentState
+        
+    def check(self, velocity: tuple, pos: tuple):
+        state = self.stateTree[self.currentState]
+        for cond, next in state.items():
+            #velocities
+            if cond[1] == 'V':
+                if self._resolve_velocities(velocity, cond):
+                    self.currentState = next
+                    return next
+        return self.currentState
+                
+
+    def _resolve_velocities(self, velocities, cond):
+        vx, vy = velocities
+        Max = 0.3
+        vx = zeroOut(vx, Max)
+        vy = zeroOut(vy, Max)
+        dir = cond[2]
+        print(vx, vy, dir)
+        #resolve in order up, down, left, right, none, any
+        if dir == "^" and vy < 0: return True
+        if dir == "_" and vy > 0: return True
+        if dir == "<" and vx < 0: return True
+        if dir == ">" and vx > 0: return True
+        if dir == "#" and vx == 0 and vy == 0: return True
+        if dir == "~" and (vx != 0 or vy != 0): return True
+        return False
+
+    def updateState(self, state: str):
+        self.currentState = state
+    def updateStateTree(self, stateTree: dict[str, dict[_Conditions, str]]):
+        self.stateTree = stateTree
+            
+

GameBox/helpers/_collisions.py

@@ -7,7 +7,6 @@ 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)
@@ -15,20 +14,12 @@ def CheckCollisions(x, y, vx, vy, dim, sample, obj):
         return x, y, vx, vy
     
 def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
-    new_rect = pygame.Rect((x, y), dim)
-    for collision in collisions:
-        #pygame.draw.rect(Global.screen, (255, 0, 0), collision, 1)
-        if collision.colliderect(new_rect):
-            if vx > 0:
-                x = collision.left - dim[0]
-            elif vx < 0:
-                x = collision.right
-            vx = 0
-
     # Y-axis collisions
+    py = y
     new_rect = pygame.Rect((x, y), dim)
+    pygame.draw.rect(Global.screen, "green", new_rect, 5)
     for collision in collisions:
-        #pygame.draw.rect(Global.screen, (255, 0, 0), collision, 1)
+        pygame.draw.rect(Global.screen, "yellow", collision, 5)
         if collision.colliderect(new_rect):
             if vy > 0:  # falling
                 y = collision.top - dim[1]
@@ -36,6 +27,16 @@ def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
             elif vy < 0:  # jumping
                 y = collision.bottom
                 vy = 0
+                
+    new_rect = pygame.Rect((x, py), dim)
+    for collision in collisions:
+        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
     

GameBox/helpers/_input.py

@@ -4,6 +4,9 @@ from ..basics._net import Global
 
 
 class _keys:
+    """
+    A class that holds all the key bindings for the game
+    """
     def __init__(self):
 
         #alphabet
@@ -61,6 +64,7 @@ class _keys:
 
         #mouse
         self.mouse_x, self.mouse_y = 0, 0
+
     def init(self): Global.game.objs.append(self)
 
     def is_pressed(self, key): 

GameBox/player/_player.py

@@ -4,37 +4,61 @@ import numpy as np
 from ..basics._net import Global
 
 from ..player._playerPhysics import _playerPhysics
+from ..player._playerSprite import _playerSprite
+
+from ..GameLevel_ui._sprites import Sprite_2d
 
 class Player:
+    """
+    Initialize a Player object.
+
+    Parameters:
+    pos (tuple): The position of the Player in world space.
+    size (tuple): The size of the Player in world space.
+    color (tuple): The color of the Player (default: (0, 0, 0)).
+    gravity (bool): Whether the Player is affected by gravity (default: False).
+
+    Returns:
+    None
+    """
     def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), gravity: bool = False):
+        # Set the position and size of the Player
         self.x, self.y = pos
         self.screenPos = pos
         self.dim = size
         self.color = color
+        self.width, self.height = size
 
+        # Set whether the Player is affected by gravity
         self.gravity = gravity
-        
+
+        # State of the Player (e.g. "jumping", "standing", etc.)
+        self.state = ""
+
+        # Add the Player to the game
         Global.game.objs.append(self)
         Global.player.pos = pos
         Global.player.player = self
 
+        # Initialize the sprite for the Player
+        self.sprite = _playerSprite(self)
+
 
     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
-        width = self.dim[0] * Global.cam.scale
-        height = self.dim[1] * Global.cam.scale
+        #ui
+
         if (Global.cam.follow) != (self):
             x = self.x - Global.cam.x
             y = self.y - Global.cam.y
         elif (Global.cam.follow) == (self):
             x = self.x
             y = self.y
-        rect = pygame.Rect(x, y, width, height)
-        pygame.draw.rect(Global.screen, self.color, rect)
+        velocity = (self.physics.vx, self.physics.vy)
+        self.sprite.update(x, y, velocity)
 
     #movement
     def top_down_movement(self):
@@ -50,3 +74,5 @@ class Player:
         The larger the sample size the longer it may take to calculate collisions per frame.
         """
         self.physics.sample = sample
+
+

GameBox/player/_playerPhysics.py

@@ -19,7 +19,7 @@ class _playerPhysics:
         self.onGround = False
         self.canJump = False
 
-        self.sample = 10
+        self.sample = 25
 
         self.vx, self.vy = 0, 0
 
@@ -34,7 +34,7 @@ class _playerPhysics:
         elif (Global.cam.follow) == (self.player):
             dx = -(self.player.x - x)
             dy = -(self.player.y - y)
-            Global.cam.move(self.vx, self.vy)
+            Global.cam._move(self.vx, self.vy)
 
 
 

GameBox/player/_playerSprite.py

@@ -0,0 +1,86 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+
+from ..GameLevel_ui._sprites import Sprite_2d, Animated_Sprite2D, AnimationPlayer2D
+from ..helpers._Conditions import Condition_check, _Conditions
+
+class _playerSprite:
+    def __init__(self, player):
+        self.player = player
+
+        self.state = player.state
+        self.statetree = {}
+        self.condition_check = None
+
+        self.sprite = None
+        
+
+    def update(self, x, y, velocity):
+        #state updates
+        if self.condition_check is not None:
+            self.state = self.condition_check.check(velocity, self.player.screenPos)
+            #set animation if possible
+            if type(self.sprite) == AnimationPlayer2D:
+                if self.state in self.sprite.anims:
+                    self.sprite.set_animation(self.state)
+        #any changes to follow target
+        if Global.cam.follow == self.player and self.sprite is not None:
+            self.sprite.__worldPos__ = False
+            self.sprite.move_to(self.player.screenPos[0], self.player.screenPos[1])
+        elif Global.cam.follow != self.player and self.sprite is not None:
+            self.sprite.__worldPos__ = True
+            self.sprite.move_to(self.player.x, self.player.y)
+        
+        if self.sprite is None:
+            #rect (x, y) is top left corner
+            rect = pygame.Rect((x, y), self.player.dim)
+            pygame.draw.rect(Global.screen, self.player.color, rect)
+        if type(self.sprite) == Sprite_2d:
+            self.sprite.update()
+        elif type(self.sprite) == Animated_Sprite2D:
+            self.sprite.update()
+        elif type(self.sprite) == AnimationPlayer2D:
+            self.sprite.update()
+
+    def add_sprite_2d(self, image, scale=1.0, dirrection=1):
+        self.sprite = Sprite_2d((self.player.x, self.player.y), image, scale, False, dirrection)
+        if Global.cam.follow == self.player:
+            self.sprite.__worldPos__ = False
+        self.sprite.__remove__()
+
+    def add_animated_sprite_2d(self, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = False, dirrection = 1):
+        self.sprite = Animated_Sprite2D((self.player.x, self.player.y), image, imageDim, tileDim, frames, speed, scale, collision, dirrection)
+        if Global.cam.follow == self.player:
+            self.sprite.__worldPos__ = False
+        self.sprite.__remove__()
+
+    def remove_sprite(self):
+        if self.sprite is not None:
+            self.sprite = None
+
+    def add_animation_player(self, scale = 1.0):
+        self.sprite = AnimationPlayer2D((self.player.x, self.player.y), scale)
+        if Global.cam.follow == self.player:
+            self.sprite.set_worldPos(False)
+        self.sprite.__remove__()
+
+    def add_animation(self, name, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = True, dirrection = 1):
+        self.sprite.add_animation(name, image, imageDim, tileDim, frames, speed, scale, collision, dirrection)
+        self.sprite.__remove__()
+        self.sprite.set_worldPos(False)
+
+    def remove_animation(self, name: str):
+        self.sprite.remove_animation(name)
+
+    def set_animation(self, anim: str):
+        self.sprite.set_animation(anim)
+
+    def set_states(self, stateTree: dict[str, dict[_Conditions, str]], currentState: str):
+        self.statetree = stateTree
+        self.state = currentState
+        self.condition_check = Condition_check(self.statetree, self.state)
+        
+
+

GameBox/tilemap/_Editor.py

@@ -3,6 +3,9 @@ import numpy as np
 
 from..helpers._input import Keys
 from ..basics._net import Global
+from ._collisionDef import _tileCollisionDefs
+
+from._editorBrushes import _brushPencil, _collisionsPencil
 
 class _tilemapEditor:
     def __init__(self, tilemap, activation):
@@ -10,92 +13,24 @@ class _tilemapEditor:
         self.activation = activation
         self.active = False
 
-        self.selectedTile = 1
-        self.mx, self.my = Keys.mouse_x, Keys.mouse_y
+        self.mode = _brushPencil()
 
-        self.mode = "paint"
+        self.changes = {
+            "pencil": Keys.b,
+            "collisions": Keys.c
+            
+        }
 
     def _update(self):
         if  self.active:
-            #update mouse pos
-            self.mx, self.my = Keys.mouse_x, Keys.mouse_y
-            self.mx += Global.cam.x
-            self.my += Global.cam.y
-            self.mx = self.mx // self.tilemap.tileDim[0] * self.tilemap.tileDim[0]
-            self.my = self.my // self.tilemap.tileDim[1] * self.tilemap.tileDim[1]
-
-            self._mode_()
-            self.moveSelectionByArrowKeys()
-            self.ui()
-
+            self.change_mode()
+            #editor stuff
+            self.mode.update(self.tilemap)
         #toggle
         if Keys.is_pressed(self.activation): self.active = not self.active
 
-    def _mode_(self):
-        x, y = Keys.mouse_x, Keys.mouse_y
-        if x > self.tilemap.tileset.get_size()[0] * self.tilemap.tilescale / 2 or y > self.tilemap.tileset.get_size()[1] * self.tilemap.tilescale / 2:
-            self.mode = "paint"
-            #more parrimeters will be placed as needed
-        else:
-            self.mode = "select"
-
-    def ui(self):
-        tile = self.tilemap.tiles[self.selectedTile]
-        image = pygame.transform.scale_by(self.tilemap.tileset, self.tilemap.tilescale / 2)
-        Global.screen.blit(image, (0, 0))
-        #show outlined sellected tile
-        x, y = self.tilemap.tilePosInImage[self.selectedTile]
-        x *= self.tilemap.tilescale / 2
-        y *= self.tilemap.tilescale / 2
-        width = self.tilemap.orginDim[0] * self.tilemap.tilescale / 2
-        height = self.tilemap.orginDim[1] * self.tilemap.tilescale / 2
-        outline = pygame.Rect(x, y, width, height)
-        pygame.draw.rect(Global.screen, "white", outline, 2)
-        #other stuff
-        if self.mode == "paint":
-            #show selected tile
-            #--outline on tileset
-            #--show beside mouse
-            x = self.mx
-            y = self.my
-
-            x -= Global.cam.x
-            y -= Global.cam.y
-            Global.screen.blit(tile, (x, y))
-            if pygame.mouse.get_pressed()[0]:
-                #check if mouse is on tilemap
-                x, y = self.mx // self.tilemap.tileDim[0], self.my // self.tilemap.tileDim[1]
-                if x >= 0 and x < self.tilemap.mapDim[0] and y >= 0 and y < self.tilemap.mapDim[1]:
-                    self.tilemap.map[int(y)][int(x)] = self.selectedTile
-            if pygame.mouse.get_pressed()[2]:
-                x, y = self.mx // self.tilemap.tileDim[0], self.my // self.tilemap.tileDim[1]
-                if x >= 0 and x < self.tilemap.mapDim[0] and y >= 0 and y < self.tilemap.mapDim[1]:
-                    self.tilemap.map[int(y)][int(x)] = 0
-        elif self.mode == "select":
-            #paint mouse hovered tile
-            x, y = Keys.mouse_x, Keys.mouse_y
-            x = (x // width)
-            y = (y // height)
-            outline = pygame.Rect(x * width, y * width, width, height)
-            pygame.draw.rect(Global.screen, "black", outline, 2)
-            if pygame.mouse.get_pressed()[0]:
-                x *= self.tilemap.orginDim[0]
-                y *= self.tilemap.orginDim[1]
-                self.selectedTile = self.tilemap.posToTile[(int(x), int(y))]
-            
-
-    def moveSelectionByArrowKeys(self):
-        x, y = self.tilemap.tilePosInImage[self.selectedTile]
-
-        width = 16
-        height = 16
-
-        if Keys.is_pressed(Keys.left): x -= width
-        if Keys.is_pressed(Keys.right): x += width
-        if Keys.is_pressed(Keys.up): y -= height
-        if Keys.is_pressed(Keys.down): y += height
-
-        if (int(x), int(y)) in self.tilemap.posToTile:
-            self.selectedTile = self.tilemap.posToTile[(int(x), int(y))]
-
-
+    def change_mode(self):
+        #key presses
+        if Keys.is_pressed(self.changes["pencil"]): self.mode = _brushPencil()
+        elif Keys.is_pressed(self.changes["collisions"]): self.mode = _collisionsPencil(self.tilemap)
+    

GameBox/tilemap/_collisionDef.py

@@ -3,6 +3,13 @@ import pygame
 class _tileCollisionDefs:
     def __init__(self, tileDim):
         width, height = tileDim
+
+
+        self.rects = ["full", "none", "halfLeft", "halfRight", "halfTop", "halfBottom", "topRight", 
+                      "topLeft", "bottomRight", "bottomLeft", "dot"]
+        
+        self.num = len(self.rects) + 1
+
         self.full = pygame.Rect(0, 0, width, height)
 
         self.halfLeft = pygame.Rect(0, 0, width / 2, height)

GameBox/tilemap/_editorBrushes.py

@@ -0,0 +1,166 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+from ..helpers._input import Keys
+from ._collisionDef import _tileCollisionDefs
+
+class _brushPencil():
+    def __init__(self):
+        self.selectedTile = 1
+        self.mode = "paint"
+
+    def update(self, tilemap):
+        #get all mouse calculations
+        x, y = Keys.mouse_x, Keys.mouse_y
+        x += Global.cam.x
+        y += Global.cam.y
+        mx = x // tilemap.tileDim[0] * tilemap.tileDim[0]
+        my = y // tilemap.tileDim[1] * tilemap.tileDim[1]
+
+        #get mode
+        x, y = Keys.mouse_x, Keys.mouse_y
+        if x > tilemap.tileset.get_size()[0] * tilemap.tilescale / 2 or y > tilemap.tileset.get_size()[1] * tilemap.tilescale / 2:
+            self.mode = "paint"
+        else:
+            self.mode = "select"
+
+        #--show tileset
+        tile = tilemap.tiles[self.selectedTile]
+        image = pygame.transform.scale_by(tilemap.tileset, tilemap.tilescale / 2)
+        Global.screen.blit(image, (0, 0))
+        #--show outlined sellected tile
+        x, y = tilemap.tilePosInImage[self.selectedTile]
+        x *= tilemap.tilescale / 2
+        y *= tilemap.tilescale / 2
+        width = tilemap.orginDim[0] * tilemap.tilescale / 2
+        height = tilemap.orginDim[1] * tilemap.tilescale / 2
+        outline = pygame.Rect(x, y, width, height)
+        pygame.draw.rect(Global.screen, "white", outline, 2)
+        #other stuff
+        if self.mode == "paint":
+            x = mx
+            y = my
+
+            x -= Global.cam.x
+            y -= Global.cam.y
+            Global.screen.blit(tile, (x, y))
+            #set tile or erase
+            if pygame.mouse.get_pressed()[0]:
+                #check if mouse is on tilemap
+                x, y = mx // tilemap.tileDim[0], my // tilemap.tileDim[1]
+                if x >= 0 and x < tilemap.mapDim[0] and y >= 0 and y < tilemap.mapDim[1]:
+                    tilemap.map[int(y)][int(x)] = self.selectedTile
+            elif pygame.mouse.get_pressed()[2]:
+                x, y = mx // tilemap.tileDim[0], my // tilemap.tileDim[1]
+                if x >= 0 and x < tilemap.mapDim[0] and y >= 0 and y < tilemap.mapDim[1]:
+                    tilemap.map[int(y)][int(x)] = 0
+        elif self.mode == "select":
+            #paint mouse hovered tile
+            x, y = Keys.mouse_x, Keys.mouse_y
+            x = (x // width)
+            y = (y // height)
+            outline = pygame.Rect(x * width, y * width, width, height)
+            pygame.draw.rect(Global.screen, "black", outline, 2)
+            if pygame.mouse.get_pressed()[0]:
+                x *= tilemap.orginDim[0]
+                y *= tilemap.orginDim[1]
+                self.selectedTile = tilemap.posToTile[(int(x), int(y))]
+
+        #move selection by arrow keys
+        x, y = tilemap.tilePosInImage[self.selectedTile]
+
+        width = 16
+        height = 16
+
+        if Keys.is_pressed(Keys.left): x -= width
+        if Keys.is_pressed(Keys.right): x += width
+        if Keys.is_pressed(Keys.up): y -= height
+        if Keys.is_pressed(Keys.down): y += height
+
+        if (int(x), int(y)) in tilemap.posToTile:
+            self.selectedTile = tilemap.posToTile[(int(x), int(y))]
+
+class _collisionsPencil():
+    def __init__(self, tilemap):
+        self.selectedTile = 0
+        self.shapes = tilemap.collisionShapes.num
+        self.mode = "paint"
+        size = tilemap.tilescale / 2
+        self.size = tilemap.orginDim[0] * size
+        self.coll = _tileCollisionDefs((tilemap.orginDim[0] * size, tilemap.orginDim[1] * size))
+
+    def update(self, tilemap):
+        x, y = Keys.mouse_x, Keys.mouse_y
+        #draw tilesets and background
+        Global.screen.fill("darkgrey")
+        image = pygame.transform.scale_by(tilemap.tileset, tilemap.tilescale / 2)
+        Global.screen.blit(image, (0, 0))
+        Global.screen.blit(image, (0, image.get_size()[1]+ 10))
+        #draw all collision rects on top tileset
+        for tile in range(tilemap.tilesetNum - 1):
+            tile+=1
+            if str(tile) not in tilemap.collisionDict: continue
+            rectshape = tilemap.collisionDict[str(tile)]
+            rect = getattr(self.coll, rectshape).copy()
+            tx, ty = tilemap.tilePosInImage[int(tile)]
+            tx = (tx // tilemap.orginDim[0]) * self.size
+            ty = (ty // tilemap.orginDim[1]) * self.size
+            rect.x += tx
+            rect.y += ty
+            pygame.draw.rect(Global.screen, "yellow", rect, 5)
+            outline = pygame.Rect(tx, ty, self.size, self.size)
+            pygame.draw.rect(Global.screen, "gray", outline, 2)
+        #change mode
+        if y > image.get_size()[1] * 2 + 50: self.mode = "select"
+        else: self.mode = "paint"
+        #draw collisions tiles at bottom
+        tx, ty = 0, image.get_size()[1] * 2 + 50
+        for tile in range(self.shapes-1):
+            rect = getattr(self.coll, tilemap.collisionShapes.rects[tile]).copy()
+            rect.x += tx
+            rect.y += ty
+            pygame.draw.rect(Global.screen, "yellow", rect, 5)
+            outline = pygame.Rect(tx, ty, self.size, self.size)
+            pygame.draw.rect(Global.screen, "gray", outline, 2)
+            tx += self.size + self.size / 2
+        #paint mode
+        if self.mode == "paint":
+            #draw tile around mouse
+            rect = getattr(self.coll, tilemap.collisionShapes.rects[self.selectedTile]).copy()
+            rect.x += x - self.size / 2
+            rect.y += y - self.size / 2
+            pygame.draw.rect(Global.screen, "yellow", rect, 5)
+            outline = pygame.Rect(x, y, self.size, self.size)
+            outline.center = (Keys.mouse_x, Keys.mouse_y)
+            pygame.draw.rect(Global.screen, "gray", outline, 2)
+            #paint collisions
+            size = tilemap.orginDim[0]
+            if pygame.mouse.get_pressed()[0]:
+                x = (x - (x % self.size)) // self.size
+                y = (y - (y % self.size)) // self.size
+                px = x * size
+                py = y * size
+                if (int(px), int(py)) in tilemap.posToTile:
+                    tilemap.collisionDict[str(tilemap.posToTile[(int(px), int(py))])] = self.coll.rects[self.selectedTile]
+            #erase collisions
+            if pygame.mouse.get_pressed()[2]:
+                x = (x - (x % self.size)) // self.size
+                y = (y - (y % self.size)) // self.size
+                px = x * size
+                py = y * size
+                if (int(px), int(py)) in tilemap.posToTile:
+                    tilemap.collisionDict[tilemap.posToTile[(int(px), int(py))]] = "none"
+
+        elif self.mode == "select":
+            #get tile at mouse
+            x = int(x // (self.size + self.size / 2))
+            #draw underline
+            underline = pygame.Rect((0, 0), (self.size, 5))
+            underline.center = (Keys.mouse_x, ty + self.size+5)
+            pygame.draw.rect(Global.screen, "black", underline)
+            #select tile
+            if pygame.mouse.get_pressed()[0] and x < self.shapes-1 and x >= 0:
+                self.selectedTile = int(x)
+                
+

GameBox/tilemap/_tilemap.py

@@ -9,6 +9,20 @@ from ._Editor import _tilemapEditor
 
 class TileMap:
     def __init__(self, tileSet: str, tileDim: tuple, tileScale: float, mapDim: tuple, mapFill: int, saveFile = None):
+        """
+        Constructor for TileMap object.
+
+        Args:
+            tileSet (str): filepath to tileset image
+            tileDim (tuple): dimensions of a single tile
+            tileScale (float): scale of tiles relative to tileset image
+            mapDim (tuple): dimensions of the map
+            mapFill (int): default tile id to fill map with
+            saveFile (str): filepath to save map to (default is None)
+
+        Returns:
+            None
+        """
         self.tilesetFile = tileSet
         self.mapFile = saveFile
         self.tileDim = (tileDim[0] * tileScale, tileDim[1] * tileScale)
@@ -17,6 +31,8 @@ class TileMap:
         self.tilescale = tileScale
         self.orginDim = tileDim
 
+        self.tilesetNum = 0
+
         self.editor = None
 
         Global.game.objs.append(self)
@@ -46,10 +62,10 @@ class TileMap:
                 self.tiles[tile_id] = pygame.transform.scale(tile, self.tileDim)
                 self.tilePosInImage[tile_id] = (x, y)
                 self.posToTile[(x, y)] = tile_id
+                self.tilesetNum += 1
                 tile_id += 1
 
         Global.tilemap.append(self)
-        print(self.posToTile)
 
     def load_map_from_json(self, filePath: str):
         with open(filePath, "r") as f:

GameBox/ui/_basicUI.py

@@ -0,0 +1,65 @@
+import pygame
+import numpy as np
+
+from ..basics._net import Global
+
+from ..GameLevel_ui._sprites import Sprite_2d
+
+class Image:
+    def __init__(self, pos: tuple, image, scale: float = 1.0):
+        """
+    Initialize an Image UI element.
+    
+    Args:
+        pos: Tuple (x, y) for the image position
+        image: Either a file path (str) or pygame.Surface object
+        scale: Scale factor for the image (default: 1.0)
+    """
+        #add to game
+        self.image = Sprite_2d(pos, image, scale)
+        self.image.__remove__()
+        Global.game.ui_objs.append(self)
+
+    def move_by(self, x: int, y: int):
+        """
+        Move the image by (x, y) in world space.
+        
+        Args:
+            x: int, the x component of the movement
+            y: int, the y component of the movement
+        """
+        self.image.move_by(x, y)
+
+    def move_to(self, x: int, y: int):
+        """
+        Move the image to (x, y) in world space.
+        
+        Args:
+            x: int, the x component of the position
+            y: int, the y component of the position
+        """
+        self.image.move_to(x, y)
+    
+    def get_pos(self):
+        """
+        Get the position of the image in world space.
+        
+        Returns:
+            tuple: (x, y) the position of the image
+        """
+        return self.image.get_pos()
+
+    def rescale(self, scale: float):
+        """
+        Rescale the image by the given scale.
+        
+        Args:
+            scale: float, the scale factor
+        """
+        self.image.rescale(scale)
+
+    def update(self):
+        """
+        Update the image by drawing it on the screen.
+        """
+        Global.screen.blit(self.image.image, self.image.pos)

{gamebox-0.2.0.dist-info → gamebox-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameBox
-Version: 0.2.0
+Version: 0.9.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

gamebox-0.9.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+GameBox/__init__.py,sha256=HVJfnUcXHAjp4wIR_uz4u9lwLZpiChdvzf6y0aPvkj8,1025
+GameBox/_game.py,sha256=l55gMoNTbFrMBYJzwK8RX8oP414qBtyDik9bmcuexys,1675
+GameBox/GameLevel_ui/_Animations.py,sha256=nza-F3Rii6VWAvIkSKNr1CpkJXxq4jLqZcYfb0Sk1hI,1051
+GameBox/GameLevel_ui/_sprites.py,sha256=BmfTi4_gnP2rlIOH6luG8cJjXwNRArBmyy_0iYrE7I0,8579
+GameBox/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameBox/basics/_net.py,sha256=zXuw1YkC3Qobx6sAl2u3fvp_ghJsfHem6L59NTmTfRE,802
+GameBox/basics/_shapes.py,sha256=2bSlNMJlRKHSHljmiD7nn9Kh8VEFPHygxzzONGvvgfs,3008
+GameBox/basics/cammera.py,sha256=MPsl-H2hMOfmPPfPiyfT--wGkUSCR1i3ZMo9Qnb9ChE,1895
+GameBox/basics/utils.py,sha256=w6H34MhxcNoX58iQtlvbT5-4GXefy3RIMTxZGP9fSxA,432
+GameBox/helpers/_Conditions.py,sha256=LY0sVuIR_3ZewDDx-Ud9WoM3HFhLh9rR2RaiRSd1Gr4,2350
+GameBox/helpers/_collisions.py,sha256=VJy26jaJOLjnKFD_i5MBhsKg0OHXpqJVcMU0PcACgrI,4414
+GameBox/helpers/_input.py,sha256=KyhqkLykI6czIhvu3BLISmFkbw_6PRzCuK48LVV4zM8,2041
+GameBox/player/_player.py,sha256=GsWAERz9SWRD3qEyBQDLXo85OLEPTP5m_5sI4CHLRL0,2486
+GameBox/player/_playerControler.py,sha256=XEb87RFlgLFoXnXqxIS4lpzHN0wywMNCX5y-NIhw0cs,1715
+GameBox/player/_playerPhysics.py,sha256=-6u-TZH_i78bwFMZwCIHP0VnQA0nOlcQtkq07rxwKwg,2919
+GameBox/player/_playerSprite.py,sha256=4Zhy94TWbsgXQTRM4xwIMHo5YPFmsfb1xjM3dmv207g,3542
+GameBox/tilemap/_Editor.py,sha256=98JcwAvL6JgSG2S-V-527lwpfzbE-A-BbezCI9EfTyI,1027
+GameBox/tilemap/_collisionDef.py,sha256=VxWcfz3nlhyYI_Hemp-LvC6IDC-YN6wIdRaU8AsgipU,1621
+GameBox/tilemap/_editorBrushes.py,sha256=GFfRV0OB3t9sFb37eO3sB8Cmwyd5i_q64q5IjYlkx1k,7247
+GameBox/tilemap/_tilemap.py,sha256=K_L7jNWrmVnnOSrrqj0aasVuJMHsTpScGj3adrnKJC0,3820
+GameBox/ui/_basicUI.py,sha256=gP8jhKo7cHH5GlKNH4DFqEziX9dIv0YxsaoFceteB1k,1778
+gamebox-0.9.0.dist-info/METADATA,sha256=4IQDtldYyMYbzsRyZP8fkj5DWErEL_CYib1nQO8BkEo,1059
+gamebox-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gamebox-0.9.0.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
+gamebox-0.9.0.dist-info/RECORD,,

gamebox-0.2.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-GameBox/__init__.py,sha256=jU3a32yFDiWvSHanU2_xJHNi3Ngcqrvjn190SyKlNwE,727
-GameBox/_game.py,sha256=QqfWQRLIiKQ-QjEGQYFLpsjEtPNuhxMqiCnPmXFyq3M,1548
-GameBox/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameBox/basics/_net.py,sha256=tZsfUc-rOsbRPxgjzR95gY6vKa8CxM8TJhCBtDnVhtg,766
-GameBox/basics/_shapes.py,sha256=7k5Mxnm_NdFssW6Zao8DSJAHJQM3pVWx2xZ4QDyF6lQ,1035
-GameBox/basics/cammera.py,sha256=qo20hc5f3FLiBpFeWgBObj-EQ93Hg4RgEUtIwPIylOI,930
-GameBox/basics/utils.py,sha256=w6H34MhxcNoX58iQtlvbT5-4GXefy3RIMTxZGP9fSxA,432
-GameBox/helpers/_collisions.py,sha256=f19oIYsyY3G9-5J-nUVBvbuFT1EPeDwcbycIP0TLGms,4336
-GameBox/helpers/_input.py,sha256=97bPxM5dkonRywOhj11lgHVQVicuLAKYi_w8EPM0Af8,1963
-GameBox/player/_player.py,sha256=R0vH1mZhl6RENiQl3Vg4ACF9agR5OP50MenvhgFBYOk,1769
-GameBox/player/_playerControler.py,sha256=XEb87RFlgLFoXnXqxIS4lpzHN0wywMNCX5y-NIhw0cs,1715
-GameBox/player/_playerPhysics.py,sha256=XqgEC5FB5mrnlalY3M5TLScw40mSvNAc0AE9g3amEr0,2918
-GameBox/tilemap/_Editor.py,sha256=Xed3Q33WEAKyLiTieTWDFeiTMMQm8m7cY2Bv7JzJr0o,4010
-GameBox/tilemap/_collisionDef.py,sha256=lZCmSwIsLgxvEB3X30re_izg1DHY83IWp84NcM1cIkM,1393
-GameBox/tilemap/_tilemap.py,sha256=fIBaAAu1Rg1iI4xEUk3Xkpe4MllpnkLzNfInj0468cw,3292
-gamebox-0.2.0.dist-info/METADATA,sha256=2nL3q0Sg_b_tyg-shYRDrlpNAXJ0MzsZy_5tmWhdKcg,1059
-gamebox-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-gamebox-0.2.0.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
-gamebox-0.2.0.dist-info/RECORD,,