def __init__(self, **kwargs):
board_items.Movable.__init__(self, **kwargs)
self.size = [1, 1]
self.name = str(uuid.uuid4())
self.type = "base_particle"
self.sprixel = gfx_core.Sprixel(graphics.GeometricShapes.BULLET)
if "bg_color" in kwargs:
self.sprixel.bg_color = kwargs["bg_color"]
if "fg_color" in kwargs:
self.sprixel.fg_color = kwargs["fg_color"]
if "model" in kwargs:
self.sprixel.model = kwargs["model"]
self.directions = [
base.Vector2D.from_direction(constants.UP, 1),
base.Vector2D.from_direction(constants.DLUP, 1),
base.Vector2D.from_direction(constants.DRUP, 1),
]
self.lifespan = 5
if "velocity" in kwargs and isinstance(kwargs["velocity"],
base.Vector2D):
self.velocity = kwargs["velocity"]
else:
self.velocity = base.Vector2D()
if "acceleration" in kwargs and isinstance(kwargs["acceleration"],
base.Vector2D):
self.acceleration = kwargs["acceleration"]
else:
self.acceleration = base.Vector2D()
for item in ["lifespan", "sprixel", "name", "type", "directions"]:
if item in kwargs:
setattr(self, item, kwargs[item])
def test_v2d_assert_values(self):
self.assertEqual(self.vectors[0].row, 0)
self.assertEqual(self.vectors[0].column, 0)
self.assertEqual(self.vectors[1].row, 1.0)
self.assertEqual(self.vectors[1].column, 1.0)
self.assertEqual(self.vectors[2].row, 2)
self.assertEqual(self.vectors[2].column, 2)
self.assertEqual(self.vectors[1].__repr__(), "Vector2D (1.0, 1.0)")
self.assertTrue(self.vectors[0] == pgl_base.Vector2D())
self.assertFalse(self.vectors[0] == pgl_base.Vector2D(1, 2))
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 setUp(self):
super().setUp()
self.vectors = []
self.vectors.append(pgl_base.Vector2D())
self.vectors.append(pgl_base.Vector2D(1.0, 1.0))
self.vectors.append(pgl_base.Vector2D(2, 2))
self.text = pgl_base.Text(
"Test case",
core.Color(0, 0, 0),
core.Color(255, 255, 0),
pgl_base.Style.BRIGHT,
)
self.math = pgl_base.Math()
def setUp(self):
super().setUp()
self.vectors = []
self.vectors.append(pgl_base.Vector2D())
self.vectors.append(pgl_base.Vector2D(1.0, 1.0))
self.vectors.append(pgl_base.Vector2D(2, 2))
self.text = pgl_base.Text(
"Test case",
pgl_base.Fore.WHITE,
pgl_base.Back.YELLOW,
pgl_base.Style.BRIGHT,
)
self.math = pgl_base.Math()
def test_v2d_mult(self):
v = self.vectors[0] * self.vectors[1]
self.assertEqual(v, 0.0)
v = self.vectors[1] * self.vectors[2]
self.assertEqual(v, 0.0)
v = (self.vectors[2] + self.vectors[1]) * self.vectors[2]
self.assertEqual(v, 0.0)
self.assertEqual(self.vectors[2] * pgl_base.Vector2D(2, 5.0), 6.0)
v = self.vectors[1] * 2
self.assertEqual(v.row, 2.0)
self.assertEqual(v.column, 2.0)
def __init__(self,
model=None,
bg_color=None,
fg_color=None,
acceleration=None,
velocity=None,
lifespan=None,
directions=None,
**kwargs):
super().__init__(**kwargs)
# NOTE: this cannot be done anymore for BoardItems
# self.size = [1, 1]
self.name = str(uuid.uuid4())
self.type = "base_particle"
self.sprixel = core.Sprixel(graphics.GeometricShapes.BULLET)
if bg_color is not None and isinstance(bg_color, core.Color):
self.sprixel.bg_color = bg_color
if fg_color is not None and isinstance(fg_color, core.Color):
self.sprixel.fg_color = fg_color
if model is not None:
self.sprixel.model = model
self.directions = [
base.Vector2D.from_direction(constants.UP, 1),
base.Vector2D.from_direction(constants.DLUP, 1),
base.Vector2D.from_direction(constants.DRUP, 1),
]
self.lifespan = 5
if velocity is not None and isinstance(velocity, base.Vector2D):
self.velocity = velocity
else:
self.velocity = base.Vector2D()
if acceleration is not None and isinstance(acceleration,
base.Vector2D):
self.acceleration = acceleration
else:
self.acceleration = base.Vector2D()
if lifespan is not None:
self.lifespan = lifespan
if directions is not None and type(directions) is list:
self.directions = directions
def test_with_sprixel(self):
i = pgl_board_items.NPC(sprixel=gfx_core.Sprixel())
i.animation = gfx_core.Animation(parent=i)
i.animation.add_frame(gfx_core.Sprixel("-"))
i.animation.add_frame(gfx_core.Sprixel("+"))
self.assertIsInstance(i.animation, gfx_core.Animation)
self.assertEqual(len(i.animation.frames), 2)
# I shouldn't test that here but I'm tired of writting test!
self.assertIsInstance(i.animation.next_frame(), gfx_core.Sprixel)
i.animation.frames[1] = pgl_base.Vector2D()
with self.assertRaises(pgl_base.PglInvalidTypeException):
i.animation.next_frame()
i.animation.next_frame()
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_v2d_create(self):
v = pgl_base.Vector2D.from_direction(pgl_base.constants.NO_DIR, 1)
self.assertEqual(v, pgl_base.Vector2D(0, 0))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.UP, 1)
self.assertEqual(v, pgl_base.Vector2D(-1, 0))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.DOWN, 1)
self.assertEqual(v, pgl_base.Vector2D(1, 0))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.LEFT, 1)
self.assertEqual(v, pgl_base.Vector2D(0, -1))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.RIGHT, 1)
self.assertEqual(v, pgl_base.Vector2D(0, 1))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.DRUP, 1)
self.assertEqual(v, pgl_base.Vector2D(-1, 1))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.DRDOWN, 1)
self.assertEqual(v, pgl_base.Vector2D(1, 1))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.DLUP, 1)
self.assertEqual(v, pgl_base.Vector2D(-1, -1))
v = pgl_base.Vector2D.from_direction(pgl_base.constants.DLDOWN, 1)
self.assertEqual(v, pgl_base.Vector2D(1, -1))
def test_v2d_unit(self):
self.assertEqual(self.vectors[0].unit(), pgl_base.Vector2D())
v = self.vectors[2] + self.vectors[1]
self.assertEqual(v.unit(), pgl_base.Vector2D(0.71, 0.71))
