tic_tac_toe_nhu 0.0.2

data/spec/tic_tac_toe/rules_spec.rb

@@ -0,0 +1,185 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/rules'
+require 'tic_tac_toe/board'
+
+describe TicTacToe::Rules do
+
+  before(:each) do
+    @player = "X"
+    @opponent = "O"
+    @board = TicTacToe::Board.new(3)
+    @rules = TicTacToe::Rules.new(@board)
+  end
+
+  context "game is not over" do
+    it "when no one made a move" do
+      @rules.should_not be_game_over
+    end
+
+    it "when there is only one marked square" do
+      mark([0], @player)
+      @rules.should_not be_game_over
+    end
+
+    it "when there is no winner and there is one square left" do
+      (1...@board.size**2).each {|i| @board.mark(i, i)}
+      @rules.should_not be_game_over
+    end
+  end
+
+  context "tie" do
+    it "is not a tied when there is no mark on the board" do
+      @rules.should_not be_tied
+    end
+
+    it "is not a tied when there is a winner" do
+      mark([0, 1, 2], @player)
+      @rules.should_not be_tied
+    end
+
+    it "is not tied when there is a winner and the board is filled" do
+      mark([0, 2, 4, 6, 8], @player)
+      mark([1, 3, 5, 7], @opponent)
+      @rules.should_not be_tied
+    end
+
+    it "is tied when there is no winner and the board is filled" do
+      mark([0, 2, 3, 4, 7], @player)
+      mark([1, 5, 6, 8], @opponent)
+      @rules.should be_tied
+    end
+  end
+
+  context "game over when there is a winner" do
+    it "when player wins horizontally" do
+      mark([0, 1, 2], @player)
+      @rules.should be_game_over
+    end
+
+    it "when player wins vertially" do
+      mark([1, 4, 7], @player)
+      @rules.should be_game_over
+    end
+
+    it "when player wins diagonally" do
+      mark([2, 4, 6], @player)
+      @rules.should be_game_over
+    end
+
+    it "when opponent wins" do
+      mark([0, 4, 8], @opponent)
+      @rules.should be_game_over
+    end
+  end
+
+  it "game over when there is a tie" do
+    mark((0...@board.size**2).to_a, "i")
+    @rules.should be_game_over
+  end
+
+
+  context "winner" do
+    context "wins horizontally" do
+      it "is the player when player marks all the first row" do
+        mark([0, 1, 2], @player)
+        @rules.winner.should == @player
+      end
+
+      it "is the player when player marks all the middle row" do
+        mark([3, 4, 5], @player)
+        @rules.winner.should == @player
+      end
+
+      it "is the player when player marks all the last row" do
+        mark([6, 7, 8], @player)
+        @rules.winner.should == @player
+      end
+
+      it "is the opponent when opponent marks all the middle row" do
+        mark([3, 4, 5], @opponent)
+        @rules.winner.should == @opponent
+      end
+
+      it "is nil when player marks two horizontal squares" do
+        mark([0, 1], @player)
+        @rules.winner.should be_nil
+      end
+
+      it "is nil when player marks two squares and opponent marks one" do
+        mark([0, 2], @player)
+        mark([1], @opponent)
+        @rules.winner.should be_nil
+      end
+    end
+
+    context "wins vertically" do
+      it "is the opponent when opponent marks all the first column" do
+        mark([0, 3, 6], @opponent)
+        @rules.winner.should == @opponent
+      end
+
+      it "is the opponent when opponent marks all the middle column" do
+        mark([1, 4, 7], @opponent)
+        @rules.winner.should == @opponent
+      end
+
+      it "is the opponent when opponent marks the last column" do
+        mark([2, 5, 8], @opponent)
+        @rules.winner.should == @opponent
+      end
+
+      it "is the player when player marks all the middle column" do
+        mark([1, 4, 7], @player)
+        @rules.winner.should == @player
+      end
+
+      it "is nil when player marks two vertical squares" do
+        mark([2, 5], @player)
+        @rules.winner.should be_nil
+      end
+
+      it "is nil when player marks two squares and opponent marks one" do
+        mark([0, 3], @player)
+        mark([6], @opponent)
+        @rules.winner.should be_nil
+      end
+    end
+
+    context "wins diagonally" do
+      it "is player when player marks all the top left to right diagonal squares" do
+        mark([0, 4, 8], @player)
+        @rules.winner.should == @player
+      end
+
+      it "is opponent when opponent marks all the top right to left diagonal squares" do
+        mark([2, 4, 6], @opponent)
+        @rules.winner.should == @opponent
+      end
+
+      it "is nil when player marks only two top left to right diagonal squares" do
+        mark([0, 4], @player)
+        @rules.winner.should be_nil
+      end
+
+      it "is nil when player marks only two top right to left diagonal squares" do
+        mark([2, 4], @player)
+        @rules.winner.should be_nil
+      end
+
+      it "is nil when player marks two squares and opponent marks one" do
+        mark([0, 4], @player)
+        mark([8], @opponent)
+        @rules.winner.should be_nil
+      end
+    end
+
+    it "is nil when there is a tied" do
+      (@board.size**2).times {|i| @board.mark(i, i)}
+      @rules.winner.should be_nil
+    end
+  end
+
+  def mark(squares, value)
+    squares.each {|i| @board.mark(i, value)}
+  end
+end

data/spec/tic_tac_toe/spec_helper.rb

@@ -0,0 +1,9 @@
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+
+rescue LoadError
+  puts 'Coverage disabled, enable by installing simplecov'
+end

data/spec/tic_tac_toe/strategy/console_user_spec.rb

@@ -0,0 +1,34 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/strategy/console_user'
+
+describe TicTacToe::Strategy::ConsoleUser do
+
+  context "gets move" do
+    before(:each) do
+      @input = StringIO.new
+      @output = StringIO.new
+      @strategy = TicTacToe::Strategy::ConsoleUser.new(@input, @output)
+    end
+
+    it "prompts the user for a move" do
+      @output.should_receive(:puts).with("Please enter a square number that is not marked: ")
+      @input.should_receive(:gets).and_return("3")
+      @strategy.move
+    end
+
+    it "returns a number when user enters a number" do
+      move = "2"
+      @input.should_receive(:gets).and_return(move)
+      @strategy.move.should == move.to_i
+    end
+
+    it "asks for user input again when user enter a character" do
+      invalid_move = "a"
+      valid_move = "2"
+      @input.should_receive(:gets).and_return(invalid_move, invalid_move, valid_move)
+      @output.should_receive(:puts).with("Please enter a square number that is not marked: ").at_least(2).times
+      @strategy.move.should == valid_move.to_i
+    end
+  end
+
+end

data/spec/tic_tac_toe/strategy/minimax_spec.rb

@@ -0,0 +1,163 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/strategy/minimax'
+
+describe TicTacToe::Strategy::Minimax, :slow_test => true do
+
+  before(:each) do
+    @board = TicTacToe::Board.new(3)
+    @opponent = "X"
+    @computer = "O"
+    @strategy = TicTacToe::Strategy::Minimax.new(@board, @computer, @opponent)
+  end
+
+  context "move" do
+    context "when there is only one position left" do
+      it "returns move when it's a winning move" do
+        mark((1...@board.size**2), @computer)
+        @strategy.move.should == 0
+      end
+
+      it "returns the move when it's a tied" do
+        mark([0, 2, 5, 6], @computer)
+        mark([1, 3, 4, 8], @opponent)
+        @strategy.move.should == 7
+      end
+
+      it "returns the move when opponent wins" do
+        mark((0...@board.size**2 - 1).to_a, @opponent)
+        @strategy.move.should == 8
+      end
+    end
+
+    context "when there are two positions left" do
+      it "returns losing scores when the two moves are losing moves" do
+        mark((2...@board.size**2).to_a, @opponent)
+        @strategy.move.should == 0
+      end
+
+      it "returns the first win move when the two moves are winning moves" do
+        mark((2...@board.size**2).to_a, @computer)
+        @strategy.move.should == 0
+      end
+
+      it "returns the first tie move when the two moves are tie moves" do
+        mark([0, 2, 7], @computer)
+        mark([1, 4, 6, 8], @opponent)
+        @strategy.move.should == 3
+      end
+
+      it "returns win move when there are winning and losing moves" do
+        mark([0, 1, 3, 7], @computer)
+        mark([2, 4, 5], @opponent)
+        @strategy.move.should == 6
+      end
+
+      it "returns winning move when there are winning and tie moves" do
+        mark([0, 2, 3, 4], @computer)
+        mark([1, 5, 8], @opponent)
+        @strategy.move.should == 6
+      end
+
+      it "returns tied move when there are losing and tie moves" do
+        mark([2, 3, 4], @computer)
+        mark([0, 5, 6, 7], @opponent)
+        @strategy.move.should == 8
+      end
+
+      context "winning move appear later in the board" do
+        it "returns win move when winning move is later than losing move" do
+          mark([1, 2, 5, 7], @computer)
+          mark([0, 3, 4], @opponent)
+          @strategy.move.should == 8
+        end
+
+        it "returns winning move when winning move is later than tie move" do
+          mark([0, 2, 4, 5], @computer)
+          mark([1, 3, 6], @opponent)
+          @strategy.move.should == 8
+        end
+
+        it "returns tied move when there are losing and tie moves" do
+          mark([2, 3, 4], @computer)
+          mark([0, 5, 6, 7], @opponent)
+          @strategy.move.should == 8
+        end
+      end
+    end
+
+    context "when there are three moves left" do
+      it "chooses the winning move when there is one available" do
+        mark([1, 4], @computer)
+        mark([0, 3, 2, 5], @opponent)
+        @strategy.move.should == 7
+      end
+
+      it "chooses a tie move when there are only losing and tie moves" do
+        mark([1, 4], @computer)
+        mark([0, 2, 5, 7], @opponent)
+        @strategy.move.should == 8
+      end
+    end
+
+    context "when there are 4 moves left" do
+      it "chooses a winning move when one is available" do
+        mark([0, 4], @computer)
+        mark([1, 2, 6], @opponent)
+        @strategy.move.should == 8
+      end
+
+      it "chooses a move that would create 2 winning moves" do
+        mark([0, 6], @computer)
+        mark([1, 3, 5], @opponent)
+        @strategy.move.should == 4
+      end
+    end
+  end
+
+  it "chooses the winning move when available" do
+    mark([1, 4], @computer)
+    mark([0], @opponent)
+    @strategy.move.should == 7
+  end
+
+  it "chooses the winning move when available" do
+    mark([0, 4], @computer)
+    mark([1, 2], @opponent)
+    @strategy.move.should == 8
+  end
+
+  it "chooses a blocking move when there is no winning move" do
+    mark([2], @computer)
+    mark([0, 4], @opponent)
+    @strategy.move.should == 8
+  end
+
+  it "chooses a blocking move when there is no winning move" do
+    mark([2], @computer)
+    mark([1, 4], @opponent)
+    @strategy.move.should == 7
+  end
+
+  it "chooses the middle square when computer is the second player" do
+    mark([0], @opponent)
+    @strategy.move.should == 4
+  end
+
+  it "chooses the first corner of the board when the middle square is taken as a second player" do
+    mark([4], @opponent)
+    @strategy.move.should == 0
+  end
+
+  it "chooses the middle square on the first move" do
+    @strategy.move.should == 4
+  end
+
+  def move_node(move, score)
+    TicTacToe::Move.new(move, score)
+  end
+
+  def mark(squares, value)
+    squares.each {|i| @board.mark(i, value)}
+  end
+end

data/spec/tic_tac_toe/strategy/mock.rb

@@ -0,0 +1,19 @@
+class MockStrategy
+  attr_accessor :moves
+
+  def initialize(moves = [])
+    @moves = moves
+  end
+
+  def add_move(move)
+    @moves << move
+  end
+
+  def move
+    @moves.shift
+  end
+
+  def needs_input?
+    true
+  end
+end

data/spec/tic_tac_toe/ui/console_spec.rb

@@ -0,0 +1,93 @@
+require 'tic_tac_toe/spec_helper'
+require 'tic_tac_toe/ui/console'
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/player'
+
+describe TicTacToe::Console do
+
+  before(:each) do
+    @size = 2
+    @output = StringIO.new
+    @input = StringIO.new
+    @board = TicTacToe::Board.new(2)
+    @console = TicTacToe::Console.new(@input, @output)
+  end
+
+  it "displays welcome message" do
+    @output.should_receive(:puts).with("Welcome to Tic Tac Toe!")
+    @console.display_welcome_message
+  end
+
+  context "displays the board" do
+    it "shows numbers for all unmarked squares" do
+      expected_display = "| 0 | 1 |\n| 2 | 3 |\n"
+      @output.should_receive(:puts).with(expected_display)
+      @console.display_board(@board)
+    end
+
+    it "shows the player value on the marked square" do
+      @board.mark(0, "X")
+      expected_display = "| X | 1 |\n| 2 | 3 |\n"
+      @output.should_receive(:puts).with(expected_display)
+      @console.display_board(@board)
+    end
+
+    it "shows the player values when all the squares are marked" do
+      (0...@size**2).each {|value| @board.mark(value, "O")}
+      expected_display = "| O | O |\n| O | O |\n"
+      @output.should_receive(:puts).with(expected_display)
+      @console.display_board(@board)
+    end
+
+    it "displays a 3x3 board" do
+      @board = TicTacToe::Board.new(3)
+      @console = TicTacToe::Console.new(@input, @output)
+      expected_display = "| 0 | 1 | 2 |\n| 3 | 4 | 5 |\n| 6 | 7 | 8 |\n"
+      @output.should_receive(:puts).with(expected_display)
+      @console.display_board(@board)
+    end
+  end
+
+  context "reading user input for game type" do
+    it "displays a list of game type" do
+      expected_display = "1 - You vs Computer\n2 - Computer vs You\n3 - You vs Friend"
+      @input.string = "1"
+      @console.game_type
+      @output.string.should match expected_display
+    end
+
+    it "displays a message asking user to select a game type" do
+      expected_display = "Please select a game type."
+      @input.string = "1"
+      @console.game_type
+      @output.string.should match expected_display
+    end
+
+    it "returns user input in integer" do
+      @input.string = "1"
+      @console.game_type.should == 1
+    end
+  end
+
+  it "displays winner" do
+    player = TicTacToe::Player.new("Todd", "X", nil)
+    @console.display_winner(player)
+    @output.string.should == "Todd(X) win!\n"
+  end
+
+  it "display tied game" do
+    @console.display_tied_game
+    @output.string.should == "It's a tied!\n"
+  end
+
+  it "displays square is not available" do
+    @console.display_square_not_available
+    @output.string.should match "Square is not available. Please enter a different square."
+  end
+
+  it "displays player turns" do
+    player = TicTacToe::Player.new("Todd", "X", nil)
+    @console.display_player_turn(player)
+    @output.string.should == "It's Todd(X) turn.\n"
+  end
+end

data/tic_tac_toe_nhu.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = 'tic_tac_toe_nhu'
+  s.version     = '0.0.2'
+  s.date        = '2013-06-11'
+  s.summary     = "Tic Tac Toe"
+  s.description = "A simple tic tac toe game with AI"
+  s.authors     = ["Nhu Nguyen"]
+  s.email       = 'nhu313@gmail.com'
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = 'http://rubygems.org/gems/tic_tac_toe_nhu'
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: tic_tac_toe_nhu
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Nhu Nguyen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-11 00:00:00.000000000 Z
+dependencies: []
+description: A simple tic tac toe game with AI
+email: nhu313@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/tic_tac_toe
+- coverage/.last_run.json
+- coverage/.resultset.json
+- features/step_definitions/tictactoe_steps.rb
+- features/support/env.rb
+- features/tictactoe_start_game.feature
+- features/tictactoe_submit_move.feature
+- lib/tic_tac_toe/board.rb
+- lib/tic_tac_toe/game.rb
+- lib/tic_tac_toe/game_factory.rb
+- lib/tic_tac_toe/main.rb
+- lib/tic_tac_toe/player.rb
+- lib/tic_tac_toe/player_factory.rb
+- lib/tic_tac_toe/rules.rb
+- lib/tic_tac_toe/strategy/console_user.rb
+- lib/tic_tac_toe/strategy/minimax.rb
+- lib/tic_tac_toe/ui/console.rb
+- spec/integration/tictactoe/tic_tac_toe.rb
+- spec/mocks/game.rb
+- spec/mocks/game_factory.rb
+- spec/mocks/player_factory.rb
+- spec/mocks/rules.rb
+- spec/mocks/strategy/dynamic.rb
+- spec/mocks/ui/console.rb
+- spec/tic_tac_toe/board_spec.rb
+- spec/tic_tac_toe/game_factory_spec.rb
+- spec/tic_tac_toe/game_spec.rb
+- spec/tic_tac_toe/main_spec.rb
+- spec/tic_tac_toe/player_factory_mock.rb
+- spec/tic_tac_toe/player_factory_spec.rb
+- spec/tic_tac_toe/player_spec.rb
+- spec/tic_tac_toe/rules_spec.rb
+- spec/tic_tac_toe/spec_helper.rb
+- spec/tic_tac_toe/strategy/console_user_spec.rb
+- spec/tic_tac_toe/strategy/minimax_spec.rb
+- spec/tic_tac_toe/strategy/mock.rb
+- spec/tic_tac_toe/ui/console_spec.rb
+- tic_tac_toe_nhu.gemspec
+homepage: http://rubygems.org/gems/tic_tac_toe_nhu
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Tic Tac Toe
+test_files: []