tic_tac_toe_bfox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b97a0ee48814d4adde4f74cd0a9218645ef8d67
+  data.tar.gz: be30925fff9cd631a7c7a31a2f6ea1a58af71e5f
+SHA512:
+  metadata.gz: a3bbebb23e84bc84d4e7bf23e2236b40cbc1d65541474414f6c5773228c3051b3516c76d90f2c25db5dc1e8669481eb64cc42496872e3f8cb134b51ef10c7aa3
+  data.tar.gz: 2c667d703865e7374250bf9386069759010d45130bbc06f1d8c829dee39dbfbb3c941974e02bf5548069dbfd8cd1b8a4940d7457080a2d44eb169fede6d56027

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+# http://yehudakatz.com/2010/12/16/clarifying-the-roles-of-the-gemspec-and-gemfile/
+# Programs/foodie example
+gemspec

data/README.md

@@ -0,0 +1,11 @@
+# tic_tac_toe
+
+**Instructions:**
+
+1. In order to play the game, please type **ruby main.rb** into your console.
+2. Follow the prompts to set your name and the value of your mark.
+3. Choose whether you would like to play a computer (**"C"**) or a human (**"H"**).
+4. If you choose to play a computer, further choose whether you would like to play
+    * an easy (**"E"**) computer: this computer selects randomly
+    * a difficult (**"D"**) computer: this computer is impossible to beat!
+5. Choose how many squares per row you would like. Note that 9 is the maximum, unless you are playing a difficult computer, who prefers to play with a maximum of 3 squares per row. 

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/tictactoe

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+#below line requires tictactoe which runs program
+require "tictactoe"
+

data/lib/tictactoe/board.rb

@@ -0,0 +1,36 @@
+module TTT
+  class Board
+    attr_accessor :rows_and_cols, :squares
+
+    def initialize(args = {})
+      @rows_and_cols = args[:rows_and_cols]
+      @squares = args[:squares]
+    end
+
+    def change_square(display_value, new_value)
+      square_to_change = retrieve_square(display_value)
+      square_to_change.change_value(new_value)
+    end
+
+    def full?
+      return squares.full?
+    end
+
+    def won?
+      return squares.any_combination_won?
+    end
+
+    def display_values
+      return squares.display_values
+    end
+
+    def available_choices
+      return squares.available_choices
+    end
+
+    private
+    def retrieve_square(display_value)
+      return squares.retrieve_square(display_value)
+    end
+  end
+end

data/lib/tictactoe/board_presenter_terminal.rb

@@ -0,0 +1,17 @@
+module TTT
+  class BoardPresenterTerminal
+    def present_board(board)
+      #board.display_values will return multidimensional array
+      display_values = board.display_values
+      display_values.each do |row|
+        row.each_with_index do |display_value, index|
+          #http://www.evc-cit.info/cit020/beginning-programming/chp_04/file_printf.html
+          printf "%2s", display_value
+          print " | " unless index == (row.size - 1)
+        end
+        print "\n"
+        puts "_"*(row.size * 5) unless row.equal? display_values.last
+      end
+    end
+  end
+end

data/lib/tictactoe/game.rb

@@ -0,0 +1,129 @@
+require_relative 'io_terminal'
+require_relative 'board_presenter_terminal'
+require_relative 'game_config'
+require_relative 'squares_factory'
+
+module TTT
+  class Game
+    attr_accessor :board, :players, :board_presenter, :number_of_turns_taken, :config
+    attr_reader :io, :input_helper
+
+    def initialize(args = {})
+      @io = args.fetch(:io, IOTerminal.new)
+      @board_presenter = args.fetch(:board_presenter, BoardPresenterTerminal.new)
+      @input_helper = InputHelper.new(@io)
+      @number_of_turns_taken = 0
+      # below finds the user needed input needed for initial players and board configuration and stores in config object
+      @config = GameConfig.new(@input_helper)
+      @players = generate_players
+      @board = generate_board
+    end
+
+    #overriding so that io and input_helper always in harmony
+    def io=(new_io)
+      @io = new_io
+      self.input_helper = InputHelper.new(new_io)
+    end
+
+    def generate_players
+      player_1 = Player.new(value: config.player_1_value, name: config.player_1_name, type: :human)
+      player_2 = Player.new(value: config.player_2_value, name: config.player_2_name, type: config.player_2_type, difficulty_level: config.computer_difficulty_level)
+      [player_1, player_2]
+    end
+
+    def generate_board
+      number_of_rows_cols = config.number_of_rows_cols
+      Board.new(rows_and_cols: number_of_rows_cols, squares: SquaresFactory.build_empty_squares(number_of_rows_cols) )
+    end
+
+    def play
+      while !over?
+        print_board
+        square_choice = get_square_choice
+        #note that change_square moves current_player forward only if game is not won
+        change_square(square_choice, current_player.value)
+      end
+
+      if won?
+        print_board
+        io.present_with_new_line("#{current_player.name} wins!")
+      else
+        print_board
+        io.present_with_new_line("Draw!")
+      end
+    end
+
+    def get_square_choice
+      if current_player.type == :human
+        input_helper.get_square_to_change(current_player.name, available_choices)
+      elsif current_player.type == :computer
+        input_helper.computer_choosing_graphic
+        if current_player.difficulty_level == :difficult
+          perfect_move
+        elsif current_player.difficulty_level == :easy
+          random_move
+        end
+      end
+    end
+
+    def change_square(display_value, new_value)
+      board.change_square(display_value, new_value)
+      if !won?
+        move_forward_one_turn
+      end
+    end
+
+    def over?
+      board.full? || board.won?
+    end
+
+    def won?
+      board.won?
+    end
+
+    def winner
+      #each move is immediately proceeded by an increment to number_of_selections_made; therefore, need to rewind won to find winner
+      if !won?
+        return nil
+      end
+      current_player
+    end
+
+    def perfect_move
+      move_generator = MoveGenerator.new(self)
+      move_generator.minimax
+      move_generator.choice
+    end
+
+    def random_move
+      available_choices.sample
+    end
+
+    def available_choices
+      board.available_choices
+    end
+
+    def print_board
+      board_presenter.present_board(board)
+    end
+
+    def current_player
+      players[current_turn_player_index]
+    end
+
+    def move_forward_one_turn
+      self.number_of_turns_taken += 1
+    end
+
+    private
+
+    def number_of_players
+      players.size
+    end
+
+
+    def current_turn_player_index
+      (number_of_turns_taken % number_of_players)
+    end
+  end
+end

data/lib/tictactoe/game_config.rb

@@ -0,0 +1,71 @@
+module TTT
+  class GameConfig
+    attr_accessor :input_helper
+
+    attr_accessor :player_1_name
+    attr_accessor :player_1_value
+    attr_accessor :player_2_type
+    attr_accessor :player_2_name
+    attr_accessor :player_2_value
+    attr_accessor :computer_difficulty_level
+    attr_accessor :number_of_rows_cols
+
+    def initialize(input_helper)
+      @input_helper = input_helper
+      setup
+
+    end
+
+    def setup
+      set_player_1_values
+      set_player_2_values
+      set_board_rows_cols
+    end
+
+    def set_player_1_values
+      self.player_1_name = input_helper.get_player_1_name
+      self.player_1_value = input_helper.get_player_1_value(player_1_name)
+    end
+
+    def set_player_2_values
+      self.player_2_type = input_helper.get_player_2_type
+      if player_2_human?
+        self.player_2_name = input_helper.get_player_2_name
+        self.player_2_value = input_helper.get_player_2_value(player_1_value)
+      elsif player_2_computer?
+        self.player_2_name = "Computer"
+        self.player_2_value = get_computer_value
+        self.computer_difficulty_level = input_helper.get_computer_difficulty_level
+      end
+    end
+
+    def set_board_rows_cols
+      #need this if else logic because if computer is difficult, it runs minimax, which is too slow to allow for more than 3 rows/cols
+      if computer_difficult?
+        self.number_of_rows_cols = input_helper.get_number_of_rows_cols_max_3
+      else
+        self.number_of_rows_cols = input_helper.get_number_of_rows_cols_max_9
+      end
+    end
+
+    def player_2_human?
+      player_2_type == :human
+    end
+
+    def player_2_computer?
+      player_2_type == :computer
+    end
+
+    def computer_difficult?
+      computer_difficulty_level == :difficult
+    end
+
+    def get_computer_value
+      if player_2_value != "O"
+        "O"
+      else
+        "X"
+      end
+    end
+  end
+end

data/lib/tictactoe/input_helper.rb

@@ -0,0 +1,99 @@
+module TTT
+  class InputHelper
+    attr_accessor :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def get_number_of_rows_cols_max_3
+      get_user_input("Please choose how many squares you would like in each row.", "Please choose number between 2 and 3.") do |input|
+        input.to_i >=2 && input.to_i <=3
+      end
+    end
+
+    def get_number_of_rows_cols_max_9
+      get_user_input("Please choose how many squares you would like in each row.", "Please choose number between 2 and 3.") do |input|
+        input.to_i >=2 && input.to_i <=9
+      end
+    end
+
+    def get_player_1_value(player_name = "Player 1")
+      user_choice = get_user_input("#{player_name}, please enter a value of either X or O", "Must be X or O. Please re-enter.") do |input|
+        input == 'x' || input == 'X' || input == 'o' || input == 'O'
+      end
+      user_choice.upcase
+    end
+
+    def get_player_2_value(taken_value)
+      user_choice = get_user_input("Player 2, please enter your value", "Must not be #{taken_value}, please re-enter") do |input|
+        input.upcase != taken_value
+      end
+      user_choice.upcase
+    end
+
+    def get_player_1_name
+      user_choice = get_user_input("Player 1, please enter your name", "Please re-enter your name, using only letters") do |input|
+        input =~ /^[a-zA-Z]+$/
+      end
+      user_choice.capitalize
+    end
+
+    def get_player_2_name
+      user_choice = get_user_input("Player 2, please enter your name", "Please re-enter your name, using only letters") do |input|
+        input =~ /^[a-zA-Z]+$/
+      end
+      user_choice.capitalize
+    end
+
+    def get_player_2_type
+      user_choice = get_user_input("Please enter \"C\" if you would like to play the Computer. Enter \"H\" if you would like to play the human sitting next to you.", "Invalid character. Please enter either C(Computer) or H(Human).") do |input|
+        input == 'c' || input == 'C' || input == 'h' || input == 'H'
+      end
+      user_choice = user_choice.upcase
+      if user_choice == "C"
+        :computer
+      elsif user_choice == "H"
+        :human
+      end
+    end
+
+    def get_computer_difficulty_level
+      user_choice = get_user_input("Please enter \"E\" if you would like to play an easy Computer. Enter \"D\" if you would like to play an extremely difficult computer.", "Invalid character. Please enter either E (Easy) or D (Difficult).") do |input|
+        input == 'd' || input == 'D' || input == 'e' || input == 'E'
+      end
+      user_choice = user_choice.upcase
+      if user_choice == "D"
+        :difficult
+      elsif user_choice == "E"
+        :easy
+      end
+    end
+
+    def get_square_to_change(player_name, available_choices)
+      get_user_input("#{player_name}, please enter the number of the square that you would like to change.", "Invalid entry. Please try again.") do |input|
+        available_choices.include?(input)
+      end
+    end
+
+    def get_user_input(prompt, reprompt, &block_validation)
+      io.present_with_new_line(prompt)
+      user_choice = nil
+      while true
+        user_choice = io.receive
+        break if block_validation.call(user_choice)
+        puts reprompt
+      end
+      user_choice
+    end
+
+    def computer_choosing_graphic
+      io.present("Computer choosing.")
+      3.times do
+        sleep(0.3)
+        io.present(".")
+      end
+      io.present("\n")
+    end
+  end
+end

data/lib/tictactoe/io_terminal.rb

@@ -0,0 +1,25 @@
+module TTT
+  class IOTerminal
+    def present(prompt)
+      print prompt
+    end
+
+    def present_with_new_line(prompt)
+      puts prompt
+    end
+
+    def receive
+      result = gets.chomp
+      if is_int?(result)
+        return result.to_i
+      else
+        return result.chomp
+      end
+    end
+
+    private
+    def is_int?(figure)
+      Integer(figure) rescue false
+    end
+  end
+end

data/lib/tictactoe/move_generator.rb

@@ -0,0 +1,70 @@
+module TTT
+  class MoveGenerator
+
+    attr_accessor :game, :choice
+
+    def initialize(game)
+      @game = game
+    end
+
+    #returns int representing display value of random available square
+    def random_move
+      available_choices.sample
+    end
+
+    def minimax
+      scores = []
+      choices = []
+      if game.over?
+        return score(game)
+      end
+
+      available_choices.each do |available_choice|
+        new_game_state = Marshal.load(Marshal.dump(game))
+        new_game_state.change_square(available_choice, game.current_player.value)
+        #below needed because pry indicates possible_game_state's board not updating after make_move above
+        # possible_game_state.game_board = possible_board_state
+        choices.push(available_choice)
+        new_move_generator = MoveGenerator.new(new_game_state)
+        scores.push new_move_generator.minimax
+      end
+
+      if game.current_player == computer_player
+
+        #https://stackoverflow.com/questions/2149802/in-ruby-what-is-the-cleanest-way-of-obtaining-the-index-of-the-largest-value-in
+        max_score_index = scores.each_with_index.max[1]
+        @choice = choices[max_score_index]
+        return scores[max_score_index]
+      else
+        # This is the min calculation
+        min_score_index = scores.each_with_index.min[1]
+        @choice = choices[min_score_index]
+        return scores[min_score_index]
+      end
+
+    end
+
+    private
+    def available_choices
+      game.available_choices
+    end
+
+    def score(game)
+      if game.won? && game.winner == computer_player
+        return +1
+      elsif game.won? && game.winner == player_1
+        return -1
+      else
+        return 0
+      end
+    end
+
+    def player_1
+      game.players[0]
+    end
+
+    def computer_player
+      game.players[1]
+    end
+  end
+end

data/lib/tictactoe/player.rb

@@ -0,0 +1,12 @@
+module TTT
+  class Player
+    attr_accessor :value, :name, :type, :difficulty_level
+
+    def initialize(args = {})
+      @value = args.fetch(:value, "X")
+      @name = args.fetch(:name, "Player 1")
+      @type = args.fetch(:type, :computer)
+      @difficulty_level = args.fetch(:difficulty_level, nil)
+    end
+  end
+end

data/lib/tictactoe/square.rb

@@ -0,0 +1,30 @@
+module TTT
+  class Square
+    attr_accessor :value, :display_value
+    attr_reader :row, :col
+
+    def initialize(args)
+      @value = args[:value]
+      @display_value = args[:display_value]
+      @row = args[:row]
+      @col = args[:col]
+    end
+
+    def change_value(new_value)
+      self.value = new_value
+      self.display_value = new_value
+    end
+
+    def empty?
+      return true unless full?
+    end
+
+    def full?
+      if value != nil
+        return true
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/tictactoe/squares.rb

@@ -0,0 +1,129 @@
+module TTT
+  class Squares
+    attr_reader :collection_of_squares
+
+    #collection_of_squares is a multi-dimensional array
+
+    def initialize(args)
+      @collection_of_squares = args[:collection_of_squares]
+    end
+
+    def retrieve_square(display_value)
+      row = (display_value - 1) / number_of_rows_cols
+      col = (display_value - 1) % number_of_rows_cols
+      if row >= number_of_rows_cols || col >= number_of_rows_cols
+        return nil
+      else
+        return collection_of_squares[row][col]
+      end
+    end
+
+    def display_values
+      collection_of_squares.map do |row|
+        row.map do |square|
+          square.display_value
+        end
+      end
+    end
+
+    def available_choices
+      available_choices = Array.new
+      collection_of_squares.each do |row|
+        row.each do |square|
+          if square.empty?
+            available_choices.push(square.display_value)
+          end
+        end
+      end
+      available_choices
+    end
+
+    def full?
+      collection_of_squares.each do |row|
+        return false if row.all? { |square| square.full? } == false
+      end
+      return true
+    end
+
+    def any_combination_won?
+      possible_winning_combinations.any? do |possible_winning_combination|
+        won?(possible_winning_combination)
+      end
+    end
+
+    def won?(array)
+      #https://stackoverflow.com/questions/3233278/how-do-i-test-if-all-items-in-an-array-are-identical
+      return false if array[0].value == nil
+      array.all? {|square| square.value == array[0].value}
+    end
+
+    def number_of_rows_cols
+      collection_of_squares.length
+    end
+
+    private
+    def cols
+      number_of_rows_cols = collection_of_squares.size
+      cols = Array.new
+      col = 0
+      while col < number_of_rows_cols
+        cols.push (
+                    collection_of_squares.map do |row|
+                      row[col]
+                    end
+                  )
+        col += 1
+      end
+      cols
+    end
+
+    #return collection_of_squares because set up as multidimensional array consisting of rows
+    def rows
+      collection_of_squares
+    end
+
+    def l_to_r_diag
+      number_of_rows_cols = collection_of_squares.size
+      diag = Array.new
+      row = 0
+      col = 0
+      while row < number_of_rows_cols
+        diag.push (
+                    collection_of_squares[row][col]
+                  )
+        row += 1
+        col += 1
+      end
+      diag
+    end
+
+    def r_to_l_diag
+      number_of_rows_cols = collection_of_squares.size
+      diag = Array.new
+      row = 0
+      col = number_of_rows_cols - 1
+      while row < number_of_rows_cols
+        diag.push (
+                    collection_of_squares[row][col]
+                  )
+        row += 1
+        col -= 1
+      end
+      diag
+    end
+
+    def possible_winning_combinations
+      winning_combinations = Array.new
+      winning_combinations.push(l_to_r_diag, r_to_l_diag)
+
+      rows.each do |row|
+        winning_combinations.push(row)
+      end
+
+      cols.each do |col|
+        winning_combinations.push(col)
+      end
+      winning_combinations
+    end
+  end
+end

data/lib/tictactoe/squares_factory.rb

@@ -0,0 +1,56 @@
+require_relative 'squares'
+require_relative 'square'
+
+module TTT
+  module SquaresFactory
+    def self.build_custom_squares(config, squares_class = Squares)
+
+      rows_and_cols = config.length
+
+      #create multi-dimensional array
+      squares = Array.new(rows_and_cols) do
+        Array.new(rows_and_cols)
+      end
+
+      squares.each_with_index do |element, row|
+        element.each_index do |col|
+          squares[row][col] = create_custom_square(config[row][col][0],config[row][col][1], row, col)
+        end
+      end
+
+      squares_class.new(collection_of_squares: squares)
+
+    end
+
+
+    def self.create_custom_square(display_value, value, row, col, square_class = Square)
+      square_class.new(display_value: display_value,
+                       value: value,
+                       row: row,
+                       col: col )
+    end
+
+    def self.build_empty_squares(rows_and_cols, squares_class = Squares)
+      squares = Array.new(rows_and_cols) do
+        Array.new(rows_and_cols)
+      end
+
+      i = 1
+      squares.each_with_index do |element, row|
+        element.each_index do |col|
+          squares[row][col] = create_empty_square(i, row, col)
+          i += 1
+        end
+      end
+
+      squares_class.new(collection_of_squares: squares)
+    end
+
+    def self.create_empty_square(display_value, row, col, square_class = Square)
+      square_class.new(display_value: display_value,
+                       value: nil,
+                       row: row,
+                       col: col )
+    end
+  end
+end

data/lib/tictactoe/version.rb

@@ -0,0 +1,3 @@
+module TTT
+  VERSION = "0.1.0"
+end

data/lib/tictactoe.rb

@@ -0,0 +1,9 @@
+Dir["./lib/tictactoe/*.rb"].each {|file| require file }
+
+class TicTacToe
+  io = TTT::IOTerminal.new
+  board_presenter = TTT::BoardPresenterTerminal.new
+
+  game = TTT::Game.new(io: io, board_presenter: board_presenter)
+  game.play
+end

data/tictactoe.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tictactoe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tic_tac_toe_bfox"
+  spec.version       = TTT::VERSION
+  spec.authors       = ["Brett Fox"]
+  spec.email         = ["brettfox11@gmail.com"]
+
+  spec.summary       = %q{Command line tic tac toe}
+  spec.description   = %q{In order to play the game, please type "tictactoe" at the command line.}
+  spec.homepage      = "https://github.com/brett11/tic_tac_toe_2"
+
+  # # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: tic_tac_toe_bfox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brett Fox
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: In order to play the game, please type "tictactoe" at the command line.
+email:
+- brettfox11@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/setup
+- bin/tictactoe
+- lib/tictactoe.rb
+- lib/tictactoe/board.rb
+- lib/tictactoe/board_presenter_terminal.rb
+- lib/tictactoe/game.rb
+- lib/tictactoe/game_config.rb
+- lib/tictactoe/input_helper.rb
+- lib/tictactoe/io_terminal.rb
+- lib/tictactoe/move_generator.rb
+- lib/tictactoe/player.rb
+- lib/tictactoe/square.rb
+- lib/tictactoe/squares.rb
+- lib/tictactoe/squares_factory.rb
+- lib/tictactoe/version.rb
+- tictactoe.gemspec
+homepage: https://github.com/brett11/tic_tac_toe_2
+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.6.10
+signing_key: 
+specification_version: 4
+summary: Command line tic tac toe
+test_files: []