ttt_gem_8thlight 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90a9a9a08a763d1a45802b801ab7209932b4f87f
-  data.tar.gz: d0fe04ab969feb057556cd9b272093338f451519
+  metadata.gz: 5422ceb23dd17ef9f678a8862c6421a4375635fe
+  data.tar.gz: 7dc9aed92efc0aa7479fc717ad616b258c51a13c
 SHA512:
-  metadata.gz: 8a2a6e285c1c8339f862dd05650ff8a857a6c315f0eb88489c6231430ffe2ddbb9043161b2f1ee024977af4c8ec2e103fe30256c426b361556b4f14f02b9fabf
-  data.tar.gz: cbbbca7956907d03c60202d60ea6fc193d7b44c66c9f9bd7f464870746cac035230dab4e2b920833fa5e0ab47e80aef2deebe7ae4d0e9ad0a5069cd88601df99
+  metadata.gz: 001ca4624857309974c523bc7c1a012b6886b3e1c44c022cf6dc849a271dec18d85f602c1c80739c5d5555b1bbe6abcdd58c08089702db32af750ee87c085db8
+  data.tar.gz: 860b4661253c1048ec48debddadc8ad87d6507c069fc6458d952e629626814594018f3dbb87db80e8c5c251c74f846ff97d42fbfe23e7af3005f1e3b6d85dd8f

data/README.md

@@ -0,0 +1,3 @@
+# Tic Tac Toe Gem
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.fail_on_error = false
+end
+
+task :default => :spec
+

data/lib/ai.rb

@@ -0,0 +1,18 @@
+module TicTacToe
+  class AI
+    attr_reader :mark
+    attr_accessor :difficulty
+
+    def initialize(mark, difficulty = :unbeatable_ai)
+      @mark = mark
+      @difficulty = difficulty
+    end
+
+    def make_move(board)
+      move = { :difficulty => @difficulty,
+               :board => board,
+               :mark => @mark }
+      AIRules::Factory.get(move)
+    end
+  end
+end

data/lib/ai/ai_factory.rb

@@ -0,0 +1,12 @@
+module TicTacToe
+  module AIRules
+    class Factory
+      def self.get(move)
+        case move[:difficulty]
+        when :unbeatable_ai
+          UnbeatableAI.make_move(move[:board], move[:mark])
+        end
+      end
+    end
+  end
+end

data/lib/ai/unbeatable_ai.rb

@@ -0,0 +1,60 @@
+module TicTacToe
+  module AIRules
+    class UnbeatableAI
+      Infinity = 100
+      Negative_Infinity = -100
+
+      def self.make_move(board, mark)
+        best_score = Negative_Infinity
+        best_space = 0
+        opponent_mark = mark == "X" ? "O" : "X"
+
+        board.empty_spaces.each do |space|
+          board.place_move(mark, space)
+          score = minimax(board, opponent_mark, 0, Negative_Infinity, Infinity, false, -1)
+          board.undo_move(space)
+
+          if score > best_score
+            best_score = score
+            best_space = space
+          end
+        end
+        return best_space
+      end
+
+      def self.minimax(board, mark, depth, score_min, score_max, max_player, color)
+        opponent_mark = mark == "X" ? "O" : "X"
+
+        return check_game_state(board, mark, depth) * color if game_done?(board, depth)
+
+        if max_player
+          board.empty_spaces.each do |spaces|
+            board.place_move(mark, spaces)
+            score_min = [score_min, minimax(board, opponent_mark, depth + 1, score_max, score_min, !(max_player), -color)].max
+            board.undo_move(spaces)
+            break if score_min >= score_max
+          end
+          return score_min
+        else
+          board.empty_spaces.each do |spaces|
+            board.place_move(mark, spaces)
+            score_max = [score_max, minimax(board, opponent_mark, depth + 1, score_max, score_min, !(max_player), -color)].min
+            board.undo_move(spaces)
+            break if score_min >= score_max
+          end
+          return score_max
+        end
+      end
+
+      def self.check_game_state(board, mark, depth)
+        return 0 if board.tied_game?
+        return 100 + depth if board.winner == mark
+        -100 + depth
+      end
+
+      def self.game_done?(board, depth)
+        board.has_winner? || board.tied_game? || depth == 6
+      end
+    end
+  end
+end

data/lib/board.rb

@@ -0,0 +1,117 @@
+module TicTacToe
+  class Board
+    attr_accessor :spaces, :solutions
+
+    def initialize
+      @spaces = %w[1 2 3 4 5 6 7 8 9]
+      winning_solutions
+    end
+
+    def self.parse(board)
+      parsed_board = self.new
+      parse_board = []
+      new_board = board.split('')
+      new_board.each_index do |space|
+        if new_board[space] == '_' || new_board[space].to_i != 0
+          parse_board << (space + 1).to_s
+        else
+          parse_board << new_board[space]
+        end
+      end
+      parsed_board.spaces = parse_board
+      parsed_board
+    end
+
+    def to_s
+      @spaces.join
+    end
+
+    def get(space)
+      @spaces[space-1]
+    end
+
+    def place_move(piece, *space)
+      space.each do |space|
+        @spaces[(space.to_i)-1] = piece
+      end
+    end
+
+    def undo_move(space)
+      @spaces[(space.to_i)-1] = space.to_s
+    end
+
+    def is_taken?(space)
+      @spaces[(space.to_i) - 1].to_i == 0
+    end
+
+    def tied_game?
+      full_board? && !has_winner?
+    end
+
+    def full_board?
+      (@spaces.count { |x| x == 'X' } + @spaces.count { |x| x == 'O' }) == 9
+    end
+
+    def is_board_empty?
+      !@spaces.include?("X") && !@spaces.include?("O")
+    end
+
+    def has_winner?
+      has_winner = false
+      @solutions.each { |sol| has_winner = true if unique?(sol)}
+      has_winner
+    end
+
+    def unique?(spaces)
+      spaces.map { |s| @spaces[s-1]}.uniq.length == 1 
+    end
+
+    def make_blank
+      @spaces.reduce("") do |blank_spaces, spaces|
+        if !spaces.to_i.zero?
+          blank_spaces << '_'
+        else
+          blank_spaces << spaces
+        end
+      end
+    end
+
+    def empty_spaces
+      @spaces.select { |x| x.to_i != 0}
+    end
+
+    def row_win
+      (@spaces.map { |space| space.to_i }).each_slice(3) { |nums| @solutions.push(nums)}
+    end
+
+    def column_win
+      3.times do |check|
+        ((check+1)..(9)).step(3).each_slice(3) do |nums|
+          @solutions.push(nums)
+        end
+      end
+    end
+
+    def diagonal_win
+      (1..(9)).step(4).each_slice(3) do |nums|
+        @solutions.push(nums)
+      end
+      ((3)..(9)-1).step(2).each_slice(3) do |nums|
+        @solutions.push(nums)
+      end
+    end
+
+    def winning_solutions
+      @solutions = []
+      row_win
+      column_win
+      diagonal_win
+    end
+
+    def winner
+      winner = ""
+      @solutions.each { |sol| winner = @spaces[sol[0]-1] if unique?(sol)}
+      winner
+    end
+  end
+end

data/lib/game.rb

@@ -0,0 +1,143 @@
+module TicTacToe
+  class Game
+    attr_reader :ui, :board, :player_one, :player_two
+    attr_accessor :over
+
+    def initialize(ui, config={}, over = false)
+      @ui = ui
+      game_config(config) if !config.empty?
+      @over = over
+    end
+
+    def self.play_game(ui, config, move="")
+      game = self.new(ui, config)
+      game.set_spaces(config[:game_board])
+      player = game.current_player(config[:game_board])
+
+      if game.board.is_board_empty? && player.class != AI
+        game.ui.display_message
+        game.ui.print_board(game.board)
+        game.place_move(player.mark, move)
+      elsif game.is_over?
+        game.ui.display_result(game.result)
+        game.over = true
+      else
+        game.ui.ask_move(player)
+        move = game.get_move(player) if player.class == AI
+        game.place_move(player.mark, move)
+        game.ui.print_board(game.board)
+
+        if game.is_over?
+          game.ui.display_result(game.result)
+          game.over = true
+        end
+      end
+      game
+    end
+
+    def game_config(config)
+      @player_one = PlayerFactory.create(:type => config[:player_one].to_sym, :mark => "X")
+      @player_two = PlayerFactory.create(:type => config[:player_two].to_sym, :mark => "O")
+      @board = Board.new
+    end
+
+    def start_game
+      @ui.print_board(@board)
+    end
+
+    def set_spaces(board)
+      @board = Board.parse(board)
+    end
+
+    def is_over?
+      tied_game? || has_winner?
+    end
+
+    def tied_game?
+      @board.tied_game?
+    end
+
+    def has_winner?
+      @board.has_winner?
+    end
+
+    def winner
+      @board.winner
+    end
+
+    def get_move(player)
+      return @ui.ask_move(player) if player.class == Human
+      return player.make_move(@board)
+    end
+
+    def valid_move?(space)
+      !@board.is_taken?(space)
+    end
+
+    def ask_move(player)
+      user_input = @ui.ask_move(player)
+      while 0 > user_input || user_input > 9
+        @ui.output.puts("Invalid Move, Try Again")
+        user_input = @ui.ask_move(player)
+      end
+      user_input
+    end
+
+    def make_moves(moves={})
+      moves[:player_one] = get_move(@player_one)
+      if valid_move?(moves[:player_one])
+        place_move(@player_one.mark, moves[:player_one])
+
+        if !is_over?
+          @ui.print_board(@board) if @player_two.class == Human
+          moves[:player_two] = get_move(@player_two)
+          place_move(@player_two.mark, moves[:player_two])
+          @ui.print_board(@obard)
+        end
+      end
+    end
+
+    def place_move(mark, move)
+      @board.place_move(mark, move) if !move.empty? && valid_move?(move)
+    end
+
+    def start
+      start_game
+      make_moves until is_over?
+      end_game
+    end
+
+    def end_game
+      @ui.print_board(@board)
+      @ui.display_result(result)
+      again?
+    end
+
+    def current_player(board)
+      count = 0
+      (0..8).each do |space|
+        count += 1 if board[space] != "_"
+      end
+
+      if count.even? || count.zero?
+        return @player_one
+      else
+        return @player_two
+      end
+    end
+
+    def again?
+      start if @ui.again?
+      @over = true
+    end
+
+    def result
+      return "tie" if tied_game?
+      winner
+    end
+
+    def unique?(spaces)
+      spaces.map { |space| @board.spaces[space-1]}.uniq.length == 1
+    end
+  end
+end

data/lib/human.rb

@@ -0,0 +1,13 @@
+module TicTacToe
+  class Human
+    attr_reader :mark
+
+    def initialize(mark)
+      @mark = mark
+    end
+
+    def make_move(space, board)
+      board.place_move(@mark, space)
+    end
+  end
+end

data/lib/mock_ui.rb

@@ -0,0 +1,33 @@
+class MockUI
+  attr_reader :asked_play_again, :board_printed, :displayed_result, :ask_again, :asked_move, :move, :displayed_message
+
+  def output
+    $stdout
+  end
+
+  def print_board(board)
+    @board_printed = true
+  end
+
+  def display_result(result)
+    @displayed_result = true
+  end
+
+  def display_message
+    @displayed_message = true
+  end
+
+  def ask_play_again?
+    @asked_play_again = true
+  end
+
+  def again?
+    @ask_again = true
+    false
+  end
+
+  def ask_move(player)
+    @asked_move = true
+    @move = "3"
+  end
+end

data/lib/player_factory.rb

@@ -0,0 +1,18 @@
+require 'human'
+
+module TicTacToe
+  class PlayerFactory
+    def self.create(input)
+      case input[:type]
+      when :ai
+        AI.new(input[:mark])
+      when :human
+        Human.new(input[:mark])
+      else
+        raise "Invalid Player Type"
+      end
+    end
+
+
+  end
+end

data/spec/ai/ai_factory_spec.rb

@@ -0,0 +1,12 @@
+require 'ai/ai_factory'
+
+describe TicTacToe::AIRules::Factory do
+  it "makes an unbeatable AI move" do
+    move = { :difficulty => :unbeatable_ai,
+             :board => TicTacToe::Board.new,
+             :mark => "O" }
+    TicTacToe::AIRules::UnbeatableAI.should_receive(:make_move).and_return("5")
+    ai = described_class.get(move)
+    ai.should == "5"
+  end  
+end

data/spec/ai/unbeatable_ai_spec.rb

@@ -0,0 +1,76 @@
+require 'ai/unbeatable_ai'
+require 'board'
+
+describe TicTacToe::AIRules::UnbeatableAI do
+  let(:board) { TicTacToe::Board.new }
+  let(:mark) { 'O' }
+
+  def test_board(board)
+    TicTacToe::Board.parse(board)
+  end
+
+  context "#minimax" do
+    let(:depth) { 0 }
+    let(:score_min) { -100 }
+    let(:score_max) { 100 }
+    
+    it "returns 100 on a winning board" do
+      board = test_board('OOO456789')
+      described_class.minimax(board, mark, depth, score_min, score_max, false, 1).should == 100
+    end
+
+    it "returns -100 on a losing board" do
+      board = test_board('XXX456789')
+      described_class.minimax(board, mark, depth, score_min, score_max, false, 1).should == -100
+    end
+
+    it "returns 0 on a tied game" do
+      board = test_board('XOXOXOOXO')
+      described_class.minimax(board, mark, depth, score_min, score_max, false, 1).should == 0
+    end
+
+    it "returns -99 one move away from winning" do
+      board = test_board('123OO6789')
+      described_class.minimax(board, mark, depth, score_min, score_max, false, -1).should == -99
+    end
+
+    it "returns 0 a move before a tie" do
+      board = test_board('XOXOXOOX9')
+      described_class.minimax(board, mark, depth, score_min, score_max, false, -1).should == 0
+    end
+
+    it "returns -100 for win" do
+      board = test_board("OOOOOOOO9")
+      described_class.minimax(board, mark, depth, score_min, score_max, true, -1).should == -100
+    end
+
+    it "returns -99 when 2 moves away" do
+      board = test_board("XX3XO6OXO")
+      described_class.minimax(board, mark, depth, score_min, score_max, false, -1).should == -99 
+    end
+  end
+
+  context "making winning moves" do
+    it "returns the winning space" do
+      board = test_board("XX3XO6OXO")
+      described_class.make_move(board, mark).should == "3"
+    end
+
+    it "wins instead of tie" do
+      board = test_board("XOX45O7OX")
+      described_class.make_move(board, mark).should == "5"
+    end
+
+    it "wins asap" do
+      board = test_board("OX34O6XX9")
+      described_class.make_move(board, mark).should == "9"
+    end
+  end
+
+  context "unbeatable" do
+    it "block" do
+      board = test_board('OXXXXO7O9')
+      described_class.make_move(board, mark).should == "7"
+    end
+  end
+end

data/spec/ai_spec.rb

@@ -0,0 +1,18 @@
+require 'ai'
+require 'board'
+
+describe TicTacToe::AI do
+  let(:ai) { described_class.new("O") }
+
+  it "sets to unbeatable AI" do
+    ai.difficulty = :unbeatable_ai
+    ai.difficulty.should == :unbeatable_ai 
+  end
+
+  it "makes a move on the board" do
+    board = TicTacToe::Board.new
+    ai.difficulty = :unbeatable_ai
+    ai.make_move(board).should == "1"
+  end
+  
+end

data/spec/board_spec.rb

@@ -0,0 +1,166 @@
+require 'board'
+
+describe TicTacToe::Board do
+  let(:board) {  described_class.new }
+  
+  describe "#new" do
+    it "creates blank board with numbers" do
+      (1..9).each do |num|
+        board.get(num).should == ("#{num}")
+      end
+    end
+  end
+
+  describe "#make_blank" do
+    it "makes the board blank" do
+      board.make_blank.should == '_________'  
+    end
+
+    it "doesn't replace moves with spaces" do
+      board.spaces[3] = "X"
+      board.make_blank.should == '___X_____'
+    end
+  end
+
+  context "making move" do
+    describe "#place_move" do
+      it "places a move" do
+        board.place_move('X', 0)
+        board.get(0).should == "X"
+      end
+
+      it "allows multiple inputs" do
+        board.place_move('X', 1, 2, 3)
+        board.get(1).should == "X"
+        board.get(2).should == "X"
+        board.get(3).should == "X"
+      end
+    end
+
+    describe "#undo_move" do
+      it "undoes a move" do
+        board.place_move('X', 2)
+        board.undo_move(2)
+        board.get(2).should == "2"
+      end
+    end
+  end
+
+  describe "#is_taken?" do
+    it "is false when the space isn't taken" do
+      board.is_taken?(5).should be_false
+    end
+
+    it "is true when the space is taken" do
+      board.place_move('X', 6)
+      board.is_taken?(6).should be_true
+    end  
+  end
+
+  describe "checking for winner" do
+    before :each do
+      board.place_move('X', 1, 3, 5, 8)
+      board.place_move('O', 2, 4, 6, 7, 9)
+    end
+    describe "#tied_game?" do
+      it "is true when the game is tied" do
+        board.tied_game?.should be_true
+      end
+    end
+  end
+
+  describe "#full_board?" do
+    it "returns true if board is full" do
+      board.place_move('X', 1, 3, 5, 8)
+      board.place_move('O', 2, 4, 6, 7, 9)
+      board.full_board?.should be_true
+    end
+
+    it "returns false if board not full" do
+      board.full_board?.should be_false
+    end
+  end
+
+  describe "#has_winner?" do
+    it "returns false with no winner" do
+      board.has_winner?.should be_false
+    end
+
+    it "returns true with a winner" do
+      board.place_move('X', 1, 2, 3)
+      board.has_winner?.should be_true
+    end
+  end
+
+  describe "#empty_spaces" do
+    it "returns all the empty spaces in the board" do
+      board.empty_spaces.should == %w(1 2 3 4 5 6 7 8 9)
+    end
+
+    it "returns all empty spaces with moves" do
+      board.place_move('O', 1,2,3)
+      board.empty_spaces.should == %w(4 5 6 7 8 9)
+    end
+  end
+
+  describe "finding winner" do
+    it "knows when X is the winner" do
+      board.place_move('X', 1, 2, 3)
+      board.winner.should == "X"
+    end
+
+    it "knows when O is the winenr" do
+      board.place_move('O', 1, 2, 3)
+      board.winner.should == "O"
+    end
+  end
+
+  describe "#is_board_empty?" do
+    it "knows when the board is empty" do
+      board.is_board_empty?.should be_true
+    end
+
+    it "isn't empty with moves" do
+      board.place_move('X', 1)
+      board.is_board_empty?.should be_false
+    end
+  end
+
+  describe "getting and parsing a board" do
+    it "parses the board" do
+      board_parsed = 'X23456O89'
+      board = described_class.parse(board_parsed)
+      board_parsed.split('').each_with_index do |mark, space|
+        board.get(space+1).should == mark
+      end
+      board.spaces.should be_a(Array)
+    end
+
+    it "gets a board" do
+      board_parsed = '12345XX8O'
+      board = described_class.parse(board_parsed)
+      board.to_s.should == board_parsed
+    end
+
+    it "gets a blank board" do
+      board_parsed = '_________'
+      board = described_class.parse(board_parsed)
+      board.to_s.should == "123456789"
+    end
+
+    it "gets a board with underscores and some marks" do
+      board_parsed = '_X_______'
+      board = described_class.parse(board_parsed)
+      board.to_s.should == "1X3456789"
+    end
+  end
+
+  describe "#winning_solutions" do
+    it "gets all winning solutions for board" do
+      board.winning_solutions
+      board.solutions.should == [[1,2,3], [4,5,6], [7,8,9],
+                                 [1,4,7], [2,5,8], [3,6,9],
+                                 [1,5,9], [3,5,7]]
+    end
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,271 @@
+require 'game'
+require 'mock_ui'
+
+describe TicTacToe::Game do
+  let(:ui) { MockUI.new }
+  let(:settings) {{:player_one => :human, :player_two => :ai }}
+  let(:game) {described_class.new(ui, settings)}
+
+  describe "#game_config" do
+    before(:each) do
+      game.game_config({:player_one => :human, :player_two => :ai})
+    end
+
+    it "creates the first player" do
+      game.player_one.class.should == TicTacToe::Human
+    end
+
+    it "creates the second player" do
+      game.player_two.class.should == TicTacToe::AI
+    end
+
+    it "creates a board" do
+      game.board.spaces.count.should == 9
+    end
+  end
+
+  describe "#is_over?" do
+    it "is true when over" do
+      game.set_spaces("OXOXOXXOX")
+      game.is_over?.should be_true
+    end
+  end
+
+  describe "#again?" do
+    it "asks user to play again" do
+      game.set_spaces("OXOXOXXOX")
+      game.start
+      ui.ask_play_again?.should be_true
+      game.over.should be_true
+    end
+  end
+
+  describe "#result" do
+    it "returns X as winner" do
+      game.set_spaces('X234X678X')
+      game.result.should == "X"
+    end
+
+    it "returns O as winner" do
+      game.set_spaces('O234O678O')
+      game.result.should == "O"
+    end
+
+    it "returns a tie" do
+      game.set_spaces('OXOXOXXOX')
+      game.result.should == "tie"
+    end
+  end
+
+  describe "#start" do
+    before(:each) do
+      game.stub(:has_winner).and_return(true)
+    end
+
+    it "prints board after game over" do
+      game.set_spaces("OOO456789")
+      game.start
+      game.ui.board_printed.should be_true
+    end
+  end
+
+
+  describe "#new" do
+    it "gets the ui" do
+      game.ui.class.should == MockUI
+    end
+
+    it "has players" do
+      game.player_one.should_not be_nil
+      game.player_two.should_not be_nil
+    end
+    
+    it "can set a board" do
+      game.set_spaces("X234567O9")
+      game.board.spaces.should == ["X", "2", "3", "4", "5", "6", "7", "O", "9"]
+    end
+  end
+
+  context "#has_winner" do
+    it "has a winner" do
+      game.set_spaces('123OOO789')
+      game.has_winner?.should be_true
+    end
+
+    it "doesnt have a winner" do
+      game.set_spaces('1234O6789')
+      game.has_winner?.should be_false
+    end
+  end
+
+  context "#matches?" do
+    it "doesnt match without marks" do
+      game.unique?([1,2, 5]).should be_false
+    end  
+
+    it "matches with moves" do
+      game.set_spaces('XXX456789')
+      game.unique?([1,2,3]).should be_true
+    end
+  end
+
+  context "#tied_game?" do
+    it "is true for a tie" do
+      game.set_spaces('XOXOXOOXO')
+      game.tied_game?.should be_true
+    end
+  end
+
+  context "#winner" do
+    it "returns X" do
+      game.set_spaces("XXX456789")
+      game.winner.should == "X"
+    end
+
+    it "returns O" do
+      game.set_spaces("OOO456789")
+      game.winner.should == "O"
+    end
+
+    it "doesnt have a winner" do
+      game.set_spaces("XXO456789")
+      game.winner.should == ""
+    end
+  end
+
+  describe "#display_result" do
+    it "displays for a tie" do
+      game.should_receive(:is_over?).and_return(true)
+      game.start
+      game.ui.displayed_result.should be_true
+    end
+  end
+
+  describe "valid_move?" do
+    it "is true for a valid move" do
+      game.valid_move?("3").should be_true
+    end
+
+    it "returns false for invalid move" do
+      game.set_spaces("1234X6789")
+      game.valid_move?("5").should be_false
+    end
+  end
+
+  describe "#current_player" do
+    it "returns for X" do
+      player = game.current_player('_________')
+      player.should == game.player_one
+    end
+
+    it "returns for O" do
+      player = game.current_player("X_________")
+      player.should == game.player_two
+    end
+
+    it "returns X after moves are made" do
+      player = game.current_player("X__O______")
+      player.should == game.player_one
+    end
+  end
+
+  describe "#play_game" do
+    let(:config) {{:player_one => :ai, :player_two => :human, :game_board => '_________'}}
+
+    it "checks for game over" do
+      config[:player_one] = :human
+      config[:player_two] = :ai
+      config[:game_board] = "O2O45X789"
+      game = described_class.play_game(ui, config)
+      game.board.to_s.should == "OOO45X789"
+      game.over.should be_true
+    end
+
+    it "asks player for their move" do
+      config[:game_board] = "12345X789"
+      described_class.play_game(ui, config)
+      ui.asked_move.should be_true
+    end
+
+    it "doesnt make a move for the human" do
+      config[:player_one] = :human
+      new_game = described_class.play_game(ui, config, "4")
+      new_game.board.to_s.should == "123X56789"
+    end
+
+    it "ends game when game is over" do
+      config[:game_board] = "XXX456789"
+      new_game = described_class.play_game(ui, config)
+      new_game.over.should be_true
+    end
+
+    it "makes a move if computer is first and board is empty" do
+      new_game = described_class.play_game(ui, config)
+      new_game.board.to_s.should == "X23456789"
+      player = game.current_player(new_game.board.to_s)
+      player.should == game.player_two
+    end
+
+    it "doesnt make a move when game is over" do
+      config[:game_board] = "OOO456789"
+      new_game = described_class.play_game(ui, config)
+      new_game.board.to_s.should == "OOO456789"
+    end
+
+    it "lets human make first move" do
+      config[:player_one] = :human
+      new_game = described_class.play_game(ui, config, "5")
+      new_game.board.to_s.should == "1234X6789"
+    end
+
+    it "makes a move when computer is second turn" do
+      config[:player_one] = :human
+      config[:player_two] = :ai
+      config[:game_board] = "12X456789"
+      new_game = described_class.play_game(ui, config)
+      new_game.board.to_s.should == "O2X456789"
+    end
+  end
+
+  describe "#place_move" do
+    it "places move on the board" do
+      game.place_move("X", "4")
+      game.board.spaces.should == %w(1 2 3 X 5 6 7 8 9)
+    end
+  end
+
+  describe "#make_moves" do
+    it "receives output" do
+      game.ui.should_receive(:ask_move).and_return(-1, 4)
+      game.ui.output.should_receive(:puts)
+      game.ask_move(game.player_one)
+    end
+
+    it "prints the board when the game is over and its human v human" do
+      game.ui.should_receive(:ask_move).once
+      game.player_two.stub(:class).and_return(TicTacToe::Human)
+      game.ui.stub(:ask_move).and_return("5")
+      game.set_spaces("123X5X789")
+      game.make_moves
+    end
+
+    it "prints the board" do
+      game.ui.should_receive(:print_board)
+      game.make_moves
+    end
+  end
+
+  describe "#get_move" do
+    it "makes the human move" do
+      game.player_one.stub(:class).and_return(TicTacToe::Human)
+      game.ui.should_receive(:ask_move).and_return("1")
+      game.get_move(game.player_one).should == "1"
+    end
+
+    it "makes a computer move" do
+      game.player_one.stub(:class).and_return(TicTacToe::AI)
+      game.player_one.should_receive(:make_move).with(game.board).and_return("2")
+      game.get_move(game.player_one).should == "2"
+    end
+  end
+end

data/spec/human_spec.rb

@@ -0,0 +1,16 @@
+require 'human'
+
+describe TicTacToe::Human do
+  let(:human) { human = described_class.new('X')}
+
+  describe "#new" do
+    it "creates a player with a mark" do
+      human.mark.should == "X"
+    end
+
+    it "makes a move on the board" do
+      board = TicTacToe::Board.new
+      human.make_move(1, board)
+    end
+  end
+end

data/spec/player_factory_spec.rb

@@ -0,0 +1,29 @@
+require 'player_factory'
+require 'human'
+
+def unbeatable_ai
+  TicTacToe::AIRules::UnbeatableAI
+end
+
+describe TicTacToe::PlayerFactory  do
+  let(:player_factory) { described_class }
+
+  it "creates a human player" do
+    input = { type: :human, mark: :X }
+    player = player_factory.create(input)
+    player.should be_an_instance_of(TicTacToe::Human)
+    player.mark.should == :X
+  end
+
+  it "creates a computer player" do
+    input = {type: :ai, mark: :O, opponent_mark: :X, difficulty: unbeatable_ai }
+    player = player_factory.create(input)
+    player.should be_an_instance_of(TicTacToe::AI)
+    player.mark.should == :O
+  end
+
+  it "raises expection if input isn't correct" do
+    input = {type: :something, mark: :G}
+    expect { player_factory.create(input)}.to raise_error("Invalid Player Type")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ttt_gem_8thlight
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Meagan Waller
@@ -9,14 +9,58 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2013-10-06 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Tic Tac Toe Gem
 email: meaganewaller@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/ttt.rb
+- README.md
+- Rakefile
+- lib/ai/ai_factory.rb
+- lib/ai/unbeatable_ai.rb
+- lib/ai.rb
+- lib/board.rb
+- lib/game.rb
+- lib/human.rb
+- lib/mock_ui.rb
+- lib/player_factory.rb
+- spec/ai/ai_factory_spec.rb
+- spec/ai/unbeatable_ai_spec.rb
+- spec/ai_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/human_spec.rb
+- spec/player_factory_spec.rb
 homepage: http://rubygems.org/gems/ttt_gem_8thlight
 licenses:
 - MIT

data/lib/ttt.rb

@@ -1,80 +0,0 @@
-class TTT
-  PLAYER_ONE = 'x'
-  PLAYER_TWO = 'o'
-  
-  attr_accessor :board, :current_player
-
-  def initialize(board = Array.new(9) {"-"}, current_player = PLAYER_ONE)
-    @board = board
-    @current_player = current_player 
-  end
-
-  def make_move(space)
-    @board[space] = @current_player
-    @current_player = @current_player == PLAYER_ONE ? PLAYER_TWO : PLAYER_ONE
-  end
-  
-  def available_spaces
-    @board.map.with_index { |space, index| index if space == '-' }.compact
-  end
-
-  def new_board_with_move(space)
-    board_with_current_player = deep_copy
-    board_with_current_player.make_move(space)
-    board_with_current_player
-  end
-
-  def deep_copy
-    copy = dup
-    copy.board = board.dup
-    copy.current_player = current_player.dup
-    copy
-  end
-
-  def possible_boards
-    available_spaces.map { |space| new_board_with_move(space) }
-  end
-
-  def possible_values
-    possible_boards.map { |board| board.minimax }
-  end
-
-  def best_move
-    return available_spaces.max_by { |space| new_board_with_move(space).minimax } if @current_player == PLAYER_ONE
-    return available_spaces.min_by { |space| new_board_with_move(space).minimax } if @current_player == PLAYER_TWO 
-  end
-
-  def minimax
-    return 100 if x_won 
-    return -100 if o_won 
-    return 0 if tie
-    return possible_values.max + available_spaces.count if @current_player == PLAYER_ONE 
-    return possible_values.min - available_spaces.count if @current_player == PLAYER_TWO 
-  end
-
-  def x_won
-    winning_player?(PLAYER_ONE)
-  end
-
-  def o_won
-    winning_player?(PLAYER_TWO)
-  end
-
-  def tie
-    !winning_player?(PLAYER_ONE) &&
-    !winning_player?(PLAYER_TWO) &&
-    available_spaces.count == 0
-  end
-
-  def winning_player?(current_player)
-    return true if @board[0..2]                      == [current_player] * 3
-    return true if @board[3..5]                      == [current_player] * 3
-    return true if @board[6..8]                      == [current_player] * 3
-    return true if [@board[0], @board[3], @board[6]] == [current_player] * 3
-    return true if [@board[1], @board[4], @board[7]] == [current_player] * 3
-    return true if [@board[2], @board[5], @board[8]] == [current_player] * 3
-    return true if [@board[0], @board[4], @board[8]] == [current_player] * 3
-    return true if [@board[2], @board[4], @board[6]] == [current_player] * 3
-  end
-end
-