def test_get_valid_moves(self):
board = blokus.Board()
player = board.players[0]
unplayed_piece = blokus.Piece(np.array([
[1, 0],
[1, 1],
[1, 1]
]), player)
player.unplayed_pieces = [ unplayed_piece ]
valid_moves = player.get_valid_moves(board)
self.assertEqual(len(valid_moves), 6)
invalid_move = np.array([
[0, 1],
[1, 1],
[1, 1]
])
self.assertTrue(all([not np.array_equal(invalid_move, move) for move in valid_moves]))
invalid_move = np.array([
[0, 1, 1],
[1, 1, 1]
])
self.assertTrue(all([not np.array_equal(invalid_move, move) for move in valid_moves]))
move_positions = map(lambda x: x._position, valid_moves)
self.assertTrue(all([position == (0, 0) for position in move_positions]))
def test_get_block(self):
board = blokus.Board()
self.assertIsNone(board.get_block((-1, 0)))
self.assertIsNone(board.get_block((0, -1)))
self.assertIsNone(board.get_block((blokus.Board.SIZE, 0)))
self.assertIsNone(board.get_block((0, blokus.Board.SIZE)))
self.assertEqual(board.get_block((5, 9)), board.board[9][5])
def test_initialization(self):
board = blokus.Board()
self.assertEqual(len(board.players), 4)
self.assertEqual(blokus.Board.SIZE, 20)
self.assertEqual(len(board.board), blokus.Board.SIZE)
self.assertTrue(all([len(row) == blokus.Board.SIZE for row in board.board]))
self.assertTrue(board.get_block((0, 0)).anchors_player(board.players[0]))
self.assertTrue(board.get_block((19, 0)).anchors_player(board.players[1]))
self.assertTrue(board.get_block((19, 19)).anchors_player(board.players[2]))
self.assertTrue(board.get_block((0, 19)).anchors_player(board.players[3]))
def test_get_blocks_affected(self):
board = blokus.Board()
player = board.players[0]
piece = blokus.Piece(np.array([
[1, 1, 1],
[0, 1, 0],
[0, 1, 0]
]), player)
move = blokus.Move(board, piece, (13, 6))
expected = [
board.get_block((13, 6)),
board.get_block((14, 6)),
board.get_block((15, 6)),
board.get_block((14, 7)),
board.get_block((14, 8))
]
self.assertEqual(set(move.get_blocks_affected()), set(expected))
# [1, 0, 0]
# [1, 1, 1]
# [1, 0, 0]
move = blokus.Move(board, piece, (5, 9), orientation=2)
expected = [
board.get_block((5, 9)),
board.get_block((5, 10)),
board.get_block((6, 10)),
board.get_block((7, 10)),
board.get_block((5, 11))
]
self.assertEqual(set(move.get_blocks_affected()), set(expected))
move = blokus.Move(board, piece, (-1, 0))
expected = [
None,
board.get_block((0, 0)),
board.get_block((1, 0)),
board.get_block((0, 1)),
board.get_block((0, 2))
]
self.assertEqual(set(move.get_blocks_affected()), set(expected))
def test_is_valid(self):
'''
A valid move is a move where:
1. At least 1 block for the move is an anchor for the player
2. All blocks allow the player
3. The piece isn't falling out of bounds
'''
board = blokus.Board()
player = board.players[0]
piece = blokus.Piece(np.array([
[1, 1],
[1, 0]
]), player)
player.unplayed_pieces.append(piece)
move = blokus.Move(board, piece, (0, 0))
self.assertTrue(move.is_valid())
# Invalid orientation, does not line up with anchor
# [0, 1]
# [1, 1]
move = blokus.Move(board, piece, (0, 0), orientation=2)
self.assertFalse(move.is_valid())
# Piece is falling off the board
move = blokus.Move(board, piece, (0, -1))
self.assertFalse(move.is_valid())
move = blokus.Move(board, piece, (-1, 0))
self.assertFalse(move.is_valid())
board.get_block((1, 0)).disallow_player(player)
# Piece covers a block where the player is not allowed
move = blokus.Move(board, piece, (0, 0))
self.assertFalse(move.is_valid())
# Piece has already been played
with patch('blokus.Piece') as played_piece:
played_piece.is_played = True
move = blokus.Move(board, played_piece, (0, 0))
self.assertFalse(move.is_valid())
def test_make_move(self):
board = blokus.Board()
with patch('blokus.Move') as invalid_move:
invalid_move.is_valid.return_value = False
with self.assertRaises(RuntimeError):
board.make_move(invalid_move)
player = board.players[2]
piece = blokus.Piece(np.array([
[1, 1, 1],
[0, 1, 0],
[0, 1, 0]
]), player)
player.unplayed_pieces = [ piece ]
# Player 2's start position is (19, 19)
# [0, 0, 1]
# [1, 1, 1]
# [0, 0, 1]
move = blokus.Move(board, piece, (17, 17), orientation=1)
board.make_move(move)
self.assertNotIn(move._piece, player.unplayed_pieces)
self._verify_make_move(
board=board,
player=player,
expected_assigned=set([ (19, 17), (19, 18), (19, 19), (17, 18), (18, 18) ]),
expected_anchors=set([ (18, 16), (16, 17), (16, 19) ]),
expected_disallowed=set([ (19, 16), (18, 17), (17, 17), (18, 19), (17, 19), (16, 18) ])
)
piece_2 = blokus.Piece(np.array([
[1, 1],
[1, 0],
[1, 1]
]), player)
player.unplayed_pieces = [ piece_2 ]
move = blokus.Move(board, piece_2, (15, 17))
board.make_move(move)
self._verify_make_move(
board=board,
player=player,
expected_assigned=set([
(19, 17), (19, 18), (19, 19), (17, 18), (18, 18),
(16, 17), (15, 17), (15, 18), (15, 19), (16, 19)
]),
expected_anchors=set([
(18, 16), (17, 16), (14, 16)
]),
expected_disallowed=set([
(19, 16), (18, 17), (17, 17), (18, 19), (17, 19), (16, 18),
(14, 19), (14, 18), (14, 17), (15, 16), (16, 16)
])
)
def __init__(self):
self.board = blokus.Board()
self.turn_count = 0
self.players_remaining = len(self.board.players)
self.is_complete = False