# Set up
from chess_py import Color, Player, Game, Color, Board, Move

# Creates color objects to initialize players with.
white_color = Color.init_white()
black_color = Color.init_black()

# Creates a game with human players playing white and black
new_game = Game(Player(white_color), Player(black_color))

# Starts game and stores result
# Result is of type integer 
# 1 - White wins
# 0.5 - Draw
# 0 - Black Wins
result = new_game.play()

# Creates a game with a human player playing white and a separate software playing black
new_game = Game(human.Player(color_white), your_class(color_black))
result = new_game.play()

# In your_class . . . 
class your_class:
    def __init__(self, color):
      # color parameter can be accessed in several different ways
      
      self.color = color
      
      # color_string is either "white" or "black"
      color_string = color.string
      # color_bool is True if color is white, or False if color is black
      color_bool = color.color
      # Your code
    
    def generate_move(self, position):
      # position parameter is an object of type Board
      # Must return a list of objects of type Move
      moves = []
      
      # Move must be initialized with parameters location, piece, status
      # Optional parameters are start_rank (y coordinate from 1 to 7), 
      #start_file (x coordinate from 1 to 7), string, and promoted_to_piece 
      #(one of 6 objects of subclass Piece)
      # Here is an example of the move e4
      my_move = Move(Location(3, 4), position.piece_at_square(Location(1, 4)), 
      # notation_const.MOVEMENT)
      # Notice a couple things:
      # Location is initialized with rank (y coordinate from 1 to 7) first, 
      # then file (x coordinate from 1 to 7)
      # Status is a constant from notation_const 
      # Other constants include CAPTURE, PROMOTE, EN_PASSANT, etc.
      
      # All of that looks tedious. What if I just have a string storing the move in 
      # algebraic notation ie. Nf3 ?
      # Then do the following
      my_move = to_move(my_algebraic_notation_move_stored_as _string)
      # If your_class wanted to move e4
      return to_move("e4")
      
      # This works for any move written in algebraic notation
      return to_move("Nxf3")
      
      # Or even
      return to_move("e8=Q)
      
      # More helpful stuff . . .
      
      # Returns list of all possible moves
      possible = position.all_possible_moves(self.color)
      
      # So if I wanted to return the pawn move that ended on e4 using all_possible_moves . . .
      for move in possible:
        if move.location.equals(Location(3, 4)) and \
            move.piece.equals(position.piece_at_square(Location(1, 4)):
            return move
        # Basically all data types built in to chess_py have an equals()
        # All of them work as you would expect except for the piece equals() method
        # They only compare color of the piece and type,  but not lacation
        # piece_at_square() in Board returns the piece at a certain Location
      
      # Gets my king
      my_king = position.get_king(self.color)
      
      # Returns bool stating if my king is in check
      my_king.in_check(position)
      
      # Your code
      return moves