ttt-core 1.0.0

data/ttt-core-0.0.1/lib/ai_player.rb

@@ -0,0 +1,117 @@
+require 'player_symbols'
+require 'player'
+
+class AiPlayer
+  include Player
+
+  def initialize(symbol)
+    super(symbol)
+  end
+
+  def choose_move(board)
+    minimax(board, true, board.vacant_indices.size, ALPHA, BETA).first[1]
+  end
+
+  def ready?
+    true
+  end
+
+  def minimax(board, is_max_player, depth, alpha, beta)
+    best_score_so_far = initial_score(is_max_player)
+
+    if round_is_over(board, depth)
+      return score(board, depth)
+    end
+
+    board.vacant_indices.each do |i|
+      new_board = board.make_move(i, current_players_symbol(is_max_player))
+      result = minimax(new_board, !is_max_player, depth - 1, alpha, beta)
+      best_score_so_far = update_score(is_max_player, i, best_score_so_far, score_from(result))
+
+      alpha = update_alpha(is_max_player, best_score_so_far, alpha)
+      beta = update_beta(is_max_player, best_score_so_far, beta)
+
+      if alpha > beta
+        break
+      end
+    end
+
+    best_score_so_far
+  end
+
+
+  private
+
+  ALPHA = -2
+  BETA = 2
+
+  def update_alpha(is_max_player, best_score_so_far, alpha)
+    if is_max_player && score_from(best_score_so_far) > alpha
+      alpha = score_from(best_score_so_far)
+    end
+    alpha
+  end
+
+  def score_from(score)
+    score.first.first
+  end
+
+  def update_beta(is_max_player, best_score_so_far, beta)
+    if !is_max_player && score_from(best_score_so_far) < beta
+        beta = score_from(best_score_so_far)
+    end
+    beta
+  end
+
+  def round_is_over(board, depth)
+    @winner = board.winning_symbol
+    !@winner.nil? || depth == 0
+  end
+
+  def score(board, depth)
+    if @winner.nil?
+      return {0 => nil}
+    end
+
+    if maximizing_player_won?(@winner)
+      return {(1 + depth) => nil}
+    end
+
+    if minimizing_player_won?(@winner)
+      return {(-1 - depth) => nil}
+    end
+  end
+
+  def maximizing_player_won?(winners_symbol)
+    symbols_are_equal?(winners_symbol, game_symbol)
+  end
+
+  def minimizing_player_won?(winners_symbol)
+    symbols_are_equal?(winners_symbol, PlayerSymbols::opponent(game_symbol))
+  end
+
+  def symbols_are_equal?(symbol1, symbol2)
+    symbol1 == symbol2
+  end
+
+  def initial_score(is_max_player)
+    if is_max_player
+      best_score_so_far = {ALPHA => nil}
+    else
+      best_score_so_far = {BETA => nil}
+    end
+  end
+
+  def current_players_symbol(is_max_player)
+    is_max_player == true ? game_symbol : PlayerSymbols::opponent(game_symbol)
+  end
+
+  def update_score(is_max_player, move, score, result_score)
+    if is_max_player && (result_score >= score_from(score))
+      return {result_score => move}
+    elsif !is_max_player && (result_score < score_from(score))
+      return {result_score => move}
+    end
+    return score
+  end
+end

data/ttt-core-0.0.1/lib/board.rb

@@ -0,0 +1,87 @@
+class Board
+
+  def initialize(symbols = Array.new(9))
+    @grid = symbols
+  end
+
+  def empty?
+    grid.all?(&:nil?)
+  end
+
+  def make_move(index, symbol)
+    copy_of_grid = grid.dup
+    copy_of_grid[index] = symbol
+    Board.new(copy_of_grid)
+  end
+
+  def free_spaces?
+    grid.include?(nil)
+  end
+
+  def get_symbol_at(position)
+    grid.at(position)
+  end
+
+  def winning_combination?
+    not_nil_row(find_winning_row_from(all_rows))
+  end
+
+  def winning_symbol
+    @winning_row = find_winning_row_from(all_rows)
+    @winning_row.nil? ? nil : @winning_row.first
+  end
+
+  def vacant_indices
+    grid.each_index.select{|v| grid[v].nil?}
+  end
+
+  def grid_for_display
+    rows
+  end
+
+  private
+
+  attr_reader :grid
+
+  def find_winning_row_from(rows)
+    @all_rows ||= rows.find do |row|
+           all_cells_match = row.all? {|cell| cell == row.first}
+           all_cells_match && not_nil_symbol(row.first)
+        end
+  end
+
+  def not_nil_row(row)
+    !row.nil?
+  end
+
+  def all_rows
+    @all ||= rows + columns + diagonals
+  end
+
+  def not_nil_symbol(cell)
+    !cell.nil?
+  end
+
+  def rows
+    [
+      [grid.at(0), grid.at(1), grid.at(2)],
+      [grid.at(3), grid.at(4), grid.at(5)],
+      [grid.at(6), grid.at(7), grid.at(8)]
+    ]
+  end
+
+  def columns
+    [
+      [grid.at(0), grid.at(3), grid.at(6)],
+      [grid.at(1), grid.at(4), grid.at(7)],
+      [grid.at(2), grid.at(5), grid.at(8)]
+    ]
+  end
+
+  def diagonals
+    [
+      [grid.at(0),grid.at(4), grid.at(8)],
+      [grid.at(2), grid.at(4), grid.at(6)]
+    ]
+  end
+end

data/ttt-core-0.0.1/lib/board_factory.rb

@@ -0,0 +1,8 @@
+require 'board'
+
+class BoardFactory
+
+  def create_board
+    Board.new
+  end
+end

data/ttt-core-0.0.1/lib/game.rb

@@ -0,0 +1,27 @@
+class Game
+
+  def initialize(board, players)
+    @board = board
+    @players = players
+  end
+
+  def play
+    while game_in_progress?
+      @board = board.make_move(current_player.choose_move(board), current_player.game_symbol)
+      players.reverse!
+    end
+    board
+  end
+
+  private
+
+  attr_reader :board, :players
+
+  def game_in_progress?
+    current_player.ready? && board.free_spaces? && !board.winning_combination?
+  end
+
+  def current_player
+    players.first
+  end
+end

data/ttt-core-0.0.1/lib/player.rb

@@ -0,0 +1,16 @@
+module Player
+
+  def initialize(symbol)
+    @symbol = symbol
+  end
+
+  def game_symbol
+    symbol
+  end
+
+  private
+
+  attr_reader :symbol
+
+end
+

data/ttt-core-0.0.1/lib/player_factory.rb

@@ -0,0 +1,38 @@
+require 'player_symbols'
+require 'player_options'
+require 'ai_player'
+
+class PlayerFactory
+  def create_players(player_option, command_line_ui)
+    if player_option == PlayerOptions::HUMAN_VS_HUMAN
+      human_vs_human(command_line_ui)
+    elsif player_option == PlayerOptions::HUMAN_VS_AI
+      human_vs_ai(command_line_ui)
+    else
+      ai_vs_human(command_line_ui)
+    end
+  end
+
+  private
+
+  def human_vs_human(command_line_ui)
+    [
+      create_human(command_line_ui, PlayerSymbols::X),
+      create_human(command_line_ui, PlayerSymbols::O)
+    ]
+  end
+
+  def human_vs_ai(command_line_ui)
+    [
+      create_human(command_line_ui, PlayerSymbols::X),
+      AiPlayer.new(PlayerSymbols::O)
+    ]
+  end
+
+  def ai_vs_human(command_line_ui)
+    [
+      AiPlayer.new(PlayerSymbols::X),
+      create_human(command_line_ui, PlayerSymbols::O)
+    ]
+  end
+end

data/ttt-core-0.0.1/lib/player_options.rb

@@ -0,0 +1,48 @@
+class PlayerOptions
+  HUMAN_VS_HUMAN = "Human vs Human"
+  HUMAN_VS_AI = "Human vs Ai"
+  AI_VS_HUMAN = "Ai vs Human"
+
+  ID_TO_PLAYER_TYPE = {
+    1 => HUMAN_VS_HUMAN,
+    2 => HUMAN_VS_AI,
+    3 => AI_VS_HUMAN
+  }
+
+  def self.valid_ids
+    ID_TO_PLAYER_TYPE.keys
+  end
+
+  def self.get_player_type_for_id(id)
+    game_value_of_player = ID_TO_PLAYER_TYPE.fetch(id)
+  end
+
+  def self.display_player_options
+    player_options_for_display = ID_TO_PLAYER_TYPE.each_pair.map do |id, option|
+      open_bracket + id.to_s + close_bracket + space + option
+    end
+    player_options_for_display.join(comma + space)
+  end
+
+  def self.all
+    ID_TO_PLAYER_TYPE
+  end
+
+  private
+
+  def self.open_bracket
+    "("
+  end
+
+  def self.close_bracket
+    ")"
+  end
+
+  def self.space
+    " "
+  end
+
+  def self.comma
+    ","
+  end
+end

data/ttt-core-0.0.1/lib/player_symbols.rb

@@ -0,0 +1,16 @@
+class PlayerSymbols
+  X = :X
+  O = :O
+
+  def self.opponent(symbol)
+    symbol == X ? O : X
+  end
+
+  def self.all
+    [X.to_s, O.to_s]
+  end
+
+  def self.to_symbol(value)
+    value == X.to_s ? X : O
+  end
+end

data/ttt-core-0.0.1/lib/replay_option.rb

@@ -0,0 +1,3 @@
+class ReplayOption
+  Y = "Y"
+end

data/ttt-core-0.0.1/spec/ai_player_spec.rb

@@ -0,0 +1,143 @@
+require 'ai_player'
+require 'board'
+
+RSpec.describe AiPlayer do
+  let(:ai_player) { AiPlayer.new(PlayerSymbols::X) }
+
+  it "has a player symbol" do
+    expect(ai_player.game_symbol).to eq(PlayerSymbols::X)
+  end
+
+  it "has ready state" do
+    expect(ai_player.ready?).to be true
+  end
+
+  it "scores zero when a draw is made" do
+    draw_board = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X])
+    expect(ai_player.minimax(draw_board, true, draw_board.vacant_indices.size, -2, 2).first.first).to be (0 + draw_board.vacant_indices.size)
+  end
+
+  it "scores one if computer wins" do
+    winning_board = Board.new([PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::X, nil, nil, PlayerSymbols::O, PlayerSymbols::O, nil, nil])
+
+    expect(ai_player.minimax(winning_board, true, winning_board.vacant_indices.size, -2, 2).first.first).to be(1 + winning_board.vacant_indices.size)
+  end
+
+  it "scores negative one if opponent wins" do
+    winning_board = Board.new([PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, nil, nil, PlayerSymbols::X, PlayerSymbols::X, nil, nil])
+
+    expect(ai_player.minimax(winning_board, true, winning_board.vacant_indices.size, -2, 2).first.first).to be(-1 - winning_board.vacant_indices.size)
+  end
+
+  it "takes a winning move on top row" do
+    winning_move_on_top_row = Board.new([PlayerSymbols::X, nil, PlayerSymbols::X, nil, nil, PlayerSymbols::O, PlayerSymbols::O, nil, nil])
+
+    move = ai_player.choose_move(winning_move_on_top_row)
+    expect(move).to eq(1)
+  end
+
+  it "takes a winning move on middle row" do
+    winning_move_on_middle_row = Board.new([PlayerSymbols::O, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::O, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(winning_move_on_middle_row)
+    expect(move).to eq(4)
+  end
+
+  it "takes a winning move on bottom row" do
+    winning_move_on_bottom_row = Board.new([PlayerSymbols::O, nil, PlayerSymbols::O, PlayerSymbols::O, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_bottom_row)
+    expect(move).to eq(6)
+  end
+
+  it "takes a winning move on left column" do
+    winning_move_on_left_column = Board.new([PlayerSymbols::X, PlayerSymbols::O, nil, nil, nil, nil,  PlayerSymbols::X, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(winning_move_on_left_column)
+    expect(move).to eq(3)
+  end
+
+  it "takes a winning move on middle column" do
+    winning_move_on_middle_column = Board.new([nil, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, nil, nil, nil, nil])
+
+    move = ai_player.choose_move(winning_move_on_middle_column)
+    expect(move).to eq(7)
+  end
+
+  it "takes a winning move on right column" do
+    winning_move_on_right_column = Board.new([nil, PlayerSymbols::O, PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_right_column)
+    expect(move).to eq(5)
+  end
+
+  it "takes a winning move on first diagonal" do
+    winning_move_on_first_diagonal = Board.new([PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_first_diagonal)
+    expect(move).to eq(4)
+  end
+
+  it "takes a winning move on second diagonal" do
+    winning_move_on_second_diagonal = Board.new([PlayerSymbols::O, nil, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::O, nil])
+
+    move = ai_player.choose_move(winning_move_on_second_diagonal)
+    expect(move).to eq(2)
+  end
+
+  it "takes a blocking move on top row" do
+    blocking_move_on_top_row = Board.new([PlayerSymbols::O, nil, PlayerSymbols::O, PlayerSymbols::X, nil, nil, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(blocking_move_on_top_row)
+    expect(move).to eq(1)
+  end
+
+  it "takes a blocking move on middle row" do
+    blocking_move_on_middle_row = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, nil, nil, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_middle_row)
+    expect(move).to eq(5)
+  end
+
+  it "takes a blocking move on bottom row" do
+    blocking_move_on_bottom_row = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::O, PlayerSymbols::O])
+
+    move = ai_player.choose_move(blocking_move_on_bottom_row)
+    expect(move).to eq(6)
+  end
+
+  it "takes a blocking move on left column" do
+    blocking_move_on_left_column = Board.new([PlayerSymbols::O, nil, nil, nil, nil, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_left_column)
+    expect(move).to eq(3)
+  end
+
+  it "takes a blocking move on middle column" do
+    blocking_move_on_middle_column = Board.new([nil, PlayerSymbols::O, nil, PlayerSymbols::X,nil, nil, nil, PlayerSymbols::O, nil])
+
+    move = ai_player.choose_move(blocking_move_on_middle_column)
+    expect(move).to eq(4)
+  end
+
+  it "takes a blocking move on right column" do
+    blocking_move_on_right_column = Board.new([nil, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::O, nil, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_right_column)
+    expect(move).to eq(8)
+  end
+
+ it "takes a blocking move on first diagonal" do
+    blocking_move_on_first_diagonal = Board.new([PlayerSymbols::O, PlayerSymbols::X, nil, nil,nil, nil, nil, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(blocking_move_on_first_diagonal)
+    expect(move).to eq(4)
+  end
+
+ it "takes a blocking move on second diagonal" do
+    blocking_move_on_second_diagonal = Board.new([nil, nil, PlayerSymbols::O, nil, nil, nil, PlayerSymbols::O, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_second_diagonal)
+    expect(move).to eq(4)
+  end
+end

data/ttt-core-0.0.1/spec/board_factory_spec.rb

@@ -0,0 +1,10 @@
+require 'board_factory'
+
+RSpec.describe BoardFactory do
+  let(:board_factory) { BoardFactory.new }
+
+  it "creates 3x3 board " do
+    board = board_factory.create_board
+    expect(board.grid_for_display.size).to be 3
+  end
+end

data/ttt-core-0.0.1/spec/board_spec.rb

@@ -0,0 +1,125 @@
+require 'board'
+require 'player_symbols'
+
+RSpec.describe Board do
+  X = PlayerSymbols::X
+  O = PlayerSymbols::O
+
+  let (:board) {Board.new}
+
+  it "is empty on initialisation" do
+    expect(board.empty?).to be true
+  end
+
+  it "is not empty when all slots are occupied" do
+    full_board = Board.new([X, O, X, O, X, O, X, X, O])
+    expect(full_board.empty?).to be false
+  end
+
+  it "returns the current grid formation" do
+    board = Board.new([nil, nil, nil, nil, X, O, nil, nil, nil])
+    expect(board.grid_for_display).to eq([[nil, nil, nil], [nil, X, O], [nil, nil, nil]])
+  end
+
+  it "can get symbol at given position" do
+    board = Board.new([nil, nil, nil, nil, X, O, nil, nil, nil])
+    expect(board.get_symbol_at(4)).to be :X
+  end
+
+  it "can be updated at a given position" do
+    updated_board = board.make_move(1, X)
+    expect(updated_board.get_symbol_at(1)).to eq(X)
+  end
+
+  it "has free spaces" do
+    expect(board.free_spaces?).to be true
+  end
+
+  it "has no free spaces when all slots are occupied" do
+    full_board = Board.new([X, O, X, O, X, O, X, X, O])
+    expect(full_board.free_spaces?).to be false
+  end
+
+  it "has no winning combination" do
+    winning_board = Board.new([O, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be false
+  end
+
+  it "has winning combination of X in top row" do
+    winning_board = Board.new([X, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in middle row" do
+    winning_board = Board.new([nil, nil, nil, X, X, X, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in bottom row" do
+    winning_board = Board.new([nil, nil, nil, nil, nil, nil, X, X, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in left column" do
+    winning_board = Board.new([X, nil, nil, X, nil, nil, X, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in middle column" do
+    winning_board = Board.new([nil, X, nil, nil, X, nil, nil, X, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in right column" do
+    winning_board = Board.new([nil, nil, X, nil, nil, X, nil, nil, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in first diagonal" do
+    winning_board = Board.new([X, nil, nil, nil, X, nil, nil, nil, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in second diagonal" do
+    winning_board = Board.new([nil, nil, X, nil, X, nil, X, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in top row" do
+    winning_board = Board.new([O, O, O, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in left column" do
+    winning_board = Board.new([O, nil, nil, O, nil, nil, O, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in first diagonal" do
+    winning_board = Board.new([O, nil, nil, nil, O, nil, nil, nil, O])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning symbol X" do
+    winning_board = Board.new([X, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_symbol).to be X
+  end
+
+  it "has winning symbol O" do
+    winning_board = Board.new([O, O, O, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_symbol).to be O
+  end
+
+  it "has no winning symbol" do
+    expect(board.winning_symbol).to be nil
+  end
+
+  it "gives all vacant indices on an empty board" do
+    expect(board.vacant_indices).to include(0, 1, 2, 3, 4, 5, 6, 7, 8)
+  end
+
+  it "gives all vacant indices on a board with moves" do
+    board = Board.new([X, nil, O, nil, nil, nil, nil, nil, nil])
+    expect(board.vacant_indices).not_to include(0, 2)
+  end
+end