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

GameBox/GameLevel_ui/_sprites.py

@@ -77,44 +77,7 @@ def split_image(image, tileDim, startPos):
     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
@@ -167,27 +130,6 @@ class Animated_Sprite2D:
         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
@@ -218,7 +160,7 @@ class AnimationPlayer2D:
 
     def __remove__(self):
         if self in Global.game.objs:
-            Global.game.objs.remove(self)
+            Global.game.objs.remove(self)\
 
     def set_scale(self, scale: float):
         for anim in self.anims:

GameBox/_game.py

@@ -57,4 +57,25 @@ class Game:
             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

@@ -20,6 +20,8 @@ class _global_:
 
         self.cond: object = None
 
+        self._debug: bool = False
+
         #objects
         self.player = self._player()
         self.tilemap = []

GameBox/basics/_shapes.py

@@ -4,26 +4,7 @@ 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
@@ -31,12 +12,6 @@ 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):
@@ -46,18 +21,11 @@ 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
@@ -65,13 +33,6 @@ class Rect:
             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
@@ -80,9 +41,4 @@ class Rect:
             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,17 +6,7 @@ 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)
@@ -26,50 +16,21 @@ class Cammera:
         self.scale = scale
 
     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

@@ -5,22 +5,14 @@ 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 start with 'C' and then command ('v' for velocity), and dir (^ up, _ down, < left, > right, # none, ~ any)
+        self.velocity_up = 'CV^'
+        self.velocity_down = 'CV_'
+        self.velocity_left = 'CV<'
+        self.velocity_right = 'CV>'
+        self.velocity_none = 'CV#'
+        self.velocity_any = 'CV~'
 
 Conditions = _Conditions()
 Global.cond = Conditions
@@ -43,9 +35,8 @@ class Condition_check:
 
     def _resolve_velocities(self, velocities, cond):
         vx, vy = velocities
-        Max = 0.3
-        vx = zeroOut(vx, Max)
-        vy = zeroOut(vy, Max)
+        vx = zeroOut(vx, 0.1)
+        vy = zeroOut(vy, 0.1)
         dir = cond[2]
         print(vx, vy, dir)
         #resolve in order up, down, left, right, none, any

GameBox/helpers/_collisions.py

@@ -17,9 +17,11 @@ def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
     # Y-axis collisions
     py = y
     new_rect = pygame.Rect((x, y), dim)
-    pygame.draw.rect(Global.screen, "green", new_rect, 5)
+    if Global._debug:
+        pygame.draw.rect(Global.screen, "green", new_rect, 5)
     for collision in collisions:
-        pygame.draw.rect(Global.screen, "yellow", collision, 5)
+        if Global._debug:
+            pygame.draw.rect(Global.screen, "yellow", collision, 5)
         if collision.colliderect(new_rect):
             if vy > 0:  # falling
                 y = collision.top - dim[1]
@@ -30,7 +32,8 @@ def _mainCollisionLogic(collisions, x, y, vx, vy, dim):
                 
     new_rect = pygame.Rect((x, py), dim)
     for collision in collisions:
-        pygame.draw.rect(Global.screen, "yellow", collision, 5)
+        if Global._debug:
+            pygame.draw.rect(Global.screen, "yellow", collision, 5)
         if collision.colliderect(new_rect):
             if vx > 0:
                 x = collision.left - dim[0]

GameBox/helpers/_input.py

@@ -4,9 +4,6 @@ from ..basics._net import Global
 
 
 class _keys:
-    """
-    A class that holds all the key bindings for the game
-    """
     def __init__(self):
 
         #alphabet
@@ -64,7 +61,6 @@ 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

@@ -9,38 +9,21 @@ 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)
 
 

GameBox/player/_playerSprite.py

@@ -50,7 +50,7 @@ class _playerSprite:
             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):
+    def add_animated_sprite_2d(self, image, imageDim, tileDim, frames, speed, scale = 1.0, collision = True, 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
@@ -66,8 +66,8 @@ class _playerSprite:
             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)
+    def add_animation(self, name, image, imageDim, tileDim, frames, speed, scale = 1.0, dirrection = 1):
+        self.sprite.add_animation(name, image, imageDim, tileDim, frames, speed, scale, False, dirrection)
         self.sprite.__remove__()
         self.sprite.set_worldPos(False)
 

GameBox/tilemap/_tilemap.py

@@ -9,20 +9,6 @@ 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)

GameBox/ui/_basicUI.py

@@ -8,58 +8,29 @@ 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)
-    """
+        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.9.0.dist-info → gamebox-0.9.1.dist-info}/METADATA

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

gamebox-0.9.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+GameBox/__init__.py,sha256=HVJfnUcXHAjp4wIR_uz4u9lwLZpiChdvzf6y0aPvkj8,1025
+GameBox/_game.py,sha256=cxlY7skQHK2OXnqgdusXwfc_0hDy7Hu3oq8o5iKzSLU,2252
+GameBox/GameLevel_ui/_Animations.py,sha256=nza-F3Rii6VWAvIkSKNr1CpkJXxq4jLqZcYfb0Sk1hI,1051
+GameBox/GameLevel_ui/_sprites.py,sha256=lRtMuGtd-5kfUPmJ_20j5fOmWdaIhKxfcCdVYM4oazc,5664
+GameBox/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameBox/basics/_net.py,sha256=65qMVXyILKGE8VnJcW_jxmJ1UxmENktbHvRWaTq5U0A,839
+GameBox/basics/_shapes.py,sha256=Rbkd0lrpxGvbVdwL98_iovFtqB1USI5Qk6umJPR0CIc,1314
+GameBox/basics/cammera.py,sha256=eP7cNkTruZ9CDf94VGTsjgdI4NNnWjN-ilCHgGLYNSs,941
+GameBox/basics/utils.py,sha256=w6H34MhxcNoX58iQtlvbT5-4GXefy3RIMTxZGP9fSxA,432
+GameBox/helpers/_Conditions.py,sha256=FSqwJWL0QBvCQmSyzhL5LtudhP5c-tRzC_8xuQENsGw,1946
+GameBox/helpers/_collisions.py,sha256=b8eBnEYbgYFxQ4m6xpAeAaNkYosbP5xUOIlT40sztBs,4503
+GameBox/helpers/_input.py,sha256=97bPxM5dkonRywOhj11lgHVQVicuLAKYi_w8EPM0Af8,1963
+GameBox/player/_player.py,sha256=HU7iOBoHj5oXJTA-lHmwPZbFt8CXm-IPzK3NWBGzRhM,1872
+GameBox/player/_playerControler.py,sha256=XEb87RFlgLFoXnXqxIS4lpzHN0wywMNCX5y-NIhw0cs,1715
+GameBox/player/_playerPhysics.py,sha256=-6u-TZH_i78bwFMZwCIHP0VnQA0nOlcQtkq07rxwKwg,2919
+GameBox/player/_playerSprite.py,sha256=7j9hqesdOvyyP4jF83VJRbpno_oYgOt31rdYKezVknk,3519
+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=SEQlokpsUO9zQkLMF-j6amx1FqNeD2eM2CRFj3zCnZ8,3330
+GameBox/ui/_basicUI.py,sha256=LnlQ-YNHFypohjal3eYRws9H52iCLUyRuZWg6n5Fg0o,1007
+gamebox-0.9.1.dist-info/METADATA,sha256=XghkrBPlIfxU7NdxwlbVZq6Hhz4U-qJp7H9ydOlgalw,1059
+gamebox-0.9.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gamebox-0.9.1.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
+gamebox-0.9.1.dist-info/RECORD,,

gamebox-0.9.0.dist-info/RECORD

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