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"
