checkers-game 0.1.0

data/lib/checkers/ai/engine/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Checkers
+  module AI
+    module Engine
+      class Base
+        attr_reader :tree_depth
+
+        def initialize(tree_depth = 3)
+          @tree_depth = tree_depth
+        end
+
+        def next_board(board)
+          if board.jumped
+            Board.generate_boards(board, :ai).first
+          else
+            decision_tree_root = Tree.build(board, tree_depth).root
+
+            yield(decision_tree_root, tree_depth)
+
+            decision_tree_root.children.max_by(&:score).board
+          end
+        end
+
+        protected
+
+        def max(a, b)
+          a > b ? a : b
+        end
+
+        def min(a, b)
+          a < b ? a : b
+        end
+      end
+    end
+  end
+end

data/lib/checkers/ai/engine/minmax.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Checkers
+  module AI
+    module Engine
+      class Minmax < Base
+        def next_board(board)
+          super(board) { |root, tree_depth| minmax(root, tree_depth, true) }
+        end
+
+        private
+
+        def minmax(node, tree_depth, maxplayer)
+          return node.score if tree_depth.zero? || node.children_size.zero?
+
+          value = nil
+
+          if maxplayer
+            value = Float::MIN
+
+            node.children.each do |child|
+              value = max(value, minmax(child, tree_depth - 1, !maxplayer))
+            end
+          else
+            value = Float::MAX
+
+            node.children.each do |child|
+              value = min(value, minmax(child, tree_depth - 1, !maxplayer))
+            end
+          end
+
+          node.score = value
+        end
+      end
+    end
+  end
+end

data/lib/checkers/ai/node.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Checkers
+  module AI
+    class Node
+      attr_reader :children, :player, :board
+      attr_accessor :score
+
+      def initialize(board, player, depth = 0)
+        @board = board
+        @player = player
+        @score = board.calculate_score(player: player)
+        @children = generate_children(depth)
+      end
+
+      def children_size
+        @children.size
+      end
+
+      private
+
+      def generate_children(depth)
+        return [] if depth.zero?
+
+        plays_next = player == :human ? :ai : :human
+        boards = Board.generate_boards(board, player)
+        boards.map { |board| Node.new(board, plays_next, depth - 1) }
+      end
+    end
+  end
+end

data/lib/checkers/ai/tree.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Checkers
+  module AI
+    class Tree
+      attr_reader :root
+
+      def self.build(board, depth)
+        Tree.new(Node.new(board, :ai, depth))
+      end
+
+      def initialize(node)
+        @root = node
+      end
+
+      def depth
+        current_depth = 0
+        children = @root.children
+
+        while children.any?
+          current_depth += 1
+          children = children.first.children
+        end
+
+        current_depth
+      end
+    end
+  end
+end

data/lib/checkers/board.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Checkers
+  HUMAN_PIECE = -1
+  HUMAN_KING = -2
+  HUMAN_PIECES = [HUMAN_PIECE, HUMAN_KING].freeze
+
+  AI_PIECE = 1
+  AI_KING = 2
+  AI_PIECES = [AI_PIECE, AI_KING].freeze
+
+  class Board
+    include Score
+    include Moves
+    extend Forwardable
+
+    attr_reader :board, :jumped, :last_move
+
+    def_delegators :board, :each_with_index, :row_count
+
+    class << self
+      def generate_boards(board_object, player)
+        moves = board_object.find_moves_for_player(player: player)
+        moves.map do |move|
+          make_move(board_object, move)
+        end
+      end
+
+      def make_move(board_object, move)
+        new_board = board_object.board.dup
+        jumped = false
+
+        new_board[*move.end_square] = if move.end_square[0].zero? && new_board[*move.start_square] == HUMAN_PIECE
+                                        HUMAN_KING
+                                      elsif move.end_square[0] == 7 && new_board[*move.start_square] == AI_PIECE
+                                        AI_KING
+                                      else
+                                        new_board[*move.start_square]
+                                      end
+        new_board[*move.start_square] = 0
+
+        if move.is_a?(JumpMove)
+          new_board[*move.jump_over_square] = 0
+          jumped = true
+        end
+        Board.new(board: new_board, jumped: jumped, last_move: move)
+      end
+    end
+
+    def initialize(board: nil, jumped: false, last_move: nil)
+      @board = board || set_board
+      @jumped = jumped
+      @last_move = last_move
+    end
+
+    def calculate_score(player:)
+      number_of_pieces(player: player) +
+        number_of_pieces_on_opponets_side(player: player) +
+        3 * movable_pieces(player: player) +
+        4 * number_of_unoccupied_promotion_squares(player: player)
+    end
+
+    def count_pieces(player:)
+      board.count { |piece| player_pieces(player).include?(piece) }
+    end
+
+    def find_moves_for_player(player:)
+      found_moves = []
+      @board.each_with_index do |e, row, col|
+        next unless player_pieces(player).include?(e)
+
+        moves = find_available_moves(row: row, col: col, player: player)
+        found_moves += moves
+        break found_moves = moves if moves.any? { |move| move.is_a?(JumpMove) }
+      end
+      found_moves
+    end
+
+    def any_jump_moves?(player:)
+      find_moves_for_player(player: player).one? { |move| move.is_a?(JumpMove) }
+    end
+
+    protected
+
+    def player_pieces(player)
+      player == :human ? HUMAN_PIECES : AI_PIECES
+    end
+
+    def adjacent_squares(row:, col:, player:)
+      possible_squares(row: row, col: col, player: player) do |squares|
+        squares.select { |square| within_board?(row: square[0], col: square[1]) }
+      end
+    end
+
+    def movable_squares(row:, col:, player:)
+      possible_squares(row: row, col: col, player: player) do |squares|
+        squares.select { |square| move?(row: square[0], col: square[1]) }
+      end
+    end
+
+    def possible_squares(row:, col:, player:)
+      move_up = [[row - 1, col + 1], [row - 1, col - 1]]
+      move_down = [[row + 1, col + 1], [row + 1, col - 1]]
+      if player == :human
+        if @board[row, col] == HUMAN_PIECE
+          yield move_up
+        else
+          yield(move_up + move_down)
+        end
+      else
+        if @board[row, col] == AI_PIECE
+          yield move_down
+        else
+          yield(move_down + move_up)
+        end
+      end
+    end
+
+    private
+
+    def move?(row:, col:)
+      within_board?(row: row, col: col) && square_empty?(row: row, col: col)
+    end
+
+    def within_board?(row:, col:)
+      row <= 7 && row >= 0 && col <= 7 && col >= 0
+    end
+
+    def square_empty?(row:, col:)
+      @board[row, col].zero?
+    end
+
+    def set_board
+      Matrix[
+        [0, 1, 0, 1, 0, 1, 0, 1],
+        [1, 0, 1, 0, 1, 0, 1, 0],
+        [0, 1, 0, 1, 0, 1, 0, 1],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [-1, 0, -1, 0, -1, 0, -1, 0],
+        [0, -1, 0, -1, 0, -1, 0, -1],
+        [-1, 0, -1, 0, -1, 0, -1, 0]
+      ]
+    end
+  end
+end

data/lib/checkers/board/moves.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Checkers
+  class Board
+    module Moves
+      def find_available_moves(row:, col:, player:)
+        jumps = jump_moves(row: row, col: col, player: player)
+        return jumps if jumps.any?
+
+        basic_moves(row: row, col: col, player: player)
+      end
+
+      def jump_moves(row:, col:, player:)
+        jump_moves = []
+        adjacent_squares(row: row, col: col, player: player).each do |square|
+          adjacent_row, adjacent_col = square
+          next if [0, *player_pieces(player)].include?(@board[adjacent_row, adjacent_col])
+
+          vector = [adjacent_row - row, adjacent_col - col]
+          jump_square = [adjacent_row + vector[0], adjacent_col + vector[1]]
+          jump_moves << JumpMove.new([row, col], jump_square) if move?(row: jump_square[0], col: jump_square[1])
+        end
+        jump_moves
+      end
+
+      def basic_moves(row:, col:, player:)
+        possible_squares(row: row, col: col, player: player) do |squares|
+          squares.filter_map { |square| Move.new([row, col], square) if move?(row: square[0], col: square[1]) }
+        end
+      end
+    end
+  end
+end

data/lib/checkers/board/score.rb

@@ -0,0 +1,72 @@
+#  frozen_string_literal: true
+
+module Checkers
+  class Board
+    module Score
+      def number_of_pieces(player:)
+        opponent = opponent(player)
+        player_pieces = board.count { |piece| player_pieces(player).include?(piece) }
+        opponent_pieces = board.count { |piece| player_pieces(opponent).include?(piece) }
+        opponent_pieces - player_pieces
+      end
+
+      def number_of_pieces_on_opponets_side(player:)
+        opponent = opponent(player)
+
+        player_pieces = board.each_with_index.count do |piece, row, _col|
+          next if row >= 3
+
+          player_pieces(player).include?(piece)
+        end
+
+        opponent_pieces = board.each_with_index.count do |piece, row, _col|
+          next unless row == 5
+
+          player_pieces(opponent).include?(piece)
+        end
+
+        opponent_pieces - player_pieces
+      end
+
+      # for kings implementation
+      def number_of_unoccupied_promotion_squares(player:)
+        opponent = opponent(player)
+        opponent_squares = 0
+        player_squares = 0
+
+        board.each_with_index do |square, row, _col|
+          next if player_pieces(player).include?(square) || player_pieces(opponent).include?(square)
+
+          opponent_squares += 1 if row == 7
+          player_squares += 1 if row.zero?
+        end
+
+        opponent_squares - player_squares
+      end
+
+      def movable_pieces(player:)
+        opponent = opponent(player)
+        opponent_pieces = 0
+        player_pieces = 0
+
+        board.each_with_index do |piece, row, col|
+          next if piece.zero?
+
+          if player_pieces(player).include?(piece) && movable_squares(row: row, col: col, player: player).any?
+            player_pieces += 1
+          elsif movable_squares(row: row, col: col, player: opponent).any?
+            opponent_pieces += 1
+          end
+        end
+
+        opponent_pieces - player_pieces
+      end
+
+      private
+
+      def opponent(player)
+        player == :human ? :ai : :human
+      end
+    end
+  end
+end

data/lib/checkers/game/engine.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Checkers
+  module Game
+    class Engine
+      def initialize(state, ai_engine)
+        @state = state
+        @ai = ai_engine
+      end
+
+      def play
+        return if @state.winner || @state.tie
+
+        if @state.turn == :ai
+          new_board = @ai.next_board(@state.board)
+
+          turn = if new_board.jumped
+                   new_board.any_jump_moves?(player: :ai) ? :ai : :human
+                 else
+                   :human
+                 end
+
+          @state.set_state(board: new_board, turn: turn)
+        end
+      end
+    end
+  end
+end

data/lib/checkers/game/state.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Checkers
+  module Game
+    class State
+      include Observable
+
+      attr_accessor :winner, :tie, :board, :turn
+      private :winner=, :tie=, :board=, :turn=
+
+      def initialize(turn)
+        @board = Board.new
+        @turn = turn
+        @winner = nil
+        @tie = false
+      end
+
+      def set_state(attrs = {})
+        changed
+        attrs.each { |attr, value| send("#{attr}=", value) }
+        notify_observers
+      end
+    end
+  end
+end