just_chess 0.1.0

data/lib/just_chess/pieces/king.rb

@@ -0,0 +1,97 @@
+require 'just_chess/pieces/piece'
+
+module JustChess
+
+  # = King
+  #
+  # The piece that moves 1 space away. Can castle and must not be put into check.
+  class King < 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)
+      base_destinations(square, game_state) + castle(square, game_state) - checked_squares(square, game_state) - shared_king_squares(game_state)
+    end
+
+    # All the squares that the king could move to normally.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def base_destinations(square, game_state)
+      game_state.squares.at_range(square, 1).unoccupied_or_occupied_by_opponent(player_number)
+    end
+
+    # All the squares that the king could castle to.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def castle(square, game_state)
+      rooks = game_state.squares.occupied_by_piece(Rook).occupied_by_player(player_number).unmoved()
+
+      if has_not_moved? && rooks.any?
+        _squares = rooks.map do |s|
+          vector = Vector.new(square, s)
+          x = square.x + (2 * vector.direction.x)
+          y = square.y
+          game_state.squares.find_by_x_and_y(x, y)
+        end
+
+        potential = SquareSet.new(squares: _squares)
+
+        potential.unoccupied().unblocked(square, game_state.squares)
+      else
+        SquareSet.new(squares: [])
+      end
+    end
+
+    # All the squares that the king could not move to because of check.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def checked_squares(square, game_state)
+      dup = game_state.clone
+      dup.squares.find_king_for_player(player_number).piece = nil
+      dup.squares.threatened_by(opponent, dup)
+    end
+
+    # All the squares that the king could not move to because another king is nearby.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def shared_king_squares(game_state)
+      all = game_state.squares.occupied_by_piece(King).map { |s| s.piece.base_destinations(s, game_state) }
+
+      all.reduce(nil) do |memo, set|
+        if memo
+          memo & set
+        else
+          set
+        end
+      end
+    end
+  end
+end

data/lib/just_chess/pieces/knight.rb

@@ -0,0 +1,23 @@
+require 'just_chess/pieces/piece'
+
+module JustChess
+
+  # = Knight
+  #
+  # The piece that jumps over pieces 1v2h or 2v1h
+  class Knight < 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.not_orthogonal_or_diagonal(square).at_range(square,2).unoccupied_or_occupied_by_opponent(player_number)
+    end
+  end
+end

data/lib/just_chess/pieces/pawn.rb

@@ -0,0 +1,103 @@
+require 'just_chess/pieces/piece'
+require 'just_chess/vector.rb'
+
+module JustChess
+
+  # = Pawn
+  #
+  # The piece that moves 1 forward or 2 forwards the first time, or 1 diagonal to capture.
+  class Pawn < Piece
+
+    # The forwards direction of the pawn for each player.
+    FORWARDS_DIRECTION = { 1 => -1, 2 => 1 }
+
+    # THe starting rank of the pawn for each player
+    STARTING_RANK = { 1 => 6, 2 => 1 }
+
+    # 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)
+      moves = move_squares(square, game_state)
+      captures = capture_squares(square, game_state)
+      en_passant = en_passant_square(square, game_state)
+
+      if en_passant
+        (moves + captures) << en_passant
+      else
+        moves + captures
+      end
+    end
+
+    # All the squares that the piece can move to.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def move_squares(square, game_state)
+      game_state.squares.in_range(square, range(square)).in_direction(square, forwards_direction).orthogonal(square).unoccupied.unblocked(square, game_state.squares)
+    end
+
+    # All the squares that the piece can capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def capture_squares(square, game_state)
+      game_state.squares.in_range(square, 1).in_direction(square, forwards_direction).diagonal(square).occupied_by_opponent(player_number)
+    end
+
+    # The Square that a pawn can capture en passant.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [Square]
+    def en_passant_square(square, game_state)
+      if square.rank_number(player_number) == 5 && game_state.last_double_step_pawn_id
+        double_step = game_state.squares.find_by_piece_id(game_state.last_double_step_pawn_id)
+        vector = Vector.new(square, double_step)
+        if vector.magnitude.abs == 1
+          x = double_step.x
+          y = square.y + forwards_direction
+          game_state.squares.find_by_x_and_y(x, y)
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    private
+
+    def range(from)
+      from.y == starting_rank ? 2 : 1
+    end
+
+    def forwards_direction
+      FORWARDS_DIRECTION[player_number]
+    end
+
+    def starting_rank
+      STARTING_RANK[player_number]
+    end
+  end
+end

data/lib/just_chess/pieces/piece.rb

@@ -0,0 +1,121 @@
+require 'just_chess/vector'
+
+module JustChess
+
+  # = Piece
+  #
+  # A piece that can move on a chess board
+  class Piece
+    def initialize(id: , player_number: , type: nil, has_moved: false)
+      @id = id
+      @player_number = player_number
+      @has_moved = has_moved
+    end
+
+    # @return [Fixnum] the identifier of the piece.
+    attr_reader :id
+
+    # @return [Fixnum] the owner of the piece.
+    attr_reader :player_number
+
+    # @return [Boolean] determines if the piece has moved.
+    attr_reader :has_moved
+
+    alias_method :has_moved?, :has_moved
+
+    # The opposing player number
+    #
+    # @return [Fixnum]
+    def opponent
+      player_number == 1 ? 2 : 1
+    end
+
+    # mark the piece as moved
+    #
+    # @return [TrueClass]
+    def moved
+      @has_moved = true
+    end
+
+    # The stringified identifier of the piece type.
+    #
+    # @return [String]
+    def has_not_moved?
+      !has_moved?
+    end
+
+    # The stringified identifier of the piece type.
+    #
+    # @return [String]
+    def type
+      self.class.to_s.split('::').last.downcase
+    end
+
+    # Can the piece move from a square, to a square, given the game state?
+    #
+    # @param [Square] from
+    #   the origin square.
+    #
+    # @param [Square] to
+    #   the destination square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [Boolean]
+    def can_move?(from, to, game_state)
+      destinations(from, game_state).include?(to)
+    end
+
+    # 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)
+      []
+    end
+
+    # All the squares that the piece can move to.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def move_squares(square, game_state)
+      destinations(square, game_state)
+    end
+
+    # All the squares that the piece can capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def capture_squares(square, game_state)
+      destinations(square, game_state)
+    end
+
+    # returns a serialized piece as a hash
+    #
+    # @return [Hash]
+    def as_json
+      {
+        id: id,
+        player_number: player_number,
+        type: type,
+        has_moved: has_moved?
+      }
+    end
+  end
+end

data/lib/just_chess/pieces/queen.rb

@@ -0,0 +1,23 @@
+require 'just_chess/pieces/piece'
+
+module JustChess
+
+  # = Queen
+  #
+  # The piece that moves any number of squares orthogonally or diagonally.
+  class Queen < 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.orthogonal_or_diagonal(square).unoccupied_or_occupied_by_opponent(player_number).unblocked(square, game_state.squares)
+    end
+  end
+end

data/lib/just_chess/pieces/rook.rb

@@ -0,0 +1,23 @@
+require 'just_chess/pieces/piece'
+
+module JustChess
+
+  # = Rook
+  #
+  # The piece that moves any number of squares orthogonally.
+  class Rook < 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.orthogonal(square).unoccupied_or_occupied_by_opponent(player_number).unblocked(square, game_state.squares)
+    end
+  end
+end

data/lib/just_chess/point.rb

@@ -0,0 +1,52 @@
+module JustChess
+
+  # = Point
+  #
+  # A point with an x and y co-ordinates
+  class Point
+
+    # New objects can be instantiated with
+    #
+    # @param [Fixnum] x
+    #   the x co-ordinate.
+    #
+    # @param [Fixnum] y
+    #   the y co-ordinate.
+    #
+    # ==== Example:
+    #   # Instantiates a new Point
+    #   JustChess::Point.new({
+    #     x: 1,
+    #     y: 1
+    #   })
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    # @return [Fixnum] the x co-ordinate.
+    attr_reader :x
+
+    # @return [Fixnum] the y co-ordinate.
+    attr_reader :y
+
+    # Add a point to another point by adding their co-ordinates and returning a new point.
+    #
+    # @param [Point] other
+    #   the other point to add.
+    #
+    # @return [Point]
+    def +(other)
+      self.class.new(self.x + other.x, self.y + other.y)
+    end
+
+    # Check if popints are equal by seeing if their co-ordinates are equal.
+    #
+    # @param [Point] other
+    #   the other point to compare to.
+    #
+    # @return [TrueClass, FalseClass]
+    def ==(other)
+      self.x == other.x && self.y == other.y
+    end
+  end
+end