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_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_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_door(self):
bi = board_items.Door()
self.assertEqual(bi.model, "]")
self.assertEqual(bi.name, "Door")
self.assertEqual(bi.type, "door")
bi = board_items.Door(
value=1,
inventory_space=5,
model="]",
name="The door",
type="closed_door",
pickable=False,
overlappable=False,
restorable=True,
)
self.assertFalse(bi.pickable())
self.assertFalse(bi.overlappable())
self.assertTrue(bi.restorable())
def make_platform(b, row, column):
psize = random.randint(2, 10)
plateform = []
tmp_game = engine.Game()
# Only because Game needs it, we don't care.
tmp_game.player = board_items.Player()
tmp_game.add_board(0, b)
tmp_game.change_level(0)
# print(
# f"[d] make_platform at {row}, {column}, psize is {psize} column will be "
# f"between {column} and {column + psize + 1}"
# )
get_up = 0
# for i in range(column, column + psize + 1):
for i in range(column - psize - 1, column):
if i >= b.size[0]:
break
if not isinstance(b.item(row, i), board_items.BoardItemVoid):
break
if i in b.visited_columns:
break
# Check if we have other platforms around.
# If yes moving the platform up.
if get_up < 3:
for e in tmp_game.neighbors(2, board_items.Door(pos=[row, i])):
if e.type == "ground":
get_up = 3
break
if get_up < 4:
for e in tmp_game.neighbors(1, board_items.Door(pos=[row, i])):
if e.type == "ground":
get_up = 4
break
m = block_color() + " " + graphics.Style.RESET_ALL
plateform.append(
[board_items.Wall(model=m, item_type="platform"), row, i])
for i in plateform:
b.place_item(i[0], i[1] - get_up, i[2])
if random.choice([True, False]):
generate_treasure(b, i[1] - get_up - 1, i[2])
else:
generate_trap(b, i[1] - get_up - 1, i[2])
b.visited_columns.append(i[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_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_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))
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:
print("done", flush=True)
if args.show and not args.silent and sprite_valid:
if spr.width <= base.Console.instance().width:
print(spr)
else:
print(
base.Text.yellow_bright(
"The generated sprite is to large to display all at once correctly in "
f"this terminal (sprite size is {spr.width}x{spr.height} and your "
f"terminal is {base.Console.instance().width}x"
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 generate_level(g, b):
# When we get the map, the last row is full of blocks
last_alt = b.size[1] - 1
gap = 0
gap_threshold = 2
b.visited_columns = []
# We keep a count of the treasures we can put on the map as well as the rate we
# can put them on (in percent). There is no possibility that we will end up with
# more items, but there is a small possibility that we end up with less
b.treasures = {
"timers": {
"count": int(math.log(g.current_level + 1)),
"rate": 10,
"placed": 0,
},
"scorers": {
"count": 1 + int(math.log(g.current_level + 1)),
"rate": 10,
"placed": 0,
},
"1UP": {"count": 1, "rate": int(math.log(g.current_level + 1)), "placed": 0},
"diamond": {"count": 1, "rate": 2, "placed": 0},
}
# We go through all the column of the map.
for x in range(5, b.size[0]):
# print(f"[d] generate level x={x}")
# We have 50% chance of putting an obstacle.
if random.choice([True, False]):
if gap > gap_threshold:
for k in range(x - gap, x):
b.clear_cell(b.size[1] - 1, k)
alt = random.randint(last_alt - 2, b.size[1] - 1)
last_alt = alt
y = 0
for y in range(alt + 1, b.size[1] - 1):
# print(f"[d] generate level y={y}")
b.place_item(
board_items.Wall(
model=block_color() + " " + graphics.Style.RESET_ALL,
type="ground",
),
y,
x,
)
# generate_treasure(b, y - 1, x)
# For the fun of it and also to break monotony we have 20% of chance
# of placing a platform here (of random size). We'll put treasures on
# them later.
if random.randint(0, 100) >= 80:
make_platform(b, last_alt - random.randint(2, 3), x)
# if y < b.size[1] - 1:
# generate_trap(b, alt, x)
# Just to break monotony, we have 33% chance of putting a cloud
# in the background
if random.randint(0, 100) >= 66:
b.place_item(
board_items.Door(
model=bg_color + "\U00002601 " + graphics.Style.RESET_ALL
),
alt - 8 + random.randint(-2, 2),
x,
)
gap = 0
else:
# If we didn't put an obstacle, we keep track of the gap we're leaving.
# When the gap is spreading over a threshold, we have 50% chance of
# emptying it (we make a pit)
gap += 1
b.place_item(
board_items.GenericActionableStructure(
model=bg_color + graphics.Models.CYCLONE + graphics.Style.RESET_ALL,
type="exit",
action=change_level,
action_parameters=[g],
),
last_alt - 1,
b.size[0] - 1,
)
# The map is done, let's add treasures and traps.
# we travel the map once again and look for openings
idx = 0
while b.available_traps > 0 or idx < 10:
for col in range(5, b.size[0]):
if random.choice([True, False]):
candidates = []
for row in range(0, b.size[1]):
item = b.item(row, col)
# We only put treasures and traps on the ground
if (
not isinstance(item, board_items.BoardItemVoid)
and item.type == "ground"
):
# We want at least 2 free cells in all directions (except down)
free_cells = [
(row - 1, col),
(row - 2, col),
(row - 1, col - 1),
(row - 1, col - 2),
(row - 2, col - 1),
(row - 2, col - 2),
(row - 1, col + 1),
(row - 1, col + 2),
(row - 2, col + 1),
(row - 2, col + 2),
]
good_candidate = True
for coord in free_cells:
if coord[0] >= b.size[1] or coord[1] >= b.size[0]:
continue
cell = b.item(coord[0], coord[1])
if not isinstance(cell, board_items.BoardItemVoid):
good_candidate = False
break
if good_candidate:
candidates.append(item)
for c in candidates:
generate_trap(b, c.pos[0], c.pos[1])
idx += 1
idx = 0
while True:
for col in range(5, b.size[0]):
if random.choice([True, False]):
candidates = []
for row in range(0, b.size[1]):
item = b.item(row, col)
# We only put treasures and traps on the ground
if (
not isinstance(item, board_items.BoardItemVoid)
and item.type == "ground"
):
# We want at least 2 free cells in all directions (except down)
free_cells = [
(row - 1, col),
(row - 2, col),
(row - 1, col - 1),
(row - 1, col - 2),
(row - 2, col - 1),
(row - 2, col - 2),
(row - 1, col + 1),
(row - 1, col + 2),
(row - 2, col + 1),
(row - 2, col + 2),
]
good_candidate = True
for coord in free_cells:
if coord[0] >= b.size[1] or coord[1] >= b.size[0]:
continue
cell = b.item(coord[0], coord[1])
if not isinstance(cell, board_items.BoardItemVoid):
good_candidate = False
break
if good_candidate:
candidates.append(item)
for c in candidates:
generate_trap(b, c.pos[0], c.pos[1])
idx += 1
if b.treasures["scorers"]["count"] <= 0 and b.treasures["timers"]["count"] <= 0:
break
if idx == 10:
break
def test_screen_buffer(self):
sprites_panda = SpriteCollection.load_json_file("tests/panda.spr")
b = engine.Board(size=[20, 20])
s = engine.Screen(50, 50)
# 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())
b.place_item(board_items.Door(), 19, 19)
b.place_item(
board_items.Door(sprixel=Sprixel(
"*", Color(125, 125, 0), is_bg_transparent=False)),
19,
19,
)
b.place_item(
board_items.Door(sprixel=Sprixel("#", is_bg_transparent=True)), 19,
19)
b.place_item(
board_items.NPC(sprixel=Sprixel("$", is_bg_transparent=True)), 19,
19)
self.assertEqual(b.layers(19, 19), 4)
b.place_item(
board_items.BoardItemVoid(sprixel=Sprixel(is_bg_transparent=True)),
19, 19)
b.place_item(
board_items.BoardItemVoid(sprixel=Sprixel(is_bg_transparent=True)),
19, 19)
self.assertIsInstance(b.render_cell(19, 19), Sprixel)
b._clean_layers(19, 19)
self.assertEqual(b.layers(19, 19), 3)
b._clean_layers(18, 19)
self.assertEqual(b.layers(18, 19), 1)
with self.assertRaises(base.PglOutOfBoardBoundException):
b.render_cell(50, 50)
self.assertIsNone(s.clear_buffers())
self.assertIsNone(s.clear_screen_buffer())
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))
self.assertIsInstance(s.get(1, 0), engine.Board)
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(sprite=Sprite(sprixels=[
[Sprixel("##"), Sprixel("##")],
[Sprixel("##"), Sprixel("##")],
])),
4,
0,
))
self.assertIsNone(
s.place(
Sprite(sprixels=[
[Sprixel("##"), Sprixel("##")],
[Sprixel("###"), Sprixel("##")],
]),
8,
0,
))
s.force_render()
with self.assertRaises(base.PglInvalidTypeException):
s.place(None, 0, 0)
with self.assertRaises(base.PglInvalidTypeException):
s.place(1, 0, 0)
with self.assertRaises(base.PglException):
s.place(TB(), 400, 0)
with self.assertRaises(base.PglException):
s.place(TB(), 0, 400)
s.force_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 / 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())
self.assertIsNone(
functions.render_string_to_buffer(
"hello",
s._display_buffer,
0,
0,
s._display_buffer.shape[0],
s._display_buffer.shape[1],
))
# This test has nothing to do here... but I'm lazy.
self.assertEqual(5, functions.clamp(5, 0, 10))
self.assertEqual(0, functions.clamp(-5, 0, 10))
self.assertEqual(10, functions.clamp(15, 0, 10))
# This one either and it's even worst: it's going to disappear!
t = base.Text("this is a text\non multiple lines")
t.render_to_buffer(
s._display_buffer,
s._display_buffer.shape[0] - 1,
s._display_buffer.shape[1] - 5,
s._display_buffer.shape[0],
s._display_buffer.shape[1],
)
s.update()
t = base.Text(
"this is a text",
Color(0, 0, 0),
Color(255, 255, 255),
font=Font("8bits"),
)
t.render_to_buffer(
s._display_buffer,
s._display_buffer.shape[0] - 1,
s._display_buffer.shape[1] - 5,
s._display_buffer.shape[0],
s._display_buffer.shape[1],
)
s.update()
