just_chess 0.1.0

data/lib/just_chess/errors/not_players_turn_error.rb

@@ -0,0 +1,22 @@
+require 'just_chess/errors/error'
+
+module JustChess
+
+  # = NotPlayersTurnError
+  #
+  # A not players turn error with a message
+  class NotPlayersTurnError < Error
+
+    # New not players turn errors can be instantiated with
+    #
+    # @option [String] message
+    #   the message to display.
+    #
+    # ==== Example:
+    #   # Instantiates a new NotPlayersTurnError
+    #   JustChess::NotPlayersTurnError.new("Custom Message")
+    def initialize(message="It is not the player's turn yet.")
+      super
+    end
+  end
+end

data/lib/just_chess/errors/off_board_error.rb

@@ -0,0 +1,22 @@
+require 'just_chess/errors/error'
+
+module JustChess
+
+  # = OffBoardError
+  #
+  # An off board error with a message
+  class OffBoardError < Error
+
+    # New off board errors can be instantiated with
+    #
+    # @option [String] message
+    #   the message to display.
+    #
+    # ==== Example:
+    #   # Instantiates a new OffBoardError
+    #   JustChess::OffBoardError.new("Custom Message")
+    def initialize(message="Cannot move off board.")
+      super
+    end
+  end
+end

data/lib/just_chess/game_state.rb

@@ -0,0 +1,323 @@
+require 'just_chess/errors/no_piece_error'
+require 'just_chess/errors/not_players_turn_error'
+require 'just_chess/errors/invalid_move_error'
+require 'just_chess/errors/invalid_promotion_error'
+require 'just_chess/errors/moved_into_check_error'
+require 'just_chess/square_set'
+
+module JustChess
+
+  # = Game State
+  #
+  # Represents a game of Chess in progress.
+  class GameState
+
+    # They piece types that a pawn can promote to.
+    PROMOTABLE_PIECE_TYPES = ['queen', 'knight', 'bishop', 'rook']
+
+    def initialize(current_player_number: , squares: [], last_double_step_pawn_id: nil)
+      @current_player_number = current_player_number
+      @squares = if squares.is_a?(SquareSet)
+        squares
+      else
+        SquareSet.new(squares: squares)
+      end
+      @last_double_step_pawn_id = last_double_step_pawn_id
+      @last_change = {}
+      @errors = []
+    end
+
+    attr_reader :current_player_number, :squares, :last_change, :errors, :last_double_step_pawn_id
+
+    # Instantiates a new GameState object in the starting position
+    #
+    # @return [GameState]
+    def self.default
+      new({
+        current_player_number: 1,
+        squares: [
+          { id: 'a8', x: 0, y: 0, piece: { id: 1, player_number: 2, type: 'rook' } },
+          { id: 'b8', x: 1, y: 0, piece: { id: 2, player_number: 2, type: 'knight' } },
+          { id: 'c8', x: 2, y: 0, piece: { id: 3, player_number: 2, type: 'bishop' } },
+          { id: 'd8', x: 3, y: 0, piece: { id: 4, player_number: 2, type: 'queen' } },
+          { id: 'e8', x: 4, y: 0, piece: { id: 5, player_number: 2, type: 'king' } },
+          { id: 'f8', x: 5, y: 0, piece: { id: 6, player_number: 2, type: 'bishop' } },
+          { id: 'g8', x: 6, y: 0, piece: { id: 7, player_number: 2, type: 'knight' } },
+          { id: 'h8', x: 7, y: 0, piece: { id: 8, player_number: 2, type: 'rook' } },
+
+          { id: 'a7', x: 0, y: 1, piece: { id: 9, player_number: 2, type: 'pawn' } },
+          { id: 'b7', x: 1, y: 1, piece: { id: 10, player_number: 2, type: 'pawn' } },
+          { id: 'c7', x: 2, y: 1, piece: { id: 11, player_number: 2, type: 'pawn' } },
+          { id: 'd7', x: 3, y: 1, piece: { id: 12, player_number: 2, type: 'pawn' } },
+          { id: 'e7', x: 4, y: 1, piece: { id: 13, player_number: 2, type: 'pawn' } },
+          { id: 'f7', x: 5, y: 1, piece: { id: 14, player_number: 2, type: 'pawn' } },
+          { id: 'g7', x: 6, y: 1, piece: { id: 15, player_number: 2, type: 'pawn' } },
+          { id: 'h7', x: 7, y: 1, piece: { id: 16, player_number: 2, type: 'pawn' } },
+
+          { id: 'a6', x: 0, y: 2, piece: nil },
+          { id: 'b6', x: 1, y: 2, piece: nil },
+          { id: 'c6', x: 2, y: 2, piece: nil },
+          { id: 'd6', x: 3, y: 2, piece: nil },
+          { id: 'e6', x: 4, y: 2, piece: nil },
+          { id: 'f6', x: 5, y: 2, piece: nil },
+          { id: 'g6', x: 6, y: 2, piece: nil },
+          { id: 'h6', x: 7, y: 2, piece: nil },
+
+          { id: 'a5', x: 0, y: 3, piece: nil },
+          { id: 'b5', x: 1, y: 3, piece: nil },
+          { id: 'c5', x: 2, y: 3, piece: nil },
+          { id: 'd5', x: 3, y: 3, piece: nil },
+          { id: 'e5', x: 4, y: 3, piece: nil },
+          { id: 'f5', x: 5, y: 3, piece: nil },
+          { id: 'g5', x: 6, y: 3, piece: nil },
+          { id: 'h5', x: 7, y: 3, piece: nil },
+
+          { id: 'a4', x: 0, y: 4, piece: nil },
+          { id: 'b4', x: 1, y: 4, piece: nil },
+          { id: 'c4', x: 2, y: 4, piece: nil },
+          { id: 'd4', x: 3, y: 4, piece: nil },
+          { id: 'e4', x: 4, y: 4, piece: nil },
+          { id: 'f4', x: 5, y: 4, piece: nil },
+          { id: 'g4', x: 6, y: 4, piece: nil },
+          { id: 'h4', x: 7, y: 4, piece: nil },
+
+          { id: 'a3', x: 0, y: 5, piece: nil },
+          { id: 'b3', x: 1, y: 5, piece: nil },
+          { id: 'c3', x: 2, y: 5, piece: nil },
+          { id: 'd3', x: 3, y: 5, piece: nil },
+          { id: 'e3', x: 4, y: 5, piece: nil },
+          { id: 'f3', x: 5, y: 5, piece: nil },
+          { id: 'g3', x: 6, y: 5, piece: nil },
+          { id: 'h3', x: 7, y: 5, piece: nil },
+
+          { id: 'a2', x: 0, y: 6, piece: { id: 17, player_number: 1, type: 'pawn' } },
+          { id: 'b2', x: 1, y: 6, piece: { id: 18, player_number: 1, type: 'pawn' } },
+          { id: 'c2', x: 2, y: 6, piece: { id: 19, player_number: 1, type: 'pawn' } },
+          { id: 'd2', x: 3, y: 6, piece: { id: 20, player_number: 1, type: 'pawn' } },
+          { id: 'e2', x: 4, y: 6, piece: { id: 21, player_number: 1, type: 'pawn' } },
+          { id: 'f2', x: 5, y: 6, piece: { id: 22, player_number: 1, type: 'pawn' } },
+          { id: 'g2', x: 6, y: 6, piece: { id: 23, player_number: 1, type: 'pawn' } },
+          { id: 'h2', x: 7, y: 6, piece: { id: 24, player_number: 1, type: 'pawn' } },
+
+          { id: 'a1', x: 0, y: 7, piece: { id: 25, player_number: 1, type: 'rook' } },
+          { id: 'b1', x: 1, y: 7, piece: { id: 26, player_number: 1, type: 'knight' } },
+          { id: 'c1', x: 2, y: 7, piece: { id: 27, player_number: 1, type: 'bishop' } },
+          { id: 'd1', x: 3, y: 7, piece: { id: 28, player_number: 1, type: 'queen' } },
+          { id: 'e1', x: 4, y: 7, piece: { id: 29, player_number: 1, type: 'king' } },
+          { id: 'f1', x: 5, y: 7, piece: { id: 30, player_number: 1, type: 'bishop' } },
+          { id: 'g1', x: 6, y: 7, piece: { id: 31, player_number: 1, type: 'knight' } },
+          { id: 'h1', x: 7, y: 7, piece: { id: 32, player_number: 1, type: 'rook' } },
+        ]
+      })
+    end
+
+    # serializes the game state as a hash
+    #
+    # @return [Hash]
+    def as_json
+      {
+        current_player_number: current_player_number,
+        squares: squares.as_json,
+        last_double_step_pawn_id: last_double_step_pawn_id
+      }
+    end
+
+    # deep clone of the game state
+    #
+    # @return [GameState]
+    def clone
+      self.class.new(as_json)
+    end
+
+    # Moves a piece owned by the player, from one square, to another, with an optional promotion.
+    #
+    # It moves the piece and returns true if the move is valid and it's the player's turn.
+    # It returns false otherwise.
+    #
+    # ==== Example:
+    #   # Moves a piece from a square to perform a move
+    #   game_state.move(1, 'h7', 'h6')
+    #
+    # @param [Fixnum] player_number
+    #   the player number, 1 or 2.
+    #
+    # @param [String] from_id
+    #   the id of the from square
+    #
+    # @param [String] to_id
+    #   the id of the to square
+    #
+    # @option [String] promote_to
+    #   the type of the piece that the pawn will promote to
+    #
+    # @return [Boolean]
+    def move(player_number, from_id, to_id, promote_to=nil)
+      @errors = []
+
+      from = squares.find_by_id(from_id)
+      to = squares.find_by_id(to_id)
+
+      if current_player_number != player_number
+        @errors.push JustChess::NotPlayersTurnError.new
+      elsif from.unoccupied?
+        @errors.push JustChess::NoPieceError.new
+      elsif !((0..7).include?(to.x) && (0..7).include?(to.y))
+        @errors.push JustChess::OffBoardError.new
+      elsif !promote_to.nil? && !PROMOTABLE_PIECE_TYPES.include?(promote_to)
+        @errors.push JustChess::InvalidPromotion.new
+      elsif from.piece.can_move?(from, to, self)
+
+        duplicate = self.clone
+        duplicate.perform_complete_move(player_number, from_id, to_id, promote_to)
+
+        if duplicate.in_check?(current_player_number)
+          @errors.push JustChess::MovedIntoCheckError.new
+        else
+          perform_complete_move(player_number, from_id, to_id, promote_to)
+        end
+      else
+        @errors.push JustChess::InvalidMoveError.new
+      end
+      @errors.empty?
+    end
+
+    # The player number of the winner. It returns nil if there is no winner.
+    #
+    # @return [Fixnum,NilClass]
+    def winner
+      case
+      when in_checkmate?(1)
+        2
+      when in_checkmate?(2)
+        1
+      else
+        nil
+      end
+    end
+
+    # Moves a piece owned by the player, from one square, to another, with an optional promotion without validation
+    #
+    # It handles castling, en passant and promotion.
+    # It moves the piece and returns true if the move is valid and it's the player's turn.
+    # It returns false otherwise.
+    #
+    # ==== Example:
+    #   # Moves a piece from a square to perform a move
+    #   game_state.move(1, 'h7', 'h6')
+    #
+    # @param [Fixnum] player_number
+    #   the player number, 1 or 2.
+    #
+    # @param [String] from_id
+    #   the id of the from square
+    #
+    # @param [String] to_id
+    #   the id of the to square
+    #
+    # @option [String] promote_to
+    #   the type of the piece that the pawn will promote to
+    #
+    # @return [Boolean]
+    def perform_complete_move(player_number, from_id, to_id, promote_to=nil)
+      from = squares.find_by_id(from_id)
+      to = squares.find_by_id(to_id)
+
+      captured = captured_square(from, to)
+      double_step_pawn = from.piece.is_a?(JustChess::Pawn) && Vector.new(from,to).magnitude == 2
+      @last_double_step_pawn_id = double_step_pawn ? from.piece.id : nil
+
+      @last_change = { type: 'move', data: {player_number: player_number, from: from_id, to: to_id} }
+
+      rook_castle = rook_castle_move(from, to)
+      perform_move(rook_castle.from, rook_castle.to, nil) if rook_castle
+
+      perform_move(from, to, captured)
+
+      promote(to, promote_to) if pawn_moved_to_last_rank(to)
+      pass_turn
+    end
+
+    def in_check?(player_number)
+      king_square = squares.find_king_for_player(player_number)
+      threatened_by = squares.threatened_by(opposing_player_number(player_number), self)
+      threatened_by.include?(king_square)
+    end
+
+    def in_checkmate?(player_number)
+      in_check?(player_number) && king_cannot_move?(player_number)
+    end
+
+
+    def king_cannot_move?(player_number)
+      king_square = squares.find_king_for_player(player_number)
+      threatened_by = squares.threatened_by(opposing_player_number(player_number), self)
+      destinations = king_square.piece.destinations(king_square, self)
+      remove_threats = destinations - threatened_by
+      remove_threats.none?
+    end
+
+    private
+
+    def captured_square(from, to)
+      if to.occupied?
+        to
+      else
+        if from.piece.is_a?(Pawn) && from.piece.en_passant_square(from, self)
+          squares.find_by_piece_id(last_double_step_pawn_id)
+        else
+          nil
+        end
+      end
+    end
+
+    def rook_castle_move(from, to)
+      if from.occupied? && from.piece.is_a?(King) && from.piece.castle(from, self).include?(to)
+        vector = Vector.new(from, to)
+
+        rook_from_x = vector.direction.x > 0 ? 7 : 0
+        rook_from_y = from.y
+        rook_from = squares.find_by_x_and_y(rook_from_x, rook_from_y)
+
+        rook_to_x = vector.direction.x > 0 ? (from.x + 1) : (from.x -1)
+        rook_to_y = from.y
+        rook_to = squares.find_by_x_and_y(rook_to_x, rook_to_y)
+
+        Struct.new(:from, :to).new(rook_from, rook_to)
+      else
+        nil
+      end
+    end
+
+    def pawn_moved_to_last_rank(square)
+      square.piece && square.piece.is_a?(Pawn) && square.last_rank(square.piece.player_number)
+    end
+
+    def pass_turn
+      @current_player_number = opposing_player_number
+    end
+
+    def opposing_player_number(player_number=nil)
+      if player_number
+        other_player_number(player_number)
+      else
+        other_player_number(@current_player_number)
+      end
+    end
+
+    def other_player_number(player_number)
+      (player_number == 1) ? 2 : 1
+    end
+
+    def perform_move(from, to, captured)
+      captured.piece = nil if captured
+      to.piece = from.piece
+      from.piece = nil
+      to.piece.moved
+    end
+
+    def promote(square, promote_to)
+      new_piece = PieceFactory.new(type: promote_to, id: square.piece.id, player_number: square.piece.player_number).build
+      square.piece = new_piece
+    end
+  end
+end

data/lib/just_chess/piece_factory.rb

@@ -0,0 +1,68 @@
+require 'just_chess/pieces/pawn'
+require 'just_chess/pieces/rook'
+require 'just_chess/pieces/knight'
+require 'just_chess/pieces/bishop'
+require 'just_chess/pieces/queen'
+require 'just_chess/pieces/king'
+
+module JustChess
+
+  # = Piece Factory
+  #
+  # Generates pieces from a hash of arguments
+  class PieceFactory
+
+    # A mapping of type descriptions to classes
+    CLASSES = {
+      'pawn' => Pawn,
+      'rook' => Rook,
+      'knight' => Knight,
+      'bishop' => Bishop,
+      'queen' => Queen,
+      'king' => King
+    }
+
+    # New objects can be instantiated by passing in a hash or the piece.
+    #
+    # @param [Hash,Piece] args
+    #   the initial attributes of the piece, hash requires type key
+    #
+    # ==== Example:
+    #   # Instantiates a new PieceFactory
+    #   JustChess::PieceFactory.new({
+    #     type: 'pawn',
+    #     id: 1,
+    #     player_number: 2
+    #   })
+    def initialize(args)
+      @args = args
+    end
+
+    # Returns a piece based on the initial arguments.
+    #
+    # @return [Piece]
+    def build
+      case @args
+      when Hash
+        build_from_hash
+      when Piece
+        @args
+      when nil
+        nil
+      else
+        raise ArgumentError, "piece must be Hash or NilClass"
+      end
+    end
+
+    private
+
+    def build_from_hash
+      klass = CLASSES[@args[:type]]
+      if klass
+        klass.new(@args)
+      else
+        raise ArgumentError, "invalid piece type: #{@args[:type].to_s}"
+      end
+    end
+  end
+end

data/lib/just_chess/pieces/bishop.rb

@@ -0,0 +1,23 @@
+require 'just_chess/pieces/piece'
+
+module JustChess
+
+  # = Bishop
+  #
+  # The piece that moves diagonally any number of squares
+  class Bishop < Piece
+
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      game_state.squares.diagonal(square).unoccupied_or_occupied_by_opponent(player_number).unblocked(square, game_state.squares)
+    end
+  end
+end