GameBox 0.9.2__py3-none-any.whl → 0.10.0.dev1__py3-none-any.whl

GameBox/basics/_shapes.py

@@ -1,44 +0,0 @@
-import pygame
-import numpy as np
-
-from ..basics._net import Global
-
-class Rect:
-    def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), collision: bool = True):
-        self.x, self.y = pos
-        self.width, self.height = size
-        self.color = color
-        Global.game.objs.append(self)
-        self.collision = collision
-
-    def update(self):
-        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
-        elif (Global.cam.follow) == (self):
-            x = self.x
-            y = self.y
-
-        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):
-        if (Global.cam.follow) != (self):
-            self.x += x
-            self.y += y
-        else:
-            Global.cam._move(x, y)
-            
-    def move_to(self, x, y):
-        if (Global.cam.follow) != (self):
-            self.x = x
-            self.y = y
-        else:
-            Global.cam.x = x
-            Global.cam.y = y
-
-    def __remove__(self):
-        Global.game.objs.remove(self)

GameBox/basics/cammera.py

@@ -1,36 +0,0 @@
-import pygame
-import numpy as np
-
-from ._net import Global
-
-from ..basics.utils import moveTward
-
-class Cammera:
-    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: int, y: int):
-        self.x += x
-        self.y += y
-
-    def update(self):
-        return
-        if self.follow is not None:
-            self.x = (self.follow.x - self.diff[0])
-            self.y = (self.follow.y - self.diff[1])
-
-    def set_follow_target(self, target: object):
-        self.follow = target
-        print(target)
-        self.diff = (target.x - self.x, target.y - self.y)
-
-    def set_scale(self, scale: float = 1.0):
-        self.scale = scale
-    def change_scale(self, scale: float = 1.0):
-        self.scale += scale

GameBox/helpers/_Conditions.py

@@ -1,56 +0,0 @@
-import pygame
-import numpy as np
-
-from ..basics.utils import zeroOut
-from ..basics._net import Global
-
-class _Conditions:
-    def __init__(self):
-        #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
-
-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
-        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
-        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/player/_player.py

@@ -1,61 +0,0 @@
-import pygame
-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:
-    def __init__(self, pos: tuple, size: tuple, color: tuple = (0, 0, 0), gravity: bool = False):
-        self.x, self.y = pos
-        self.screenPos = pos
-        self.dim = size
-        self.color = color
-        self.width, self.height = size
-
-        self.gravity = gravity
-
-        self.state = ""
-        
-        Global.game.objs.append(self)
-        Global.player.pos = pos
-        Global.player.player = self
-
-        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()
-        #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
-        velocity = (self.physics.vx, self.physics.vy)
-        self.sprite.update(x, y, velocity)
-
-    #movement
-    def top_down_movement(self):
-        self.physics.top_down_movement()
-
-    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/_playerSprite.py

@@ -1,86 +0,0 @@
-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 = 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
-        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, dirrection = 1):
-        self.sprite.add_animation(name, image, imageDim, tileDim, frames, speed, scale, False, 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

@@ -1,36 +0,0 @@
-import pygame
-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):
-        self.tilemap = tilemap
-        self.activation = activation
-        self.active = False
-
-        self.mode = _brushPencil()
-
-        self.changes = {
-            "pencil": Keys.b,
-            "collisions": Keys.c
-            
-        }
-
-    def _update(self):
-        if  self.active:
-            self.change_mode()
-            #editor stuff
-            self.mode.update(self.tilemap)
-        #toggle
-        if Keys.is_pressed(self.activation): self.active = not self.active
-
-    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

@@ -1,41 +0,0 @@
-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)
-        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/_editorBrushes.py

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

@@ -1,94 +0,0 @@
-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.tilesetNum = 0
-
-        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
-                self.tilesetNum += 1
-                tile_id += 1
-
-        Global.tilemap.append(self)
-
-    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/ui/_basicUI.py

@@ -1,36 +0,0 @@
-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):
-        self.image.move_by(x, y)
-
-    def move_to(self, x: int, y: int):
-        self.image.move_to(x, y)
-    
-    def get_pos(self):
-        return self.image.get_pos()
-
-    def rescale(self, scale: float):
-        self.image.rescale(scale)
-
-    def update(self):
-        Global.screen.blit(self.image.image, self.image.pos)

gamebox-0.9.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-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=q29j6N1bNh7hp9OoX5ipODLf4n6FjPzGb8vNSZ_x4Oc,5692
-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.2.dist-info/METADATA,sha256=8FWr5TfY0d3CxfiJlDUAPO1oq0AfDAmfqVyu8H7oir4,1059
-gamebox-0.9.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-gamebox-0.9.2.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
-gamebox-0.9.2.dist-info/RECORD,,