Example #1
0
    def get_diagonal_moves(self, piece: Piece,
                           board: List[List[Piece]]) -> List[Move]:
        """
        returns a list of all diagonal moves

        arguments:
        piece -- piece to generate moves
        board -- board to validate moves
        """

        if piece.piece_type != Type.BISHOP and piece.piece_type != Type.QUEEN:
            return []

        directions: List[Tuple[int, int]] = [(1, 1), (-1, 1), (-1, -1),
                                             (1, -1)]
        moves: List[Move] = []

        for direction in directions:
            destination: Coordinate = Coordinate(
                piece.coordinate.get_rank() + direction[0],
                piece.coordinate.get_file() + direction[1],
            )
            while self.in_board(destination):
                moves.append(
                    Move(piece.coordinate, destination,
                         self.piece_at(destination, board)))
                if self.piece_at(destination, board):
                    break
                destination = Coordinate(
                    destination.get_rank() + direction[0],
                    destination.get_file() + direction[1],
                )

        return moves
Example #2
0
 def test_first_input(self):
     coordinate = Coordinate(1, 2)
     plateau = Plateau(5, 5)
     rover = Rover(coordinate, North())
     RoverManager(plateau, rover).perform("LMLMLMLMM")
     self.assertEqual(rover.coordinate, Coordinate(1, 3))
     self.assertEqual(rover.direction, North())
Example #3
0
 def test_second_input(self):
     coordinate = Coordinate(3, 3)
     plateau = Plateau(5, 5)
     rover = Rover(coordinate, East())
     RoverManager(plateau, rover).perform("MMRMMRMRRM")
     self.assertEqual(rover.coordinate, Coordinate(5, 1))
     self.assertEqual(rover.direction, East())
Example #4
0
 def test_snake_has_coordinates(self):
     snake = self.get_snake()
     assert snake.coordinates == [
         Coordinate(10, 15),
         Coordinate(11, 15),
         Coordinate(11, 16),
         Coordinate(11, 17)
     ]
Example #5
0
    def in_board(self, coordinate: Coordinate) -> bool:
        """
        returns whether a coordinate is within the bounds of the board

        arguments:
        coordinate -- coordinate to check
        """

        return (coordinate.get_rank() >= 0 and coordinate.get_file() >= 0
                and coordinate.get_rank() < self.HEIGHT
                and coordinate.get_file() < self.WIDTH)
Example #6
0
    def test_snake_can_tell_if_contains_coordinates(self):
        snake = self.get_snake()

        coordinate = Coordinate(9, 15)
        assert snake.contains_coordinate(coordinate) == False

        coordinate = Coordinate(10, 14)
        assert snake.contains_coordinate(coordinate) == False

        coordinate = Coordinate(10, 15)
        assert snake.contains_coordinate(coordinate) == True
Example #7
0
    def test_snake_can_get_all_moves(self):
        snake = self.get_snake()

        all_moves = [
            Coordinate(9, 15),
            Coordinate(11, 15),
            Coordinate(10, 14),
            Coordinate(10, 16)
        ]

        assert snake.get_all_moves() == all_moves
Example #8
0
    def piece_at(self, coordinate: Coordinate,
                 board: List[List[Piece]]) -> Union[Piece, None]:
        """
        returns a reference to the piece at a specified coordinate, if no piece is present returns None

        arguments:
        coordinate -- coordinate to check
        board -- board to check for piece in
        """

        if not self.in_board(coordinate):
            return None
        else:
            return board[coordinate.get_rank()][coordinate.get_file()]
    def test_coordinates_can_be_compared(self):
        coordinate_a = Coordinate(4, 5)
        coordinate_b = Coordinate(4, 5)
        # Coordinate objects are unique.
        assert coordinate_a is not coordinate_b
        # Coordinates are comparable based on x and y values.
        assert coordinate_a == coordinate_b

        coordinate_c = Coordinate(5, 4)
        assert coordinate_a != coordinate_c

        coordinate_d = (coordinate_a.x, coordinate_a.y)
        # Coordinates can only be compared against other coordinates.
        assert (coordinate_a == coordinate_d) is not True
        assert coordinate_a != coordinate_d
Example #10
0
 def foods(self) -> List[Coordinate]:
     """Retreive the list of food from the board data."""
     if self._foods is None:
         self._foods = [
             Coordinate(food_data) for food_data in self._data['food']
         ]
     return self._foods
Example #11
0
 def coordinates(self) -> List[Coordinate]:
     """Get the List of Coordinates which describes the location of this Snake."""
     if not self._coordinates:
         self._coordinates = [
             Coordinate(coordinate_tuple)
             for coordinate_tuple in self._data['body']
         ]
     return self._coordinates
Example #12
0
    def test_brain_can_avoid_headons(self):

        two_close_snakes = self.main_snake + self.equal_snake
        brain = self.get_brain(two_close_snakes, self.foods, self.width)

        assert brain.get_threatening_snakes_moves() == [
            Coordinate(2,1),
            Coordinate(4,1),
            Coordinate(3,0),
            Coordinate(3,2),
        ]
        assert brain.get_valid_moves() == ["left"]

        snake_and_smol_snek = self.main_snake + self.smol_snek
        unthreatened_brain = self.get_brain(snake_and_smol_snek , self.foods, self.width)
        assert unthreatened_brain.get_threatening_snakes_moves() == []
        assert unthreatened_brain.get_valid_moves() == ["left", "right", "up"]
Example #13
0
 def test_brain_can_get_moves_to_coord(self):
     brain = self.get_brain(self.main_snake, self.foods, self.width)
     assert brain.get_moves_to(Coordinate(9,0)) == ["right", "up"]
     assert brain.get_moves_to(Coordinate(9,2)) == ["right"]
     assert brain.get_moves_to(Coordinate(9,9)) == ["right", "down"]
     assert brain.get_moves_to(Coordinate(2,9)) == ["down"]
     assert brain.get_moves_to(Coordinate(0,9)) == ["down", "left"]
     assert brain.get_moves_to(Coordinate(0,2)) == ["left"]
     assert brain.get_moves_to(Coordinate(0,0)) == ["left", "up"]
Example #14
0
    def get_nearest_food(self) -> Optional[Coordinate]:
        """Get the food item which has coordinates closest to this snake's head."""
        closest_food = (Coordinate((0, 0)), 9999.0)

        for food in self.board.foods:
            distance = self.me.head.get_distance_from(food)

            if distance < closest_food[1]:
                closest_food = (food, distance)

        if closest_food[1] == 9999.0:
            return None

        return closest_food[0]
Example #15
0
    def get_nearest_food(self) -> Optional[Coordinate]:
        """Get the food item which has coordinates closest to this snake's head."""
        closest_food = (Coordinate((0, 0)), 9999.0)

        for food in self.board.foods:
            x_diff = self.me.head.x - food.x
            y_diff = self.me.head.y - food.y
            distance = math.sqrt(x_diff * x_diff + y_diff * y_diff)

            if distance < closest_food[1]:
                closest_food = (food, distance)

        if closest_food[1] == 9999.0:
            return None

        return closest_food[0]
Example #16
0
    def checkmated(self, color: Color, board: List[List[Piece]]) -> bool:
        """
        checks whether a side is currently in checkmate on a board

        arguments:
        color -- color to check if in check
        board -- board to check on
        """

        if not self.in_check(color, board):
            return False

        for r in range(self.HEIGHT):
            for f in range(self.WIDTH):
                piece: Union[Piece,
                             None] = self.piece_at(Coordinate(r, f), board)
                if piece and piece.color == color and len(
                        self.get_moves(piece, board)):
                    return False

        return True
Example #17
0
    def get_knight_moves(self, piece: Piece,
                         board: List[List[Piece]]) -> List[Move]:
        """
        returns a list of all knight moves

        arguments:
        piece -- piece to generate moves
        board -- board to validate moves
        """

        if piece.piece_type != Type.KNIGHT:
            return []

        offsets: List[Tuple[int, int]] = [
            (2, 1),
            (1, 2),
            (-1, 2),
            (-2, 1),
            (-2, -1),
            (-1, -2),
            (1, -2),
            (2, -1),
        ]
        moves: List[Move] = []

        for offset in offsets:
            destination: Coordinate = Coordinate(
                piece.coordinate.get_rank() + offset[0],
                piece.coordinate.get_file() + offset[1],
            )
            if self.in_board(destination):
                moves.append(
                    Move(piece.coordinate, destination,
                         self.piece_at(destination, board)))

        return moves
Example #18
0
    def test_coordinate_is_in_bounds(self):
        board = self.get_board()

        coordinate = Coordinate(-1, 0)
        assert board.is_coordinate_in_bounds(coordinate) == False

        coordinate = Coordinate(0, -1)
        assert board.is_coordinate_in_bounds(coordinate) == False

        coordinate = Coordinate(15, 0)
        assert board.is_coordinate_in_bounds(coordinate) == False

        coordinate = Coordinate(0, 15)
        assert board.is_coordinate_in_bounds(coordinate) == False

        coordinate = Coordinate(0, 14)
        assert board.is_coordinate_in_bounds(coordinate) == True

        coordinate = Coordinate(14, 0)
        assert board.is_coordinate_in_bounds(coordinate) == True
 def test_coordinate_can_provide_left_coordinate(self):
     coordinate = (self.DEFAULT_X - 1, self.DEFAULT_Y)
     left_coordinate = Coordinate(coordinate)
     assert self.get_coordinate().get_left() == left_coordinate
 def test_coordinate_can_provide_right_coordinate(self):
     coordinate = (self.DEFAULT_X + 1, self.DEFAULT_Y)
     right_coordinate = Coordinate(coordinate)
     assert self.get_coordinate().get_right() == right_coordinate
 def test_coordinate_can_provide_down_coordinate(self):
     coordinate = (self.DEFAULT_X, self.DEFAULT_Y + 1)
     down_coordinate = Coordinate(coordinate)
     assert self.get_coordinate().get_down() == down_coordinate
 def test_coordinate_can_provide_up_coordinate(self):
     coordinate = (self.DEFAULT_X, self.DEFAULT_Y - 1)
     up_coordinate = Coordinate(coordinate)
     assert self.get_coordinate().get_up() == up_coordinate
 def test_create_coordinate(self):
     assert type(Coordinate(5, 5)).__name__ == 'Coordinate'
Example #24
0
 def test_coordinate_Created(self):
     coordinate = Coordinate(1, 2)
     self.assertEqual(coordinate, Coordinate(1, 2))
 def test_move_when_pointed_east_in_x_direction_forward(self):
     rover = Rover(self.coordinate, East())
     rover.move(self.plateau.is_coordinate_with_bounds)
     self.assertEqual(rover.coordinate, Coordinate(2, 2))
 def get_coordinate(self):
     coordinate = (self.DEFAULT_X, self.DEFAULT_Y)
     return Coordinate(coordinate)
Example #27
0
 def test_board_has_foods(self):
     assert self.get_board().foods == [Coordinate(10, 5), Coordinate(6, 12)]
 def test_move_when_pointed_south_in_y_direction_downwards(self):
     rover = Rover(self.coordinate, South())
     rover.move(self.plateau.is_coordinate_with_bounds)
     self.assertEqual(rover.coordinate, Coordinate(1, 1))
Example #29
0
    def test_board_can_advance_snake(self):
        board = self.get_board()

        path = [
            Coordinate(3, 2),
            Coordinate(4, 2),
            Coordinate(5, 2),
            Coordinate(6, 2),
            Coordinate(7, 2),
            Coordinate(8, 2),
            Coordinate(9, 2),
            Coordinate(10, 2),
            Coordinate(10, 3),
            Coordinate(10, 4),
            Coordinate(10, 5)
        ]

        new_board = board.advance_snake_along_path(board.snakes[0].id, path)
        new_snake_coords = new_board.snakes[0].coordinates
        assert new_snake_coords[0] == Coordinate(10, 5)
        assert new_snake_coords[1] == Coordinate(10, 4)
        assert new_snake_coords[2] == Coordinate(10, 3)
        assert new_snake_coords[3] == Coordinate(10, 3)
        assert len(new_snake_coords) == 4
 def test_move_when_pointed_west_in_x_direction_backwards(self):
     rover = Rover(self.coordinate, West())
     rover.move(self.plateau.is_coordinate_with_bounds)
     self.assertEqual(rover.coordinate, Coordinate(0, 2))