def test_get_block_bottom_right(board_16x16) -> None:
bottom_right = (board_16x16.size, board_16x16.size)
middle = (round(board_16x16.size / 2), round(board_16x16.size / 2))
board = _get_block(board_16x16, bottom_right, 0)
board3 = _get_block(board_16x16, middle, 1)
assert board is None
assert board3 == board_16x16.children[3]
def test_get_block_2(self):
"""
(0, 0) (50, 0) (75, 0) (99, 0)
___________________________
| | | |
| (50, 25)|______|______| (99, 25)
| | | |
(0, 50) |____________|______|______| (99, 50)
| | |
| | |
| | |
|____________|_____________| (99, 99)
"""
for i in range(50):
for j in range(50):
temp = _get_block(self.one_internal, (i, j), 1)
self.assertBlock(temp, [(0, 0), 50, (80, 80, 80), 1, 2, 0],
True, True)
for i in range(50, 100):
for j in range(0, 50):
temp = _get_block(self.one_internal, (i, j), 1)
self.assertBlock(temp, [(50, 0), 50, None, 1, 2, 4], False,
False)
for i in range(50):
for j in range(50, 100):
temp = _get_block(self.one_internal, (i, j), 1)
self.assertBlock(temp, [(0, 50), 50, (70, 70, 70), 1, 2, 0],
True, True)
for i in range(50, 100):
for j in range(50, 100):
temp = _get_block(self.one_internal, (i, j), 1)
self.assertBlock(temp, [(50, 50), 50, (60, 60, 60), 1, 2, 0],
True, True)
def test_get_block_top_left(self, board_16x16) -> None:
"""Test that the correct block is retrieved from the reference board
when requesting the top-left corner of the board.
"""
top_left = (0, 0)
assert _get_block(board_16x16, top_left, 0) == board_16x16
assert _get_block(board_16x16, top_left, 1) == board_16x16.children[1]
def test_get_block(board_16x16) -> None:
new_block = _get_block(board_16x16, (0, 0), 1)
assert new_block.colour == COLOUR_LIST[1]
assert new_block.level == 1
block2 = _get_block(board_16x16, (350, 0), 8)
assert block2.colour == COLOUR_LIST[1]
assert block2.level == 1
def test_get_block_top_top_left(board_16x16) -> None:
top_left = (0, 0)
board0 = _get_block(board_16x16, top_left, 0)
board1 = _get_block(board_16x16, top_left, 1)
board2 = _get_block(board_16x16, top_left, 2)
assert board0 == board_16x16
assert board1 == board_16x16.children[1]
assert board2 is None
def test_get_block_top_right(self, board_16x16) -> None:
"""Test that the correct block is retrieved from the reference board
when requesting the top-right corner of the board.
"""
top_right = (board_16x16.size - 1, 0)
assert _get_block(board_16x16, top_right, 0) == board_16x16
assert _get_block(board_16x16, top_right, 1) == board_16x16.children[0]
assert _get_block(board_16x16, top_right, 2) == \
board_16x16.children[0].children[0]
def test_get_block_bottom_right(self, board_16x16) -> None:
"""Test that the correct block is retrieved from the reference board
when requesting the bottom-right corner of the board.
"""
bottom_right = (board_16x16.size - 1, board_16x16.size - 1)
assert _get_block(board_16x16, bottom_right, 0) == board_16x16
assert _get_block(board_16x16, bottom_right, 1) == board_16x16.children[3]
assert _get_block(board_16x16, bottom_right, 2) == \
board_16x16.children[3] # Works when children are defined
def player_playground():
from player import RandomPlayer, SmartPlayer, create_players, _get_block
b = block_three_level1()
found = _get_block(b, (0, 0), 0)
print(block_graph(found))
found = _get_block(b, (0, 0), 1)
print(block_graph(found))
players = create_players(1, 1, [10])
print(players)
def test_get_block_middle(board_16x16) -> None:
middle = (round(board_16x16.size / 2), 0)
board0 = _get_block(board_16x16, middle, 0)
board1 = _get_block(board_16x16, middle, 1)
board2 = _get_block(board_16x16, middle, 2)
board3 = _get_block(board_16x16, middle, 3)
board4 = _get_block(board_16x16, middle, 4)
assert board0 == board_16x16
assert board1 == board_16x16.children[0]
assert board2 == board_16x16.children[0].children[1]
assert board3 == board_16x16.children[0].children[1].children[1]
assert board4 is None
def test_depth_5_board(renderer):
random.seed(1002)
board = generate_board(5, BOARD_SIZE)
renderer.draw_board(_block_to_squares(board))
renderer.save_to_file('board_5_ref.png')
renderer.clear()
goal1 = BlobGoal(COLOUR_LIST[0]) # blue
goal2 = BlobGoal(COLOUR_LIST[1]) # red
player1 = RandomPlayer(1, goal1)
player2 = RandomPlayer(2, goal2)
player1._proceed = True
move1 = player1.generate_move(board)
move1_block = move1[2]
to_do = _get_block(board, move1_block.position, move1_block.level)
assert move1[0] == "swap" and move1[1] == 0
assert to_do.swap(0)
renderer.draw_board(_block_to_squares(board))
renderer.save_to_file('board_5_move1.png')
renderer.clear()
afterfirst1 = goal1.score(board)
afterfirst2 = goal2.score(board)
player2._proceed = True
move2 = player2.generate_move(board)
move2_block = move2[2]
to_do_2 = _get_block(board, move2_block.position, move2_block.level)
assert move2[0] == "smash"
assert to_do_2.smash()
renderer.draw_board(_block_to_squares(board))
renderer.save_to_file('board_5_move2.png')
renderer.clear()
aftersecond1 = goal1.score(board)
aftersecond2 = goal2.score(board)
player1._proceed = True
move3 = player1.generate_move(board)
move3_block = move3[2]
to_do_3 = _get_block(board, move3_block.position, move3_block.level)
assert move3[0] == "rotate" and move3[1] == 3
assert to_do_3.rotate(3)
renderer.draw_board(_block_to_squares(board))
renderer.save_to_file('board_5_move3.png')
renderer.clear()
afterthird1 = goal1.score(board)
afterthird2 = goal2.score(board)
def test_get_block_1(self):
"""
(10, 10) (19, 10)
____________
| |
| |
|___________|
(10, 19) (19, 19)
"""
block = self.leaf_block
corners = [(10, 10), (19, 10), (10, 19), (19, 19)]
for corner in corners:
act = _get_block(block, corner, 0)
self.assertBlock(act, [(10, 10), 10, (10, 10, 10), 0, 0, 0], True, True)
outbounds = [9, 20, 20, 100]
for outbound in outbounds:
for i in range(100):
act = _get_block(block, (outbound, i), 0)
self.assertIsNone(act, "The coordinates are out of bound you should return None")
def test__get_block() -> None:
"""Test _get_block and my helper function _location_in_block.
- helper:
- when location is in block
- when location is not in block
- when location is on the edge of a block
- function:
- base case
- children case
"""
block = Block((0, 0), 100, (0, 0, 0), 0, 1)
l1 = (50, 50)
l2 = (200, 200)
l3 = (100, 0)
l4 = (99, 0)
l5 = (0, 100)
l6 = (30, 100)
assert _location_in_block(block, l1)
assert _location_in_block(block, l2) is False
assert _location_in_block(block, l3) is False
assert _location_in_block(block, l4)
assert _location_in_block(block, l5) is False
assert _location_in_block(block, l6) is False
assert _get_block(block, l1, 1) == block
assert _get_block(block, l2, 0) is None
assert block.smash()
child = _get_block(block, l1, 1)
assert child == block.children[3]
assert _get_block(block, l1, 0) == block
assert _get_block(block, l2, 1) is None
new_block = Block((0, 0), 100, (0, 0, 0), 0, 3)
assert new_block.smash()
child = _get_block(new_block, (60, 70), 2)
assert child.level >= 1
def test_get_block() -> None:
block = Block((0, 0), 16, None, 0, 5)
b1 = Block((8, 0), 8, (1, 128, 181), 1, 5)
b2 = Block((0, 0), 8, (199, 44, 58), 1, 5)
b3 = Block((0, 8), 8, None, 1, 5)
b4 = Block((8, 8), 8, (255, 211, 92), 1, 5)
block.children = [b1, b2, b3, b4]
b31 = Block((4, 8), 4, (1, 128, 181), 2, 5)
b32 = Block((0, 8), 4, (199, 44, 58), 2, 5)
b33 = Block((0, 12), 4, (255, 211, 92), 2, 5)
b34 = Block((4, 12), 4, (199, 44, 58), 2, 5)
b3.children = [b31, b32, b33, b34]
x = _get_block(block, (3, 7), 2)
y = _get_block(block, (7, 10), 2)
a = _get_block(block, (8, 8), 1)
b = _get_block(block, (16, 8), 1)
z = _get_block(block, (15, 13), 5)
assert b is None
assert a.position == (8, 8)
assert y.position == (4, 8)
assert x.position == (0, 0)
assert z.position == (8, 8)
def test_get_block_level_none5(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (244, 750), 0)
assert get_block is None
def test_get_block_3(self):
"""
(0, 0) (50, 0) (75, 0) (99, 0)
___________________________
| | | |
| (50, 25)|______|______| (99, 25)
| | | |
(0, 50) |____________|______|______| (99, 50)
| | |
| | |
| | |
|____________|_____________| (99, 99)
"""
act = _get_block(self.one_internal, (50, 0), 0)
self.assertBlock(act, [(0, 0), 100, None, 0, 2, 4], False, False)
act1 = _get_block(self.one_internal, (50, 0), 1)
self.assertBlock(act1, [(50, 0), 50, None, 1, 2, 4], False, False)
act2 = _get_block(self.one_internal, (49, 0), 1)
self.assertBlock(act2, [(0, 0), 50, (80, 80, 80), 1, 2, 0], True, True)
act3 = _get_block(self.one_internal, (49, 50), 1)
self.assertBlock(act3, [(0, 50), 50, (70, 70, 70), 1, 2, 0], True,
True)
act4 = _get_block(self.one_internal, (50, 50), 1)
self.assertBlock(act4, [(50, 50), 50, (60, 60, 60), 1, 2, 0], True,
True)
act5 = _get_block(self.one_internal, (75, 0), 2)
self.assertBlock(act5, [(75, 0), 25, (40, 40, 40), 2, 2, 0], True,
True)
act6 = _get_block(self.one_internal, (75, 25), 2)
self.assertBlock(act6, [(75, 25), 25, (10, 10, 10), 2, 2, 0], True,
True)
act7 = _get_block(self.one_internal, (99, 25), 2)
self.assertBlock(act7, [(75, 25), 25, (10, 10, 10), 2, 2, 0], True,
True)
act8 = _get_block(self.one_internal, (74, 25), 2)
self.assertBlock(act8, [(50, 25), 25, (20, 20, 20), 2, 2, 0], True,
True)
act9 = _get_block(self.one_internal, (50, 0), 2)
self.assertBlock(act9, [(50, 0), 25, (30, 30, 30), 2, 2, 0], True,
True)
act11 = _get_block(self.one_internal, (75, 25), 1)
self.assertBlock(act11, [(50, 0), 50, None, 1, 2, 4], False, False)
act10 = _get_block(self.one_internal, (50, 50), 2)
self.assertBlock(act10, [(50, 50), 50, None, 1, 2, 0], False, False)
def test_get_block_level_under(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (0, 0), 2)
assert get_block == Block((0, 0), 375, COLOUR_LIST[2], 1, 3)
def test_get_block_middle2(board_16x16) -> None:
middle = (round(board_16x16.size / 2) + round(board_16x16.size / 8), round(board_16x16.size / 8))
board = _get_block(board_16x16, middle, 3)
assert board == board_16x16.children[0].children[1].children[3]
def test_get_block(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (0, 0), 1)
the_block = Block((0, 0), 375, COLOUR_LIST[2], 1, 3)
assert get_block == the_block
def test_get_block_max_level(self) -> None:
borde = standard_borde()
# print(_get_block(borde, (50, 50), 3))
assert _get_block(borde, (50, 50), 3) is None
def test_get_block_level_0(self) -> None:
borde = standard_borde()
assert _get_block(borde, (0, 0), 0) == borde
def test_get_block_level_none4(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (750, 375), 0)
assert get_block is None
def test_get_block_middle(self, board_2x2) -> None:
middle = (board_2x2.size / 2, board_2x2.size / 2)
assert _get_block(board_2x2, middle, 0) == board_2x2
assert _get_block(board_2x2, middle, 1) == board_2x2.children[3]
def test_get_block_middle1(self, board_2x2_2) -> None:
middle = (board_2x2_2.size / 2, board_2x2_2.size / 2)
left_middle = (0, board_2x2_2.size / 2)
assert _get_block(board_2x2_2, middle, 2) == board_2x2_2.children[3]
assert _get_block(board_2x2_2, left_middle) == board_2x2_2.children[2]
def test_get_block(self) -> None:
single_block = Block((0, 0), 16, (0, 0, 0), 0, 0)
one_level = Block((0, 0), 16, None, 0, 1)
one_level_upper_left = Block((0, 0), 8, None, 1, 1)
one_level_upper_right = Block((8, 0), 8, PACIFIC_POINT, 1, 1)
one_level_lower_left = Block((0, 8), 8, DAFFODIL_DELIGHT, 1, 1)
one_level_lower_right = Block((8, 8), 8, BLACK, 1, 1)
lul = Block((0, 0), 4, BLACK, 1, 1)
lur = Block((4, 0), 4, PACIFIC_POINT, 1, 1)
lll = Block((0, 4), 4, DAFFODIL_DELIGHT, 1, 1)
llr = Block((4, 4), 4, WHITE, 1, 1)
one_level.children = [
one_level_upper_right, one_level_upper_left, one_level_lower_left,
one_level_lower_right
]
one_level_upper_left.children = [lur, lul, lll, llr]
assert None == _get_block(single_block, (16, 5), 0)
assert None == _get_block(single_block, (5, 16), 0)
assert single_block == _get_block(single_block, (0, 5), 0)
assert single_block == _get_block(single_block, (5, 0), 0)
assert single_block == _get_block(single_block, (5, 5), 0)
assert single_block == _get_block(single_block, (5, 5), 0)
assert one_level == _get_block(one_level, (0, 0), 0)
assert one_level_upper_left == _get_block(one_level, (0, 0), 1)
assert one_level_upper_right == _get_block(one_level, (8, 0), 1)
assert one_level_lower_left == _get_block(one_level, (0, 8), 1)
assert one_level_lower_right == _get_block(one_level, (8, 8), 1)
assert one_level_upper_left == _get_block(one_level, (1, 5), 1)
assert one_level_upper_right == _get_block(one_level, (9, 5), 1)
assert one_level_lower_left == _get_block(one_level, (4, 14), 1)
assert one_level_lower_right == _get_block(one_level, (13, 9), 1)
assert lul == _get_block(one_level, (0, 0), 2)
assert lur == _get_block(one_level, (4, 0), 2)
assert lll == _get_block(one_level, (0, 4), 2)
assert llr == _get_block(one_level, (4, 4), 2)
assert lul == _get_block(one_level, (3, 2), 2)
assert lur == _get_block(one_level, (5, 3), 2)
assert lll == _get_block(one_level, (3, 6), 2)
assert llr == _get_block(one_level, (5, 7), 2)
def test_get_block_board(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (35, 127), 0)
assert get_block == board_32x32
def test_get_block() -> None:
""" Test the _get_block function. """
b1 = Block((0, 0), 500, (255, 0, 0), 0, 3)
assert _get_block(b1, (55, 75), 0) is b1
assert _get_block(b1, (0, 0), 0) is b1
assert _get_block(b1, (500, 425), 0) is None
assert _get_block(b1, (55, 75), 5) is b1
b2 = Block((0, 0), 1000, None, 0, 2)
b2.children = [Block((500, 0), 500, (255, 0, 0), 1, 2),
Block((0, 0), 500, (255, 255, 0), 1, 2),
Block((0, 500), 500, (255, 0, 255), 1, 2),
Block((500, 500), 500, (0, 0, 255), 1, 2)]
b2.children[1].colour = None
b2.children[1].children = [Block((250, 0), 250, (0, 0, 0), 2, 2),
Block((0, 0), 250, (0, 255, 0), 2, 2),
Block((0, 250), 250, (255, 255, 255), 2, 2),
Block((250, 250), 250, (0, 255, 255), 2, 2)]
assert _get_block(b2, (288, 22), 0) is b2
assert _get_block(b2, (51, 155), 2) is b2.children[1].children[1]
assert _get_block(b2, (51, 243), 1) is b2.children[1]
assert _get_block(b2, (1, 1000), 1) is None
assert _get_block(b2, (250, 1000), 1) is None
assert _get_block(b2, (250, 16), 2) is b2.children[1].children[0]
assert _get_block(b2, (550, 670), 2) is b2.children[3]
def test_get_block_corner(self, board_32x32) -> None:
get_block = _get_block(board_32x32, (376, 376), 1)
the_block = Block((375, 375), 375, COLOUR_LIST[3], 1, 3)
assert get_block == the_block
