erics_tic_tac_toe 0.1.0 → 0.5.0

data/.gitignore

@@ -1 +1,2 @@
 pkg/
+coverage/

data/README.markdown

@@ -4,12 +4,11 @@ Tic Tac Toe
 How to play
 ----
 
-    irb -Ilib
-    require 'game'
-    Game.new.run
+    gem install erics_tic_tac_toe
+    tic_tac_toe
 
-Whats coming
-----
+TODO
+---
 
-Gem and Bin executable for playing games easily
-Play games on boards bigger than 3x3
+* Use Curses for a nicer playing experience
+* Colorize diffs so that its easier to see what move was just played

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rake'
+include Rake::DSL
 require 'bundler'
 require 'rake/testtask'
 
@@ -6,7 +7,7 @@ Bundler::GemHelper.install_tasks
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = '**/*_test.rb'
 end
 
 task :default => :test

data/bin/tic_tac_toe

@@ -6,7 +6,7 @@ begin
 rescue LoadError
   case $!.to_s
   when /tic_tac_toe/
-  if !$:.include?(libdir)
+    if !$:.include?(libdir)
       warn "warn: #$!. trying again with #{libdir} on load path"
       $:.unshift(libdir)
       retry
@@ -15,4 +15,43 @@ rescue LoadError
   raise
 end
 
-TicTacToe::Game.new.run
+def setup
+  game = TicTacToe::Game.new
+  terminal = TicTacToe::TerminalGame.new(game.board)
+
+  if terminal.computer_goes_first?
+    @player_1 = TicTacToe::ComputerPlayer.new(letter: 'o')
+    @player_2 = TicTacToe::HumanPlayer.new(letter: 'x')
+  else
+    @player_1 = TicTacToe::HumanPlayer.new(letter: 'o')
+    @player_2 = TicTacToe::HumanPlayer.new(letter: 'x')
+  end
+
+  game = TicTacToe::Game.new(nil, @player_1, @player_2)
+
+  [game, terminal]
+end
+
+game, terminal = setup
+
+loop do
+  game.start
+  terminal = TicTacToe::TerminalGame.new(game.board)
+
+  if game.solved? || game.cats?
+    terminal.update_board
+    break unless terminal.play_again?
+    game, terminal = setup
+  end
+
+  terminal.update_board
+
+  move = terminal.get_move_from_user
+  @player_1 = TicTacToe::HumanPlayer.new(letter: @player_1.letter, move: move)
+  @player_2 = TicTacToe::ComputerPlayer.new(letter: @player_2.letter)
+
+  grid = game.grid
+  game = TicTacToe::Game.new(grid, @player_1, @player_2)
+
+end
+

data/lib/tic_tac_toe.rb

@@ -7,7 +7,8 @@ module TicTacToe
 end
 
 # Internal Project Requires
-require 'tic-tac-toe/board'
-require 'tic-tac-toe/solver'
-require 'tic-tac-toe/game'
-
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/game'
+require 'tic_tac_toe/player'
+require 'tic_tac_toe/presentors/game_presenter'
+require 'tic_tac_toe/presentors/player_presenter'

data/lib/tic_tac_toe/board.rb

@@ -0,0 +1,153 @@
+module TicTacToe
+  # The main class for managing the state of the game board
+  # The board data is represented at a two dimensional array
+  # It provides helper methods for access the data
+  class Board
+
+    attr_accessor :grid
+
+    def initialize(size=3)
+      #[[ nil, nil, nil],
+      # [ nil, nil, nil],
+      # [ nil, nil, nil]]
+      @grid = Array.new(size) { Array.new(size) { nil } }
+    end
+
+    def get_cell(row, column)
+      @grid[column][row]
+    end
+
+    # Returns the corners of the empty cells
+    def empty_positions(&block)
+      positions = []
+      each_position do |row, column|
+        next if get_cell(row, column)
+        yield(row, column) if block_given?
+        positions << [row, column]
+      end
+      positions
+    end
+
+    # Plays a letter at a position, unless that position has already been taken
+    def play_at(row, column, letter)
+      @grid[column][row] ||= letter
+      self
+    end
+
+    # Returns true if the grid is empty
+    def empty?
+      each_cell do |cell|
+        return false if cell
+      end
+      true
+    end
+
+    # Returns true if the grid only has one element
+    def only_one?
+      counter = 0
+      each_cell do |cell|
+        counter += 1 if cell
+        return false if counter >= 2
+      end
+      counter == 1
+    end
+
+    # Returns true if every cell is set to a value
+    def full?
+      each_cell do |cell|
+        return false unless cell
+      end
+      true
+    end
+
+    # Returns true if the board has a wining pattern
+    def solved?
+      letter = won_across?
+      return letter if letter
+      letter = won_up_and_down?
+      return letter if letter
+      letter = won_diagonally?
+      return letter if letter
+      false
+    end
+
+    def winner
+      solved?
+    end
+
+    def to_s
+      output = ["-----------\n"]
+      @grid.each_with_index do |row, i|
+        row.each_with_index do |cell, j|
+          output << "#{cell || ((i*@grid.size)+j+1)} | #{"\n" if j==@grid.size-1}"
+        end
+      end
+      output << ["-----------\n\n"]
+      output.join
+    end
+
+    # Preform a deep clone of the board
+    def clone
+      board = Board.new
+      board.grid = @grid.map { |row| row.map { |cell| cell } }
+      board
+    end
+
+    def size
+      @grid.size
+    end
+
+private 
+
+    def each_cell(&block)
+      @grid.each do |row|
+        row.each do |cell|
+          yield(cell)
+        end
+      end
+    end
+
+    def each_position(&block)
+      @grid.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          yield(y, x)
+        end
+      end
+    end
+
+    def won_across?(grid = @grid)
+      winning_letter = false
+      grid.each do |row|
+        winning_letter = row[0] if winning_group?(row)
+      end
+      winning_letter
+    end
+
+    def won_up_and_down?
+      won_across?(@grid.transpose)
+    end
+
+    def won_diagonally?
+      right_limit = @grid.size-1
+      base = (0..right_limit)
+      
+      letter = create_and_check_group(base) { |i| @grid[i][i] }
+      return letter if letter
+      letter = create_and_check_group(base) { |i| @grid[i][right_limit-i] }
+      return letter if letter
+
+      false
+    end
+
+    def create_and_check_group(base, &block)
+      group = base.collect { |i| yield(i) }
+      return group[0] if winning_group?(group)
+      false
+    end
+
+    def winning_group?(group)
+      !group.any? { |cell| cell.nil? } && group.uniq.size == 1
+    end
+
+  end
+end

data/lib/tic_tac_toe/game.rb

@@ -0,0 +1,70 @@
+#This is a computer that will play a perfect game of tic-tac-toe
+#Author: Eric Koslow
+
+require_relative 'game_types/terminal_game'
+require_relative 'strategies/three_by_three_strategy'
+require_relative 'strategies/minimax_strategy'
+require_relative 'players/human_player'
+require_relative 'players/computer_player'
+
+module TicTacToe
+  # The main director of the program
+  # Directs its gametype when to retrieve information from the user
+  class Game
+    attr_reader :board
+
+    attr_reader :player_moves
+
+    def initialize(board=nil, player_1=nil, player_2=nil)
+      @board = Board.new
+      @board.grid = board || [[nil,nil,nil],[nil,nil,nil],[nil,nil,nil]]
+      @player_1 = player_1
+      @player_2 = player_2
+      @current_player = @player_1 && @player_1.has_next_move? ? @player_1 : @player_2
+    end
+
+    def start
+      while @current_player && (move = @current_player.get_move(@board))
+        move = number_to_cords(move) unless move.is_a?(Array)
+
+        @board.play_at(*move, @current_player.letter)
+        break if over?
+
+        switch_player
+      end
+    end
+
+    def grid
+      @board.grid
+    end
+
+    def solved?
+      @board.solved?
+    end
+
+    def cats?
+      @board.full? && !solved?
+    end
+
+    def winner
+      @board.winner
+    end
+
+    private
+
+    def over?
+      solved? || cats?
+    end
+
+    def number_to_cords(num)
+      num = num.to_i
+      num -= 1
+      [num % @board.size, num/@board.size]
+    end
+
+    def switch_player
+      @current_player = @current_player == @player_1 ? @player_2 : @player_1
+    end
+    
+  end
+end

data/lib/tic_tac_toe/game_types/terminal_game.rb

@@ -0,0 +1,86 @@
+module TicTacToe
+  # Terminal GameType
+  # Interacts with the user through the terminal
+  # Uses puts for output, and gets for input
+  class TerminalGame
+    # Internal Error used when a user tries pulling an illegal move
+    class IllegalMove < RuntimeError
+    end
+
+    def initialize(board, io=Kernel)
+      @board = board
+      @io = io
+    end
+
+    def computer_goes_first?
+      input = get_input("Would you like to play first or second? (f/s)")
+
+      return true unless input =~ /^(f|first)$/i
+      false
+    end
+
+    def get_move_from_user
+      cords = get_cords_from_user
+
+      raise IllegalMove.new("That cell is already taken") unless empty_cell?(cords)
+
+      cords
+    rescue IllegalMove => error
+      display_text "Illegal Move: #{error.message}. Please try again"
+      retry
+    end
+
+    def play_again?
+      input = get_input "Play again? (y/n)"
+      input =~ /^(y|yes)$/i
+    end
+
+    def select(choices)
+      loop do
+        output = "Select the solver:\n"
+        choices.each_with_index { |choice, i| output += "#{i+1}: #{choice}\n" }
+
+        input = get_input(output)
+
+        if input =~ /^\d+$/ and input.to_i <= choices.size
+          return choices[input.to_i-1]
+        end
+
+        display_text("Not a valid choice") 
+      end
+    end
+
+    def update_board
+      @io.puts @board
+    end
+
+    def display_text(text)
+      @io.puts text
+    end
+
+    private
+
+    def get_input(text)
+      @io.print text + ' '
+      @io.gets.chomp
+    end
+
+    def empty_cell?(cords)
+      !@board.get_cell(*cords)
+    end
+
+    def get_cords_from_user
+      input = get_input("Your move (1-#{@board.size**2}):")
+
+      raise IllegalMove.new("That is not a real location") unless input =~ /^\d+$/
+
+      cord_from_num(input.to_i)
+    end
+
+    def cord_from_num(num)
+      num -= 1
+      [num % @board.size, num/@board.size]
+    end
+  end
+
+end

data/lib/tic_tac_toe/player.rb

@@ -0,0 +1,13 @@
+module TicTacToe
+  class Player
+    HUMAN = 'human'
+    COMPUTER = 'computer'
+
+    def self.build(params)
+      return HumanPlayer.new(params) if params['type'] == HUMAN
+
+      ComputerPlayer.new(params)
+    end
+
+  end
+end

data/lib/tic_tac_toe/players/computer_player.rb

@@ -0,0 +1,26 @@
+module TicTacToe
+
+  class ComputerPlayer
+    attr_reader :letter
+
+    def initialize(params, solver=MinimaxStrategy)
+      @letter = params['letter'] || params[:letter]
+      @solver = solver
+    end
+
+    def get_move(board)
+      @solver.new(board, @letter).solve
+    end
+
+    def has_next_move?
+      true
+    end
+    
+    def type
+      Player::COMPUTER
+    end
+
+  end
+
+
+end