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

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.0.3"
+__version__ = "0.1.3"
 __author__ = "Sam Fertig"
 
 #____imports____
@@ -14,6 +14,8 @@ from .basics.cammera import Cammera
 from .basics._shapes import Rect
 from .player._player import Player
 from .basics.utils import clamp, moveTward, zeroOut
+from .tilemap._tilemap import TileMap
+from.helpers._input import Keys
 
 
 __all__ = [
@@ -23,6 +25,8 @@ __all__ = [
     "Player",
     "clamp",
     "moveTward",
-    "zeroOut"
+    "zeroOut",
+    "TileMap",
+    "Keys",
 ]
 

GameBox/_game.py

@@ -1,6 +1,7 @@
 import pygame
 import numpy as np
 
+
 from .basics._net import Global
 from .player._player import Player
 
@@ -9,7 +10,7 @@ class Game:
         """
         Initialize the Game object.
 
-        ParameArters:
+        Parameters:
         width (int): The width of the game window.
         height (int): The height of the game window.
         bg_color (tuple): The background color of the game window.
@@ -26,8 +27,12 @@ class Game:
         Global.game = self
         self.objs = []
 
-    def update(self, frame_rate=60):
+
+    def update(self, event: pygame.event,frame_rate=60):
+        Global.event = event
+        #clear collisions
         Global.collisions.clear()
+
         Global.dt = Global.clock.tick(frame_rate) / 1000.0
         Global.screen.fill(Global.bgColor)
         player = None
@@ -36,3 +41,14 @@ class Game:
             else: obj.update()
         if player != None: player.update()
         pygame.display.update()
+
+    def get_screen(self):
+        return Global.screen
+    
+    def quit(self):
+        #will save files later
+        for obj in self.objs:
+            if hasattr(obj, "_quit") and callable(obj._quit):
+                obj._quit()
+
+

GameBox/basics/_net.py

@@ -14,15 +14,18 @@ class _global_:
         #--game and cam
         self.game: object = None
         self.cam: object = None
+        self.event: pygame.event = None
         #-collisions
         self.collisions: list[pygame.Rect] = []
 
         #objects
         self.player = self._player()
+        self.tilemap = []
 
     class _player:
         def __init__(self):
             self.pos: tuple = None
+            self.player: object = None
 
 
 

GameBox/basics/_shapes.py

@@ -12,6 +12,8 @@ class Rect:
         self.collision = collision
 
     def update(self):
+        width = self.width * Global.cam.scale
+        height = self.height * Global.cam.scale
         if (Global.cam.follow) != (self):
             x = self.x - Global.cam.x
             y = self.y - Global.cam.y
@@ -19,7 +21,7 @@ class Rect:
             x = self.x
             y = self.y
 
-        rect = pygame.Rect(x, y, self.width, self.height)
+        rect = pygame.Rect(x, y, width ,height)
         if self.collision: Global.collisions.append(rect)
         pygame.draw.rect(Global.screen, self.color, rect)
 

GameBox/basics/cammera.py

@@ -6,13 +6,14 @@ from ._net import Global
 from ..basics.utils import moveTward
 
 class Cammera:
-    def __init__(self):
+    def __init__(self, scale: float = 1.0):
         self.x = 0
         self.y = 0
         Global.game.objs.append(self)
         Global.cam = self
         self.follow = None
         self.diff = (0, 0)
+        self.scale = scale
 
     def move(self, x, y):
         self.x += x
@@ -28,3 +29,8 @@ class Cammera:
         self.follow = target
         print(target)
         self.diff = (target.x - self.x, target.y - self.y)
+
+    def set_scale(self, scale: float = 1.0):
+        self.scale = scale
+    def change_scale(self, scale: float = 1.0):
+        self.scale += scale

GameBox/helpers/_collisions.py

@@ -0,0 +1,110 @@
+import pygame
+import numpy as np
+
+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)
+
+        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
+    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 vy > 0:  # falling
+                y = collision.top - dim[1]
+                vy = 0
+            elif vy < 0:  # jumping
+                y = collision.bottom
+                vy = 0
+
+    return x, y, vx, vy
+    
+def _checkTilemapCollisions(x, y, vx, vy, dim, sample, obj):
+    if len(Global.tilemap) == 0:
+        return x, y, vx, vy
+    
+    for tilemap in Global.tilemap:
+    
+        #get player reletive tilemap  pos
+        prect = pygame.Rect(x, y, dim[0], dim[1])
+        prx, pry = prect.center
+        if Global.cam.follow != obj:
+            if Global.cam.x != 0 or Global.cam.y != 0:
+                px = int((prx) - Global.cam.x)
+                py = int((pry) - Global.cam.y) 
+                px = int(px  // tilemap.tileDim[0])
+                py = int(py  // tilemap.tileDim[1])
+            else:
+                px = int((x) / tilemap.tileDim[0])
+                py = int((y ) / tilemap.tileDim[1])
+        else:
+            if Global.cam.x != 0 or Global.cam.y != 0:
+                px = int(((prx + Global.cam.x)) // tilemap.tileDim[0])
+                py = int(((pry + Global.cam.y)) // tilemap.tileDim[1])
+            else:
+                px = int((x) / tilemap.tileDim[0])
+                py = int((y) / tilemap.tileDim[1])
+
+
+        #check if player is on tilemap
+        if px < 0 or px >= tilemap.mapDim[0] or py < 0 or py >= tilemap.mapDim[1]:
+            return x, y, vx, vy
+        #get collision rects around player
+        collisions: list[pygame.Rect] = []
+        for tx in range(px - sample, px + sample):
+            for ty in range(py - sample, py + sample):
+                nx = int(px + tx)
+                ny = int(py + ty)
+                #if tile is on map
+                if nx < 0 or nx >= tilemap.mapDim[0] or ny < 0 or ny >= tilemap.mapDim[1]:
+                    continue
+                #if tile has defined collision shape
+                tile = str(tilemap.map[ny][nx])
+                if tile not in tilemap.collisionDict: continue
+
+                #get collision shape 
+                rectshape = tilemap.collisionDict[str(tile)]
+                rect = getattr(tilemap.collisionShapes, rectshape).copy()
+
+                # Position rect correctly in the world
+                if Global.cam.follow != obj:
+                    if Global.cam.x != 0 or Global.cam.y != 0:
+                        rect.x = ((nx * tilemap.tileDim[0])) - Global.cam.x
+                        rect.y = ((ny * tilemap.tileDim[1])) - Global.cam.y
+                    else:
+                        rect.x += (nx * tilemap.tileDim[0]) - Global.cam.x
+                        rect.y += (ny * tilemap.tileDim[1]) - Global.cam.y
+                else:
+                    if Global.cam.x != 0 or Global.cam.y != 0:
+                        rect.x += ((nx * tilemap.tileDim[0])) - Global.cam.x
+                        rect.y += ((ny * tilemap.tileDim[1])) - Global.cam.y
+                    else:
+                        rect.x += (nx * tilemap.tileDim[0]) - Global.cam.x
+                        rect.y += (ny * tilemap.tileDim[1]) - Global.cam.y
+                collisions.append(rect)
+
+        #check collisions
+        x, y, vx, vy = _mainCollisionLogic(collisions, x, y, vx, vy, dim)
+
+        return x, y, vx, vy
+

GameBox/helpers/_input.py

@@ -0,0 +1,75 @@
+import pygame
+
+from ..basics._net import Global
+
+
+class _keys:
+    def __init__(self):
+
+        #alphabet
+        self.a = pygame.K_a
+        self.b = pygame.K_b
+        self.c = pygame.K_c
+        self.d = pygame.K_d
+        self.e = pygame.K_e
+        self.f = pygame.K_f
+        self.g = pygame.K_g
+        self.h = pygame.K_h
+        self.i = pygame.K_i
+        self.j = pygame.K_j
+        self.k = pygame.K_k
+        self.l = pygame.K_l
+        self.m = pygame.K_m
+        self.n = pygame.K_n
+        self.o = pygame.K_o
+        self.p = pygame.K_p
+        self.q = pygame.K_q
+        self.r = pygame.K_r
+        self.s = pygame.K_s
+        self.t = pygame.K_t
+        self.u = pygame.K_u
+        self.v = pygame.K_v
+        self.w = pygame.K_w
+        self.x = pygame.K_x
+        self.y = pygame.K_y
+        self.z = pygame.K_z
+
+        #numbers
+        self.n0 = pygame.K_0
+        self.n1 = pygame.K_1
+        self.n2 = pygame.K_2
+        self.n3 = pygame.K_3
+        self.n4 = pygame.K_4
+        self.n5 = pygame.K_5
+        self.n6 = pygame.K_6
+        self.n7 = pygame.K_7
+        self.n8 = pygame.K_8
+        self.n9 = pygame.K_9
+
+        #special keys
+        self.enter = pygame.K_RETURN
+        self.escape = pygame.K_ESCAPE
+        self.space = pygame.K_SPACE
+        self.backspace = pygame.K_BACKSPACE
+        self.tab = pygame.K_TAB
+
+        #arrow keys
+        self.up = pygame.K_UP
+        self.down = pygame.K_DOWN
+        self.left = pygame.K_LEFT
+        self.right = pygame.K_RIGHT
+
+        #mouse
+        self.mouse_x, self.mouse_y = 0, 0
+    def init(self): Global.game.objs.append(self)
+
+    def is_pressed(self, key): 
+        for event in Global.event:
+            if event.type == pygame.KEYDOWN:
+                if event.key == key: return True
+        return False
+
+    def update(self): self.mouse_x, self.mouse_y = pygame.mouse.get_pos()
+
+
+Keys = _keys()

GameBox/player/_player.py

@@ -16,6 +16,7 @@ class Player:
         
         Global.game.objs.append(self)
         Global.player.pos = pos
+        Global.player.player = 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):
@@ -24,7 +25,15 @@ class Player:
     def update(self):
         self.physics.update()
         #debug rect
-        rect = pygame.Rect(self.x, self.y, self.dim[0], self.dim[1])
+        width = self.dim[0] * Global.cam.scale
+        height = self.dim[1] * Global.cam.scale
+        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)
 
     #movement
@@ -33,3 +42,11 @@ class Player:
 
     def platforming_movement(self):
         self.physics.platforming_movement()
+
+    def set_tilemap_sample(self, sample: int = 10):
+        """
+        Sets the sample size for player physics collisions. 
+        Is the radius of tiles that will be used to get tilemap collisions around player. Note: 
+        The larger the sample size the longer it may take to calculate collisions per frame.
+        """
+        self.physics.sample = sample

GameBox/player/_playerPhysics.py

@@ -3,6 +3,7 @@ import numpy as np
 
 from ..basics._net import Global
 from ..basics.utils import clamp, moveTward, zeroOut
+from ..helpers._collisions import CheckCollisions
 
 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):
@@ -18,11 +19,15 @@ class _playerPhysics:
         self.onGround = False
         self.canJump = False
 
+        self.sample = 10
+
         self.vx, self.vy = 0, 0
 
     def update(self):
         self.ckeck_is_on_ground()
-        x, y = self.check_collisions()
+        x, y, self.vx, self.vy = CheckCollisions(self.player.x, self.player.y, 
+                               self.vx, self.vy, self.player.dim, 
+                               self.sample,self.player)
         if (Global.cam.follow) != (self.player):
             self.player.x = x
             self.player.y = y
@@ -30,34 +35,9 @@ class _playerPhysics:
             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

GameBox/tilemap/_Editor.py

@@ -0,0 +1,101 @@
+import pygame
+import numpy as np
+
+from..helpers._input import Keys
+from ..basics._net import Global
+
+class _tilemapEditor:
+    def __init__(self, tilemap, activation):
+        self.tilemap = tilemap
+        self.activation = activation
+        self.active = False
+
+        self.selectedTile = 1
+        self.mx, self.my = Keys.mouse_x, Keys.mouse_y
+
+        self.mode = "paint"
+
+    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()
+
+        #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))]
+
+

GameBox/tilemap/_collisionDef.py

@@ -0,0 +1,34 @@
+import pygame
+
+class _tileCollisionDefs:
+    def __init__(self, tileDim):
+        width, height = tileDim
+        self.full = pygame.Rect(0, 0, width, height)
+
+        self.halfLeft = pygame.Rect(0, 0, width / 2, height)
+        self.halfRight = pygame.Rect(width / 2, 0, width / 2, height)
+        self.halfTop = pygame.Rect(0, 0, width, height / 2)
+        self.halfBottom = pygame.Rect(0, height / 2, width, height / 2)
+
+        self.topRight = pygame.Rect(width / 2, 0, width / 2, height / 2)
+        self.topLeft = pygame.Rect(0, 0, width / 2, height / 2)
+        self.bottomRight = pygame.Rect(width / 2, height / 2, width / 2, height / 2)
+        self.bottomLeft = pygame.Rect(0, height / 2, width / 2, height / 2)
+
+        self.dot = pygame.Rect(0, 0, 3, 3)
+
+        self.center = pygame.Rect(width / 2, height / 2, width / 2, height / 2)
+
+        self.none = pygame.Rect(0, 0, 0, 0)
+
+    def regenerate(self, tileDim):
+        width, height = tileDim
+        self.full = pygame.Rect(0, 0, width, height)
+
+        self.halfLeft = pygame.Rect(0, 0, width / 2, height)
+        self.halfRight = pygame.Rect(width / 2, 0, width / 2, height)
+        self.halfTop = pygame.Rect(0, 0, width, height / 2)
+        self.halfBottom = pygame.Rect(0, height / 2, width, height / 2)
+
+        self.center = pygame.Rect(width / 2, height / 2, width / 2, height / 2)
+

GameBox/tilemap/_tilemap.py

@@ -0,0 +1,92 @@
+import pygame
+import numpy as np
+import json
+
+from ..basics._net import Global
+
+from ._collisionDef import _tileCollisionDefs
+from ._Editor import _tilemapEditor
+
+class TileMap:
+    def __init__(self, tileSet: str, tileDim: tuple, tileScale: float, mapDim: tuple, mapFill: int, saveFile = None):
+        self.tilesetFile = tileSet
+        self.mapFile = saveFile
+        self.tileDim = (tileDim[0] * tileScale, tileDim[1] * tileScale)
+        self.tileDim = (self.tileDim[0] * Global.cam.scale, self.tileDim[1] * Global.cam.scale)
+        self.mapDim = mapDim
+        self.tilescale = tileScale
+        self.orginDim = tileDim
+
+        self.editor = None
+
+        Global.game.objs.append(self)
+
+        self.collisionShapes = _tileCollisionDefs(self.tileDim)
+
+        self.collisionDict = {}
+
+        self.tilePosInImage = {}
+        self.posToTile = {}
+
+        #map, tile splitting, ect
+        #--create map
+        self.map = np.full(self.mapDim, mapFill)
+        #--split map into tiles
+        self.tiles = {}
+        tileset = pygame.image.load(tileSet).convert_alpha()
+        self.tileset = tileset
+        tile_w, tile_h = tileDim
+        tile_id = 1
+        tileset_w, tileset_h = tileset.get_size()
+
+        for y in range(0, tileset_h, tile_h):
+            for x in range(0, tileset_w, tile_w):
+                tile = pygame.Surface(tileDim, pygame.SRCALPHA)
+                tile.blit(tileset, (0, 0), (x, y, tile_w, tile_h))
+                self.tiles[tile_id] = pygame.transform.scale(tile, self.tileDim)
+                self.tilePosInImage[tile_id] = (x, y)
+                self.posToTile[(x, y)] = tile_id
+                tile_id += 1
+
+        Global.tilemap.append(self)
+        print(self.posToTile)
+
+    def load_map_from_json(self, filePath: str):
+        with open(filePath, "r") as f:
+            data = json.load(f)
+        self.__private_loadData(filePath, data)
+
+    def __private_loadData(self, path: str, data: dict):
+        self.map = np.array(data["map"])
+        self.mapFile = path
+        self.collisionDict = data["collisions"]
+
+    def activate_editor(self, activation):
+        print(f"editor activated. press {activation} to toggle")
+        self.editor = _tilemapEditor(self, activation)
+
+    def update(self):
+        self.draw_tiles()
+        if self.editor is not None: self.editor._update()
+            
+
+    def draw_tiles(self):
+        for y in range(self.mapDim[1]):
+            for x in range(self.mapDim[0]):
+                if self.map[y][x] == 0:
+                    continue
+                tile = self.tiles[self.map[y][x]]
+                mx = (x * self.tileDim[0]) - Global.cam.x
+                my = (y * self.tileDim[1]) - Global.cam.y
+                if mx < -self.tileDim[0] or mx > Global.screenDim[0] or my < -self.tileDim[1] or my > Global.screenDim[1]: continue
+                Global.screen.blit(tile, (mx, my))
+
+    def _quit(self):
+        #save map
+        if self.mapFile is not None:
+            print('tilemap saved')
+            with open(self.mapFile, "w") as f:
+                data = {}
+                data["map"] = self.map.tolist()
+                data["collisions"] = self.collisionDict
+                json.dump(data, f)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameBox
-Version: 0.1.2
+Version: 0.2.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
@@ -14,6 +14,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.
 
+github: https://github.com/sfertig/GameBox
+
 Versioning
 GameBox follows a modified semantic versioning scheme.
 Versions starting with 0.x.x are experimental and may change without notice.

gamebox-0.2.0.dist-info/RECORD

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

gamebox-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-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=uMcZJNx2ouoX2wrWH9oOEl6pAo38Z9K3wnJlRxc9Ljk,949
-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=usljs6q3pQcJu_ZK6xIohZDxnNSGeMADNv2GRuuxmVQ,1069
-GameBox/player/_playerControler.py,sha256=XEb87RFlgLFoXnXqxIS4lpzHN0wywMNCX5y-NIhw0cs,1715
-GameBox/player/_playerPhysics.py,sha256=cInqQPTiTkJw6vPcRnb-CyOufquzb1RtnTczWXyAURc,3639
-gamebox-0.1.2.dist-info/METADATA,sha256=kInczaK_uVb9qWKQw85qkHShqM9b7JBat28FUojrE2M,1015
-gamebox-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-gamebox-0.1.2.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
-gamebox-0.1.2.dist-info/RECORD,,