tactical_tic_tac_toe 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01bb765823d823d69d962bdcf3cd43e8bf7fc48f
+  data.tar.gz: d2215f338e0b37e2fe3e6fc2d7b17fb4c731e3c1
+SHA512:
+  metadata.gz: f44cc813fba53dec3622cb8051a8551578e7ff941c12d11539e4d48b38eb118641abb19c8b2439aa8e26b6b8b09cd41c30513979363eb06417c8684d32be6772
+  data.tar.gz: bda0c00122f5e46f4234725dd4045f3541d757b30de32ec6f159c496bf1bb04fe7eb8927153bed5a42fd49204461fdc293d1ebfbd69ab486b879e45fe4a65396

data/bin/ttt

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "tactical_tic_tac_toe"
+
+TicTacToe::Game.new({}).run

data/lib/available_player_types.rb

@@ -0,0 +1,8 @@
+module TicTacToe
+  module AvailablePlayerTypes
+
+    HUMAN = :human
+    COMPUTER = :computer
+
+  end
+end

data/lib/board.rb

@@ -0,0 +1,118 @@
+module TicTacToe
+  class Board
+    BoardError = Class.new(StandardError)
+    BLANK_MARK = nil
+
+    attr_reader :size, :last_move_made
+
+    def self.blank_mark
+      BLANK_MARK
+    end
+
+    def initialize(parameters)
+      fail BoardError, "Given size is too small, must be 3 or greater" if parameters[:size] < 3
+
+      @size = parameters[:size]
+      config = parameters[:config] || blank_board_configuration
+      @cells = map_configuration_to_cells(config)
+    end
+
+    def read_cell(row, col)
+      fail BoardError, "Cell coordinates are out of bounds" if out_of_bounds?([row, col])
+
+      @cells[row][col]
+    end
+
+    def mark_cell(mark, row, col)
+      fail BoardError, "Cell coordinates are out of bounds" if out_of_bounds?([row, col])
+      fail BoardError, "Cannot alter a marked cell" if marked?([row, col])
+
+      @last_move_made = [row, col]
+      @cells[row][col] = mark
+    end
+
+    def lines
+      (0...@size).each_with_object([left_diag, right_diag]) do |index, lines|
+        lines << row_at(index) << col_at(index)
+      end
+    end
+
+    def all_coordinates
+      (0...@size).to_a.repeated_permutation(2).to_a
+    end
+
+    def blank_cell_coordinates
+      all_coordinates.reject { |coordinates| marked?(coordinates) }
+    end
+
+    def last_mark_made
+      return if @last_move_made.nil?
+      self.read_cell(*last_move_made)
+    end
+
+    def deep_copy
+      Board.new(size: @size, config: map_cells_to_configuration(@cells))
+    end
+
+    def blank?(coordinates)
+      self.read_cell(*coordinates) == BLANK_MARK
+    end
+
+    def marked?(coordinates)
+      !blank?(coordinates)
+    end
+
+    def out_of_bounds?(coordinates)
+      coordinates.any? { |i| !i.between?(0, @size - 1) }
+    end
+
+    def all_blank?
+      all_coordinates.all? { |coordinates| blank?(coordinates) }
+    end
+
+    def all_marked?
+      all_coordinates.all? { |coordinates| marked?(coordinates) }
+    end
+
+    def has_winning_line?
+      lines.each do |line|
+        return true if line.first != BLANK_MARK && line.all? { |cell| cell == line.first }
+      end
+      false
+    end
+
+    private
+
+    def map_configuration_to_cells(config)
+      if Math.sqrt(config.size).to_i != @size
+        fail BoardError, "Given size does not reconcile with given configuration"
+      end
+
+      config.each_slice(@size).to_a
+    end
+
+    def map_cells_to_configuration(cells)
+      cells.flatten
+    end
+
+    def blank_board_configuration
+      (0...@size**2).map { BLANK_MARK }
+    end
+
+    def row_at(row)
+      (0...@size).map { |col| self.read_cell(row, col) }
+    end
+
+    def col_at(col)
+      (0...@size).map { |row| self.read_cell(row, col) }
+    end
+
+    def left_diag
+      (0...@size).map { |index| self.read_cell(index, index) }
+    end
+
+    def right_diag
+      (0...@size).map { |row| self.read_cell(row, @size - row - 1) }
+    end
+  end
+end

data/lib/command_line_interface.rb

@@ -0,0 +1,96 @@
+module TicTacToe
+  class CommandLineInterface
+
+    def initialize(parameters)
+      @input = parameters[:input]
+      @output = parameters[:output]
+    end
+
+    def game_setup_interaction(player_marks)
+      @output.puts instructions
+      player_marks.map { |mark| solicit_player_type(mark) }
+    end
+
+    def solicit_player_type(player_mark)
+      @output.puts "Is player #{player_mark} a human or computer?"
+      @output.puts "Enter 'computer' or 'human'."
+
+      cleaned_input = get_valid_input(/^(computer|human)$/)
+      cleaned_input.to_sym
+    end
+
+    def show_game_board(board)
+      row_separator = "----" * board.size + "-\n"
+      col_separator = "|"
+
+      @output.print assemble_board_string(board, row_separator, col_separator)
+    end
+
+    def solicit_move(player_mark)
+      @output.puts "Player #{player_mark}: select your move."
+      @output.puts "Enter your move coordinates in the format 'row, col' - eg. '0, 0'."
+
+      cleaned_input = get_valid_input(/^\s*\d+\s*,\s*\d+\s*$/)
+      cleaned_input.split(",").map(&:to_i)
+    end
+
+    def get_valid_input(valid_input_pattern)
+      catch(:success) do
+        loop do
+          cleaned_input = @input.gets.strip.downcase
+          throw(:success, cleaned_input) if valid_input_pattern =~ cleaned_input
+          @output.puts "Sorry, '#{cleaned_input}' is not valid input. Please try again."
+        end
+      end
+    end
+
+    def report_invalid_move(move_coordinates)
+      row, col = move_coordinates
+      @output.puts "Couldn't move at row: #{row}, column: #{col}. Please try again."
+    end
+
+    def report_move(player_mark, move_coordinates)
+      row, col = move_coordinates
+      @output.puts "Player #{player_mark} moved at row: #{row}, column: #{col}."
+    end
+
+    def report_game_over(winning_player)
+      if winning_player == :none
+        report_draw
+      else
+        report_win(winning_player)
+      end
+    end
+
+    def report_win(player_mark)
+      @output.puts "Player #{player_mark} wins!"
+    end
+
+    def report_draw
+      @output.puts "The game ended in a draw."
+    end
+
+    def instructions
+      <<-EOS
+~*~ Welcome to TIC TAC TOE ~*~
+You've probably done this a million times before.
+You don't need me to tell you what to do.
+Go get 'em killer~
+EOS
+    end
+
+    private
+
+    def assemble_board_string(board, row_separator, col_separator)
+      output_string = row_separator
+      (0...board.size).each do |row|
+        output_string += col_separator
+        (0...board.size).each do |col|
+          output_string += " #{board.read_cell(row, col) || " "} " + col_separator
+        end
+        output_string += "\n" + row_separator
+      end
+      output_string
+    end
+  end
+end

data/lib/computer_player.rb

@@ -0,0 +1,86 @@
+require "negamax"
+
+module TicTacToe
+  class ComputerPlayer
+    attr_reader :player_mark
+
+    def initialize(parameters)
+      @board = parameters[:board]
+      @player_mark = parameters[:player_mark]
+      @opponent_mark = parameters[:opponent_mark]
+    end
+
+    def move
+      if @board.all_blank? && @board.size.odd?
+        [:row, :col].map { @board.size / 2 }
+      else
+        choose_best_move
+      end
+    end
+
+    private
+
+    def choose_best_move
+      @negamax ||= create_negamax
+      @negamax.apply(initial_node).fetch(:last_move_made)
+    end
+
+    def create_negamax
+      parameters = {
+        child_node_generator: create_child_node_generator,
+        terminal_node_criterion: create_terminal_node_criterion,
+        evaluation_heuristic: create_evaluation_heuristic
+      }
+      Negamax.new(parameters)
+    end
+
+    def initial_node
+      {
+        board: @board,
+        current_player_mark: @player_mark,
+        last_move_made: nil
+      }
+    end
+
+    def create_child_node_generator
+      lambda do |node|
+        board = node.fetch(:board)
+        current_player_mark = node.fetch(:current_player_mark)
+
+        board.blank_cell_coordinates.map do |coordinates|
+          child_node = {
+            board: board.deep_copy,
+            current_player_mark: toggle_mark(current_player_mark),
+            last_move_made: coordinates
+          }
+          child_node[:board].mark_cell(current_player_mark, *coordinates)
+          child_node
+        end
+      end
+    end
+
+    def create_terminal_node_criterion
+      lambda do |node|
+        board = node.fetch(:board)
+
+        board.has_winning_line? || board.all_marked?
+      end
+    end
+
+    def create_evaluation_heuristic
+      lambda do |node|
+        board = node.fetch(:board)
+
+        board.lines.each do |line|
+          return 1 if line.all? { |cell|  cell == @player_mark }
+          return -1 if line.all? { |cell|  cell == @opponent_mark }
+        end
+        0
+      end
+    end
+
+    def toggle_mark(mark)
+      mark == @player_mark ? @opponent_mark : @player_mark
+    end
+  end
+end

data/lib/game.rb

@@ -0,0 +1,88 @@
+require "board"
+require "player_factory"
+require "command_line_interface"
+
+module TicTacToe
+  class Game
+    attr_reader :interface, :board, :player_marks, :players
+
+    def initialize(parameters)
+      @player_marks = parameters[:player_marks] || [:x, :o]
+      @board = parameters[:board] || create_default_board
+      @interface = parameters[:interface] || create_default_interface
+      @players = []
+    end
+
+    def run
+      set_up
+      handle_turns
+      handle_game_over
+    end
+
+    def set_up
+      player_types = @interface.game_setup_interaction(@player_marks)
+
+      @players = @player_marks.zip(player_types).map { |mark, type| create_player(mark, type) }
+    end
+
+    def handle_turns
+      catch(:game_over) do
+        @players.cycle do |current_player|
+          handle_one_turn(current_player)
+          throw :game_over if over?
+        end
+      end
+    end
+
+    def handle_one_turn(current_player)
+      @interface.show_game_board(@board)
+      coordinates = get_valid_move(current_player)
+      @board.mark_cell(current_player.player_mark, *coordinates)
+      @interface.report_move(current_player.player_mark, coordinates)
+    end
+
+    def get_valid_move(player)
+      loop do
+        coordinates = player.move
+        if @board.out_of_bounds?(coordinates) || @board.marked?(coordinates)
+          @interface.report_invalid_move(coordinates)
+        else
+          return coordinates
+        end
+      end
+    end
+
+    def handle_game_over
+      @interface.show_game_board(@board)
+      winning_player_mark = @board.has_winning_line? ? @board.last_mark_made : :none
+      @interface.report_game_over(winning_player_mark)
+    end
+
+    def over?
+      @board.has_winning_line? || @board.all_marked?
+    end
+
+    private
+
+    def create_default_board
+      Board.new(size: 3)
+    end
+
+    def create_default_interface
+      parameters = {
+        input: $stdin,
+        output: $stdout
+      }
+      CommandLineInterface.new(parameters)
+    end
+
+    def create_player(mark, type)
+      player_config = {
+        type: type,
+        game: self,
+        player_mark: mark
+      }
+      PlayerFactory.build(player_config)
+    end
+  end
+end

data/lib/human_player.rb

@@ -0,0 +1,14 @@
+module TicTacToe
+  class HumanPlayer
+    attr_reader :player_mark
+
+    def initialize(parameters)
+      @player_mark = parameters[:player_mark]
+      @interface = parameters[:interface]
+    end
+
+    def move
+      @interface.solicit_move(@player_mark)
+    end
+  end
+end

data/lib/negamax.rb

@@ -0,0 +1,39 @@
+module TicTacToe
+  class Negamax
+    def initialize(parameters)
+      @child_node_generator = parameters[:child_node_generator]
+      @terminal_node_criterion = parameters[:terminal_node_criterion]
+      @evaluation_heuristic = parameters[:evaluation_heuristic]
+    end
+
+    def apply(node)
+      if terminal_node?(node)
+        node
+      else
+        generate_child_nodes(node).max_by { |child| -score(child, -1) }
+      end
+    end
+
+    private
+
+    def score(node, color)
+      if terminal_node?(node)
+        evaluate(node, color)
+      else
+        generate_child_nodes(node).map { |child| -score(child, -color) }.max
+      end
+    end
+
+    def generate_child_nodes(node)
+      @child_node_generator.call(node)
+    end
+
+    def terminal_node?(node)
+      @terminal_node_criterion.call(node)
+    end
+
+    def evaluate(node, color)
+      @evaluation_heuristic.call(node) * color
+    end
+  end
+end

data/lib/old_computer_player.rb

@@ -0,0 +1,89 @@
+module TicTacToe
+  class OldComputerPlayer
+    attr_reader :player_mark
+
+    def initialize(parameters)
+      @player_mark = parameters[:player_mark]
+      @opponent_mark = parameters[:opponent_mark]
+      @board = parameters[:board]
+    end
+
+    def move
+      center_coordinate = [@board.size / 2, @board.size / 2]
+      if !@board.marked?(center_coordinate) && @board.size.odd?
+        center_coordinate
+      else
+        select_best_move
+      end
+    end
+
+    private
+
+    def select_best_move
+      best_score_so_far = {
+        player: -Float::INFINITY, # highest score is best for player
+        opponent: Float::INFINITY # lowest score is best for opponent
+      }
+
+      successor_boards = generate_possible_successor_boards(@board, @player_mark)
+      best_board = successor_boards.max_by { |board| minimax(board, false, best_score_so_far) }
+      best_board.last_move_made
+    end
+
+    def generate_possible_successor_boards(board, mark)
+      board.blank_cell_coordinates.map do |coordinates|
+        successor_board = board.deep_copy
+        successor_board.mark_cell(mark, *coordinates)
+        successor_board
+      end
+    end
+
+    def minimax(board, my_turn, best_score_so_far)
+      if board.has_winning_line? || board.all_marked?
+        evaluate(board)
+      else
+        select_score_of_best_successor_board(board, my_turn, best_score_so_far.dup)
+      end
+    end
+
+    def evaluate(board)
+      board.lines.each do |line|
+        return Float::INFINITY if line.all? { |cell| cell == @player_mark }
+        return -Float::INFINITY if line.all? { |cell| cell == @opponent_mark }
+      end
+      0
+    end
+
+    def select_score_of_best_successor_board(board, my_turn, best_score_so_far)
+      current_player_mark = my_turn ? @player_mark : @opponent_mark
+
+      successor_boards = generate_possible_successor_boards(board, current_player_mark)
+      scores = score_successor_boards(successor_boards, my_turn, best_score_so_far)
+
+      my_turn ? scores.max : scores.min
+    end
+
+    def score_successor_boards(successor_boards, my_turn, best_score_so_far)
+      successor_boards.each_with_object([]) do |board, scores|
+        score = minimax(board, !my_turn, best_score_so_far.dup)
+        scores << score
+
+        update_best_score_so_far(my_turn, best_score_so_far, score)
+        return scores if best_score_guaranteed_elsewhere?(best_score_so_far)
+      end
+    end
+
+    def update_best_score_so_far(my_turn, best_score_so_far, score)
+      if score > best_score_so_far[:player] && my_turn
+        best_score_so_far[:player] = score
+      end
+      if score < best_score_so_far[:opponent] && !my_turn
+        best_score_so_far[:opponent] = score
+      end
+    end
+
+    def best_score_guaranteed_elsewhere?(best_score_so_far)
+      best_score_so_far[:player] >= best_score_so_far[:opponent]
+    end
+  end
+end

data/lib/player_factory.rb

@@ -0,0 +1,35 @@
+require "human_player"
+require "computer_player"
+require "available_player_types"
+
+module TicTacToe
+  module PlayerFactory
+    def self.build(config)
+      case config[:type]
+      when AvailablePlayerTypes::HUMAN
+        create_human_player(config)
+      when AvailablePlayerTypes::COMPUTER
+        create_computer_player(config)
+      end
+    end
+
+    private
+
+    def self.create_human_player(config)
+      human_parameters = {
+        player_mark: config[:player_mark],
+        interface: config[:game].interface
+      }
+      HumanPlayer.new(human_parameters)
+    end
+
+    def self.create_computer_player(config)
+      computer_parameters = {
+        player_mark: config[:player_mark],
+        opponent_mark: (config[:game].player_marks - [config[:player_mark]]).pop,
+        board: config[:game].board
+      }
+      ComputerPlayer.new(computer_parameters)
+    end
+  end
+end

data/lib/tactical_tic_tac_toe.rb

@@ -0,0 +1 @@
+require "game"