tic_tac_toes 0.0.2 → 0.0.3

data/spec/tic_tac_toes/move_strategies/easy_ai_spec.rb

@@ -0,0 +1,19 @@
+require 'test_board_generator'
+require 'tic_tac_toes/move_strategies/easy_ai'
+
+describe TicTacToes::MoveStrategies::EasyAI do
+  describe '#move' do
+    let(:players) { double("players") }
+    let(:easy_ai) { TicTacToes::MoveStrategies::EasyAI }
+
+    it "returns a randomly-selected valid move" do
+      board = TestBoardGenerator.generate([ :O, nil, nil,
+                                           nil,  :X, nil,
+                                           nil,  :X, nil])
+      valid_moves = [1, 2, 3, 5, 6, 8]
+
+      move = easy_ai.move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/move_strategies/hard_ai_spec.rb

@@ -0,0 +1,95 @@
+require 'test_board_generator'
+require 'tic_tac_toes/move_strategies/hard_ai'
+require 'tic_tac_toes/player'
+
+describe TicTacToes::MoveStrategies::HardAI do
+  let(:hard_ai) { TicTacToes::MoveStrategies::HardAI }
+  let(:x) { TicTacToes::Player.new("human", "x", false, "io") }
+  let(:o) { TicTacToes::Player.new(hard_ai, "o", true, "io") }
+  let(:players) { [o, x] }
+
+
+  describe '#move' do
+    it "returns the best move" do
+      board = TestBoardGenerator.generate([x, nil, nil,
+                                           o,   o, nil,
+                                           x, nil,   x])
+      best_move = 5
+
+      expect(hard_ai.move(board, players)).to eql(best_move)
+    end
+  end
+
+
+  describe '#minimax' do
+    it "returns the correct score for a pre-win board" do
+      board = TestBoardGenerator.generate([x, nil, nil,
+                                           o,   o, nil,
+                                           x, nil,   x])
+      win_score = 1
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(win_score)
+    end
+
+    it "returns the correct score for a pre-loss board" do
+      board = TestBoardGenerator.generate([  o,   o,   x,
+                                           nil, nil, nil,
+                                             x, nil,   x])
+      loss_score = -1
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(loss_score)
+    end
+
+    it "returns the correct score for a pre-draw board" do
+      board = TestBoardGenerator.generate([x,   x, o,
+                                           o, nil, x,
+                                           x,   o, x])
+      draw_score = 0
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(draw_score)
+    end
+  end
+
+
+  describe '#generate_board' do
+    it "returns a board based on a token, a space, and an existing board" do
+      token, space = o, 3
+      board = TestBoardGenerator.generate([  x, nil, nil,
+                                           nil,   o, nil,
+                                             x, nil, nil])
+
+      new_board = hard_ai.generate_board(token, space, board)
+      expect(new_board.space(space)).to eql(token)
+    end
+  end
+
+
+  describe '#score' do
+    it "returns the correct score when HardAI has won" do
+      board = TestBoardGenerator.generate([  o, nil, nil,
+                                           nil,   o, nil,
+                                           nil, nil,   o])
+      win_score = 1
+
+      expect(hard_ai.score(board, players)).to eql(win_score)
+    end
+
+    it "returns the correct score when no one has won" do
+      board = TestBoardGenerator.generate([o, o, x,
+                                           x, x, o,
+                                           o, x, o])
+      draw_score = 0
+
+      expect(hard_ai.score(board, players)).to eql(draw_score)
+    end
+
+    it "returns the correct score when the opponent has won" do
+      board = TestBoardGenerator.generate([  x, nil, nil,
+                                           nil,   x, nil,
+                                           nil, nil,   x])
+      loss_score = -1
+
+      expect(hard_ai.score(board, players)).to eql(loss_score)
+    end
+  end
+end

data/spec/tic_tac_toes/move_strategies/human_spec.rb

@@ -0,0 +1,31 @@
+require 'tic_tac_toes/move_strategies/human'
+
+describe TicTacToes::MoveStrategies::Human do
+  describe '#move' do
+    let(:io)     { double("io", solicit_input: 0, move_solicitation: true, not_an_integer_error: true) }
+    let(:human)  { TicTacToes::MoveStrategies::Human.new(io) }
+
+    it "displays a move solicitation" do
+      expect(io).to receive(:move_solicitation)
+      human.move("board", "players")
+    end
+
+    context 'when given not-integer-like input' do
+      let(:not_integer_like)  { "string" }
+      let(:integer_like)      { "100" }
+
+      it "displays a not an integer error" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io).to receive(:not_an_integer_error).once
+        human.move("board", "players")
+      end
+
+      it "only returns a move (converted to integer) once it gets integer-like input" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(human.move("board", "players")).to eq(100)
+      end
+    end
+  end
+end

data/spec/tic_tac_toes/move_strategies/medium_ai_spec.rb

@@ -0,0 +1,21 @@
+require 'test_board_generator'
+require 'tic_tac_toes/move_strategies/medium_ai'
+
+describe TicTacToes::MoveStrategies::MediumAI do
+  let(:medium_ai) { TicTacToes::MoveStrategies::MediumAI }
+  let(:x) { TicTacToes::Player.new("human", "x", false, "io") }
+  let(:o) { TicTacToes::Player.new(medium_ai, "o", true, "io") }
+  let(:players) { [x, o] }
+
+  describe '#move' do
+    it "returns a valid move (based on either EasyAI or HardAI)" do
+      board = TestBoardGenerator.generate([  o, o,   x,
+                                           nil, x, nil,
+                                           nil, x, nil])
+      valid_moves = [3, 5, 6, 8]
+
+      move = medium_ai.move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/player_factory_spec.rb

@@ -1,33 +1,30 @@
-require 'command_line/io'
-require 'tic_tac_toes/io_interface'
-require 'tic_tac_toes/medium_ai'
+require 'tic_tac_toes/move_strategies/human'
+require 'tic_tac_toes/move_strategies/medium_ai'
 require 'tic_tac_toes/player_factory'
-require 'tic_tac_toes/spec_helper'
 
 describe TicTacToes::PlayerFactory do
-  let(:io) { CommandLine::IO }
-  let(:io_interface) { TicTacToes::IOInterface.new(io) }
-  let(:player_factory) { TicTacToes::PlayerFactory.new(io_interface) }
-
+  let(:player_factory) { TicTacToes::PlayerFactory.new("io") }
 
   describe '#generate_human_player' do
-    it "returns a player with the correct token and decider" do
-      token = "X"
+    it "returns a player with the correct token and move strategy" do
+      strategy = TicTacToes::MoveStrategies::Human
+      token = 'X'
 
       human_player = player_factory.generate_human_player(token)
-      expect(human_player.decider).to be_a TicTacToes::IOInterface
+      expect(human_player.move_strategy).to be_a strategy
       expect(human_player.token).to eq(token)
     end
   end
 
-
   describe '#generate_computer_player' do
-    it "returns a player with the correct token and decider when given a valid difficulty" do
-      token = "O"
+    it 'returns a player with the correct token and move strategy' do
+      token = 'O'
       difficulty = :medium
+      strategy = TicTacToes::MoveStrategies::MediumAI
 
-      computer_player = player_factory.generate_computer_player(token, difficulty)
-      expect(computer_player.decider).to eql(TicTacToes::MediumAI)
+      computer_player = player_factory.generate_computer_player(token,
+                                                                difficulty)
+      expect(computer_player.move_strategy).to eq(strategy)
       expect(computer_player.token).to eq(token)
     end
   end

data/spec/tic_tac_toes/player_spec.rb

@@ -1,34 +1,32 @@
 require 'tic_tac_toes/board'
-require 'tic_tac_toes/io_interface'
 require 'tic_tac_toes/player'
-require 'tic_tac_toes/spec_helper'
 
 describe TicTacToes::Player do
-  let(:board) { TicTacToes::Board.new(row_size: 3) }
-  let(:io_interface) { double("io_interface", invalid_move_error: true) }
-  let(:players) { double("players") }
+  let(:board)         { TicTacToes::Board.new(row_size: 3) }
+  let(:io)            { double("io", invalid_move_error: true) }
+  let(:players)       { double("players") }
 
-  describe '#make_move' do
-    let(:decider) { double("decider") }
-    let(:token) { "X" }
-    let(:needs_to_think) { false }
+  describe '#place_and_return_move' do
+    let(:move_strategy)   { double("move_strategy") }
+    let(:token)           { "X" }
+    let(:needs_to_think)  { false }
 
-    let(:player) { TicTacToes::Player.new(decider, token, needs_to_think, io_interface) }
+    let(:player) { TicTacToes::Player.new(move_strategy, token, needs_to_think, io) }
  
-    it "only returns a move once it receives a valid move" do
+    it "only places/returns a move once it receives a valid move" do
       invalid_space, valid_space = 9, 0
-      allow(decider).to receive(:make_move).and_return(invalid_space, valid_space)
+      allow(move_strategy).to receive(:move).and_return(invalid_space, valid_space)
 
-      player.make_move(board, players)
+      player.place_and_return_move(board, players)
       expect(board.space(valid_space)).to eq(player)
     end
 
     it "displays an invalid move error when given an invalid move" do
       invalid_space, valid_space = 9, 0
-      allow(decider).to receive(:make_move).and_return(invalid_space, valid_space)
+      allow(move_strategy).to receive(:move).and_return(invalid_space, valid_space)
 
-      expect(io_interface).to receive(:invalid_move_error)
-      player.make_move(board, players)
+      expect(io).to receive(:invalid_move_error)
+      player.place_and_return_move(board, players)
     end
   end
 end

data/spec/tic_tac_toes/rules_spec.rb

@@ -1,4 +1,4 @@
-require 'tic_tac_toes/spec_helper'
+require 'test_board_generator'
 require 'tic_tac_toes/rules'
 
 describe TicTacToes::Rules do
@@ -60,28 +60,25 @@ describe TicTacToes::Rules do
 
   describe '#game_over?' do
     it "returns false if there is not yet a winner and the board is not full" do
-      structure = [x, x,   o,
-                   o, o, nil,
-                   x, o,   x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([x, x,   o,
+                                           o, o, nil,
+                                           x, o,   x])
 
       expect(rules.game_over?(board, players)).to be false
     end
 
     it "returns true if any player has won" do
-      structure = [  x, nil, nil,
-                   nil,   x, nil,
-                   nil, nil,   x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([  x, nil, nil,
+                                           nil,   x, nil,
+                                           nil, nil,   x])
 
       expect(rules.game_over?(board, players)).to be true
     end
 
     it "returns true if the board is full" do
-      structure = [x, x, o,
-                   o, o, x,
-                   x, o, x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([x, x, o,
+                                           o, o, x,
+                                           x, o, x])
 
       expect(rules.game_over?(board, players)).to be true
     end
@@ -90,20 +87,18 @@ describe TicTacToes::Rules do
 
   describe '#determine_winner' do
     it "returns the winning token when there is a winner" do
-      structure = [  o, nil, nil,
-                   nil,   o, nil,
-                   nil, nil,   o]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([  o, nil, nil,
+                                           nil,   o, nil,
+                                           nil, nil,   o])
       winning_token = "o"
 
       expect(rules.determine_winner(board, players)).to eql(winning_token)
     end
 
     it "returns nil if there is not a winner" do
-      structure = [x, x,   o,
-                   o, o, nil,
-                   x, o,   x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([x, x,   o,
+                                           o, o, nil,
+                                           x, o,   x])
 
       expect(rules.determine_winner(board, players)).to be_nil
     end
@@ -112,46 +107,41 @@ describe TicTacToes::Rules do
 
   describe '#win?' do
     it "returns false if the given token has not won" do
-      structure = [x, x,  o,
-                   o, o, nil,
-                   x, o,  x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([x, x,  o,
+                                           o, o, nil,
+                                           x, o,  x])
 
       expect(rules.win?(board, x)).to be false
     end
 
     it "returns true if the given token has achieved a back diagonal win" do
-      structure = [  x, nil, nil,
-                   nil,   x, nil,
-                   nil, nil,   x]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([  x, nil, nil,
+                                           nil,   x, nil,
+                                           nil, nil,   x])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a front diagonal win" do
-      structure = [nil, nil,   x,
-                   nil,   x, nil,
-                     x, nil, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([nil, nil,   x,
+                                           nil,   x, nil,
+                                             x, nil, nil])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a horizonatal win" do
-      structure = [nil, nil, nil,
-                     x,   x,   x,
-                   nil, nil, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([nil, nil, nil,
+                                             x,   x,   x,
+                                           nil, nil, nil])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a vertical win" do
-      structure = [nil, x, nil,
-                   nil, x, nil,
-                   nil, x, nil]
-      board = generate_board(structure)
+      board = TestBoardGenerator.generate([nil, x, nil,
+                                           nil, x, nil,
+                                           nil, x, nil])
 
       expect(rules.win?(board, x)).to be true
     end

data/spec/tic_tac_toes/strings_spec.rb

@@ -1,6 +1,5 @@
 require 'tic_tac_toes/board'
 require 'tic_tac_toes/rules'
-require 'tic_tac_toes/spec_helper'
 require 'tic_tac_toes/strings'
 
 describe TicTacToes::Strings do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toes
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ben Spatafora
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-23 00:00:00.000000000 Z
+date: 2014-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -85,36 +86,44 @@ files:
 - bin/destroy_ttt_databases
 - bin/set_up_ttt_databases
 - bin/tic_tac_toes
-- lib/command_line/io.rb
 - lib/command_line/menu.rb
+- lib/command_line/prompt.rb
 - lib/command_line/runner.rb
 - lib/database/pg_wrapper.rb
+- lib/tasks/destroy_databases.rake
+- lib/tasks/set_up_databases.rake
 - lib/tic_tac_toes/board.rb
-- lib/tic_tac_toes/easy_ai.rb
-- lib/tic_tac_toes/hard_ai.rb
+- lib/tic_tac_toes/board_factory.rb
+- lib/tic_tac_toes/game_state.rb
+- lib/tic_tac_toes/game_state_factory.rb
 - lib/tic_tac_toes/history.rb
-- lib/tic_tac_toes/io_interface.rb
-- lib/tic_tac_toes/medium_ai.rb
+- lib/tic_tac_toes/io.rb
+- lib/tic_tac_toes/move_strategies/easy_ai.rb
+- lib/tic_tac_toes/move_strategies/hard_ai.rb
+- lib/tic_tac_toes/move_strategies/human.rb
+- lib/tic_tac_toes/move_strategies/medium_ai.rb
 - lib/tic_tac_toes/player.rb
 - lib/tic_tac_toes/player_factory.rb
 - lib/tic_tac_toes/rules.rb
 - lib/tic_tac_toes/strings.rb
-- lib/tic_tac_toes/tasks/destroy_databases.rake
-- lib/tic_tac_toes/tasks/set_up_databases.rake
 - lib/tic_tac_toes/version.rb
 - spec/command_line/menu_spec.rb
 - spec/command_line/runner_spec.rb
 - spec/database/pg_wrapper_spec.rb
+- spec/test_board_generator.rb
+- spec/tic_tac_toes/board_factory_spec.rb
 - spec/tic_tac_toes/board_spec.rb
-- spec/tic_tac_toes/easy_ai_spec.rb
-- spec/tic_tac_toes/hard_ai_spec.rb
+- spec/tic_tac_toes/game_state_factory_spec.rb
+- spec/tic_tac_toes/game_state_spec.rb
 - spec/tic_tac_toes/history_spec.rb
-- spec/tic_tac_toes/io_interface_spec.rb
-- spec/tic_tac_toes/medium_ai_spec.rb
+- spec/tic_tac_toes/io_spec.rb
+- spec/tic_tac_toes/move_strategies/easy_ai_spec.rb
+- spec/tic_tac_toes/move_strategies/hard_ai_spec.rb
+- spec/tic_tac_toes/move_strategies/human_spec.rb
+- spec/tic_tac_toes/move_strategies/medium_ai_spec.rb
 - spec/tic_tac_toes/player_factory_spec.rb
 - spec/tic_tac_toes/player_spec.rb
 - spec/tic_tac_toes/rules_spec.rb
-- spec/tic_tac_toes/spec_helper.rb
 - spec/tic_tac_toes/strings_spec.rb
 - tic_tac_toes.gemspec
 homepage: http://github.com/bspatafora/tic_tac_toes
@@ -145,14 +154,18 @@ test_files:
 - spec/command_line/menu_spec.rb
 - spec/command_line/runner_spec.rb
 - spec/database/pg_wrapper_spec.rb
+- spec/test_board_generator.rb
+- spec/tic_tac_toes/board_factory_spec.rb
 - spec/tic_tac_toes/board_spec.rb
-- spec/tic_tac_toes/easy_ai_spec.rb
-- spec/tic_tac_toes/hard_ai_spec.rb
+- spec/tic_tac_toes/game_state_factory_spec.rb
+- spec/tic_tac_toes/game_state_spec.rb
 - spec/tic_tac_toes/history_spec.rb
-- spec/tic_tac_toes/io_interface_spec.rb
-- spec/tic_tac_toes/medium_ai_spec.rb
+- spec/tic_tac_toes/io_spec.rb
+- spec/tic_tac_toes/move_strategies/easy_ai_spec.rb
+- spec/tic_tac_toes/move_strategies/hard_ai_spec.rb
+- spec/tic_tac_toes/move_strategies/human_spec.rb
+- spec/tic_tac_toes/move_strategies/medium_ai_spec.rb
 - spec/tic_tac_toes/player_factory_spec.rb
 - spec/tic_tac_toes/player_spec.rb
 - spec/tic_tac_toes/rules_spec.rb
-- spec/tic_tac_toes/spec_helper.rb
 - spec/tic_tac_toes/strings_spec.rb

data/lib/tic_tac_toes/easy_ai.rb

@@ -1,9 +0,0 @@
-require 'tic_tac_toes/board'
-
-module TicTacToes
-  module EasyAI
-    def self.make_move(board, _players)
-      board.open_spaces.sample
-    end
-  end
-end

data/lib/tic_tac_toes/hard_ai.rb

@@ -1,57 +0,0 @@
-require 'tic_tac_toes/rules'
-
-module TicTacToes
-  module HardAI
-    def self.make_move(board, players)
-      open_spaces = Hash[board.open_spaces.map { |space| [space, nil] }]
-
-      open_spaces.each do |space, score|
-        score = minimax(generate_board(players.first, space, board), :min, players)
-        open_spaces[space] = score
-      end
-
-      best_score = open_spaces.values.max
-      open_spaces.each { |space, score| return space if score == best_score }
-    end
-
-    def self.minimax(board, current_player, players)
-      return score(board, players) if Rules.game_over?(board, players)
-
-      if current_player == :max
-        best_score = -1
-        board.open_spaces.each do |space|
-          score = minimax(generate_board(players.first, space, board), :min, players)
-          best_score = [best_score, score].max
-        end
-        best_score
-
-      elsif current_player == :min
-        best_score = 1
-        board.open_spaces.each do |space|
-          score = minimax(generate_board(players.last, space, board), :max, players)
-          best_score = [best_score, score].min
-        end
-        best_score
-      end
-    end
-
-    def self.generate_board(player, space, board)
-      new_board = Marshal.load(Marshal.dump(board))
-      new_board.place(player, space)
-      new_board
-    end
-
-    def self.score(board, players)
-      own_token, opponent_token = players.first.token, players.last.token
-
-      case Rules.determine_winner(board, players)
-      when own_token
-        1
-      when opponent_token
-        -1
-      else
-        0
-      end
-    end
-  end
-end

data/lib/tic_tac_toes/io_interface.rb

@@ -1,96 +0,0 @@
-require 'tic_tac_toes/strings'
-
-module TicTacToes
-  class IOInterface
-    def initialize(io)
-      @io = io
-    end
-
-    def make_move(_board, _players)
-      move_solicitation
-
-      Integer(@io.solicit_input)
-      rescue ArgumentError
-        not_an_integer_error
-        make_move(_board, _players)
-    end
-
-    def get_row_size
-      row_size_solicitation
-
-      Integer(@io.solicit_input)
-      rescue ArgumentError
-        not_an_integer_error
-        get_row_size
-    end
-
-    def get_token(player)
-      token_solicitation(player)
-      @io.solicit_input
-    end
-
-    def get_difficulty
-      difficulty_solicitation
-      @io.solicit_input.downcase.to_sym
-    end
-
-    def draw_board(board)
-      @io.display(Strings.board(board))
-    end
-
-    def invalid_row_size_error
-      @io.display_red(Strings::INVALID_ROW_SIZE)
-    end
-
-    def invalid_token_error
-      @io.display_red(Strings::INVALID_TOKEN)
-    end
-
-    def invalid_difficulty_error
-      @io.display_red(Strings::INVALID_DIFFICULTY)
-    end
-
-    def invalid_move_error
-      @io.display_red(Strings::INVALID_MOVE)
-    end
-
-    def thinking_notification
-      @io.display_red(Strings::THINKING)
-    end
-
-    def game_over_notification(winner)
-      winner = "Nobody" if winner.nil?
-      @io.display(Strings.game_over_notification(winner))
-    end
-
-    def red(message)
-      @io.red(message)
-    end
-
-    def blue(message)
-      @io.blue(message)
-    end
-
-    private
-
-    def move_solicitation
-      @io.display(Strings::MOVE_SOLICITATION)
-    end
-
-    def row_size_solicitation
-      @io.display(Strings::ROW_SIZE_SOLICITATION)
-    end
-
-    def token_solicitation(player)
-      @io.display(Strings.token_solicitation(player))
-    end
-
-    def difficulty_solicitation
-      @io.display(Strings::DIFFICULTY_SOLICITATION)
-    end
-
-    def not_an_integer_error
-      @io.display_red(Strings::NOT_AN_INTEGER)
-    end
-  end
-end