ttt-core 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 592a2b99d813d6eff7554da5722ef2ce5f960470
-  data.tar.gz: 65262df5515d534718ed484cab124e32f847fb22
+  metadata.gz: 824e96f3c46aab6ab11e4d1fdca9771b30656d8e
+  data.tar.gz: 436d80f07cb56f402e20f3d258df8d4315270c75
 SHA512:
-  metadata.gz: e1eb6b836b09ba27c3c944a4ae5064242f8595e20955dbb0516405ad22bccebec1247e3a1a32c2999b32a06050cb7bbf3dc1a88bdedb059da668643bf9596f99
-  data.tar.gz: ce091661e1f82bd04dca7b1fa02a128a63361cba5fdb90bfd35b477aab073d85a475fddf55fb58ff0776de7001cf9ddb7f9771f3a872a455fe0ffa3c46184fca
+  metadata.gz: 066027d759aaee23a10b626a2e86c35884aebb5ad1d6f4191479f04726a2d71d562a2b6b0622f1eedb927b731836ff4fb47e3168c5a064ef279dc3b62ab5a6db
+  data.tar.gz: 91596679e33a8026f5d1c7e84bc2dfa75869cd7f3b4241c68f19d5908695ae6055091bb17416f523a6000a742df4c7aec3b0b83812619117b1037203ff070b62

data/lib/ai_player.rb

@@ -1,117 +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
+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/lib/board.rb

@@ -18,7 +18,7 @@ class Board
     grid.include?(nil)
   end
 
-  def get_symbol_at(position)
+  def symbol_at(position)
     grid.at(position)
   end
 

data/lib/game.rb

@@ -7,21 +7,29 @@ class Game
 
   def play
     while game_in_progress?
-      @board = board.make_move(current_player.choose_move(board), current_player.game_symbol)
-      players.reverse!
+      current_player = players[player_symbol]
+      @board = board.make_move(current_player.choose_move(board), player_symbol)
     end
     board
   end
 
+  def play_specific(move)
+    @board = board.make_move(move, player_symbol)
+    play
+  end
+
   private
 
   attr_reader :board, :players
 
-  def game_in_progress?
-    current_player.ready? && board.free_spaces? && !board.winning_combination?
+  def player_symbol
+    number_of_x = board.grid_for_display.flatten.count(PlayerSymbols::X)
+    number_of_o = board.grid_for_display.flatten.count(PlayerSymbols::O)
+    next_players_symbol = number_of_x > number_of_o ? PlayerSymbols::O : PlayerSymbols::X
   end
 
-  def current_player
-    players.first
+  def game_in_progress?
+    players[player_symbol].ready? && board.free_spaces? && !board.winning_combination?
   end
+
 end

data/lib/player_options.rb

@@ -13,7 +13,7 @@ class PlayerOptions
     ID_TO_PLAYER_TYPE.keys
   end
 
-  def self.get_player_type_for_id(id)
+  def self.player_type_for_id(id)
     game_value_of_player = ID_TO_PLAYER_TYPE.fetch(id)
   end
 

data/lib/ttt-core/version.rb

@@ -1,3 +1,3 @@
 module TTTCore
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/spec/board_spec.rb

@@ -23,12 +23,12 @@ RSpec.describe Board do
 
   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
+    expect(board.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)
+    expect(updated_board.symbol_at(1)).to eq(X)
   end
 
   it "has free spaces" do

data/spec/game_spec.rb

@@ -2,11 +2,34 @@ require 'board'
 require 'game'
 require 'player'
 require 'player_symbols'
+require 'player_options'
 
 RSpec.describe Game do
   let(:player_x_spy) { instance_double(FakePlayer).as_null_object }
   let(:player_o_spy) { instance_double(FakePlayer).as_null_object }
 
+  it "game is played with specific move" do
+    allow(player_o_spy).to receive(:ready?).and_return(false)
+
+    game = Game.new(Board.new, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy })
+    updated_board = game.play_specific(3)
+
+    expect(updated_board.symbol_at(3)).to be (PlayerSymbols::X)
+  end
+
+  it "game is started with a specific move" do
+    allow(player_x_spy).to receive(:ready?).and_return(false)
+    allow(player_o_spy).to receive(:choose_move).and_return(8)
+    allow(player_o_spy).to receive(:ready?).and_return(true, false)
+
+    game = Game.new(Board.new, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy })
+    updated_board = game.play_specific(3)
+
+    expect(updated_board.symbol_at(3)).to be (PlayerSymbols::X)
+    expect(updated_board.symbol_at(8)).to be (PlayerSymbols::O)
+    expect(updated_board.vacant_indices.size).to eq 7
+  end
+
   it "continues until player is not ready" do
     allow(player_x_spy).to receive(:ready?).and_return(true, false)
     allow(player_o_spy).to receive(:ready?).and_return(true)
@@ -14,31 +37,32 @@ RSpec.describe Game do
     expect(player_x_spy).to receive(:choose_move).exactly(1).times.and_return(2)
     expect(player_o_spy).to receive(:choose_move).exactly(1).times.and_return(8)
 
-    Game.new(Board.new, [player_x_spy, player_o_spy]).play
+    Game.new(Board.new, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy }).play
   end
 
   it "players take turn until there is no space on board" do
     expect(player_x_spy).to receive(:choose_move).exactly(5).times.and_return(0, 1, 4, 5, 6)
     expect(player_o_spy).to receive(:choose_move).exactly(4).times.and_return(2, 3, 7, 8)
 
-    Game.new(Board.new, [player_x_spy, player_o_spy]).play
+    Game.new(Board.new, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy }).play
 
   end
 
   it "game ends when a winning combination is formed" do
+    allow(player_x_spy).to receive(:ready?).and_return(true)
     allow(player_x_spy).to receive(:choose_move).once.and_return(2)
     allow(player_x_spy).to receive(:game_symbol).and_return(PlayerSymbols::X)
 
-    board = Board.new([PlayerSymbols::X, PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, nil, nil, nil])
-    updated_board = Game.new(board, [player_x_spy, player_o_spy]).play
+    board = Board.new([PlayerSymbols::X, PlayerSymbols::X, nil, PlayerSymbols::O, nil, PlayerSymbols::O, nil, nil, nil])
+    updated_board = Game.new(board, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy }).play
 
-    expect(updated_board.get_symbol_at(2)).to be (PlayerSymbols::X)
+    expect(updated_board.symbol_at(2)).to be (PlayerSymbols::X)
     expect(player_o_spy).to_not have_received(:choose_move)
   end
 
   it "game ends when there are no free spaces on the board" do
     full_board = Board.new([PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X])
-    game = Game.new(full_board, [player_x_spy, player_o_spy]).play
+    game = Game.new(full_board, { PlayerSymbols::X => player_x_spy, PlayerSymbols::O => player_o_spy }).play
 
     expect(player_o_spy).to_not have_received(:choose_move)
     expect(player_x_spy).to_not have_received(:choose_move)

data/spec/player_options_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe PlayerOptions do
   end
 
   it "gets player type for id" do
-    expect(PlayerOptions::get_player_type_for_id(1)).to eq (PlayerOptions::HUMAN_VS_HUMAN)
+    expect(PlayerOptions::player_type_for_id(1)).to eq (PlayerOptions::HUMAN_VS_HUMAN)
   end
 
   it "gets player options for display" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ttt-core
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Georgina McFadyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-02 00:00:00.000000000 Z
+date: 2016-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler