tictactien-gem 0.3.2

data/spec/board_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe "Board" do    
+  
+  it "returns its new grid" do
+    board = Board.new
+    board.grid.should == [[nil, nil, nil],
+                          [nil, nil, nil],
+                          [nil, nil, nil]]
+  end
+  
+  ['x', 'o'].each do |player_token|
+    [
+      [[], [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]],
+      [[[0,0]], [[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2]], [[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0]], [[1,1],[1,2],[2,0],[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0],[1,1]], [[1,2],[2,0],[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2]], [[2,0],[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0]], [[2,1],[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1]], [[2,2]]],
+      [[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]], []],
+    ].each do |pieces, spaces|
+      it "finds available spaces" do
+        board = Board.new
+        pieces.each do |piece|
+          board.add_piece(player_token, piece)
+        end
+        board.available_spaces.should == spaces
+      end
+    end
+  end
+  
+  ['x', 'o'].each do |player_token|    
+    [
+      [[0,0], [[player_token, nil, nil], [nil, nil, nil], [nil, nil, nil]]],
+      [[0,1], [[nil, player_token, nil], [nil, nil, nil], [nil, nil, nil]]],
+      [[0,2], [[nil, nil, player_token], [nil, nil, nil], [nil, nil, nil]]],
+      [[1,0], [[nil, nil, nil], [player_token, nil, nil], [nil, nil, nil]]],
+      [[1,1], [[nil, nil, nil], [nil, player_token, nil], [nil, nil, nil]]],
+      [[1,2], [[nil, nil, nil], [nil, nil, player_token], [nil, nil, nil]]],
+      [[2,0], [[nil, nil, nil], [nil, nil, nil], [player_token, nil, nil]]],
+      [[2,1], [[nil, nil, nil], [nil, nil, nil], [nil, player_token, nil]]],
+      [[2,2], [[nil, nil, nil], [nil, nil, nil], [nil, nil, player_token]]],
+    ].each do |location, grid|    
+      it "adds a piece to its grid at loc #{location.first},#{location.last}" do
+        board = Board.new
+        board.add_piece(player_token, location)
+        board.grid.should == grid
+      end
+    end
+  end
+  
+  ['x', 'o'].each do |player_token|
+    [
+      [[], nil],
+      [[[0,0],[1,1],[2,2]], player_token],
+      [[[0,2],[1,1],[2,0]], player_token],
+      [[[0,0],[0,1],[0,2]], player_token],
+      [[[1,0],[1,1],[1,2]], player_token],
+      [[[2,0],[2,1],[2,2]], player_token],
+      [[[0,0],[1,0],[2,0]], player_token],
+      [[[0,1],[1,1],[2,1]], player_token],
+      [[[0,2],[1,2],[2,2]], player_token],
+    ].each do |pieces, result|
+        it "checks for a winning player" do
+        board = Board.new
+        pieces.each do |piece|
+          board.add_piece(player_token, piece)
+        end
+        board.calculate_win.should == result
+      end
+    end
+  end
+end

data/spec/console_game_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "ConsoleGame" do
+  it "starts a game loop" do    
+#    console = ConsoleGame.new
+
+#    console.start
+  end
+end

data/spec/cpu_player_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "CpuPlayer" do
+  it "it has an AI" do
+    cpu_player = CpuPlayer.new('x', RandomAi.new)
+    
+    cpu_player.ai.should_not be_nil
+  end
+  
+  it "performs a move" do
+    cpu_player = CpuPlayer.new('x', RandomAi.new)
+    game_state  = GameState.new(cpu_player)
+    board = game_state.board
+    
+    move = mock('move', :first => 0, :last => 0)
+    cpu_player.ai.should_receive(:calculate_move).with(board, cpu_player).and_return(move)
+    board.should_receive(:add_piece).with(cpu_player.token, move)
+    
+    cpu_player.perform_move(game_state)
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Game" do
+  it "creates a new game" do
+    player_one = PlayerFactory.create_player('Random CPU', 'x')
+    player_two = PlayerFactory.create_player('Random CPU', 'o')
+    
+    game = Game.new
+    game.players = {:one => player_one, :two => player_two}
+    game.game_state = GameState.new(player_one)
+    
+    game.game_state.should_not be_nil
+  end  
+  
+  it "switches the active player" do
+    player_one = PlayerFactory.create_player('Random CPU', 'x')
+    player_two = PlayerFactory.create_player('Random CPU', 'o')
+    
+    game = Game.new
+    game.players = {:one => player_one, :two => player_two}
+    game.game_state = GameState.new(player_one)
+    
+    game.switch_active_player
+    game.game_state.active_player.should == player_two
+    game.switch_active_player
+    game.game_state.active_player.should == player_one
+    game.switch_active_player
+    game.game_state.active_player.should == player_two
+  end
+end

data/spec/game_state_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "GameState" do
+  it "creates a snapshot of the current game state" do
+    board = Board.new
+    active_player = Player.new('x')
+    
+    game_state = GameState.new(board, active_player)
+    
+    game_state.board.should == board
+    game_state.active_player.should == active_player
+  end
+  
+  it "updates its board state with a new move" do
+    board = Board.new
+    active_player = Player.new('x')
+    game_state = GameState.new(board, active_player)
+    
+    move = mock('move', :first => 0, :last => 0)
+    game_state.board.should_receive(:add_piece).with(game_state.active_player.token, move)
+    game_state.update(move)
+  end
+  
+  it "does not update its board state with an invalid move" do
+    board = Board.new
+    board.grid[0][0] = 'x'
+    active_player = Player.new('x')
+    game_state = GameState.new(board, active_player)
+    
+    move = mock('move', :first => 0, :last => 0)
+    game_state.board.should_receive(:add_piece).with(game_state.active_player.token, move).and_return(false)
+    game_state.update(move)
+  end
+end

data/spec/human_player_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "HumanPlayer" do
+  it "performs a move" do
+    human_player = HumanPlayer.new('x')
+    game_state = GameState.new(human_player)
+    board = game_state.board
+    
+    move = [0, 0]
+#    Game.stub(:ask_move).with(board, human_player.token).and_return(move)
+    board.should_receive(:add_piece).with(human_player.token, move)
+    
+    human_player.perform_move(game_state, move)
+  end
+end

data/spec/minimax_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe "Minimax" do
+  it "is created with a grid, a move and a player" do
+    board = Board.new
+    board.grid = 
+           [[nil, nil, nil],
+            [nil, nil, nil],
+            [nil, nil, nil]]  
+    last_move = [0, 0]
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, last_move, current_player.token, current_player.token)
+    
+    minimax_node.board.should == board
+    minimax_node.last_move.should == last_move
+    
+  end
+  
+  it "evaluates a score for a game in progress" do
+    board = Board.new
+    board.grid = 
+           [[nil, nil, nil],
+            [nil, nil, nil],
+            [nil, nil, nil]]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.game_ended.should be_nil
+  end
+  
+  it "evaluates the score for a winning game" do
+    board = Board.new
+    board.grid = 
+           [['x', nil, nil],
+            [nil, 'x', nil],
+            [nil, nil, 'x']]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.game_ended.should == 1
+  end
+  
+  it "evaluates the score for a losing game" do
+    board = Board.new
+    board.grid = 
+           [[nil, nil, nil],
+            ['o', 'o', 'o'],
+            [nil, nil, nil]]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.game_ended.should == -1
+  end
+  
+  it "evaluates the score for a cat game" do
+    board = Board.new
+    board.grid = 
+           [['x', 'x', 'o'],
+            ['o', 'o', 'x'],
+            ['x', 'o', 'x']]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.game_ended.should == 0
+  end
+  
+  it "correctly evaluates the score of a sure game" do
+    board = Board.new
+    board.grid = 
+           [['x', 'x', nil],
+            ['o', 'o', 'x'],
+            ['o', 'o', 'x']]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.build_tree
+    
+    minimax_node.score.should == 1
+  end
+  
+  it "correctly evaluates the score of a cat game" do
+    board = Board.new
+    board.grid = 
+           [['x', 'x', 'o'],
+            ['o', 'o', 'x'],
+            ['x', 'o', nil]]  
+    
+    current_player = Player.new('x')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.build_tree
+    
+    minimax_node.score.should == 0
+  end
+
+  it "correctly evaluates the score of a lost game" do
+    board = Board.new
+    board.grid = 
+           [['x', 'x', nil],
+            ['x', 'o', 'o'],
+            [nil, 'o', 'x']]  
+    
+    current_player = Player.new('o')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.build_tree
+    
+    minimax_node.score.should == -1
+  end
+  
+  it "gets the next best move" do
+    board = Board.new
+    board.grid = 
+           [['x', 'x', nil],
+            [nil, 'o', nil],
+            [nil, nil, nil]]
+    
+    current_player = Player.new('o')
+    
+    minimax_node = Minimax.new(board, nil, current_player.token, current_player.token)
+    minimax_node.build_tree
+    minimax_node.get_next_move.should == [0,2]
+  end
+end

data/spec/perfect_ai_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "PerfectAi" do  
+  it "calculates a perfect move 1" do
+    perfect_ai = PerfectAi.new
+    board = Board.new
+    current_player = Player.new('x')
+    
+    perfect_ai.calculate_move(board, current_player).should == [0,0]
+  end
+  
+  it "calculates a perfect move 2" do
+    perfect_ai = PerfectAi.new
+    board = Board.new
+    current_player = Player.new('o')
+    
+    board.grid = [['x', nil, nil],
+                  [nil, nil, nil],
+                  [nil, nil, nil]]
+    
+    perfect_ai.calculate_move(board, current_player).should == [1,1]
+  end
+  
+  it "calculates a perfect move 3" do
+    perfect_ai = PerfectAi.new
+    board = Board.new
+    current_player = Player.new('x')
+    
+    board.grid = [['x', nil, nil],
+                  [nil, 'o', nil],
+                  [nil, nil, nil]]
+    
+    perfect_ai.calculate_move(board, current_player).should == [0,1]
+  end
+end

data/spec/player_factory_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "PlayerFactory" do
+  it "creates a human player" do
+    human = PlayerFactory.create_player(PlayerFactory::HUMAN, 'x')  
+    
+    human.class.should == HumanPlayer
+    human.token.should == 'x'
+  end
+  
+  it "creates a random cpu player" do
+    random_cpu = PlayerFactory.create_player(PlayerFactory::RANDOM_CPU, 'x')
+    
+    random_cpu.class.should == CpuPlayer
+    random_cpu.token.should == 'x'
+    random_cpu.ai.class.should == RandomAi
+  end
+  
+  it "creates a perfect cpu player" do
+    perfect_cpu = PlayerFactory.create_player(PlayerFactory::PERFECT_CPU, 'o')
+    
+    perfect_cpu.class.should == CpuPlayer
+    perfect_cpu.token.should == 'o'
+    perfect_cpu.ai.class.should == PerfectAi
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,8 @@
+#require '../lib/player'
+
+describe "Player" do
+  it "has a player token" do
+    player = Player.new('x')
+    player.token.should_not be_nil
+  end
+end

data/spec/rails_game_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe "RailsGame" do
+  it "chooses the first player as human" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("Human")
+    
+    rails_game.players[:one].class.should == HumanPlayer
+    rails_game.players[:one].token.should == 'x'
+  end
+  
+  it "chooses the first player as a Random CPU" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("RandomCPU")
+    
+    rails_game.players[:one].class.should == CpuPlayer
+    rails_game.players[:one].ai.class.should == RandomAi
+    rails_game.players[:one].token.should == 'x'
+  end
+  
+  it "chooses the second player as a Perfect CPU" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_two("PerfectCPU")
+    
+    rails_game.players[:two].class.should == CpuPlayer
+    rails_game.players[:two].ai.class.should == PerfectAi
+    rails_game.players[:two].token.should == 'o'
+  end
+  
+  it "starts a rails game" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("Human")
+    rails_game.choose_player_two("RandomCPU")
+    
+    rails_game.start
+    
+    rails_game.game_state.active_player.should == rails_game.players[:one]
+  end
+  
+  it "updates its state with a new move" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("Human")
+    rails_game.choose_player_two("RandomCPU")
+    
+    rails_game.start
+    
+    move = mock('move', :first => 0, :last => 0)
+    rails_game.game_state.should_receive(:update).with(move)
+    rails_game.stub!(:switch_active_player)
+    
+    rails_game.update(move)    
+  end
+  
+  it "updates its state by switching the active player" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("Human")
+    rails_game.choose_player_two("RandomCPU")
+    
+    rails_game.start
+    
+    move = mock('move', :first => 0, :last => 0)
+    rails_game.game_state.stub!(:update).with(move).and_return(true)
+    rails_game.should_receive(:switch_active_player)
+    
+    rails_game.update(move)
+  end
+  
+  it "prints the current board" do
+    rails_game = RailsGame.new
+    rails_game.choose_player_one("Human")
+    rails_game.choose_player_two("RandomCPU")
+    
+    rails_game.start
+    
+    rails_game.game_state.board.should_receive(:print)
+    
+    rails_game.print_board
+  end
+end

data/spec/random_ai_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "RandomAi" do
+  it "calculates a random move" do
+    random_ai = RandomAi.new
+    board = Board.new
+    current_player = Player.new('x')
+    
+    available_spaces = mock("list of spaces")
+    board.stub!(:available_spaces).and_return(available_spaces)
+    available_spaces.should_receive(:sample).and_return("the move")
+    
+    random_ai.calculate_move(board, current_player).should == "the move"
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# Dir["../lib/*.rb"].each {|file| require file }
+#require '../lib/tictactien-gem'
+#require '../lib/board'
+#require '../lib/game'
+#require '../lib/console_game'
+#require '../lib/ai'
+#require '../lib/player'
+#require '../lib/human_player'
+#require '../lib/cpu_player'
+#require '../lib/minimax'
+#require '../lib/perfect_ai'
+#require '../lib/random_ai'
+#require '../lib/player_factory'
+#require '../lib/game_state'
+
+require 'tictactien-gem'
+require 'board'
+require 'game'
+require 'rails_game'
+require 'console_game'
+require 'ai'
+require 'player'
+require 'human_player'
+require 'cpu_player'
+require 'minimax'
+require 'perfect_ai'
+require 'random_ai'
+require 'player_factory'
+require 'game_state'

data/spec/spec_helper_jeweler.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'tictactien-gem'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/tictactien-gem_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "Tictactien" do
+#  it "creates a human player" do
+#    human = Tictactien.create_player(Tictactien::HUMAN, 'x')  
+#    
+#    human.class.should == HumanPlayer
+#    human.token.should == 'x'
+#  end
+#  
+#  it "creates a random cpu player" do
+#    random_cpu = Tictactien.create_player(Tictactien::RANDOM_CPU, 'x')
+#    
+#    random_cpu.class.should == CpuPlayer
+#    random_cpu.token.should == 'x'
+#    random_cpu.ai.class.should == RandomAi
+#  end
+#  
+#  it "creates a perfect cpu player" do
+#    perfect_cpu = Tictactien.create_player(Tictactien::PERFECT_CPU, 'o')
+#    
+#    perfect_cpu.class.should == CpuPlayer
+#    perfect_cpu.token.should == 'o'
+#    perfect_cpu.ai.class.should == PerfectAi
+#  end
+#  
+#  it "creates a snapshot of the current game state" do
+#    active_player = Player.new('x')
+#    
+#    game_state = Tictactien.create_new_game(active_player)
+#    
+#    game_state.board.should_not be_nil
+#    game_state.active_player.should == active_player
+#  end
+  
+  # it "adds a piece to the board" do
+  #   game_state = Tictactien.create_new_game('x')
+  #   location = [0,0]
+  #   Tictactien.add_piece(game_state.board, game_state.active_player, location)
+  #   
+  #   game_state.board.grid.should == [['x', nil, nil],
+  #                                    [nil, nil, nil],
+  #                                    [nil, nil, nil]]
+  # end
+end

data/tictactien-gem.gemspec

@@ -0,0 +1,90 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tictactien-gem}
+  s.version = "0.3.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tien H. Nguyen"]
+  s.date = %q{2011-06-20}
+  s.description = %q{Tic-Tac-Toe game in Ruby...}
+  s.email = %q{nht007@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/ai.rb",
+    "lib/board.rb",
+    "lib/console_game.rb",
+    "lib/cpu_player.rb",
+    "lib/game.rb",
+    "lib/game_state.rb",
+    "lib/human_player.rb",
+    "lib/minimax.rb",
+    "lib/perfect_ai.rb",
+    "lib/player.rb",
+    "lib/player_factory.rb",
+    "lib/rails_game.rb",
+    "lib/random_ai.rb",
+    "lib/tictactien-gem.rb",
+    "spec/ai_spec.rb",
+    "spec/board_spec.rb",
+    "spec/console_game_spec.rb",
+    "spec/cpu_player_spec.rb",
+    "spec/game_spec.rb",
+    "spec/game_state_spec.rb",
+    "spec/human_player_spec.rb",
+    "spec/minimax_spec.rb",
+    "spec/perfect_ai_spec.rb",
+    "spec/player_factory_spec.rb",
+    "spec/player_spec.rb",
+    "spec/rails_game_spec.rb",
+    "spec/random_ai_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/spec_helper_jeweler.rb",
+    "spec/tictactien-gem_spec.rb",
+    "tictactien-gem.gemspec"
+  ]
+  s.homepage = %q{http://github.com/nht007/tictactien-gem}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Tic-Tac-Toe game in Ruby}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+  end
+end
+