def test_create_animation(self):
self.item = pgl_board_items.NPC(model="-o-", name="Dancer")
self.animation = gfx_core.Animation(parent=self.item,
refresh_screen=self.redraw,
display_time=0.5)
self.assertEqual(self.item.name, self.animation.parent.name)
a = gfx_core.Animation(
animated_object=self.item,
refresh_screen=self.redraw,
display_time=0.5,
initial_index=2,
)
self.assertEqual(a._initial_index, 2)
a.reset()
self.assertEqual(a._initial_index, a._frame_index)
col = gfx_core.SpriteCollection()
col.add(gfx_core.Sprite(name="s1"))
col.add(gfx_core.Sprite(name="s2"))
i = pgl_board_items.ComplexNPC(sprite=col["s1"])
a = gfx_core.Animation(frames=col, parent=i)
i.animation = a
self.assertIsInstance(a, gfx_core.Animation)
self.assertEqual(len(a.frames), 2)
# I shouldn't test that here but I'm tired of writting test!
self.assertIsInstance(a.next_frame(), gfx_core.Sprite)
def test_screen_flip_vert(self):
spr = gfx_core.Sprite(
sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
]
)
spr_flipped = spr.flip_vertically()
self.assertEqual(spr.sprixel(1, 0), gfx_core.Sprixel.yellow_rect())
self.assertEqual(spr_flipped.sprixel(1, 0), gfx_core.Sprixel.cyan_rect())
spr = gfx_core.Sprite(
sprixels=[
[gfx_core.Sprixel("▄"), gfx_core.Sprixel("▄")],
[gfx_core.Sprixel("▀"), gfx_core.Sprixel("▀")],
]
)
spr_flipped = spr.flip_vertically()
self.assertEqual(spr.sprixel(0, 0).model, "▀")
self.assertIsNone(spr.set_transparency(True))
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_sprite_create_empty(self):
spr = gfx_core.Sprite()
self.assertEqual(spr.size[0], 2)
self.assertEqual(spr.size[1], 2)
self.assertEqual(spr.width, 2)
self.assertEqual(spr.height, 2)
self.assertEqual(spr.sprixel(1, 1), gfx_core.Sprixel())
self.assertEqual(spr.__repr__(), "\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m")
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
spr.sprixel("crash", 1)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
spr.sprixel(1, "crash")
with self.assertRaises(gfx_core.base.PglException) as e:
spr.sprixel(1, 10)
self.assertEqual(e.exception.error, "out_of_sprite_boundaries")
self.assertTrue(type(spr.sprixel(1)) is list)
with self.assertRaises(gfx_core.base.PglException) as e:
spr.sprixel(10, 1)
self.assertEqual(e.exception.error, "out_of_sprite_boundaries")
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
spr.set_sprixel(1, "crash", "bork")
with self.assertRaises(gfx_core.base.PglException) as e:
spr.set_sprixel(1, 10, "bork")
self.assertEqual(e.exception.error, "out_of_sprite_boundaries")
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
spr.set_sprixel(1, 1, "bork")
def test_scale(self):
spr = gfx_core.Sprite(
sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
]
)
self.assertEqual(spr.width, 3)
self.assertEqual(spr.height, 2)
spr2 = spr.scale(2)
self.assertEqual(spr2.width, 6)
self.assertEqual(spr2.height, 4)
spr3 = spr2.scale(0.5)
self.assertEqual(spr3.width, 3)
self.assertEqual(spr3.height, 2)
self.assertEqual(spr3.width, spr.width)
self.assertEqual(spr3.height, spr.height)
self.assertEqual(spr, spr.scale(1))
self.assertIsNone(spr.scale(0))
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_screen_create3(self):
spr = gfx_core.Sprite(sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
])
self.assertEqual(spr.size[0], 3)
self.assertEqual(spr.size[1], 2)
self.assertEqual(spr.sprixel(1, 1), gfx_core.Sprixel.blue_rect())
def test_screen_empty(self):
spr = gfx_core.Sprite(sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
])
self.assertEqual(spr.sprixel(1, 0), gfx_core.Sprixel.yellow_rect())
spr.empty()
self.assertEqual(spr.sprixel(1, 0), spr.default_sprixel)
def test_complexnpc(self):
sprite = gfx_core.Sprite(
name="test_sprite",
sprixels=[
[
gfx_core.Sprixel(" ", gfx_core.Color(255, 0, 0)),
gfx_core.Sprixel(" ", gfx_core.Color(255, 0, 0)),
]
],
)
n = board_items.ComplexNPC(name="Test NPC", sprite=sprite)
n.actuator = actuators.RandomActuator()
data = n.serialize()
self.assertEqual(n.name, data["name"])
self.assertEqual(n.sprite.name, data["sprite"]["name"])
n2 = board_items.ComplexNPC.load(data)
self.assertEqual(n.name, n2.name)
def test_screen_flip_horiz(self):
spr = gfx_core.Sprite(sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
])
spr_flipped = spr.flip_horizontally()
self.assertEqual(spr.sprixel(1, 0), gfx_core.Sprixel.yellow_rect())
self.assertEqual(spr_flipped.sprixel(1, 0),
gfx_core.Sprixel.white_rect())
def test_player(self):
p = board_items.Player(inventory=board_items.engine.Inventory())
self.assertFalse(p.pickable())
self.assertTrue(p.has_inventory())
sprite = gfx_core.Sprite(
name="test_sprite",
sprixels=[
[
gfx_core.Sprixel(" ", gfx_core.Color(255, 0, 0)),
gfx_core.Sprixel(" ", gfx_core.Color(255, 0, 0)),
]
],
)
n = board_items.ComplexPlayer(name="Test Player", sprite=sprite)
n.actuator = actuators.RandomActuator()
data = n.serialize()
self.assertEqual(n.name, data["name"])
self.assertEqual(n.sprite.name, data["sprite"]["name"])
n2 = board_items.ComplexPlayer.load(data)
self.assertEqual(n.name, n2.name)
def test_collection(self):
spr = gfx_core.Sprite(
sprixels=[
[
gfx_core.Sprixel.cyan_rect(),
gfx_core.Sprixel.red_rect(),
gfx_core.Sprixel.green_rect(),
],
[
gfx_core.Sprixel.yellow_rect(),
gfx_core.Sprixel.blue_rect(),
gfx_core.Sprixel.white_rect(),
],
]
)
spr2 = spr.flip_horizontally()
spr3 = spr.flip_vertically()
sc = gfx_core.SpriteCollection()
sc.add(spr)
sc.add(spr2)
sc.add(spr3)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
sc.add(1)
self.assertEqual(spr.name, sc[spr.name].name)
self.assertEqual(spr.name, sc.get(spr.name).name)
self.assertEqual(spr2.name, sc[spr2.name].name)
self.assertEqual(spr2.name, sc.get(spr2.name).name)
self.assertEqual(spr3.name, sc[spr3.name].name)
self.assertEqual(spr3.name, sc.get(spr3.name).name)
self.assertIsNone(sc.rename(spr.name, "test_rename"))
self.assertEqual(sc["test_rename"].sprixel(0, 0), spr.sprixel(0, 0))
self.assertIsNone(sc.to_json_file("test.pgs"))
sc2 = gfx_core.SpriteCollection.load_json_file("test.pgs")
self.assertIsInstance(sc2, gfx_core.SpriteCollection)
self.assertEqual(spr3.sprixel(1, 1), sc2.get(spr3.name).sprixel(1, 1))
with self.assertRaises(gfx_core.base.PglException) as e:
gfx_core.SpriteCollection.load({})
self.assertEqual(e.exception.error, "invalid_sprite_data")
with self.assertRaises(gfx_core.base.PglException) as e:
gfx_core.SpriteCollection.load({"sprites_count": 2, "sprites": {}})
self.assertEqual(e.exception.error, "corrupted_sprite_data")
def test_screen_create2(self):
spr = gfx_core.Sprite(default_sprixel=gfx_core.Sprixel.cyan_rect())
self.assertEqual(spr.size[0], 2)
self.assertEqual(spr.size[1], 2)
self.assertEqual(spr.sprixel(1, 1), gfx_core.Sprixel.cyan_rect())
def test_screen_create1(self):
spr = gfx_core.Sprite(size=[4, 4])
self.assertEqual(spr.size[0], 4)
self.assertEqual(spr.size[1], 4)
self.assertEqual(spr.sprixel(1, 1), gfx_core.Sprixel())
def test_tinting(self):
sp = gfx_core.Sprite(
sprixels=[
[
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
],
[
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
gfx_core.Sprixel(
" ",
gfx_core.Color(255, 255, 255),
gfx_core.Color(255, 255, 255),
),
],
]
)
spr = sp.tint(gfx_core.Color(0, 255, 0), 0.2)
self.assertEqual(spr.sprixel(0, 0).bg_color.r, 204)
self.assertEqual(spr.sprixel(0, 0).bg_color.g, 255)
self.assertEqual(spr.sprixel(0, 0).bg_color.b, 204)
# Original sprite should not be modified by tint
self.assertEqual(sp.sprixel(0, 0).bg_color.r, 255)
self.assertEqual(sp.sprixel(0, 0).bg_color.g, 255)
self.assertEqual(sp.sprixel(0, 0).bg_color.b, 255)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
sp.tint(gfx_core.Color(0, 255, 0), 1.2)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
sp.tint(gfx_core.Color(0, 255, 0), -1.2)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
sp.modulate(gfx_core.Color(0, 255, 0), 1.2)
with self.assertRaises(gfx_core.base.PglInvalidTypeException):
sp.modulate(gfx_core.Color(0, 255, 0), -1.2)
sp.modulate(gfx_core.Color(0, 255, 0), 0.2)
# Original sprite should be modified by modulate
self.assertEqual(sp.sprixel(0, 0).bg_color.r, 204)
self.assertEqual(sp.sprixel(0, 0).bg_color.g, 255)
self.assertEqual(sp.sprixel(0, 0).bg_color.b, 204)
