tic_tac_toes 0.0.7 → 0.0.8

data/lib/tic_tac_toes/move_strategies/human.rb

@@ -1,18 +0,0 @@
-module TicTacToes
-  module MoveStrategies
-    class Human
-      def initialize(io)
-        @io = io
-      end
-
-      def move(board, players)
-        @io.move_solicitation
-
-        Integer(@io.solicit_input)
-        rescue ArgumentError
-          @io.not_an_integer_error
-          move(board, players)
-      end
-    end
-  end
-end

data/lib/tic_tac_toes/move_strategies/medium_ai.rb

@@ -1,13 +0,0 @@
-require 'tic_tac_toes/move_strategies/easy_ai'
-require 'tic_tac_toes/move_strategies/hard_ai'
-
-module TicTacToes
-  module MoveStrategies
-    module MediumAI
-      def self.move(board, players)
-        move_strategy = [EasyAI, HardAI, HardAI].sample
-        move_strategy.move(board, players)
-      end
-    end
-  end
-end

data/lib/tic_tac_toes/player.rb

@@ -1,20 +0,0 @@
-module TicTacToes
-  class Player
-    attr_reader :move_strategy, :token, :needs_to_think
-
-    def initialize(move_strategy, token, needs_to_think, io)
-      @move_strategy = move_strategy
-      @token = token
-      @needs_to_think = needs_to_think
-      @io = io
-    end
-
-    def place_and_return_move(board, players)
-      loop do
-        space = @move_strategy.move(board, players)
-        break [@token, space] if board.place(self, space)
-        @io.invalid_move_error
-      end
-    end
-  end
-end

data/lib/tic_tac_toes/player_factory.rb

@@ -1,28 +0,0 @@
-require 'tic_tac_toes/move_strategies/human'
-require 'tic_tac_toes/move_strategies/easy_ai'
-require 'tic_tac_toes/move_strategies/medium_ai'
-require 'tic_tac_toes/move_strategies/hard_ai'
-require 'tic_tac_toes/player'
-
-module TicTacToes
-  class PlayerFactory
-    def initialize(io)
-      @io = io
-    end
-
-    AIS = { 
-      easy:    ::TicTacToes::MoveStrategies::EasyAI,
-      medium:  ::TicTacToes::MoveStrategies::MediumAI,
-      hard:    ::TicTacToes::MoveStrategies::HardAI }
-
-    def generate_human_player(token)
-      needs_to_think = false
-      Player.new(TicTacToes::MoveStrategies::Human.new(@io), token, needs_to_think, @io)
-    end
-
-    def generate_computer_player(token, difficulty)
-      needs_to_think = true
-      Player.new(AIS[difficulty], token, needs_to_think, @io)
-    end
-  end
-end

data/lib/tic_tac_toes/rules.rb

@@ -1,64 +0,0 @@
-require 'tic_tac_toes/player_factory'
-
-module TicTacToes
-  module Rules
-    ROW_SIZE_RANGE = (2..10)
-
-    def self.row_size_valid?(row_size)
-      row_size.between?(ROW_SIZE_RANGE.min, ROW_SIZE_RANGE.max)
-    end
-
-    def self.token_valid?(token, taken_tokens)
-      correct_length = token.length == 1
-      untaken = !taken_tokens.include?(token)
-
-      correct_length && untaken
-    end
-
-    def self.difficulty_valid?(difficulty)
-      PlayerFactory::AIS.include? difficulty
-    end
-
-    def self.game_over?(board, players)
-      winner = !determine_winner(board, players).nil?
-      tie = board.full?
-
-      winner || tie
-    end
-
-    def self.determine_winner(board, players)
-      winner = nil
-
-      players.each do |player|
-        player_has_won = win?(board, player)
-        winner = player.token if player_has_won
-      end
-
-      winner
-    end
-
-    def self.win?(board, player)
-      diagonal_win?(board, player) ||
-      horizontal_win?(board, player) ||
-      vertical_win?(board, player)
-    end
-
-    private
-
-    def self.diagonal_win?(board, player)
-      set_win?(board.diagonals, player)
-    end
-
-    def self.horizontal_win?(board, player)
-      set_win?(board.rows, player)
-    end
-
-    def self.vertical_win?(board, player)
-      set_win?(board.columns, player)
-    end
-
-    def self.set_win?(sets, player)
-      sets.any? { |set| set.all? { |space| space.token == player.token unless space.nil?  } }
-    end
-  end
-end

data/lib/tic_tac_toes/strings.rb

@@ -1,104 +0,0 @@
-require 'command_line/prompt'
-require 'tic_tac_toes/rules'
-
-module TicTacToes
-  module Strings
-    smallest_row_size = Rules::ROW_SIZE_RANGE.min
-    largest_row_size = Rules::ROW_SIZE_RANGE.max
-
-    NOT_AN_INTEGER           =  "Input must be an integer"
-    INVALID_ROW_SIZE         =  "Input must be between #{smallest_row_size} and #{largest_row_size}"
-    INVALID_TOKEN            =  "Input must be a single, untaken character"
-    INVALID_DIFFICULTY       =  "Input must be a valid difficulty"
-    INVALID_MOVE             =  "Input must be a space that is on the board and untaken"
-    ROW_SIZE_SOLICITATION    =  "Pick row size of board:"
-    DIFFICULTY_SOLICITATION  =  "Pick difficulty (easy, medium, hard):"
-    MOVE_SOLICITATION        =  "Pick a space:"
-    THINKING                 =  "Thinking..."
-
-    def self.token_solicitation(player)
-      "Pick #{player} token:"
-    end
-
-    def self.game_over_notification(winner)
-      "#{winner} wins!"
-    end
-
-    def self.board(board)
-      board_string = ""
-      board.rows.each_with_index do |row, index|
-        row_start_index = (index * board.row_size).to_i
-        at_last_row = index == board.row_size - 1
-        board_string << "\n"
-        board_string << row(row, row_start_index, board.size)
-        board_string << "\n"
-        board_string << horizontal_divider(board.row_size, board.size) unless at_last_row
-      end
-      board_string << "\n"
-    end
-
-    private
-
-    def self.row(row, row_start_index, board_size)
-      row_array = []
-      row.each_with_index do |space, index|
-        if space.nil?
-          board_index = index + row_start_index
-          row_array << empty_space(board_index, board_size)
-        else
-          row_array << token(space, board_size)
-        end
-      end
-      row_array.join("|")
-    end
-
-    def self.empty_space(board_index, board_size)
-      if space_needs_buffer?(board_index, board_size)
-        "[ #{board_index}]"
-      else
-        "[#{board_index}]"
-      end
-    end
-
-    def self.token(space, board_size)
-      token = get_colored_token(space)
-
-      if double_digit_board?(board_size)
-        "  #{token} "
-      else
-        " #{token} "
-      end
-    end
-
-    def self.get_colored_token(player)
-      if player.needs_to_think
-        return CommandLine::Prompt.red(player.token)
-      else
-        return CommandLine::Prompt.blue(player.token)
-      end
-    end
-
-    def self.space_needs_buffer?(board_index, board_size)
-      is_double_digit_board = double_digit_board?(board_size)
-      is_single_digit_space = board_index < 10
-
-      is_double_digit_board && is_single_digit_space
-    end
-
-    def self.double_digit_board?(board_size)
-      board_size > 10
-    end
-
-    def self.horizontal_divider(row_size, board_size)
-      horizontal_divider = ""
-      divider_unit = "-"
-      divider_units_per_space = double_digit_board?(board_size) ? 5 : 4
-      extra_units_per_row = 1
-
-      raw_length = (row_size * divider_units_per_space).to_i
-      truncated_length = raw_length - extra_units_per_row
-      truncated_length.times { horizontal_divider << divider_unit }
-      horizontal_divider
-    end
-  end
-end

data/lib/ui/adapter.rb

@@ -1,94 +0,0 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/game_state'
-require 'tic_tac_toes/player_factory'
-require 'tic_tac_toes/rules'
-
-module UI
-  module Adapter
-    def self.new_board_structure
-      board = TicTacToes::Board.new
-      board.spaces
-    end
-
-    def self.make_move(board_structure, move, listener)
-      move = move.to_i
-      game_state = game_state_from_board_structure(board_structure)
-
-      human_player = game_state.players.first
-      game_state.board.place(human_player, move)
-
-      if TicTacToes::Rules.game_over?(game_state.board, game_state.players)
-        return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
-      end
-
-      game_state.turn_over(move)
-
-      computer_player = game_state.players.first
-      computer_player.place_and_return_move(game_state.board, game_state.players)
-
-      if TicTacToes::Rules.game_over?(game_state.board, game_state.players)
-        return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
-      end
-
-      listener.move_was_valid(game_state_to_board_structure(game_state))
-    end
-
-    def self.game_state_from_board_structure(board_structure)
-      player_factory = TicTacToes::PlayerFactory.new('unused_io')
-      human_player = player_factory.generate_human_player('X')
-      computer_player = player_factory.generate_computer_player('O', :hard)
-      players = [human_player, computer_player]
-
-      board_structure_with_players = replace_tokens_with_players(board_structure, human_player, computer_player)
-      board = board_from_structure(board_structure_with_players)
-
-      TicTacToes::GameState.new(board, players, NullHistory.new)
-    end
-
-    def self.game_state_to_board_structure(game_state)
-      structure_with_players = game_state.board.spaces
-
-      replace_players_with_tokens(structure_with_players)
-    end
-
-    private
-
-    def self.replace_tokens_with_players(board_structure, human_player, computer_player)
-      board_structure.map do |space|
-        case space
-        when 'X'
-          human_player
-        when 'O'
-          computer_player
-        else
-          nil
-        end
-      end
-    end
-
-    def self.replace_players_with_tokens(board_structure)
-      board_structure.map { |space| space.token unless space.nil? }
-    end
-
-    def self.board_from_structure(board_structure)
-      row_size = Math.sqrt(board_structure.count).to_i
-      board = TicTacToes::Board.new(row_size: row_size)
-
-      board_structure.each_with_index do |player, index|
-        board.place(player, index)
-      end
-
-      board
-    end
-  end
-
-  class NullHistory
-    def record_board_size(size)
-      nil
-    end
-
-    def record_move(move)
-      nil
-    end
-  end
-end

data/spec/test_board_generator.rb

@@ -1,15 +0,0 @@
-require 'tic_tac_toes/board'
-
-module TestBoardGenerator
-  def self.generate(structure)
-    board_size = structure.count
-    row_size = Math.sqrt(board_size)
-    board = TicTacToes::Board.new(row_size: row_size)
-
-    structure.each_with_index do |player, index|
-      board.place(player, index)
-    end
-
-    board
-  end
-end

data/spec/tic_tac_toes/game_state_spec.rb

@@ -1,66 +0,0 @@
-require 'tic_tac_toes/game_state'
-
-describe TicTacToes::GameState do
-  describe '@initialize' do
-    it "records its board's size" do
-      size = 5
-      board = double(size: size)
-      history = double
-
-      expect(history).to receive(:record_board_size).with(size)
-      TicTacToes::GameState.new(board, 'players', history)
-    end
-  end
-
-  describe '#current_player' do
-    it 'returns the first item of its players array' do
-      history = double(record_board_size: true)
-      players = ['first_player', 'second_player']
-      game_state = TicTacToes::GameState.new('board', players, history)
-
-      current_player = game_state.current_player
-      expect(current_player).to eq('first_player')
-    end
-  end
-
-  describe '#turn_over' do
-    it 'records the last move' do
-      move = double
-      players = double(rotate!: true)
-      history = double(record_board_size: true)
-      game_state = TicTacToes::GameState.new('board', players, history)
-
-      expect(history).to receive(:record_move).with(move)
-      game_state.turn_over(move)
-    end
-
-    it 'rotates its player array' do
-      players = ['first_player', 'second_player']
-      history = double(record_board_size: true, record_move: true)
-      game_state = TicTacToes::GameState.new('board', players, history)
-
-      game_state.turn_over('move')
-      expect(game_state.current_player).to eq('second_player')
-    end
-  end
-
-  describe '#game_over' do
-    it 'records the winner' do
-      winner = double
-      history = double(record_board_size: true, persist: true)
-      game_state = TicTacToes::GameState.new('board', 'players', history)
-
-      expect(history).to receive(:record_winner).with(winner)
-      game_state.game_over(winner)
-    end
-
-    it 'persists its history' do
-      winner = double
-      history = double(record_board_size: true, record_winner: true)
-      game_state = TicTacToes::GameState.new('board', 'players', history)
-
-      expect(history).to receive(:persist)
-      game_state.game_over(winner)
-    end
-  end
-end

data/spec/tic_tac_toes/move_strategies/easy_ai_spec.rb

@@ -1,19 +0,0 @@
-require 'test_board_generator'
-require 'tic_tac_toes/move_strategies/easy_ai'
-
-describe TicTacToes::MoveStrategies::EasyAI do
-  describe '#move' do
-    let(:players) { double("players") }
-    let(:easy_ai) { TicTacToes::MoveStrategies::EasyAI }
-
-    it "returns a randomly-selected valid move" do
-      board = TestBoardGenerator.generate([ :O, nil, nil,
-                                           nil,  :X, nil,
-                                           nil,  :X, nil])
-      valid_moves = [1, 2, 3, 5, 6, 8]
-
-      move = easy_ai.move(board, players)
-      expect(valid_moves).to include(move)
-    end
-  end
-end

data/spec/tic_tac_toes/move_strategies/hard_ai_spec.rb

@@ -1,121 +0,0 @@
-require 'test_board_generator'
-require 'tic_tac_toes/move_strategies/hard_ai'
-require 'tic_tac_toes/player'
-
-describe TicTacToes::MoveStrategies::HardAI do
-  let(:hard_ai) { TicTacToes::MoveStrategies::HardAI }
-  let(:x) { TicTacToes::Player.new("human", "x", false, "io") }
-  let(:o) { TicTacToes::Player.new(hard_ai, "o", true, "io") }
-  let(:players) { [o, x] }
-
-
-  describe '#move' do
-    it "returns the best move" do
-      board = TestBoardGenerator.generate([x, nil, nil,
-                                           o,   o, nil,
-                                           x, nil,   x])
-      best_move = 5
-
-      expect(hard_ai.move(board, players)).to eql(best_move)
-    end
-
-    context "when playing on a 3x3 board" do
-      it "returns 4 when the opponent’s first move was a corner" do
-        board = TestBoardGenerator.generate([nil, nil, nil,
-                                             nil, nil, nil,
-                                             nil, nil,   x])
-
-        expect(hard_ai.move(board, players)).to eq(4)
-      end
-      
-      it "returns 4 when the opponent’s first move was an edge" do
-        board = TestBoardGenerator.generate([nil, nil, nil,
-                                             nil, nil,   x,
-                                             nil, nil, nil])
-
-        expect(hard_ai.move(board, players)).to eq(4)
-      end
-
-      it "returns 0 when the opponent’s first move was the center" do
-        board = TestBoardGenerator.generate([nil, nil, nil,
-                                             nil,   x, nil,
-                                             nil, nil, nil])
-
-        expect(hard_ai.move(board, players)).to eq(0)
-      end
-    end
-  end
-
-
-  describe '#minimax' do
-    it "returns the correct score for a pre-win board" do
-      board = TestBoardGenerator.generate([x, nil, nil,
-                                           o,   o, nil,
-                                           x, nil,   x])
-      win_score = 1
-
-      expect(hard_ai.minimax(board, :max, players)).to eql(win_score)
-    end
-
-    it "returns the correct score for a pre-loss board" do
-      board = TestBoardGenerator.generate([  o,   o,   x,
-                                           nil, nil, nil,
-                                             x, nil,   x])
-      loss_score = -1
-
-      expect(hard_ai.minimax(board, :max, players)).to eql(loss_score)
-    end
-
-    it "returns the correct score for a pre-draw board" do
-      board = TestBoardGenerator.generate([x,   x, o,
-                                           o, nil, x,
-                                           x,   o, x])
-      draw_score = 0
-
-      expect(hard_ai.minimax(board, :max, players)).to eql(draw_score)
-    end
-  end
-
-
-  describe '#generate_board' do
-    it "returns a board based on a token, a space, and an existing board" do
-      token, space = o, 3
-      board = TestBoardGenerator.generate([  x, nil, nil,
-                                           nil,   o, nil,
-                                             x, nil, nil])
-
-      new_board = hard_ai.generate_board(token, space, board)
-      expect(new_board.space(space)).to eql(token)
-    end
-  end
-
-
-  describe '#score' do
-    it "returns the correct score when HardAI has won" do
-      board = TestBoardGenerator.generate([  o, nil, nil,
-                                           nil,   o, nil,
-                                           nil, nil,   o])
-      win_score = 1
-
-      expect(hard_ai.score(board, players)).to eql(win_score)
-    end
-
-    it "returns the correct score when no one has won" do
-      board = TestBoardGenerator.generate([o, o, x,
-                                           x, x, o,
-                                           o, x, o])
-      draw_score = 0
-
-      expect(hard_ai.score(board, players)).to eql(draw_score)
-    end
-
-    it "returns the correct score when the opponent has won" do
-      board = TestBoardGenerator.generate([  x, nil, nil,
-                                           nil,   x, nil,
-                                           nil, nil,   x])
-      loss_score = -1
-
-      expect(hard_ai.score(board, players)).to eql(loss_score)
-    end
-  end
-end

data/spec/tic_tac_toes/move_strategies/medium_ai_spec.rb

@@ -1,21 +0,0 @@
-require 'test_board_generator'
-require 'tic_tac_toes/move_strategies/medium_ai'
-
-describe TicTacToes::MoveStrategies::MediumAI do
-  let(:medium_ai) { TicTacToes::MoveStrategies::MediumAI }
-  let(:x) { TicTacToes::Player.new("human", "x", false, "io") }
-  let(:o) { TicTacToes::Player.new(medium_ai, "o", true, "io") }
-  let(:players) { [x, o] }
-
-  describe '#move' do
-    it "returns a valid move (based on either EasyAI or HardAI)" do
-      board = TestBoardGenerator.generate([  o, o,   x,
-                                           nil, x, nil,
-                                           nil, x, nil])
-      valid_moves = [3, 5, 6, 8]
-
-      move = medium_ai.move(board, players)
-      expect(valid_moves).to include(move)
-    end
-  end
-end