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