def test_board_management(self): b = engine.Board() g = engine.Game(player=constants.NO_PLAYER) self.assertIsNone(g.add_board(19, b)) self.assertIsNone(g.change_level(19)) self.assertIsNone(g.display_board()) # Reset g = engine.Game() with self.assertRaises(base.PglInvalidTypeException): g.add_board(1, 1) with self.assertRaises(base.PglInvalidTypeException): g.add_board("1", 1) with self.assertRaises(base.PglInvalidTypeException): g.get_board("1") self.assertIsInstance(g.get_board(1), engine.Board) with self.assertRaises(base.PglInvalidLevelException): g.current_board() with self.assertRaises(base.PglException) as e: g.change_level(1) self.assertEqual(e.error, "undefined_player") g.player = board_items.Player() self.assertIsNone(g.change_level(1)) self.assertIsNone(g.add_board(2, engine.Board())) self.assertIsNone(g.change_level(2)) self.assertIsNone(g.change_level(1)) with self.assertRaises(base.PglInvalidLevelException): g.change_level(99) with self.assertRaises(base.PglInvalidTypeException): g.change_level("2")
def test_board_management(self): b = engine.Board() g = engine.Game(player=board_items.Player()) self.assertIsNone(g.add_board(19, b)) self.assertIsNone(g.change_level(19)) self.assertIsNone(g.display_board()) # Test display_board but with partial display on. g.enable_partial_display = True g.partial_display_viewport = [2, 2] self.assertIsNone(g.display_board()) # Reset g = engine.Game() with self.assertRaises(base.PglInvalidTypeException): g.add_board(1, 1) with self.assertRaises(base.PglInvalidTypeException): g.add_board("1", 1) with self.assertRaises(base.PglInvalidTypeException): g.get_board("1") g.add_board(1, b) self.assertIsInstance(g.get_board(1), engine.Board) with self.assertRaises(base.PglInvalidLevelException): g.current_board() with self.assertRaises(base.PglException) as e: g.change_level(1) self.assertEqual(e.exception.error, "undefined_player") g.player = board_items.Player() self.assertIsNone(g.change_level(1)) self.assertIsNone(g.add_board(2, engine.Board())) self.assertIsNone(g.change_level(2)) self.assertIsNone(g.change_level(1)) with self.assertRaises(base.PglInvalidLevelException): g.change_level(99) with self.assertRaises(base.PglInvalidTypeException): g.change_level("2")
def test_item(self): self.board = pgl_engine.Board(name="test_board", size=[10, 10], player_starting_position=[5, 5]) self.placed_item = pgl_board_items.BoardItem() self.board.place_item(self.placed_item, 1, 1) self.returned_item = self.board.item(1, 1) self.assertEqual(self.placed_item, self.returned_item) with self.assertRaises( pgl_base.PglOutOfBoardBoundException) as excinfo: self.board.item(15, 15) self.assertTrue( "out of the board boundaries" in str(excinfo.exception)) sprix = gfx_core.Sprixel(bg_color=gfx_core.Color(45, 45, 45)) sprix.is_bg_transparent = True self.board.place_item( pgl_board_items.Door(sprixel=gfx_core.Sprixel( bg_color=gfx_core.Color(15, 15, 15))), 5, 5, ) i = pgl_board_items.NPC(sprixel=sprix) self.assertIsNone(self.board.place_item(i, 5, 5)) self.assertIsNone( self.board.place_item( pgl_board_items.ComplexNPC( base_item_type=pgl_board_items.Movable), 8, 8, 8, )) self.assertIsNone(self.board.place_item(pgl_board_items.Tile(), 8, 2)) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.place_item(1, 1, 1) with self.assertRaises(pgl_base.PglOutOfBoardBoundException): self.board.place_item(i, 100, 100) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.remove_item(1) # Let's try to break things j = pgl_board_items.NPC() j.store_position(2, 2) with self.assertRaises(pgl_base.PglException) as e: self.board.remove_item(j) self.assertEqual(e.exception.error, "invalid_item") self.assertTrue(self.board.remove_item(i)) b = pgl_engine.Board() i = pgl_board_items.ComplexNPC(sprite=gfx_core.Sprite( sprixels=[[gfx_core.Sprixel("#"), gfx_core.Sprixel("#")]])) self.assertIsNone(b.place_item(i, 5, 5, 0)) self.assertTrue(b.remove_item(i))
def test_sanity_ui_board_void_cell_sprixel(self): with self.assertRaises(pgl_base.PglException) as context: self.board = pgl_engine.Board(name="test_board", size=[10, 10], ui_board_void_cell_sprixel=[]) self.assertEqual(context.error, "SANITY_CHECK_KO") b = pgl_engine.Board( name="test_board", size=[90, 90], DISPLAY_SIZE_WARNINGS=True, ui_board_void_cell_sprixel=gfx_core.Sprixel(), ) self.assertIsInstance(b, pgl_engine.Board) self.assertIsNone(b.display()) self.board.item(0, 2).model = "#" self.assertIsNone(self.board.display())
def test_sanity_ui_border_right_string(self): with self.assertRaises(Exception) as context: self.board = pgl_engine.Board(name="test_board", size=[10, 10], ui_border_right=[]) self.assertTrue("must be a string" in str(context.exception))
def test_sanity_name_string(self): with self.assertRaises(Exception) as context: self.board = pgl_engine.Board(name=100, size=[10, 10], player_starting_position=[5, 5]) self.assertTrue("must be a string" in str(context.exception))
def test_sanity_size_has_two_elements(self): with self.assertRaises(Exception) as context: self.board = pgl_engine.Board( name="test_board", size=["one"], player_starting_position=[5, 5] ) self.assertTrue("must be a list of 2 elements" in str(context.exception))
def test_clear_cell(self): self.board = pgl_engine.Board(name="test_board", size=[10, 10], player_starting_position=[5, 5]) self.placed_item = pgl_board_items.BoardItem() self.board.place_item(item=self.placed_item, row=1, column=1) self.assertIsInstance(self.board.item(1, 1), pgl_board_items.BoardItem) self.board.clear_cell(1, 1) self.assertIsInstance(self.board.item(1, 1), pgl_board_items.BoardItemVoid) self.assertIsNone(self.board.clear_cell(1, 1, 10)) r = self.board.height - 1 c = self.board.width - 1 self.board.place_item(pgl_board_items.Door(name="door_layer_0"), r, c, 0) self.board.place_item(pgl_board_items.Door(name="door_layer_1"), r, c, 1) self.board.place_item(pgl_board_items.Door(name="door_layer_2"), r, c, 2) self.board.place_item(pgl_board_items.Door(name="door_layer_3"), r, c, 3) self.assertIsNone(self.board.clear_cell(r, c, 2)) self.assertEqual(self.board.layers(r, c), 3) self.board.place_item(pgl_board_items.Door(name="door_layer_3bis"), r, c, 3, False) self.assertIsNone(self.board.clear_cell(r, c, 1)) self.assertEqual(self.board.layers(r, c), 4)
def test_npc_management(self): b = engine.Board() g = engine.Game() self.assertIsNone(g.add_board(1, b)) npc = board_items.NPC(step=None) self.assertIsNone(g.add_npc(1, npc)) with self.assertRaises(base.PglInvalidTypeException): g.add_npc(1, board_items.NPC(step=None), "1") with self.assertRaises(base.PglInvalidTypeException): g.add_npc(1, board_items.NPC(step=None), None, "1") with self.assertRaises(base.PglInvalidTypeException): g.add_npc(1, board_items.NPC(step=None), 1, "1") with self.assertRaises(base.PglInvalidTypeException): g.add_npc(1, board_items.NPC(step=None), "1", 1) with self.assertRaises(base.PglInvalidTypeException): g.add_npc(1, 1) with self.assertRaises(base.PglInvalidTypeException): g.add_npc("1", board_items.NPC()) self.assertIsNone(g.actuate_npcs(1)) g.mode = constants.MODE_RT self.assertIsNone(g.actuate_npcs(1)) with self.assertRaises(base.PglInvalidLevelException): g.actuate_npcs(99) with self.assertRaises(base.PglInvalidTypeException): g.actuate_npcs("1") g.remove_npc(1, npc)
def test_sanity_size_element_two_int(self): with self.assertRaises(Exception) as context: self.board = pgl_engine.Board(name="test_board", size=[10, "two"], player_starting_position=[5, 5]) self.assertTrue("second element of the" in str(context.exception))
def change_level(params): next_level_wave_obj.play() game = params[0] board = engine.Board( size=[250, 30], ui_borders="", ui_board_void_cell=bg_color + " " + graphics.Style.RESET_ALL, player_starting_position=[25, 0], DISPLAY_SIZE_WARNINGS=False, ) board.ui_border_bottom = graphics.Models.RADIOACTIVE + " " board.sprouted_count = 0 # Let's use a nice curve to increase the trap number. board.available_traps = int(10 + 10 * g.current_level * 0.2) board.max_traps_number = board.available_traps for i in range(0, board.size[0]): board.place_item( board_items.Wall( model=block_color() + " " + graphics.Style.RESET_ALL, type="platform" ), board.size[1] - 1, i, ) generate_level(game, board) game.score += 50 * game.current_level new_level = game.current_level + 1 game.add_board(new_level, board) game.change_level(new_level) game.move_player(constants.RIGHT, 3) game.player.last_y = game.player.pos[0] game.player.last_x = game.player.pos[1] g.player.max_y = g.player.pos[0] g.player.dy = gravity_speed g.obj_stack = []
def test_tools_function(self): b = engine.Board() g = engine.Game() g.player = constants.NO_PLAYER self.assertIsNone(g.add_board(1, b)) self.assertIsNone(g.change_level(1)) self.assertIsNone( g.add_npc(1, board_items.NPC(value=10, inventory_space=1), 1, 1)) self.assertIsNone( b.place_item(board_items.Door(value=10, inventory_space=1), 1, 2)) self.assertIsNone( b.place_item(board_items.Wall(value=10, inventory_space=1), 1, 3)) self.assertIsNone( b.place_item( board_items.GenericStructure(value=10, inventory_space=1), 1, 4)) self.assertIsNone( b.place_item( board_items.GenericActionableStructure(value=10, inventory_space=1), 1, 5, )) self.assertIsNone( b.place_item( board_items.Door(value=10, inventory_space=1, sprixel=core.Sprixel("#")), 2, 2, )) self.assertIsNone( b.place_item(board_items.Treasure(value=10, inventory_space=1), 1, 6)) with self.assertRaises(base.PglInvalidTypeException): g.neighbors("2") with self.assertRaises(base.PglInvalidTypeException): g.neighbors(2, "crash") g.object_library.append(board_items.NPC()) self.assertIsNone( g.save_board(1, "test-pygamelib.engine.Game.lvl1.json")) with self.assertRaises(base.PglInvalidTypeException): g.save_board("1", "test-pygamelib.engine.Game.lvl1.json") with self.assertRaises(base.PglInvalidTypeException): g.save_board(1, 1) with self.assertRaises(base.PglInvalidLevelException): g.save_board(11, "test-pygamelib.engine.Game.lvl1.json") self.assertIsInstance( g.load_board("test-pygamelib.engine.Game.lvl1.json", 1), engine.Board) self.assertEqual(g._string_to_constant("UP"), constants.UP) self.assertEqual(g._string_to_constant("DOWN"), constants.DOWN) self.assertEqual(g._string_to_constant("LEFT"), constants.LEFT) self.assertEqual(g._string_to_constant("RIGHT"), constants.RIGHT) self.assertEqual(g._string_to_constant("DRUP"), constants.DRUP) self.assertEqual(g._string_to_constant("DRDOWN"), constants.DRDOWN) self.assertEqual(g._string_to_constant("DLUP"), constants.DLUP) self.assertEqual(g._string_to_constant("DLDOWN"), constants.DLDOWN)
def test_sanity_size_is_list(self): with self.assertRaises(Exception) as context: self.board = pgl_engine.Board(name="test_board", size="bad", player_starting_position=[5, 5]) self.assertTrue("must be a list." in str(context.exception))
def test_serialization(self): class Bork(pgl_board_items.Wall): def __init__(self, **kwargs): super().__init__(**kwargs) b = pgl_engine.Board(ui_board_void_cell_sprixel=gfx_core.Sprixel( " ", gfx_core.Color(0, 0, 0))) b.place_item(pgl_board_items.Wall(), 2, 2) b.place_item(TestItem(), 4, 4) data = b.serialize() self.assertIsNotNone(data) self.assertIsNone(pgl_engine.Board.load(None)) bl = pgl_engine.Board.load(data) self.assertEqual(b.player_starting_position, bl.player_starting_position) self.assertEqual(b.name, bl.name) self.assertEqual(b.ui_board_void_cell, bl.ui_board_void_cell) self.assertIsInstance(b.item(2, 2), pgl_board_items.Wall) self.assertEqual(b.item(2, 2).model, bl.item(2, 2).model) data["map_data"]["(2, 2, 0)"]["object"] = "<'=bork.bork'>" with self.assertRaises(SyntaxError): pgl_engine.Board.load(data) b.place_item(Bork(), 6, 6) with self.assertRaises(SyntaxError): pgl_engine.Board.load(b.serialize())
def test_size(self): board = pgl_engine.Board(name="test_board", size=[20, 30], player_starting_position=[5, 5]) self.assertEqual(board.height, 30) self.assertEqual(board.width, 20) self.assertEqual(board.layers(0, 0), 1)
def test_clear_cell(self): self.board = pgl_engine.Board( name="test_board", size=[10, 10], player_starting_position=[5, 5] ) self.placed_item = pgl_board_items.BoardItem() self.board.place_item(item=self.placed_item, row=1, column=1) self.assertIsInstance(self.board.item(1, 1), pgl_board_items.BoardItem) self.board.clear_cell(1, 1) self.assertIsInstance(self.board.item(1, 1), pgl_board_items.BoardItemVoid)
def test_create_board(self): self.board = pgl_engine.Board( name="test_board", size=[10, 10], player_starting_position=[5, 5], ui_borders="*", ) self.assertEqual(self.board.name, "test_board") self.assertEqual(self.board.ui_border_bottom, "*") ret = self.board.__str__() self.assertIsNotNone(ret) b = pgl_engine.Board( name="test_board_sprixel", size=[10, 10], player_starting_position=[5, 5], ui_board_void_cell_sprixel=gfx_core.Sprixel(), ) vc = b.generate_void_cell() self.assertIsInstance(vc.sprixel, gfx_core.Sprixel)
def test_move_complex(self): def _act(p): p[0].assertEqual(p[1], 1) self.board = pgl_engine.Board( name="test_board", size=[10, 10], player_starting_position=[5, 5], ) i = pgl_board_items.ComplexNPC(sprite=gfx_core.Sprite( default_sprixel=gfx_core.Sprixel("*"))) g = pgl_engine.Game(mode=constants.MODE_RT) self.board.place_item(i, 1, 1) self.assertIsInstance(self.board.item(1, 1), pgl_board_items.ComplexNPC) self.assertIsNone(self.board.move(i, constants.RIGHT, 1)) i = pgl_board_items.ComplexPlayer(sprite=gfx_core.Sprite( default_sprixel=gfx_core.Sprixel("*"), sprixels=[[gfx_core.Sprixel("@"), gfx_core.Sprixel("@")]], )) self.board.place_item(i, 3, 1) self.assertIsInstance(self.board.item(3, 1), pgl_board_items.ComplexPlayer) self.board.place_item( pgl_board_items.GenericActionableStructure( action=_act, action_parameters=[self, 1]), i.row, i.column + i.width, ) self.assertIsNone(self.board.move(i, constants.RIGHT, 1)) self.board.place_item(pgl_board_items.Treasure(value=50), i.row + i.height, i.column) self.assertIsNone(self.board.move(i, constants.DOWN, 1)) self.assertEqual(i.inventory.value(), 50) i.parent = g i.dtmove = 0.0 self.assertIsNone(self.board.move(i, pgl_base.Vector2D(1, 0))) i.dtmove = 5.0 self.assertIsNone(self.board.move(i, pgl_base.Vector2D(1, 0))) with self.assertRaises(pgl_base.PglObjectIsNotMovableException): self.board.move(pgl_board_items.Immovable(), constants.DOWN, 1) g.mode = constants.MODE_TBT self.board.place_item(pgl_board_items.Door(), i.row, i.column + i.width) self.assertIsNone(self.board.move(i, constants.RIGHT, 1)) self.assertIsNone(self.board.move(i, constants.RIGHT, 2)) self.assertIsNone(self.board.move(i, constants.DOWN, 2)) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.move(i, constants.DOWN, "1") with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.move(i, "constants.DOWN", 1)
def test_move_simple(self): def _act(p): setattr(p[0], "test_callback", True) p[0].assertEqual(p[1], 1) i = pgl_board_items.Player(sprixel=gfx_core.Sprixel("*")) i.sprixel.is_bg_transparent = True b = pgl_engine.Board( name="test_board", size=[10, 10], player_starting_position=[0, 0], ) b.place_item(i, 0, 0) self.assertIsNone(b.move(i, constants.DOWN, 1)) self.assertIsNone(b.move(i, constants.UP, 1)) self.assertIsNone(b.move(i, constants.RIGHT, 1)) self.assertIsNone(b.move(i, constants.LEFT, 1)) self.assertIsNone(b.move(i, constants.DRDOWN, 1)) self.assertIsNone(b.move(i, constants.DRUP, 1)) self.assertIsNone(b.move(i, constants.DLDOWN, 1)) self.assertIsNone(b.move(i, constants.DLUP, 1)) self.assertIsNone(b.move(i, pgl_base.Vector2D(0, 0))) self.assertEqual(i.pos, [0, 0, 0]) setattr(self, "test_callback", False) b.place_item( pgl_board_items.GenericActionableStructure( action=_act, action_parameters=[self, 1]), 0, 1, ) self.assertIsNone(b.move(i, constants.RIGHT, 1)) self.assertIsNone(b.move(i, constants.RIGHT, 1)) self.assertTrue(getattr(self, "test_callback")) b.place_item(pgl_board_items.Treasure(value=50), i.row + 1, i.column) self.assertIsNone(b.move(i, constants.DOWN, 1)) self.assertEqual(i.inventory.value(), 50) b.place_item( pgl_board_items.Door(sprixel=gfx_core.Sprixel( bg_color=gfx_core.Color(45, 45, 45))), i.row + 1, i.column, ) b.place_item( pgl_board_items.Door(sprixel=gfx_core.Sprixel( bg_color=gfx_core.Color(45, 45, 45))), i.row + 2, i.column, ) self.assertIsNone(b.move(i, constants.DOWN, 1)) self.assertIsNone(b.move(i, constants.DOWN, 1)) self.assertIsNone(b.clear_cell(i.row, i.column))
def test_get_objects(self): b = pgl_engine.Board( name="test_board", size=[10, 10], player_starting_position=[0, 0], ) for i in range(1, 4): b.place_item(pgl_board_items.NPC(name=f"mover{i}", type="mover"), 0, i) for i in range(1, 4): b.place_item(pgl_board_items.Wall(name=f"static{i}", type="static"), i, 0) ret = b.get_immovables(type="static") self.assertEqual(len(ret), 3) self.assertEqual(len(ret), len(b.get_immovables())) ret = b.get_movables(type="static") self.assertEqual(len(ret), 0) ret = b.get_movables(type="mover") self.assertEqual(len(ret), 3) self.assertEqual(len(ret), len(b.get_movables()))
def test_level_insertion(self): g = engine.Game.instance() g.insert_board(1, engine.Board(name="lvl1")) g.insert_board(2, engine.Board(name="lvl2")) g.insert_board(3, engine.Board(name="lvl3")) self.assertEqual(g.get_board(1).name, "lvl1") g.insert_board(1, engine.Board(name="lvl4")) self.assertEqual(g.get_board(1).name, "lvl4") self.assertEqual(g.get_board(2).name, "lvl1") g.insert_board(41, engine.Board(name="lvl41")) self.assertEqual(g.get_board(41).name, "lvl41") with self.assertRaises(base.PglInvalidTypeException): g.insert_board("1", engine.Board()) with self.assertRaises(base.PglInvalidTypeException): g.insert_board(1, "engine.Board()")
def test_display_around(self): i = pgl_board_items.NPC() self.board.place_item(i, 2, 2) self.board.display_around(i, 2, 2) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.display_around(1, 2, 2) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.display_around(i, "2", 2) with self.assertRaises(pgl_base.PglInvalidTypeException): self.board.display_around(i, 2, "2") self.assertIsNone(self.board.display_around(i, 20, 20)) self.assertIsNone(self.board.display_around(i, 2, 20)) self.assertIsNone(self.board.display_around(i, 20, 2)) self.board.item(2, 3).model = "#" self.assertIsNone(self.board.display_around(i, 2, 2)) self.board.clear_cell(2, 2) i = pgl_board_items.ComplexNPC() self.board.place_item(i, 2, 2) self.assertIsNone(self.board.display_around(i, 2, 2)) b = pgl_engine.Board(parent=pgl_engine.Game()) self.assertIsInstance(b, pgl_engine.Board) b.place_item(i, 2, 2) self.assertIsNone(self.board.display_around(i, 2, 2)) self.assertIsNone(self.board.display())
def test_pathfinder_bfs(self): npc = board_items.NPC() b = engine.Board() g = engine.Game() g.player = board_items.Player() g.add_board(1, b) g.add_npc(1, npc, 5, 5) g.change_level(1) actuators.PathFinder(actuated_object=npc) npc.actuator = actuators.PathFinder(parent=npc, game=g, circle_waypoints=False) with self.assertRaises(engine.base.PglInvalidTypeException): actuators.PathFinder( parent=npc, game=g, circle_waypoints=False, algorithm="constants.ALGO_BFS" ) npc.actuator.set_destination(2, 2) npc.actuator.find_path() self.assertTrue(len(npc.actuator.current_path()) > 0) with self.assertRaises(engine.base.PglInvalidTypeException): npc.actuator.set_destination("2", 2) npc.actuator.actuated_object = None with self.assertRaises(engine.base.PglException) as e: npc.actuator.find_path() self.assertEqual(e.error, "actuated_object is not defined") npc.actuator.actuated_object = board_items.Door() with self.assertRaises(engine.base.PglException) as e: npc.actuator.find_path() self.assertEqual(e.error, "actuated_object not a Movable object") npc.actuator.actuated_object = board_items.Door() npc.actuator.actuated_object = npc npc.actuator.destination = None with self.assertRaises(engine.base.PglException) as e: npc.actuator.find_path() self.assertEqual(e.error, "destination is not defined") b.place_item(board_items.Wall(), 2, 2) npc.actuator.set_destination(2, 2) self.assertEqual(npc.actuator.find_path(), []) # These tests are a recipe of how to NOT do things... npc.actuator.destination = (None, None) self.assertEqual(npc.actuator.next_move(), constants.NO_DIR) npc.actuator.set_destination(5, 5) npc.actuator._current_path = [] npc.actuator.next_move() npc.actuator.set_destination(2, 5) npc.actuator._current_path = [] nm = npc.actuator.next_move() self.assertEqual(nm, constants.UP) npc.actuator.add_waypoint(5, 6) npc.actuator.add_waypoint(6, 6) npc.actuator.add_waypoint(5, 4) npc.actuator.add_waypoint(4, 6) nm = None while nm != constants.NO_DIR: nm = npc.actuator.next_move() b.move(npc, nm, npc.step) with self.assertRaises(engine.base.PglInvalidTypeException): npc.actuator.add_waypoint(5, "6") with self.assertRaises(engine.base.PglInvalidTypeException): npc.actuator.add_waypoint("5", 6) npc.actuator.clear_waypoints() self.assertEqual(npc.actuator.next_waypoint(), (None, None)) npc.actuator.clear_waypoints() npc.actuator.destination = (None, None) npc.actuator.add_waypoint(10, 10) npc.actuator.add_waypoint(12, 15) self.assertEqual(npc.actuator.destination, (10, 10)) self.assertEqual(npc.actuator.next_waypoint(), (10, 10)) self.assertEqual(npc.actuator.next_waypoint(), (12, 15)) self.assertEqual(npc.actuator.next_waypoint(), (None, None)) npc.actuator.circle_waypoints = True self.assertEqual(npc.actuator.next_waypoint(), (10, 10)) with self.assertRaises(engine.base.PglInvalidTypeException): npc.actuator.remove_waypoint(10, "10") with self.assertRaises(engine.base.PglInvalidTypeException): npc.actuator.remove_waypoint("10", 10) with self.assertRaises(engine.base.PglException) as e: npc.actuator.remove_waypoint(30, 30) self.assertEqual(e.error, "invalid_waypoint") self.assertIsNone(npc.actuator.remove_waypoint(10, 10))
def test_tools_function(self): b = engine.Board() g = engine.Game() g.player = constants.NO_PLAYER self.assertIsNone(g.add_board(1, b)) self.assertIsNone(g.change_level(1)) self.assertIsNone( g.add_npc(1, board_items.NPC(value=10, inventory_space=1), 1, 1)) tmp_npc = g.get_board(1).item(1, 1) tmp_npc.actuator = actuators.PathFinder(game=g, actuated_object=tmp_npc) tmp_npc.actuator.set_destination(2, 5) tmp_npc.actuator.find_path() self.assertIsNone( b.place_item(board_items.Door(value=10, inventory_space=1), 1, 2)) self.assertIsNone( b.place_item(board_items.Wall(value=10, inventory_space=1), 1, 3)) self.assertIsNone( b.place_item( board_items.GenericStructure(value=10, inventory_space=1), 1, 4)) self.assertIsNone( b.place_item( board_items.GenericActionableStructure(value=10, inventory_space=1), 1, 5, )) self.assertIsNone( b.place_item( board_items.Door(value=10, inventory_space=1, sprixel=core.Sprixel("#")), 2, 2, )) self.assertIsNone( b.place_item(board_items.Treasure(value=10, inventory_space=1), 1, 6)) with self.assertRaises(base.PglInvalidTypeException): g.neighbors("2") with self.assertRaises(base.PglInvalidTypeException): g.neighbors(2, "crash") g.object_library.append(board_items.NPC()) self.assertIsNone( g.save_board(1, "test-pygamelib.engine.Game.lvl1.json")) with self.assertRaises(base.PglInvalidTypeException): g.save_board("1", "test-pygamelib.engine.Game.lvl1.json") with self.assertRaises(base.PglInvalidTypeException): g.save_board(1, 1) with self.assertRaises(base.PglInvalidLevelException): g.save_board(11, "test-pygamelib.engine.Game.lvl1.json") self.assertIsInstance( g.load_board("test-pygamelib.engine.Game.lvl1.json", 1), engine.Board) self.assertEqual(g._string_to_constant("UP"), constants.UP) self.assertEqual(g._string_to_constant("DOWN"), constants.DOWN) self.assertEqual(g._string_to_constant("LEFT"), constants.LEFT) self.assertEqual(g._string_to_constant("RIGHT"), constants.RIGHT) self.assertEqual(g._string_to_constant("DRUP"), constants.DRUP) self.assertEqual(g._string_to_constant("DRDOWN"), constants.DRDOWN) self.assertEqual(g._string_to_constant("DLUP"), constants.DLUP) self.assertEqual(g._string_to_constant("DLDOWN"), constants.DLDOWN) with self.assertRaises(base.PglInvalidTypeException): g.delete_level() with self.assertRaises(base.PglInvalidLevelException): g.delete_level(42) g.delete_level(1) g.delete_all_levels() self.assertIsNone(g.current_board()) bi = board_items.Door( value=10, inventory_space=0, pickable=False, overlappable=True, restorable=True, ) obj = engine.Game._ref2obj(bi.serialize()) self.assertIsInstance(obj, board_items.Door) bi = board_items.Treasure( value=10, inventory_space=0, pickable=False, overlappable=True, restorable=True, ) obj = engine.Game._ref2obj(bi.serialize()) self.assertIsInstance(obj, board_items.Treasure) bi = board_items.GenericActionableStructure( value=10, inventory_space=0, pickable=False, overlappable=True, restorable=True, ) obj = engine.Game._ref2obj(bi.serialize()) self.assertIsInstance(obj, board_items.GenericActionableStructure) bi = board_items.NPC( value=10, inventory_space=10, pickable=False, overlappable=True, restorable=True, ) bi.actuator = actuators.PathActuator(path=[constants.UP]) obj = engine.Game._ref2obj(bi.serialize()) self.assertIsInstance(obj, board_items.NPC) bi.actuator = actuators.PatrolActuator(path=[constants.UP]) obj = engine.Game._ref2obj(bi.serialize()) self.assertIsInstance(obj.actuator, actuators.PatrolActuator)
def test_projectile_management(self): def _hit(p, t, ex): if len(ex) > 0: ex[0].stop() def _fake_hit(p, t, ex): pass def _upd(g, i, dt): pass b = engine.Board() g = engine.Game(user_update=_upd) g.player = constants.NO_PLAYER self.assertIsNone(g.add_board(1, b)) g.change_level(1) p = board_items.Projectile(hit_model="*", hit_callback=_fake_hit, callback_parameters=[g]) p.actuator = None p.step = None self.assertIsNone(g.add_projectile(1, p, 1, 1)) self.assertIsNone(g.add_projectile(1, board_items.Projectile(), 1, 100)) b.place_item(board_items.Wall(), 5, 5) b.place_item(board_items.Wall(), 1, 3) p2 = board_items.Projectile(hit_model="*", hit_callback=_fake_hit, callback_parameters=[g]) p2.set_direction(constants.LEFT) g.add_projectile(1, p2, 1, 5) g.add_projectile( 1, board_items.Projectile(hit_model="*", hit_callback=_hit, callback_parameters=[g]), 8, 1, ) g.add_projectile( 1, board_items.Projectile( hit_model="*", hit_callback=_fake_hit, callback_parameters=[g], range=3, is_aoe=True, ), 9, 1, ) self.assertIsNone( g.add_projectile(1, board_items.Projectile(hit_callback=_hit), 5, 5)) self.assertIsNone( g.add_projectile( 1, board_items.Projectile(hit_callback=_hit, is_aoe=True), 5, 5)) with self.assertRaises(base.PglInvalidTypeException): g.add_projectile(1, board_items.Projectile(), "1") with self.assertRaises(base.PglInvalidTypeException): g.add_projectile(1, board_items.Projectile(), None, "1") with self.assertRaises(base.PglInvalidTypeException): g.add_projectile(1, board_items.Projectile(), 1, "1") with self.assertRaises(base.PglInvalidTypeException): g.add_projectile(1, board_items.Projectile(), "1", 1) with self.assertRaises(base.PglInvalidTypeException): g.add_projectile(1, 1) with self.assertRaises(base.PglInvalidTypeException): g.add_projectile("1", board_items.NPC()) self.assertIsNone(g.actuate_projectiles(1)) g.mode = constants.MODE_RT g.start() self.assertIsNone(g.actuate_projectiles(1)) with self.assertRaises(base.PglInvalidLevelException): g.actuate_projectiles(99) with self.assertRaises(base.PglInvalidTypeException): g.actuate_projectiles("1") g.run()
if not ans.startswith("y"): sprite_valid = False print(f"{spr_id} is {base.Text.red_bright('ignored')}.") if sprite_valid: sc.add(spr) sc.to_json_file(final) os.remove(tmp_file) board_file = os.path.join(output_dir, spr_id + ".json") if args.board: not args.silent and print( "Generating a Board out of the image...", end="", flush=True) # tile = board_items.Tile(sprite=spr) b = engine.Board(size=spr.size, ui_borders="", name=spr_id, DISPLAY_SIZE_WARNINGS=False) # b.place_item(tile, 0, 0) # Here we should just place a Tile but unfortunately the previous version of the # pygamelib do not actually save and load complex items but their components. # So for the moment we will convert each sprixel into a Door object. # TODO: add a --compatibility flag : when on we do that, when off we don't (i.e: we # place a Tile on the board) for sr in range(0, spr.height): for sc in range(0, spr.width): b.place_item(board_items.Door(sprixel=spr.sprixel(sr, sc)), sr, sc) # The game object is required to save boards... not a terribly good design... g = engine.Game() g.add_board(1, b) g.save_board(1, board_file) if not args.silent:
def test_screen_buffer(self): sprites_panda = SpriteCollection.load_json_file("tests/panda.spr") b = engine.Board(size=[20, 20]) s = engine.Screen() # This is a dirty hack for CircleCI as it returns a 0x0 screen size. if s.width <= 0 or s.height <= 0: s._display_buffer = np.array( [[Sprixel(" ") for i in range(0, 50, 1)] for j in range(0, 50, 1)] ) s._screen_buffer = np.array( [[Sprixel(" ") for i in range(0, 50, 1)] for j in range(0, 50, 1)] ) # Because CircleCI return a console with no size (most probably because we are # not attached to any terminal), we need to make sure that the partial display # tests work in that environment too screen_width = 0 screen_height = 0 if s.width <= 0: screen_width = 50 else: screen_width = s.width if s.height <= 0: screen_height = 50 else: screen_height = s.height self.assertEqual(s.vcenter, int(s.height / 2)) self.assertEqual(s.hcenter, int(s.width / 2)) b.place_item(board_items.Tile(sprite=sprites_panda["panda"]), 0, 0) self.assertIsInstance(b.render_cell(1, 1), Sprixel) b.item(19, 19).model = "@" b.item(19, 19).sprixel = None self.assertIsInstance(b.render_cell(19, 19), Sprixel) self.assertEqual(b.render_cell(19, 19), Sprixel()) with self.assertRaises(base.PglOutOfBoardBoundException): b.render_cell(50, 50) self.assertIsNone(s.clear_buffers()) self.assertIsNone(s.clear_screen_buffer()) # And again after clear buffers. if s.width <= 0 or s.height <= 0: s._display_buffer = np.array( [[Sprixel(" ") for i in range(0, 50, 1)] for j in range(0, 50, 1)] ) s._screen_buffer = np.array( [[Sprixel(" ") for i in range(0, 50, 1)] for j in range(0, 50, 1)] ) self.assertTrue(s._is_dirty) self.assertTrue(functions.pgl_isinstance(s.buffer, "numpy.ndarray")) self.assertIsNone(s.update()) b = engine.Board(size=[1, 1]) b.place_item(board_items.Wall(model="##"), 0, 0) self.assertIsNone(s.place("test", 0, 0)) self.assertIsNone(s.place(b, 1, 0)) t = base.Text("test 2") self.assertIsNone(s.place(t, 2, 0)) self.assertIsNone(s.place(sprites_panda["panda"], 0, 5)) self.assertIsNone(s.place(TB(), 3, 0)) self.assertIsNone(s.place(board_items.BoardItem(model="##"), 10, 0)) self.assertIsNone( s.place( board_items.Tile( sprixels=[ [Sprixel("##"), Sprixel("##")], [Sprixel("##"), Sprixel("##")], ] ), 4, 0, ) ) with self.assertRaises(base.PglInvalidTypeException): s.place(None, 0, 0) with self.assertRaises(base.PglInvalidTypeException): s.place(1, 0, 0) s.update() t.text = "update" self.assertIsNone( s.place(sprites_panda["panda"], screen_height - 2, screen_width - 2) ) self.assertIsNone(s.place("test", 1, screen_width - 2)) s.update() self.assertIsNone(s.render()) # Should not render self.assertFalse(s.need_rendering) s.trigger_rendering() self.assertTrue(s.need_rendering) # Now testing partial display camera = board_items.Camera() camera.row = 0 camera.column = 0 b = engine.Board( size=[screen_width * 2, screen_height * 2], enable_partial_display=True, partial_display_viewport=[ int(screen_height / 2) - 1, int(screen_width / 2) - 1, ], partial_display_focus=camera, DISPLAY_SIZE_WARNINGS=False, ) for row in range(0, b.height): for col in range(0, b.width): b.place_item( board_items.Wall( sprixel=Sprixel(" ", Color(row * 4, col, int((row + col) / 2))), ), row, col, ) self.assertIsNone(s.place(b, 0, 0, 2)) s.trigger_rendering() self.assertIsNone(s.update()) b.partial_display_viewport = [ int(screen_height * 3) - 1, int(screen_width * 3) - 1, ] camera.row += 1 with self.assertRaises(IndexError): s.force_render() s.update() b.partial_display_viewport = [ int(screen_height / 2) - 1, int(screen_width / 2) - 1, ] camera.row = b.height - 1 camera.column = b.width - 1 self.assertIsNone(s.trigger_rendering()) self.assertIsNone(s.update()) camera = board_items.Tile( sprite=Sprite( sprixels=[[Sprixel("+"), Sprixel("+")], [Sprixel("+"), Sprixel("+")]] ) ) b.partial_display_focus = camera # Please never do that in real life... camera.pos = [1, 1] self.assertIsNone(s.trigger_rendering()) self.assertIsNone(s.render()) self.assertIsNone(s.update()) # This will succeed but the str type cannot benefit from deferred rendering. self.assertIsNone(s.place("test delete", 0, 0, 2)) self.assertIsNone(s.update()) self.assertIsNone(s.delete(0, 0)) self.assertIsNone(s.update())
sys.stdout.write("\u001b[1000D") # sys.stdout.flush() # time.sleep(1) sys.stdout.write(str(9 - i) + " secondes") sys.stdout.flush() print() # first let's create 3 boards, we are just going to create default boards # with different border colors. # We are going to set different starting position for the player on each board. # On this board the player starts at the top left corner lvl1 = engine.Board( ui_borders=graphics.CYAN_SQUARE, ui_board_void_cell=graphics.BLACK_SQUARE, player_starting_position=[0, 0], ) # On that board the player starts at the center lvl2 = engine.Board( ui_borders=graphics.MAGENTA_SQUARE, ui_board_void_cell=graphics.BLACK_SQUARE, player_starting_position=[5, 5], ) # And on that board the player starts at the bottom right corner lvl3 = engine.Board( ui_borders=graphics.RED_SQUARE, ui_board_void_cell=graphics.BLACK_SQUARE, player_starting_position=[9, 9],
from pygamelib.assets import graphics import time ############################################################################### # # # IMPORTANT NOTE: # # # # The companion article for this tutorial code is at: # # https://astro.hyrul.es/guides/hac-game-lib/tutorial-02-player-movements.html# # # ############################################################################### mygame = engine.Game(name="Demo game") board1 = engine.Board( name="Level 1", ui_borders=graphics.Models.BRICK, ui_board_void_cell=graphics.BLACK_SQUARE, player_starting_position=[0, 0], ) board2 = engine.Board( name="Level 2", ui_borders=graphics.RED_SQUARE, ui_board_void_cell=graphics.BLACK_SQUARE, player_starting_position=[4, 4], ) mygame.player = board_items.Player(name="DaPlay3r", model=graphics.Models.UNICORN) mygame.add_board(1, board1) mygame.add_board(2, board2)
g.current_board().clear_cell(item.pos[0], item.pos[1]) def redraw_screen(): global g g.clear_screen() nb_blocks = int((g.player.mp / g.player.max_mp) * 20) print("Mana [" + graphics.BLUE_RECT * nb_blocks + graphics.BLACK_RECT * (20 - nb_blocks) + "]") g.display_board() # manage_fireballs() b = engine.Board( ui_borders=graphics.WHITE_SQUARE, ui_board_void_cell=graphics.BLACK_SQUARE, size=[20, 20], player_starting_position=[5, 5], ) wall = board_items.Wall(model=graphics.Models.BRICK) b.place_item(wall, 1, 6) g = engine.Game() g.add_board(1, b) g.player = board_items.Player(model=graphics.Models.MAGE, name="The Maje") g.player.mp = 20 g.player.max_mp = 20 g.change_level(1) key = None black_circle = "-\U000025CF" circle_jot = "-\U0000233E"