nick_tac_toe 0.1.4

data/bin/nick_tac_toe

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require 'nick_tac_toe'
+
+players = [Human.new("x"), Minimax.new("o")]
+players.shuffle!
+game = Game.new(players.first, players.last)
+
+# the main game loop!
+until game.over?
+  game.board.print
+  game.take_next_turn
+end
+
+# displays the winner
+game.board.print
+if game.won? == true
+  puts "We have a winner! o__o"
+else
+  puts "It is a draw. u__u"
+end

data/lib/nick_tac_toe/board.rb

@@ -0,0 +1,140 @@
+class Board
+  
+  attr_accessor :player_one, :player_two, :cells
+    
+  def initialize(player_one, player_two)
+    @cells = [empty_spot]*9
+    @player_one = player_one
+    @player_two = player_two
+  end
+  
+  def print
+    list = []
+    cells.each_with_index do |marker, index|
+      if marker == empty_spot
+        list << index+1
+      else
+        list << marker
+      end
+    end
+    list.map! do |m|
+      case m
+      when 'x'
+        "\e[1;36mx\e[0m"
+      when 'o'
+        "\e[1;33mo\e[0m"
+      else
+        "\e[1;30m#{m}\e[0m"
+      end
+    end
+    puts "\n#{list[0]} | #{list[1]} | #{list[2]}\n----------\n#{list[3]} | #{list[4]} | #{list[5]}\n----------\n#{list[6]} | #{list[7]} | #{list[8]}\n "
+  end
+  
+  def get_cell position
+    @cells[position]
+  end
+
+  def set_cell position, team
+    @cells[position] = team
+  end
+  
+  def rows
+    [@cells[0..2], @cells[3..5], @cells[6..8]]
+  end
+
+  def columns
+    [
+      [@cells[0], @cells[3], @cells[6]],
+      [@cells[1], @cells[4], @cells[7]],
+      [@cells[2], @cells[5], @cells[8]]
+    ]
+  end
+  
+  def diagonals
+    [
+      [@cells[0], @cells[4], @cells[8]],
+      [@cells[2], @cells[4], @cells[6]],
+    ]
+  end
+  
+  def valid_move?(position)
+    if [0,1,2,3,4,5,6,7,8].include?(position.to_i-1)
+      if get_cell(position-1) == empty_spot
+        return true
+      end
+    else
+      return false
+    end
+  end
+  
+  def blocking_group_for(team)
+    3.times do |i| # rows
+      return [3*i, 3*i + 1, 3*i + 2] if rows[i].sort == [empty_spot, opponent_for(team), opponent_for(team)]
+    end
+
+    3.times do |i| # columns
+      return [i, i + 3, i + 6] if columns[i].sort == [empty_spot, opponent_for(team), opponent_for(team)]
+    end
+    
+    return [0, 4, 8] if diagonals[0].sort == [empty_spot, opponent_for(team), opponent_for(team)]
+    return [2, 4, 6] if diagonals[1].sort == [empty_spot, opponent_for(team), opponent_for(team)]
+
+    return nil
+  end
+  
+  def empty_spot_in_group(group)
+    empty_spots = group.select do |position|
+      get_cell(position) == empty_spot
+    end
+    return empty_spots.first
+  end
+  
+  def winning_group_for(team)
+    blocking_group_for(opponent_for(team))
+  end
+
+  def center
+    4
+  end
+  
+  def empty_at_center?
+    get_cell(4) == empty_spot
+  end
+  
+  def first_empty_cell
+    @cells.each_with_index do |cell, index|
+      return index if cell == empty_spot
+    end
+  end
+  
+  def opponent_for(team)
+    if team == @player_one
+      return @player_two
+    else
+      return @player_one
+    end
+  end
+ 
+ def remaining_moves
+   count = []
+   9.times do |index|
+     count << index if @cells[index] == empty_spot
+   end
+   return count
+ end
+ 
+ def copy
+   new_board = self.dup
+   new_board.cells = @cells.dup
+#   new_board.player_one = @player_one.dup
+#   new_board.player_one = @player_two.dup
+   return new_board
+ end
+
+  private ################################
+  
+  def empty_spot
+    ""
+  end
+  
+end

data/lib/nick_tac_toe/game.rb

@@ -0,0 +1,61 @@
+require 'nick_tac_toe/board'
+
+class Game
+  attr_reader :board, :current_player, :player_one, :player_two
+
+  def initialize(player_one, player_two)
+    @board = Board.new(player_one.team, player_two.team)
+    @player_one = player_one
+    @player_two = player_two
+    @current_player = player_one
+  end
+  
+  def take_next_turn
+    make_move(current_player.move_for(board))
+  end
+  
+  def make_move(position)
+    @board.set_cell(position, current_player.team)
+    toggle_current_player
+  end
+  
+  def over?
+    return true if draw? || won?
+  end
+
+  def draw?
+    return false if won?
+    return board.cells.all? {|cell| cell == @player_one.team || cell == @player_two.team }
+  end
+  
+  def won?
+    return true if board.rows.any? { |row| winner_in_group(row) }
+    return true if board.columns.any? { |column| winner_in_group(column) }
+    return true if board.diagonals.any? { |diagonal| winner_in_group(diagonal) }
+  end
+  
+  def winner_in_group(group)
+    group == [@player_two.team]*3 || group == [@player_one.team]*3
+  end
+  
+  def player_won?(player)
+    return true if board.rows.any? { |row| row == [player.team]*3 }
+    return true if board.columns.any? { |column| column == [player.team]*3 }
+    return true if board.diagonals.any? { |diagonal| diagonal == [player.team]*3 }
+  end
+  
+  def winner
+    return player_one if player_won?(player_one)
+    return player_two if player_won?(player_two)
+  end
+  
+  private
+  
+  def toggle_current_player
+    if @current_player == @player_one
+      @current_player = @player_two
+    else
+      @current_player = @player_one
+    end 
+  end
+end

data/lib/nick_tac_toe/human.rb

@@ -0,0 +1,12 @@
+class Human < Player  
+  def move_for(board)
+    puts "Where will you move? Pick an empty space, 1-9."
+    move_choice = gets.chomp.to_i
+    while !board.valid_move?(move_choice)
+      puts "That is not a valid move!"
+      move_choice = gets.chomp.to_i
+    end
+    return move_choice - 1
+  end
+end
+

data/lib/nick_tac_toe/minimax.rb

@@ -0,0 +1,58 @@
+class Minimax < Player
+  def move_for(board)
+    get_max_move(board).position
+  end
+  
+
+  def get_max_move(board)
+    current_max_move = Move.new(0, -1)
+    board.remaining_moves.each do |remaining_move|
+      new_board = board.copy
+      new_board.set_cell(remaining_move, team)
+      return Move.new(remaining_move, 1) if player_won?(team, new_board)
+      return Move.new(remaining_move, 0) if new_board.cells.all? { |cell| cell == new_board.player_one || cell == new_board.player_two }
+      return Move.new(remaining_move, -1) if player_won?(new_board.opponent_for(team), new_board)
+      new_rating = get_min_move(new_board).rating
+      if new_rating > current_max_move.rating
+        current_max_move = Move.new(remaining_move, new_rating)
+      end
+    end
+    return current_max_move
+  end
+
+  def get_min_move(board)
+    current_min_move = Move.new(0, 1)
+    board.remaining_moves.each do |remaining_move|
+      new_board = board.copy
+      new_board.set_cell(remaining_move, new_board.opponent_for(team));
+      return Move.new(current_min_move.position, 1) if player_won?(team, new_board)
+      return Move.new(current_min_move.position, 0) if new_board.cells.all? { |cell| cell == new_board.player_one || cell == new_board.player_two }
+      return Move.new(current_min_move.position, -1) if player_won?(new_board.opponent_for(team), new_board)
+      new_rating = get_max_move(new_board).rating
+      if new_rating < current_min_move.rating
+        current_min_move = Move.new(remaining_move, new_rating)
+      end
+    end
+    return current_min_move
+  end
+
+  def player_won?(team, board)
+    return true if board.rows.any? { |row| row == [team]*3 }
+    return true if board.columns.any? { |column| column == [team]*3 }
+    return true if board.diagonals.any? { |diagonal| diagonal == [team]*3 }
+  end
+  
+  def computer?
+    true
+  end
+
+  private #################
+
+  def winning_group(board)
+    board.winning_group_for(@team)
+  end
+  
+  def blocking_group(board)
+    board.blocking_group_for(@team)
+  end
+end

data/lib/nick_tac_toe/move.rb

@@ -0,0 +1,7 @@
+class Move
+  attr_accessor :position, :rating
+  def initialize(position, rating)
+    @position = position
+    @rating = rating
+  end
+end

data/lib/nick_tac_toe/player.rb

@@ -0,0 +1,11 @@
+class Player
+  attr_reader :team
+  
+  def initialize(team)
+    @team = team
+  end
+  
+  def computer?
+    false
+  end
+end

data/lib/nick_tac_toe/setup.rb

@@ -0,0 +1,12 @@
+def get_player_team
+  puts "Choose a team (x or o)"
+  input = gets.chomp
+  unless input == "x" || input == "X" || input == "o" || input == "O"
+    puts "That is neither x nor o!"
+    get_player_team
+  else
+    input = "x" if input == "X"
+    input = "o" if input == "O"
+    return input
+  end
+end

data/lib/nick_tac_toe.rb

@@ -0,0 +1,7 @@
+require 'nick_tac_toe/board'
+require 'nick_tac_toe/game'
+require 'nick_tac_toe/player'
+require 'nick_tac_toe/human'
+require 'nick_tac_toe/minimax'
+require 'nick_tac_toe/move'
+require 'nick_tac_toe/setup'

data/spec/board_spec.rb

@@ -0,0 +1,255 @@
+require "nick_tac_toe"
+
+describe Board do
+  it "has a team for the computer player" do
+    board = Board.new("o", "x")
+    board.player_one.should == "o"
+  end
+  
+  it "has a team for the opponent" do
+    board = Board.new("o", "x")
+    board.player_two.should == "x"
+  end
+  
+  it "gets a cell" do
+    board = Board.new("o", "x")
+    board.get_cell(0).should == ""
+  end
+  
+  it "sets a cell" do
+    board = Board.new("o", "x")
+    board.set_cell(0, "x")
+    board.get_cell(0).should == "x"
+  end
+  
+  it "returns the board as rows" do
+    board = Board.new("o", "x")
+    board.set_cell(0, "x")
+    board.set_cell(3, "x")
+    board.set_cell(6, "x")    
+    board.rows.should == [["x", "", ""],["x", "", ""],["x", "", ""]]
+  end
+
+  it "returns the board as coulmns" do
+    board = Board.new("o", "x")
+    board.set_cell(0, "x")
+    board.set_cell(3, "x")
+    board.set_cell(6, "x")    
+    board.columns.should == [["x", "x", "x"],["", "", ""],["", "", ""]]
+  end
+
+  it "returns the board as diagonals" do
+    board = Board.new("o", "x")
+    board.set_cell(0, "x")
+    board.set_cell(3, "x")
+    board.set_cell(6, "x")    
+    board.diagonals.should == [["x", "", ""],["", "", "x"]]
+  end
+  
+  it "is valid for an in range move on an empty board" do
+    board = Board.new("o", "x")
+    board.valid_move?(3).should be_true
+  end
+
+  it "is not valid for a move out of range on an empty board" do
+    board = Board.new("o", "x")
+    board.valid_move?(-1).should be_false
+  end
+
+  it "is not valid for a move to a space that is not empty" do
+    board = Board.new("o", "x")
+    board.set_cell(4, "x")
+    board.valid_move?(5).should be_false
+  end
+
+  it "is not valid for a string to be a move" do
+    board = Board.new("o", "x")
+    board.valid_move?("s").should be_false
+  end
+
+  context "blocking_group_for" do
+    before(:each) do
+      @board = Board.new("o", "x")
+    end
+
+    it "finds the first row as a blocking group" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.blocking_group_for("o").should == [0,1,2]
+    end
+  
+    it "returns nothing if there is nowhere to block" do
+      @board.blocking_group_for("o").should == nil
+    end
+  
+    it "returns the second row" do
+      @board.set_cell(3, "x")
+      @board.set_cell(4, "x")
+      @board.blocking_group_for("o").should == [3,4,5]
+    end
+  
+    it "returns the second row if you can block in the center" do
+      @board.set_cell(3, "x")
+      @board.set_cell(5, "x")
+      @board.blocking_group_for("o").should == [3,4,5]
+    end
+  
+    it "returns a blocking row for the other team" do
+      @board.set_cell(3, "o")
+      @board.set_cell(5, "o")
+      @board.blocking_group_for("x").should == [3,4,5]
+    end
+  
+    it "does not return a row that is full" do
+      @board.set_cell(3, "o")
+      @board.set_cell(4, "x")
+      @board.set_cell(5, "o")
+      @board.blocking_group_for("x").should == nil
+    end
+
+    it "finds the first column as a blocking group" do
+      @board.set_cell(0, "x")
+      @board.set_cell(3, "x")
+      @board.blocking_group_for("o").should == [0,3,6]
+    end
+  
+    it "finds the second column as a blocking group" do
+      @board.set_cell(1, "x")
+      @board.set_cell(4, "x")
+      @board.blocking_group_for("o").should == [1,4,7]
+    end
+  
+    it "finds the third column as a blocking group" do
+      @board.set_cell(2, "x")
+      @board.set_cell(5, "x")
+      @board.blocking_group_for("o").should == [2,5,8]
+    end
+  
+    it "finds the first diagonal as a blocking group" do
+      @board.set_cell(0, "x")
+      @board.set_cell(4, "x")
+      @board.blocking_group_for("o").should == [0,4,8]
+    end
+  
+    it "finds the other diagonal as a blocking group" do
+      @board.set_cell(2, "x")
+      @board.set_cell(4, "x")
+      @board.blocking_group_for("o").should == [2,4,6]
+    end
+  end
+  
+  context "empty_spot_in_group" do
+    before(:each) do
+      @board = Board.new("o", "x")
+    end
+    
+    it "returns the first spot" do
+      @board.set_cell(1, "x")
+      @board.set_cell(2, "o")
+      @board.empty_spot_in_group([0,1,2]).should == 0
+    end
+
+    it "returns the first spot" do
+      @board.set_cell(0, "x")
+      @board.set_cell(2, "o")
+      @board.empty_spot_in_group([0,1,2]).should == 1
+    end
+    
+    it "returns the third spot" do
+      @board.set_cell(2, "x")
+      @board.set_cell(4, "o")
+      @board.empty_spot_in_group([2,4,6]).should == 6
+    end
+    
+    it "returns nil if the row is full" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.set_cell(2, "o")
+      @board.empty_spot_in_group([0,1,2]).should == nil
+    end
+  end
+  
+  context "winning_group_for" do
+    before(:each) do
+      @board = Board.new("o", "x")
+    end
+
+    it "finds the first row as a winning group" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.winning_group_for("x").should == [0,1,2]
+    end
+    
+    it "finds the first column as a winning group" do
+      @board.set_cell(0, "x")
+      @board.set_cell(3, "x")
+      @board.winning_group_for("x").should == [0,3,6]
+    end
+  end
+
+  context "remaining_moves" do
+    before(:each) do
+      @board = Board.new("o", "x")
+    end
+    it "calculates the number of remaining moves when there is one spot left" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.set_cell(2, "o")
+      @board.set_cell(3, "x")
+      @board.set_cell(4, "x")
+      @board.set_cell(5, "o")
+      @board.set_cell(6, "x")
+      @board.set_cell(7, "x")
+      @board.remaining_moves.should == [8]
+    end
+    
+    it "calculates the number of remaining moves when there are two spots left" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.set_cell(2, "o")
+      @board.set_cell(3, "x")
+      @board.set_cell(4, "x")
+      @board.set_cell(5, "o")
+      @board.set_cell(6, "x")
+      @board.remaining_moves.should == [7,8]
+    end
+
+    it "calculates the number of remaining moves when there are no spots left" do
+      @board.set_cell(0, "x")
+      @board.set_cell(1, "x")
+      @board.set_cell(2, "o")
+      @board.set_cell(3, "x")
+      @board.set_cell(4, "x")
+      @board.set_cell(5, "o")
+      @board.set_cell(6, "x")
+      @board.set_cell(7, "x")
+      @board.set_cell(8, "x")
+      @board.remaining_moves.should == []
+    end
+  end
+  
+  context "dup" do
+    before(:each) do
+      @board = Board.new("o", "x")
+    end
+    it "returns a copy of the board" do
+      @board.set_cell(1,"x")
+      new_board = @board.copy
+      new_board.get_cell(1).should == "x"
+    end
+    
+    it "does not affect the original board when changing the new board" do
+      @board.set_cell(1,"x")
+      new_board = @board.copy
+      new_board.set_cell(0, "o")
+      @board.get_cell(0).should_not == "o"
+    end
+
+    it "dups players!" do
+      new_board = @board.copy
+      new_board.player_one = "f"
+      @board.player_one.should_not == "f"
+    end
+
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,181 @@
+require "nick_tac_toe"
+
+describe "Game" do
+  
+  before(:each) do
+    @player_one = Human.new("x")
+    @player_two = Human.new("o")
+    @game = Game.new(@player_one, @player_two)
+  end
+
+  context "Game over" do
+    it "starts with player one as the current player" do
+      @game.current_player.should == @player_one
+    end
+    
+    it "makes a move on the board" do
+      @game.make_move(1)
+      @game.board.get_cell(1).should == @player_one.team
+    end
+    
+    it "makes a move using player twos team" do
+      @game.make_move(1)
+      @game.make_move(2)
+      @game.board.get_cell(2).should == @player_two.team
+    end
+    
+    it "switches to player two's turn" do
+      @game.make_move(2)
+      @game.current_player.should == @player_two
+    end
+    
+    it "switches back to player one" do
+      @game.make_move(2)
+      @game.make_move(2)
+      @game.current_player.should == @player_one
+    end
+    
+    it "does not call the game a draw if the board is not full" do
+      @game.board.set_cell(0, "x")
+      @game.draw?.should be_false
+    end
+    
+    it "is not a draw if the game is full with a winner" do
+      @game.board.set_cell(0, "o")
+      @game.board.set_cell(1, "o")
+      @game.board.set_cell(2, "o")
+      @game.board.set_cell(3, "o")
+      @game.board.set_cell(4, "x")
+      @game.board.set_cell(5, "x")
+      @game.board.set_cell(6, "o")
+      @game.board.set_cell(7, "x")
+      @game.board.set_cell(8, "x")
+      @game.draw?.should be_false
+    end
+    
+    it "has no winner for new game" do
+      @game.winner.should be_nil
+    end
+
+    it "has player one as the winner" do
+      @game.board.set_cell(0, "x")
+      @game.board.set_cell(3, "o")
+      @game.board.set_cell(1, "x")
+      @game.board.set_cell(4, "o")
+      @game.board.set_cell(2, "x")
+      @game.winner.should == @game.player_one
+    end
+    
+    it "has player two as the winner" do
+      @game.board.set_cell(0, "x")
+      @game.board.set_cell(3, "o")
+      @game.board.set_cell(1, "x")
+      @game.board.set_cell(4, "o")
+      @game.board.set_cell(8, "x")
+      @game.board.set_cell(5, "o")
+      @game.winner.should == @game.player_two
+    end
+
+    it "has no winner for draw game" do
+      @game.board.set_cell(0, "x")
+      @game.board.set_cell(1, "o")
+      @game.board.set_cell(2, "x")
+      @game.board.set_cell(3, "x")
+      @game.board.set_cell(4, "o")
+      @game.board.set_cell(5, "o")
+      @game.board.set_cell(6, "o")
+      @game.board.set_cell(7, "x")
+      @game.board.set_cell(8, "x")
+      @game.winner.should be_nil
+    end
+    # new tests end
+    
+    
+    it "knows that the game a draw if the board is full" do
+      # x o x
+      # x o o
+      # o x x
+      @game.board.set_cell(0, "x")
+      @game.board.set_cell(1, "o")
+      @game.board.set_cell(2, "x")
+      @game.board.set_cell(3, "x")
+      @game.board.set_cell(4, "o")
+      @game.board.set_cell(5, "o")
+      @game.board.set_cell(6, "o")
+      @game.board.set_cell(7, "x")
+      @game.board.set_cell(8, "x")
+      @game.draw?.should be_true
+    end
+    
+    it "knows that three horizonal marks is a win" do
+      @game.board.set_cell(0, "o")
+      @game.board.set_cell(1, "o")
+      @game.board.set_cell(2, "o")
+      @game.won?.should be_true
+    end
+    
+    it "knows that three vertical marks is a win" do
+      @game.board.set_cell(0, "o")
+      @game.board.set_cell(3, "o")
+      @game.board.set_cell(6, "o")
+      @game.won?.should be_true
+    end
+    
+    it "knows that three diagonal marks is a win" do
+      @game.board.set_cell(0, "o")
+      @game.board.set_cell(4, "o")
+      @game.board.set_cell(8, "o")
+      @game.won?.should be_true
+    end
+    
+    it "knows if there is not a winner in a group" do
+      @game.winner_in_group(["x","x","o"]).should be_false
+    end
+
+    it "knows if there is a winner in a group" do
+      @game.winner_in_group(["x","x","x"]).should be_true
+    end
+    
+    it "knows if a specific player won in a row" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(1, @player_one.team)
+      @game.board.set_cell(2, @player_one.team)      
+      @game.player_won?(@player_one).should be_true
+    end
+    
+    it "returns false if the other player won in a row" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(1, @player_one.team)
+      @game.board.set_cell(2, @player_one.team)      
+      @game.player_won?(@player_two).should be_false
+    end
+
+    it "knows if a specific player won in a column" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(3, @player_one.team)
+      @game.board.set_cell(6, @player_one.team)      
+      @game.player_won?(@player_one).should be_true
+    end
+    
+    it "returns false if the other player won in a column" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(3, @player_one.team)
+      @game.board.set_cell(6, @player_one.team)      
+      @game.player_won?(@player_two).should be_false
+    end
+
+    it "knows if a specific player won in a diagonal" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(4, @player_one.team)
+      @game.board.set_cell(8, @player_one.team)      
+      @game.player_won?(@player_one).should be_true
+    end
+    
+    it "returns false if the other player won in a diagonal" do
+      @game.board.set_cell(0, @player_one.team)
+      @game.board.set_cell(4, @player_one.team)
+      @game.board.set_cell(8, @player_one.team)      
+      @game.player_won?(@player_two).should be_false
+    end
+  end
+end

data/spec/minimax_spec.rb

@@ -0,0 +1,76 @@
+require "nick_tac_toe"
+
+describe "Minimax" do
+  before(:each) do
+    @board = Board.new("o", "x")
+    @minimax = Minimax.new("o")
+  end
+  
+  it "blocks the opponent" do
+    # o - -
+    # x x -
+    # - - -
+    @board.set_cell(0, "o")
+    @board.set_cell(3, "x")
+    @board.set_cell(4, "x")
+    @minimax.move_for(@board).should == 5
+  end
+
+  xit "should win" do
+    @board.set_cell(0, "o")
+    @board.set_cell(1, "o")
+    @minimax.move_for(@board).should == 2
+  end
+  
+  it "places a mark in the last available spot on the board" do
+    # 0 1 2     x x o
+    # 3 4 5     o o x
+    # 6 7 8     x o x
+    @board.set_cell(0, "x")
+    @board.set_cell(1, "x")
+    @board.set_cell(2, "o")
+    @board.set_cell(3, "o")
+    @board.set_cell(4, "o")
+    @board.set_cell(5, "x")
+    @board.set_cell(6, "x")
+    @board.set_cell(8, "x")
+    @minimax.move_for(@board).should == 7
+  end
+
+  xit "places in the top left corner if it goes first" do
+    @minimax.move_for(@board).should == 0
+  end
+  
+  it "avoids this trap I made!" do
+    # x 1 2
+    # 3 o 5
+    # 6 x 8
+    @board.set_cell(0, "x")
+    @board.set_cell(4, "o")
+    @board.set_cell(7, "x")
+    @minimax.move_for(@board).should == 3
+  end
+  
+  it "avoids the classic trap!" do
+    @board.set_cell(0, "x")
+    @minimax.move_for(@board).should == 4    
+  end
+
+  it "should avoid stage 2 of the classic trap!" do
+    @board.set_cell(0, "x")
+    @board.set_cell(4, "o")
+    @board.set_cell(8, "x")
+    @minimax.move_for(@board).should_not == 2    
+  end
+  
+  it "should avoid stage 2 of the classic trap part 2!" do
+    @board.set_cell(0, "x")
+    @board.set_cell(4, "o")
+    @board.set_cell(8, "x")
+    @minimax.move_for(@board).should_not == 6
+  end
+  
+  it "is a computer" do
+    Minimax.new("o").should be_computer
+  end
+end

data/spec/move_spec.rb

@@ -0,0 +1,13 @@
+require "nick_tac_toe"
+
+describe Move do
+  it "has a position" do
+    move = Move.new("position", nil)
+    move.position.should == "position"
+  end
+  
+  it "has a rating" do
+    move = Move.new(nil, "rating")
+    move.rating.should == "rating" 
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,11 @@
+require "nick_tac_toe"
+
+describe "Player" do
+  it "has a team" do
+    Player.new("team").team.should == "team"
+  end
+  
+  it "is not a computer by default" do
+    Player.new(nil).should_not be_computer
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: nick_tac_toe
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.4
+platform: ruby
+authors: 
+- Nick Meccia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Your mum.
+email: nickmeccia@gmail.com
+executables: 
+- nick_tac_toe
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/nick_tac_toe
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/minimax_spec.rb
+- spec/move_spec.rb
+- spec/player_spec.rb
+- lib/nick_tac_toe/board.rb
+- lib/nick_tac_toe/game.rb
+- lib/nick_tac_toe/human.rb
+- lib/nick_tac_toe/minimax.rb
+- lib/nick_tac_toe/move.rb
+- lib/nick_tac_toe/player.rb
+- lib/nick_tac_toe/setup.rb
+- lib/nick_tac_toe.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Yes, sir.
+test_files: []
+