def as_move_list(move_list):
moves = Move()
prev_move = None
for move in move_list:
if prev_move is not None:
moves.add(prev_move, move)
prev_move = move
return moves
def _add_moves_for_col(self, row_dir, col_dir):
new_row = self.row + row_dir
new_col = self.col + col_dir
if self.board.valid_position(new_row, new_col) and self.board.get_piece(new_row, new_col) is None:
move_list = Move()
move_list.add((self.row, self.col), (new_row, new_col))
return [move_list]
elif self.board.get_piece(new_row, new_col) is not None and self.board.get_piece(new_row, new_col).get_origin() != self.origin:
return self._calculate_jumped_moves(new_row, new_col, row_dir, col_dir)
return []
def test_pieces_eaten_for_jump_is_how_many_moves_are_in_it(self):
move = Move()
move.add((6, 6), (4, 4))
self.assertEqual(1, move.get_pieces_eaten())
move.add((4, 4), (2, 2))
self.assertEqual(2, move.get_pieces_eaten())
def _calculate_jumped_moves(self, row, col, row_dir, col_dir):
#We have the row & column on which there is a piece. we have to keep going
#along the diagonal -> if the next piece is occupied, return empty list - this isn't a valid move
#if it's not occupied... that's the tricky part
new_row = row + row_dir
new_col = col + col_dir
if self.board.get_piece(new_row, new_col) is not None or self.board.invalid_position(new_row, new_col):
return []
move = Move()
move.add((row-row_dir, col-col_dir), (new_row, new_col))
moves = [move]
#Keep going along the same direction
new_new_row = self._continue_adding_jumps_in_same_dir(row_dir, new_row, new_col, move, moves)
self._account_for_king_movements(row_dir, col_dir, new_row, new_col, move, moves, new_new_row)
return moves
def test_pieces_eaten_for_non_jump_is_0(self):
move = Move()
move.add((3, 3), (4, 4))
self.assertEqual(0, move.get_pieces_eaten())
def __init__(self, game, origin=origin.BOTTOM):
self.game = game
self.piece = None
self.origin = other_origin(origin)
self.moves = Move()
self.over = False
class Turn(object):
def __init__(self, game, origin=origin.BOTTOM):
self.game = game
self.piece = None
self.origin = other_origin(origin)
self.moves = Move()
self.over = False
def handle_movement(self, from_loc, to_loc):
if self._illegal_move(from_loc, to_loc):
return
self.game.set_piece(to_loc[0], to_loc[1], self.game.get_piece(from_loc[0], from_loc[1]))
self.game.set_piece(from_loc[0], from_loc[1], None)
self.moves.add(from_loc, to_loc)
self._check_if_turn_complete(to_loc)
def _check_if_turn_complete(self, to_loc):
new_moves = Movement(self.game.board, to_loc[0], to_loc[1]).get_available_moves()
for move in new_moves:
if move.contains_jump() and move.jumps_are_not_backward_from(self.moves) \
and (self.moves.contains_jump() or len(self.moves) == 0):
return
self.over = True
def _illegal_move(self, from_loc, to_loc):
moves = Movement(self.game.board, from_loc[0], from_loc[1]).get_available_moves()
piece = self.game.get_piece(from_loc[0], from_loc[1])
if piece is not None and piece.get_origin() != self.origin:
return True
if self.piece is not None and self.piece is not piece:
return True
return not self._is_valid_forward_movement(to_loc, piece, moves) and \
not self._is_valid_backward_movement(from_loc, to_loc)
def _is_valid_forward_movement(self, to_loc, piece, moves):
for move_list in moves:
if (len(self.moves) > 0 and move_list.contains_jump_ending_in(to_loc)) \
or (len(self.moves) == 0 and move_list.contains_move_ending_in(to_loc)):
self.piece = piece
return True
return False
def _is_valid_backward_movement(self, from_loc, to_loc):
for move in self.moves:
if move.is_backwards_version_of(from_loc, to_loc):
return True
return False
def handle_jumps(self):
for move in self.moves:
if move.is_jump():
row, col = move.get_jumped_piece()
self.game.set_piece(row, col, None)
def is_over(self):
return self.over
def is_computers_turn(self, computer):
return self.origin == computer.origin
