示例#1
0
 def create_level(self):
     """ Creates a new player and restarts level sprites. """
     self._paused = False
     self._game.ui.clear()
     self._player = PlayerCtrl()
     self._level = Level('level_1.tmx', self._player, self)
     self._timer = Timer()
示例#2
0
文件: main.py 项目: Fuyingxue/game1
    def __init__(self, hud):
        super(GameLayer, self).__init__()
        # 添加板子和球
        self.is_on_exiting = True
        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height / 2)
        self.add(self.ball.sprite)
        # hud 用于记录,更新关卡,死亡,金币数据
        self.hud = hud
        # 生成关卡
        self.level = Level()
        self.level.levels = self.hud.levels

        self.add(self.hud.gold_hud)
        self.add(self.hud.level_hud)
        self.add(self.hud.death_hud)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)
示例#3
0
    def __init__(self, hud):
        super(GameLayer, self).__init__()
        # 添加板子和球
        self.is_on_exiting = True
        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height / 2)
        self.add(self.ball.sprite)
        # hud 用于记录,更新关卡,死亡,金币数据
        self.hud = hud
        # 生成关卡
        self.level = Level()
        self.level.levels = self.hud.levels

        self.add(self.hud.gold_hud)
        self.add(self.hud.level_hud)
        self.add(self.hud.death_hud)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)
示例#4
0
文件: Game.py 项目: cthit/CodeIT
    def load_level(self, index):
        try:
            if self.level is not None:
                try:
                    self.last_level_coins = self.get_player_coins()
                except:
                    pass
                self.previous_level_index = int(
                    self.level.config["General"]["index"])
                self.level.clear()

            self.game_methods.last_level_time_left = self.game_methods.time_left
            self.game_methods.time_left = 0
            self.level = Level.get_level_by_index(index)
            if self.level is None:
                if index != 0:
                    self.load_level(0)
                else:
                    raise NoLevelFoundException

            self.level.load()
            self.gui.clear_view()
            try:
                view_name = self.level.config["GUI"]["view"]
                self.gui.load_view(view_name, self.game_methods)
            except KeyError:
                pass
            self.camera.set_settings(self.level.config["Camera"])
            self.camera.set_level(self.level)
            self.time = 0
            self.time_at_last_fps_update = 0
            self.frame_count = 0
        except KeyError:
            pass
        return True
示例#5
0
 def test_move_entity(self):
     level = Level(self.config).create_empty_tiles()
     level.tiles[0][0].set_type('floor')
     level.tiles[1][0].set_type('floor')
     entity = Entity(0, 0)
     entity.move(1, 0, level)
     self.assertEqual((1, 0), (entity.x, entity.y))
    def load_game(self, game_id):
        try:
            save = open(f"saves/save_{game_id}.xml", "r")

            # Test if there is a current saved game
            if save:
                tree_root = etree.parse(save).getroot()
                index = tree_root.find("level/index").text.strip()
                level_name = 'maps/level_' + index + '/'
                game_status = tree_root.find("level/phase").text.strip()
                turn_nb = 0
                if game_status != 'I':
                    turn_nb = int(tree_root.find("level/turn").text.strip())

                # Load level with current game status, foes states, and team
                self.level_id = int(index)
                level = Level(level_name, self.level_id, game_status, turn_nb, tree_root.find("level/entities"))
                self.play(level)
                save.close()
                return
        except FileNotFoundError:
            # No saved game
            self.background_menus.append([self.active_menu, True])

            name = "Load Game"
            entries = [[{'type': 'text', 'text': "No saved game.", 'font': fonts['MENU_SUB_TITLE_FONT']}]]
            width = self.screen.get_width() // 2
            self.active_menu = InfoBox(name, "", "imgs/interface/PopUpMenu.png",
                                       entries, width, close_button=1)
示例#7
0
 def setup_level(self):
     level = Level(self.config).create_empty_tiles()
     for x in range(0, level.width):
         for y in range(0, level.height):
             level.tiles[x][y].set_type('floor')
     for column in level.tiles:
         level.flattened_tiles.extend(column)
     return level
示例#8
0
    def reset_blocks(self):
        level = Level()
        level.levels = self.save_as

        # 通过文件生成块
        level.reset()
        # 删除已存在的块
        for b in self.blocks:
            self.remove(b.sprite)

        # 清空存储的块和坐标
        self.blocks.clear()
        # self.props.clear()

        # 添加新的块
        for b in level.blocks:
            self.add(b.sprite)
            self.blocks.append(b)
示例#9
0
    def __init__(self) -> None:
        """
        Creates a data model which is used for a graphic representation of
        Sokoban level (QGraphics View framework). QGraphicsScene.keyPressEvent()
        is implemented to process various player input.
        """

        super().__init__()
        self._level = Level("levels/01/01")
        self.setSceneRect(
            QRectF(QPointF(0, 0), QPointF(self._level.width,
                                          self._level.height)))
        [
            self.addItem(item) for item in self._level.tiles +
            self._level.boxes + tuple([self._level.player])
        ]
        self._level.player.moveFinished.connect(self.unlockGame)
        self._gameLock = False
示例#10
0
    def enter(self, app):
        self.app = app
        self.view = app.view

        self.palette = []
        for name in get_all('entities'):
            newtype = entities.get(name)
            self.palette.append(newtype)

        self.level = Level(app)

        self.mode = 't'
        self.mark = None
        self.delmark = None
        self.markmat = entities.get('mark')
        self.ground = entities.get('ground')

        print "CURRENT BRUSH:", self.brush
示例#11
0
文件: editor.py 项目: Fuyingxue/game1
    def reset_blocks(self):
        level = Level()
        level.levels = self.save_as

        # 通过文件生成块
        level.reset()
        # 删除已存在的块
        for b in self.blocks:
            self.remove(b.sprite)

        # 清空存储的块和坐标
        self.blocks.clear()
        # self.props.clear()

        # 添加新的块
        for b in level.blocks:
            self.add(b.sprite)
            self.blocks.append(b)
示例#12
0
    def __init__(self, game_info, sound_manager):
        GameState.__init__(self, GameState.STATE_GAME, GameState.STATE_LOAD)

        self.game_info = game_info
        self.sound_manager = sound_manager

        self.game_info.set_timer_in_seconds(300)

        self.mario_game_time = -1
        self.world_shift = 0

        self.player = Player(self.sound_manager, game_info)

        self.active_sprite_list = pygame.sprite.Group()
        self.active_sprite_list.add(self.player)

        self.level = Level(game_info, self.player, self.sound_manager)

        if constants.DEBUG:
            self.debug_overlay = DebugOverlay(self.game_info, self.player)

        self.sound_manager.play_music(constants.MUSIC_MAIN_THEME)
示例#13
0
    def enter(self, app):
	self.app = app
	self.view = app.view
        
        self.palette = [ ]
        for name  in get_all('entities'):
            newtype = entities.get(name)
            self.palette.append(newtype)
            
        self.level = Level(app)

        self.mode = 't'
        self.mark = None
        self.delmark = None
        self.markmat = entities.get('mark')
        self.ground = entities.get('ground')
        
        print "CURRENT BRUSH:", self.brush
示例#14
0
    def __init__(self, levels=1, golds=0, deadcount=0):
        super(GameLayer, self).__init__()
        # 添加板子和球

        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height/2)
        self.add(self.ball.sprite)
        # 生成关卡
        self.level = Level()
        self.level.levels = levels
        # 添加标签用于记录金币和关卡。死亡次数
        self.gold = golds
        self.deadcount = deadcount

        self.hud = Label('金币: '+str(golds))
        self.level_hud = Label('关卡: '+str(levels))
        self.deadstu = Label('死亡: '+str(deadcount))

        self.hud.position = (0, 460)
        self.level_hud.position = (80, 460)
        self.deadstu.position = (160, 460)
        self.add(self.hud)
        self.add(self.level_hud)
        self.add(self.deadstu)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.blocks = []
        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)
示例#15
0
class TestGameplay(unittest.TestCase):
    app = None

    @classmethod
    def setUpClass(cls):
        global app
        app = QtGui.QApplication([])

    def setUp(self):
        self.game = Game()
        self.level = Level("testUser", 1)
        self.board = Board(self.level, self.game)
        self.clearBricks()
        self.board.start()

    def tearDown(self):
        self.board.destroy()
        self.game.destroy()

    @classmethod
    def tearDownClass(cls):
        app.quit()

    def testInitializeBoardWithConcreteWalls(self):
        self.assertEqual(self.board.level.board[0][0].peek(), Tile.Concrete, "Corner tile should be Concrete, board not initialized properly")

    def testInitializeBoardWithExactlyOneBomberman(self):
        numberOfBombermanOnTheBoard = 0
        board = self.board.level.board
        for i in range(len(board)):
            for j in range(len(board[i])):
                if board[i][j].peek() == Tile.Bomberman:
                    numberOfBombermanOnTheBoard += 1

        self.assertEqual(numberOfBombermanOnTheBoard, 1, "Did not see exactly one level on the board")

    def testSetTileAt(self):
        self.assertEqual(self.board.level.board[1][1].peek(), Tile.Empty)
        self.board.setTileAt(1, 1, Tile.Brick)
        self.assertEqual(self.board.level.board[1][1].peek(), Tile.Brick)

    def testTileAt(self):
        for i in range(len(self.board.level.board)):
            for j in range(len(self.board.level.board[i])):
                self.assertEqual(self.board.tileAt(j, i), self.board.level.board[i][j].peek())

    def testSetBomberman(self):
        self.assertNotEqual(self.board.tileAt(1, 2), Tile.Bomberman)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 2
        self.board.level.setBomberman()
        self.assertEqual(self.board.tileAt(1, 2), Tile.Bomberman)

    def testSetBomb(self):
        self.assertNotEqual(self.board.tileAt(1, 2), Tile.Bomb)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 2
        self.board.level.setBomberman() #level should be here already
        self.board.level.setBomb()

        self.assertEqual(len(self.board.level.bombQueue), 1, "Bomb did not get enqueued")
        self.assertEqual(self.board.level.bombQueue.pop(), (1, 2, constant.TIME_BOMB), "Bomb's coordinates are wrong")
        self.assertEqual(self.board.tileAt(1, 2), Tile.Bomberman, "Bomberman is not on top of a bomb")

        self.board.popTileAt(1, 2)
        self.assertEqual(self.board.tileAt(1, 2), Tile.Bomb, "There is no bomb underneath Bomberman")

    def testDetonateBomb(self):
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.detonateBomb()

        self.board.popTileAt(1, 1) #pop Bomberman
        self.assertNotEqual(self.board.tileAt(1, 1), Tile.Bomb, "Bomb did not explode")

    def testDetonateBombHasNoEffectOnConcrete(self):
        self.board.curX = 1
        self.board.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.detonateBomb()

        self.board.popTileAt(1, 1) #pop Bomberman
        self.assertEqual(self.board.tileAt(1, 0), Tile.Concrete, "Concrete got destroyed by bomb")

    def testDetonateBombDestroysBrick(self):
        self.board.setTileAt(1, 2, Tile.Brick)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()
        
        self.board.level.bomberman.rangeOfBombs = 3

        self.board.detonateBomb()

        self.assertEqual(self.board.tileAt(1, 2), Tile.Empty, "Brick did not get destroyed by bomb")

    def testDetonateBombDestroysOnlyClosestBrickInTheSameDirection(self):
        self.board.setTileAt(1, 2, Tile.Brick)
        self.board.setTileAt(1, 3, Tile.Brick)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.level.bomberman.rangeOfBombs = 3

        self.board.detonateBomb()

        self.assertEqual(self.board.tileAt(1, 2), Tile.Empty, "Closer Brick did not get destroyed by bomb")
        self.assertEqual(self.board.tileAt(1, 3), Tile.Brick, "Further Brick got destroyed by bomb")

    def testDetonateBombDestroysMultipleBricks(self):
        self.board.setTileAt(1, 2, Tile.Brick)
        self.board.setTileAt(2, 1, Tile.Brick)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.level.bomberman.rangeOfBombs = 3

        self.board.detonateBomb()

        self.assertEqual(self.board.tileAt(1, 2), Tile.Empty, "One of the Bricks did not get destroyed by bomb")
        self.assertEqual(self.board.tileAt(2, 1), Tile.Empty, "One of the Bricks did not get destroyed by bomb")

    def testDetonateBombKillsEnemies(self):
        self.level.clearEnemies()
        self.board.setTileAt(2, 1, Tile.Balloom)
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        tempList = [2, 1, constant.DIRECTION_WEST, Tile.Balloom]
        self.level.listEnemies.append(tempList)

        self.level.numberEnemies = 1
        self.level.listTypeEnemies[0] = 1
        self.board.level.bomberman.rangeOfBombs = 3

        self.board.tryMove(1, 2)

        self.board.detonateBomb()

        self.assertEqual(self.board.tileAt(2, 1), Tile.Empty, "Bomb detonation did not kill enemy")
        self.assertEqual(0, self.level.numberEnemies, "Enemy was not removed from map")

    def testDetonateBombSpawnsEnemiesWhenExitIsHit(self):
        self.board.setTileAt(1, 2, Tile.Exit)

        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.level.bomberman.rangeOfBombs = 3

        self.board.detonateBomb()

        count = 0

        for i in range(self.level.numberEnemies):
            if (self.level.listTypeEnemies[i] != 0):
                count += 1

        self.assertEqual(count, 1, "Not all enemies are the same type when the exit is hit")
        self.assertEqual(len(self.level.listEnemies), 8, "The number of enemies when the exit is hit is not 8")

    def testDetonateBombSpawnsEnemiesWhenPowerupIsHit(self):
        self.board.setTileAt(1, 2, Tile.Powerup)

        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.level.bomberman.rangeOfBombs = 3

        self.board.detonateBomb()

        count = 0

        for i in range(self.level.numberEnemies):
            if (self.level.listTypeEnemies[i] != 0):
                count += 1

        self.assertEqual(count, 1, "Not all enemies are the same type when the powerup is hit")
        self.assertEqual(len(self.level.listEnemies), 8, "The number of enemies when the powerup is hit is not 8")

    def testTimeRunsOut(self):
        self.level.timeLeft = 0
        self.level.timeDone = False
        self.board.timeoutEvent()

        check = False

        for i in range(7):
            if (self.level.listTypeEnemies[i] != 0):
                check = True

        self.assertEqual(self.level.numberEnemies, 8, "Number of enemies is not equal to 8")
        self.assertFalse(check, "At least one enemy is not a Pontan")


    def testTryMoveToConcrete(self):
        self.board.setTileAt(0, 0, Tile.Concrete)
        self.assertFalse(self.board.tryMove(0, 0), "Was able to move to a concrete tile")

    def testTryMoveToBrick(self):
        self.board.setTileAt(1, 1, Tile.Brick)
        self.assertFalse(self.board.tryMove(1, 1), "Was able to move to a brick tile")

    def testTryMoveToBrick(self):
        self.board.setTileAt(2, 2, Tile.Empty)
        self.assertTrue(self.board.tryMove(2, 2), "Was not able to move to an empty tile")

    def testMoveEnemyWithIntelligence1(self):
        self.level.clearEnemies()
        self.board.setTileAt(2, 1, Tile.Balloom)
        self.board.setTileAt(1, 1, Tile.Empty)

        tempList = [2, 1, constant.DIRECTION_WEST, Tile.Balloom]
        self.level.listEnemies.append(tempList)

        self.level.numberEnemies = 1
        self.level.listTypeEnemies[0] = 1

        self.board.moveEnemy(constant.SPEED_SLOW)

        self.assertEqual(self.board.tileAt(1, 1), Tile.Balloom, "Enemy did not move")
        
    def testMoveEnemyWithIntelligence2(self):
        self.level.clearEnemies()
        self.board.setTileAt(2, 1, Tile.Oneal)
        self.board.setTileAt(1, 1, Tile.Empty)
        self.board.setTileAt(3, 1, Tile.Empty)
        self.board.setTileAt(2, 0, Tile.Empty)
        self.board.setTileAt(2, 2, Tile.Empty)

        tempList = [2, 1, constant.DIRECTION_WEST, Tile.Oneal]
        self.level.listEnemies.append(tempList)

        self.level.numberEnemies = 1
        self.level.listTypeEnemies[0] = 1

        self.board.moveEnemy(constant.SPEED_NORMAL)

        check = False
        if (self.board.tileAt(1, 1) == Tile.Oneal or self.board.tileAt(3, 1) == Tile.Oneal or self.board.tileAt(2, 0) == Tile.Oneal or self.board.tileAt(2, 2) == Tile.Oneal):
            check = True
        self.assertTrue(check, "Enemy did not move")

    def testMoveEnemyWithIntelligence3(self):
        self.level.clearEnemies()
        self.board.setTileAt(2, 1, Tile.Kondoria)
        self.board.setTileAt(1, 1, Tile.Empty)
        self.board.setTileAt(3, 1, Tile.Empty)
        self.board.setTileAt(2, 0, Tile.Empty)
        self.board.setTileAt(2, 2, Tile.Empty)

        tempList = [2, 1, constant.DIRECTION_WEST, Tile.Kondoria]
        self.level.listEnemies.append(tempList)

        self.level.numberEnemies = 1
        self.level.listTypeEnemies[0] = 1

        self.board.moveEnemy(constant.SPEED_SLOWEST)

        check = False
        if (self.board.tileAt(1, 1) == Tile.Kondoria or self.board.tileAt(3, 1) == Tile.Kondoria or self.board.tileAt(2, 0) == Tile.Kondoria or self.board.tileAt(2, 2) == Tile.Kondoria):
            check = True
        self.assertTrue(check, "Enemy did not move")

    def testDetonateBombKillsBomberman(self):
        self.level.lives = 3
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.level.setBomb()

        self.board.tryMove(1, 2)

        self.board.detonateBomb()

        self.assertEqual(2, self.level.bomberman.lives, "Bomberman did not lose a life when hit by a bomb")

    def testDeathWhenEnemyMovesToBomberman(self):
        self.level.lives = 3
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()

        self.level.clearEnemies()
        self.board.setTileAt(2, 1, Tile.Balloom)
        self.level.numberEnemies = 1

        tempList = [2, 1, constant.DIRECTION_WEST, Tile.Balloom]
        self.level.listEnemies.append(tempList)

        self.level.listTypeEnemies[0] = 1

        self.board.moveEnemy(constant.SPEED_SLOW)

        self.assertEqual(2, self.level.bomberman.lives, "Bomberman did not lose a life when an enemy moves into him")

    def testDeathWhenBombermanMovesToEnemy(self):
        self.level.lives = 3
        self.board.level.bomberman.curX = 1
        self.board.level.bomberman.curY = 1
        self.board.level.setBomberman()
        self.board.setTileAt(1, 2, Tile.Balloom)

        self.board.tryMove(1, 2)

        self.assertEqual(2, self.level.bomberman.lives, "Bomberman did not lose a life when he moves into an enemy")

    def testGetScoreOfKilledEnemies(self):
        # No enemies:
        enemies = [[], [], []]
        self.assertEquals(self.board.getScoreOfKilledEnemies(enemies), 0)

        # 1 enemy at distance 1, with bomb range 1
        enemies = [[Tile.Balloom]]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points'])

        # 1 enemy at distance 1, with bomb range >1
        enemies = [[Tile.Balloom], [], []]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points'])

        # 1 enemy at distance >1
        enemies = [[], [Tile.Balloom], []]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points'])

        # 2 enemies at different distance
        enemies = [[Tile.Balloom], [], [Tile.Doll]]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points'] + 2*Enemy.getEnemy(Tile.Doll)['points'])

        # 2 enemies at same distance
        enemies = [[Tile.Doll, Tile.Balloom], [], []]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points'] + 2*Enemy.getEnemy(Tile.Doll)['points'])

        # multiple enemies at multiple distances
        enemies = [[Tile.Doll, Tile.Balloom, Tile.Doll], [], [Tile.Ovapi, Tile.Ovapi], [Tile.Pontan]]
        self.assertEqual(self.board.getScoreOfKilledEnemies(enemies), Enemy.getEnemy(Tile.Balloom)['points']
                                                                    + 2*Enemy.getEnemy(Tile.Doll)['points']
                                                                    + 4*Enemy.getEnemy(Tile.Doll)['points']
                                                                    + 8*Enemy.getEnemy(Tile.Ovapi)['points']
                                                                    + 16*Enemy.getEnemy(Tile.Ovapi)['points']
                                                                    + 32*Enemy.getEnemy(Tile.Pontan)['points'])

    def clearBricks(self):
        for x in range(constant.BOARD_WIDTH):
            for y in range(constant.BOARD_HEIGHT):
                if self.board.tileAt(x, y) == Tile.Brick:
                    self.board.popTileAt(x, y)
示例#16
0
class GameLayer(Layer):
    is_event_handler = True

    def __init__(self, levels=1, golds=0, deadcount=0):
        super(GameLayer, self).__init__()
        # 添加板子和球

        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height/2)
        self.add(self.ball.sprite)
        # 生成关卡
        self.level = Level()
        self.level.levels = levels
        # 添加标签用于记录金币和关卡。死亡次数
        self.gold = golds
        self.deadcount = deadcount

        self.hud = Label('金币: '+str(golds))
        self.level_hud = Label('关卡: '+str(levels))
        self.deadstu = Label('死亡: '+str(deadcount))

        self.hud.position = (0, 460)
        self.level_hud.position = (80, 460)
        self.deadstu.position = (160, 460)
        self.add(self.hud)
        self.add(self.level_hud)
        self.add(self.deadstu)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.blocks = []
        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)
    # def on_enter(self):
    #     self.visible = True

    def reset(self):
        self.paddle.reset()
        self.ball.reset()
        # 清空界面上的block
        for b in self.blocks:
            self.remove(b)
        # 再初始化新的砖块
        self.blocks = []
        positions = self.level.blocks_pos
        number_of_blocks = len(positions)
        for i in range(number_of_blocks):
            b = Sprite('images/block.png')
            b.position = positions[i]
            self.add(b)
            self.blocks.append(b)

    def game_over(self):
        self.deadcount += 1
        scene = Scene(GameOver(self.level.levels, self.gold, self.deadcount))
        director.replace(scene)

    def update_hud(self):
        self.hud.element.text = '金币: ' + str(self.gold)
        self.level_hud.element.text = '关卡: ' + str(self.level.levels)

    def update_blocks(self):
        for b in self.blocks:
            if collision(b, self.ball.sprite):
                self.ball.hit()
                self.blocks.remove(b)
                self.remove(b)
                self.gold += 1
                self.update_hud()
                print('金币:', self.gold)
                break

    def update_ball(self):
        if self.ball.fired:
            self.ball.update()
        else:
            bx, by = self.ball.sprite.position
            px, py = self.paddle.sprite.position
            self.ball.sprite.position = (px, by)
        collide = collision(self.ball.sprite, self.paddle.sprite)
        if collide:
            self.ball.hit()
        if self.ball.dead():
            self.game_over()

    def update_paddle(self):
        self.paddle.update()

    def update_input(self):
        self.paddle.move_right = self.key_pressed_right
        self.paddle.move_left = self.key_pressed_left
        if self.key_pressed_up:
            self.ball.fire()

    def update_newlevel(self):
        if len(self.blocks) == 0:
            self.level.next()
            print(self.level.levels)
            # self.reset()
            scene = Scene(GuoCangDongHua(self.level.levels, self.gold, self.deadcount))
            director.replace(scene)
            # director.replace(FadeTransition(Scene(GameLayer(self.level.levels, self.gold))))

    def update(self, dt):
        self.update_newlevel()
        self.update_ball()
        self.update_paddle()
        self.update_input()
        self.update_blocks()
        self.update_hud()

    def on_key_press(self, key, modifiers):
        k = symbol_string(key)
        status = True
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status

    def on_key_release(self, key, modifiers):
        k = symbol_string(key)

        status = False
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status
 def load_level(level, team=None):
     if team is None:
         team = []
     return Level('maps/level_' + str(level) + '/', level, players=team)
示例#18
0
 def setUp(self):
     self.game = Game()
     self.level = Level("testUser", 1)
     self.board = Board(self.level, self.game)
     self.clearBricks()
     self.board.start()
示例#19
0
Including my hygienic proclivities.''')

hallway = Room(
    'hallway', '''I stepped out of my house, and... what's this???
Instead of my front yard, I walk into a hallway that seems to extend forever.
Each side of the hallway is lined with room doors just like mine!
My hangover suddenly gave way to a sick stomach and wobbly knees.
... What's going on here???

To the west, I spotted an elevator that looks too old to function.
But it seemed to be the only thing that would get me out of this nightmare.''')

elevator = Room(
    'elevator',
    '''This elevator is operated with a steel lever.\nQuite old school.''')

spa = Room(
    'spa', '''I pulled the lever and headed down.
The counter kept counting, counting, counting down.
In God-knows-how-long, I exit the elevator,
and I'm greeted by a friendly Velociraptor in a tuxedo and a bow-tie.
"Welcome, Sirmadam!"''')

bedRoom.set_east(kitchen)
bedRoom.set_south(living)
bedRoom.set_north(hallway)
hallway.set_west(elevator)
elevator.set_south(spa)

level_one = Level(bedRoom)
示例#20
0
class MarioGame(GameState):
    def __init__(self, game_info, sound_manager):
        GameState.__init__(self, GameState.STATE_GAME, GameState.STATE_LOAD)

        self.game_info = game_info
        self.sound_manager = sound_manager

        self.game_info.set_timer_in_seconds(300)

        self.mario_game_time = -1
        self.world_shift = 0

        self.player = Player(self.sound_manager, game_info)

        self.active_sprite_list = pygame.sprite.Group()
        self.active_sprite_list.add(self.player)

        self.level = Level(game_info, self.player, self.sound_manager)

        if constants.DEBUG:
            self.debug_overlay = DebugOverlay(self.game_info, self.player)

        self.sound_manager.play_music(constants.MUSIC_MAIN_THEME)

    def process_events(self, events):
        for event in events:
            if event.type == pygame.KEYDOWN:
                key = event.key
                if key == pygame.K_LEFT:
                    self.player.go_left()
                if key == pygame.K_RIGHT:
                    self.player.go_right()
                if key == pygame.K_UP:
                    self.player.jump()
                if key == pygame.K_DOWN:
                    self.player.crouch()
                if key == pygame.K_a:
                    self.player.transition(constants.POWER_LARGE)
                if key == pygame.K_s:
                    self.player.transition(constants.POWER_SMALL)
                if key == pygame.K_t:
                    self.player.start_death_sequence()
                if key == pygame.K_ESCAPE or key == pygame.K_q:
                    # TODO should be pause
                    pass

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_LEFT and self.player.x_vel < 0:
                    self.player.stop()
                if event.key == pygame.K_RIGHT and self.player.x_vel > 0:
                    self.player.stop()
                if event.key == pygame.K_DOWN:
                    self.player.stop()

    def update(self, game_time):
        if self.mario_game_time == -1:
            self.mario_game_time = game_time
        else:
            self.game_info.timer -= (game_time - self.mario_game_time)
            self.mario_game_time = game_time

        if self.player.rect.bottom > constants.SCREEN_HEIGHT and self.player.transition_state is not constants.TRANSITION_DEATH_SEQUENCE:
            self.player.start_death_sequence()

        if self.player.state == constants.STATE_DEAD:
            self.switch = True
            self.game_info.num_lives -= 1
            if self.game_info.num_lives < 0:
                self.set_next_state(GameState.STATE_GAME_OVER)

        self.level.update(game_time)

    def draw(self, screen):
        self.level.draw(screen)
        self.active_sprite_list.draw(screen)

        if constants.DEBUG:
            self.debug_overlay.draw(screen)
示例#21
0
 def test_default_update_just_returns_true(self):
     self.assertTrue(Entity(0, 0).update(Level(self.config)))
示例#22
0
class GamePlayingState:
    def __init__(self, game):
        self._game = game
        self._paused = False
        self._game_over = False

    def enter(self):
        self.create_level()

    def create_level(self):
        """ Creates a new player and restarts level sprites. """
        self._paused = False
        self._game.ui.clear()
        self._player = PlayerCtrl()
        self._level = Level('level_1.tmx', self._player, self)
        self._timer = Timer()

    def exit(self):
        # Save score or something
        self._game.ui.clear()

    def process_events(self, event):
        if not self._game_over:
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_p:
                    self.pause()

    def pause(self):
        if self._paused:
            self._game.ui.pop_menu()
            Timer.unpause_timers()
        else:
            actions = [{
                'action': self.pause,
                'text': 'Resume'
            }, {
                'action': self.create_level,
                'text': 'Restart'
            }, {
                'action':
                lambda: self._game.set_state(GameNotPlayingState),
                'text':
                'Main Menu'
            }]
            self._game.ui.make_menu("Game Paused", actions, 24, cfg.WHITE)
            Timer.pause_timers()
        self._paused = not self._paused

    def game_over(self):
        actions = [{
            'action': lambda: self._game.set_state(GamePlayingState),
            'text': 'Play Again'
        }, {
            'action': lambda: self._game.set_state(GameNotPlayingState),
            'text': 'Main Menu'
        }, {
            'action': self._game.quit,
            'text': 'Quit'
        }]
        if self._player.alive():
            title = "You win!"
        else:
            title = "Game Over!"
        self._game.ui.make_menu(title, actions, 24, cfg.WHITE)
        self._timer.pause()
        self._game_over = True

    def handle_input(self, active_bindings, mouse_state, mouse_x, mouse_y):
        if not (self._paused or self._game_over):
            self._player.handle_keys(active_bindings)
            self._player.handle_mouse(mouse_state, mouse_x, mouse_y)

    def update(self, dt):
        if not self._paused:
            self._level.update(dt)

    def draw(self):
        self._level.draw(self._game.screen)
        self._game.ui.draw(self._game.screen)
        total_secs = self._timer.elapsed_time() // 1000
        mins = total_secs // 60
        secs = total_secs % 60
        gtext.render(self._game.screen,
                     f"{mins:02d}:{secs:02d}",
                     24,
                     cfg.WHITE,
                     location='n')
示例#23
0
 def on_click(self):
     self.window.show_view(Level(1))
示例#24
0
class GameLayer(Layer):
    is_event_handler = True

    def __init__(self, hud):
        super(GameLayer, self).__init__()
        # 添加板子和球
        self.is_on_exiting = True
        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height / 2)
        self.add(self.ball.sprite)
        # hud 用于记录,更新关卡,死亡,金币数据
        self.hud = hud
        # 生成关卡
        self.level = Level()
        self.level.levels = self.hud.levels

        self.add(self.hud.gold_hud)
        self.add(self.hud.level_hud)
        self.add(self.hud.death_hud)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)

    def reset(self):
        self.paddle.reset()
        self.ball.reset()
        # 清空界面上的block
        for b in self.level.blocks:
            self.remove(b.sprite)
        # 再初始化新的砖块
        self.level.reset()
        for b in self.level.blocks:
            self.add(b.sprite)

    def game_over(self):
        self.hud.death += 1
        self.is_on_exiting = False
        scene = create_scene(GameOver(self.hud))
        director.replace(scene)

    def update_hud(self):
        self.hud.update()

    def update_blocks(self):
        for b in self.level.blocks:
            if collised(b.sprite, self.ball.sprite):
                print(1)
                self.ball.hit()
                b.live -= 1
                if b.live < 0:
                    self.level.blocks.remove(b)
                    self.remove(b.sprite)
                else:
                    b.reset()
                self.hud.gold += 1
                self.update_hud()
                print('金币:', self.hud.gold)
                break

    def update_ball(self):
        if self.ball.fired:
            self.ball.update()
        else:
            bx, by = self.ball.sprite.position
            px, py = self.paddle.sprite.position
            self.ball.sprite.position = (px, by)
        collide = collised(self.ball.sprite, self.paddle.sprite)
        if collide:
            xisu = 1
            bx, by = self.ball.sprite.position
            px, py = self.paddle.sprite.position
            offect_scale = (bx - px) / (self.paddle.sprite.width / 2)
            ball_speedx_change = offect_scale * xisu
            self.ball.speedx += ball_speedx_change
            self.ball.hit()
        if self.ball.dead():
            self.game_over()

    def update_paddle(self):
        self.paddle.update()

    def update_input(self):
        self.paddle.move_right = self.key_pressed_right
        self.paddle.move_left = self.key_pressed_left
        if self.key_pressed_up:
            self.ball.fire()

    def update_newlevel(self):
        if len(self.level.blocks) == 0:
            self.is_on_exiting = False
            if self.level.next():
                print(self.level.levels)
                self.hud.levels += 1
                scene = create_scene(GuoCangDongHua(self.hud))
            else:
                scene = create_scene(GameComplite(self.hud))
            director.replace(scene)

    def update(self, dt):
        if self.is_on_exiting:
            self.update_newlevel()
            self.update_ball()
            self.update_paddle()
            self.update_input()
            self.update_blocks()
            self.update_hud()

    def on_key_press(self, key, modifiers):
        k = symbol_string(key)
        status = True
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status

    def on_key_release(self, key, modifiers):
        k = symbol_string(key)

        status = False
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status
示例#25
0
    pg.init()

    # Load fonts
    fonts.init_fonts()

    # Window parameters
    pg.display.set_caption("In the name of the Five Cats")
    screen = pg.display.set_mode((MAIN_WIN_WIDTH, MAIN_WIN_HEIGHT))

    # Load constant sprites
    Destroyable.init_constant_sprites()
    Breakable.init_constant_sprites()
    Movable.init_constant_sprites()
    Sidebar.init_constant_sprites()
    Level.init_constant_sprites()

    # Load some data
    races = Loader.load_races()
    classes = Loader.load_classes()
    Character.init_data(races, classes)

    clock = pg.time.Clock()

    start_screen = StartScreen(screen)

    quit_game = False
    while not quit_game:
        for e in pg.event.get():
            if e.type == pg.QUIT:
                quit_game = True
示例#26
0
class EditorScene(Scene):
    def __init__(self):
	self.dirty = True

    def enter(self, app):
	self.app = app
	self.view = app.view
        
        self.palette = [ ]
        for name  in get_all('entities'):
            newtype = entities.get(name)
            self.palette.append(newtype)
            
        self.level = Level(app)

        self.mode = 't'
        self.mark = None
        self.delmark = None
        self.markmat = entities.get('mark')
        self.ground = entities.get('ground')
        
        print "CURRENT BRUSH:", self.brush

    def build(self, x, y, etype, *args, **kwargs):
        ct = self.level.tile_at(x, y)
        if ct:
            self.destroy(ct)
        self.level.tiles.append(etype(x, y, *args, **kwargs))

    def place(self, x, y, etype, *args, **kwargs):
        ce = self.level.ent_at(x, y)
        if ce:
            self.remove(ce)
        self.level.entities.append(etype(x, y, *args, **kwargs))

    def destroy(self, entity):
        if entity in self.level.tiles:
            self.level.tiles.remove(entity)

    def remove(self, entity):
        if entity in self.level.entities:
            self.level.entities.remove(entity)

    def reset_editor(self):
        self.mode = 't'
        self.mark = None
        self.delmark = None

    def next_brush(self):
        self.palette.append(self.palette.pop(0))

    def prev_brush(self):
        self.palette.insert(0, self.palette.pop())

    def _getbrush(self):
        return self.palette[0]
    brush = property(_getbrush)

    def save(self, filename):
        filename = filename.strip()
        print os.getcwd()
        fobj = open(os.path.join("data/levels", filename + '.lvl'), 'w')
        pickle.dump(self.level, fobj)
        print "Level '{0}' saved".format(filename)

    def load(self, filename):
        
        try:
            fobj = open(os.path.join("data/levels", filename + '.lvl'), 'r')
            self.level = pickle.load(fobj)
            self.reset_editor()
            self.dirty = True
            print "Level '{0}' loaded".format(filename)
        except Exception, e:
            raise e
            print "Unable to load '{0}'".format(filename)
示例#27
0
class EditorScene(Scene):
    def __init__(self):
        self.dirty = True

    def enter(self, app):
        self.app = app
        self.view = app.view

        self.palette = []
        for name in get_all('entities'):
            newtype = entities.get(name)
            self.palette.append(newtype)

        self.level = Level(app)

        self.mode = 't'
        self.mark = None
        self.delmark = None
        self.markmat = entities.get('mark')
        self.ground = entities.get('ground')

        print "CURRENT BRUSH:", self.brush

    def build(self, x, y, etype, *args, **kwargs):
        ct = self.level.tile_at(x, y)
        if ct:
            self.destroy(ct)
        self.level.tiles.append(etype(x, y, *args, **kwargs))

    def place(self, x, y, etype, *args, **kwargs):
        ce = self.level.ent_at(x, y)
        if ce:
            self.remove(ce)
        self.level.entities.append(etype(x, y, *args, **kwargs))

    def destroy(self, entity):
        if entity in self.level.tiles:
            self.level.tiles.remove(entity)

    def remove(self, entity):
        if entity in self.level.entities:
            self.level.entities.remove(entity)

    def reset_editor(self):
        self.mode = 't'
        self.mark = None
        self.delmark = None

    def next_brush(self):
        self.palette.append(self.palette.pop(0))

    def prev_brush(self):
        self.palette.insert(0, self.palette.pop())

    def _getbrush(self):
        return self.palette[0]

    brush = property(_getbrush)

    def save(self, filename):
        filename = filename.strip()
        print os.getcwd()
        fobj = open(os.path.join("data/levels", filename + '.lvl'), 'w')
        pickle.dump(self.level, fobj)
        print "Level '{0}' saved".format(filename)

    def load(self, filename):

        try:
            fobj = open(os.path.join("data/levels", filename + '.lvl'), 'r')
            self.level = pickle.load(fobj)
            self.reset_editor()
            self.dirty = True
            print "Level '{0}' loaded".format(filename)
        except Exception, e:
            raise e
            print "Unable to load '{0}'".format(filename)
示例#28
0
class DataModel(QGraphicsScene):

    ################################################################################

    def __init__(self) -> None:
        """
        Creates a data model which is used for a graphic representation of
        Sokoban level (QGraphics View framework). QGraphicsScene.keyPressEvent()
        is implemented to process various player input.
        """

        super().__init__()
        self._level = Level("levels/01/01")
        self.setSceneRect(
            QRectF(QPointF(0, 0), QPointF(self._level.width,
                                          self._level.height)))
        [
            self.addItem(item) for item in self._level.tiles +
            self._level.boxes + tuple([self._level.player])
        ]
        self._level.player.moveFinished.connect(self.unlockGame)
        self._gameLock = False

################################################################################

    @property
    def level(self) -> Level:
        """
        :return: current level object
        """

        return self._level

################################################################################

    def lockGame(self) -> None:
        """
        Locks the game to deny the player any input.

        :return: None
        """

        self._gameLock = True

################################################################################

    def unlockGame(self) -> None:
        """
        Unlocks the game to allow the player any input.

        :return: None
        """

        self._gameLock = False

################################################################################

    def keyPressEvent(self, event: QKeyEvent) -> None:
        """
        Handles the player's keyboard input.
        Possible actions:
        -move player up, down, left, right
        -reset level to the initial state
        -start bfs algorithm (deterministic)
        -start bfs algorithm (non-deterministic)
        -start dfs algorithm (deterministic)
        -start dfs algorithm (non-deterministic)
        
        :param event: QKeyEvent to be handled
        :return: None
        """

        if not self._gameLock:
            key = event.key()
            if key in self._level.DIRECTIONS:
                dRow = self._level.DIRECTIONS[key][0]
                dColumn = self._level.DIRECTIONS[key][1]
                self._level.movePlayer(dRow, dColumn, animated=True)
            elif key == Qt.Key_R:
                self._level.reset()
            elif key == Qt.Key_B:
                if event.modifiers() == Qt.ShiftModifier:
                    self._level.bfs(deterministic=False)
                else:
                    self._level.bfs()
            elif key == Qt.Key_D:
                if event.modifiers() == Qt.ShiftModifier:
                    self._level.dfs(deterministic=False)
                else:
                    self._level.dfs()
        super().keyPressEvent(event)
示例#29
0
def debug():
    cwd = os.getcwd()
    level1 = Level('../levels/007.xml')
    start(level1)
    print('stop')
示例#30
0
文件: main.py 项目: Fuyingxue/game1
class GameLayer(Layer):
    is_event_handler = True

    def __init__(self, hud):
        super(GameLayer, self).__init__()
        # 添加板子和球
        self.is_on_exiting = True
        self.paddle = Paddle('images/paddle.png')
        self.add(self.paddle.sprite)
        self.ball = Ball('images/ball.png')
        self.ball.reset_position = (320, self.paddle.sprite.height + self.ball.sprite.height / 2)
        self.add(self.ball.sprite)
        # hud 用于记录,更新关卡,死亡,金币数据
        self.hud = hud
        # 生成关卡
        self.level = Level()
        self.level.levels = self.hud.levels

        self.add(self.hud.gold_hud)
        self.add(self.hud.level_hud)
        self.add(self.hud.death_hud)

        # 添加按键状态
        self.key_pressed_left = False
        self.key_pressed_right = False
        self.key_pressed_up = False
        self.key_pressed_down = False

        self.reset()

        # 定期调用 self.update 函数
        # FPS frame per second 每秒帧数
        self.schedule(self.update)

    def reset(self):
        self.paddle.reset()
        self.ball.reset()
        # 清空界面上的block
        for b in self.level.blocks:
            self.remove(b.sprite)
        # 再初始化新的砖块
        self.level.reset()
        for b in self.level.blocks:
            self.add(b.sprite)

    def game_over(self):
        self.hud.death += 1
        self.is_on_exiting = False
        scene = create_scene(GameOver(self.hud))
        director.replace(scene)

    def update_hud(self):
        self.hud.update()

    def update_blocks(self):
        for b in self.level.blocks:
            if collised(b.sprite, self.ball.sprite):
                print(1)
                self.ball.hit()
                b.live -= 1
                if b.live < 0:
                    self.level.blocks.remove(b)
                    self.remove(b.sprite)
                else:
                    b.reset()
                self.hud.gold += 1
                self.update_hud()
                print('金币:', self.hud.gold)
                break

    def update_ball(self):
        if self.ball.fired:
            self.ball.update()
        else:
            bx, by = self.ball.sprite.position
            px, py = self.paddle.sprite.position
            self.ball.sprite.position = (px, by)
        collide = collised(self.ball.sprite, self.paddle.sprite)
        if collide:
            xisu = 1
            bx, by = self.ball.sprite.position
            px, py = self.paddle.sprite.position
            offect_scale = (bx - px) / (self.paddle.sprite.width / 2)
            ball_speedx_change = offect_scale * xisu
            self.ball.speedx += ball_speedx_change
            self.ball.hit()
        if self.ball.dead():
            self.game_over()

    def update_paddle(self):
        self.paddle.update()

    def update_input(self):
        self.paddle.move_right = self.key_pressed_right
        self.paddle.move_left = self.key_pressed_left
        if self.key_pressed_up:
            self.ball.fire()

    def update_newlevel(self):
        if len(self.level.blocks) == 0:
            self.is_on_exiting = False
            if self.level.next():
                print(self.level.levels)
                self.hud.levels += 1
                scene = create_scene(GuoCangDongHua(self.hud))
            else:
                scene = create_scene(GameComplite(self.hud))
            director.replace(scene)

    def update(self, dt):
        if self.is_on_exiting:
            self.update_newlevel()
            self.update_ball()
            self.update_paddle()
            self.update_input()
            self.update_blocks()
            self.update_hud()

    def on_key_press(self, key, modifiers):
        k = symbol_string(key)
        status = True
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status

    def on_key_release(self, key, modifiers):
        k = symbol_string(key)

        status = False
        if k == 'LEFT':
            self.key_pressed_left = status
        elif k == 'RIGHT':
            self.key_pressed_right = status
        elif k == 'UP':
            self.key_pressed_up = status
示例#31
0
 def setUp(self):
     self.level = Level({'width': 10, 'height': 10})
     self.collision_controller = CollisionController(self.level)
示例#32
0
 def test_move_entity_gets_stuck_on_unwalkable_tile(self):
     level = Level(self.config).create_empty_tiles()
     level.tiles[0][0].set_type('floor')
     entity = Entity(0, 0)
     entity.move(1, 0, level)
     self.assertEqual((0, 0), (entity.x, entity.y))