tic_tac_toes 0.0.2 → 0.0.3

data/lib/tic_tac_toes/medium_ai.rb

@@ -1,11 +0,0 @@
-require 'tic_tac_toes/easy_ai'
-require 'tic_tac_toes/hard_ai'
-
-module TicTacToes
-  module MediumAI
-    def self.make_move(board, players)
-      ai = [EasyAI, HardAI, HardAI].sample
-      ai.make_move(board, players)
-    end
-  end
-end

data/spec/tic_tac_toes/easy_ai_spec.rb

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

data/spec/tic_tac_toes/hard_ai_spec.rb

@@ -1,103 +0,0 @@
-require 'tic_tac_toes/hard_ai'
-require 'tic_tac_toes/player'
-require 'tic_tac_toes/spec_helper'
-
-describe TicTacToes::HardAI do
-  let(:ai) { TicTacToes::HardAI }
-  let(:x) { TicTacToes::Player.new("decider", "x", false, "interface") }
-  let(:o) { TicTacToes::Player.new(ai, "o", true, "interface") }
-  let(:players) { [o, x] }
-
-
-  describe '#make_move' do
-    it "returns the best move" do
-      structure = [x, nil, nil,
-                   o,   o, nil,
-                   x, nil,   x]
-      board = generate_board(structure)
-      best_move = 5
-
-      expect(ai.make_move(board, players)).to eql(best_move)
-    end
-  end
-
-
-  describe '#minimax' do
-    it "returns the correct score for a pre-win board" do
-      structure = [x, nil, nil,
-                   o,   o, nil,
-                   x, nil,   x]
-      board = generate_board(structure)
-      win_score = 1
-
-      expect(ai.minimax(board, :max, players)).to eql(win_score)
-    end
-
-    it "returns the correct score for a pre-loss board" do
-      structure = [  o,   o,   x,
-                   nil, nil, nil,
-                     x, nil,   x]
-      board = generate_board(structure)
-      loss_score = -1
-
-      expect(ai.minimax(board, :max, players)).to eql(loss_score)
-    end
-
-    it "returns the correct score for a pre-draw board" do
-      structure = [x,   x, o,
-                   o, nil, x,
-                   x,   o, x]
-      board = generate_board(structure)
-      draw_score = 0
-
-      expect(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
-      structure = [  x, nil, nil,
-                   nil,   o, nil,
-                     x, nil, nil]
-      board = generate_board(structure)
-
-      new_board = 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
-      structure = [  o, nil, nil,
-                   nil,   o, nil,
-                   nil, nil,   o]
-      board = generate_board(structure)
-      win_score = 1
-
-      expect(ai.score(board, players)).to eql(win_score)
-    end
-
-    it "returns the correct score when no one has won" do
-      structure = [o, o, x,
-                   x, x, o,
-                   o, x, o]
-      board = generate_board(structure)
-      draw_score = 0
-
-      expect(ai.score(board, players)).to eql(draw_score)
-    end
-
-    it "returns the correct score when the opponent has won" do
-      structure = [  x, nil, nil,
-                   nil,   x, nil,
-                   nil, nil,   x]
-      board = generate_board(structure)
-      loss_score = -1
-
-      expect(ai.score(board, players)).to eql(loss_score)
-    end
-  end
-end

data/spec/tic_tac_toes/io_interface_spec.rb

@@ -1,175 +0,0 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/io_interface'
-require 'tic_tac_toes/spec_helper'
-require 'tic_tac_toes/strings'
-
-describe TicTacToes::IOInterface do
-  let(:strings) { TicTacToes::Strings }
-  let(:io) { double("io", solicit_input: 0, display: true, display_red: true) }
-  let(:io_interface) { TicTacToes::IOInterface.new(io) }
-
-
-  describe '#make_move' do
-    it "displays a move solicitation" do
-      expect(io_interface).to receive(:move_solicitation)
-      io_interface.make_move("_board", "_players")
-    end
-
-    context 'when given not-integer-like input' do
-      let(:not_integer_like) { "string" }
-      let(:integer_like) { "100" }
-
-      it "displays a not an integer error" do
-        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
-
-        expect(io_interface).to receive(:not_an_integer_error).once
-        io_interface.make_move("_board", "_players")
-      end
-
-      it "only returns a move (converted to integer) once it gets integer-like input" do
-        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
-
-        expect(io_interface.make_move("_board", "_players")).to eq(100)
-      end
-    end
-  end
-
-
-  describe '#get_row_size' do
-    it "displays a row size solicitation" do
-      expect(io_interface).to receive(:row_size_solicitation)
-      io_interface.get_row_size
-    end
-
-    context 'when given not-integer-like input' do
-      let(:not_integer_like) { "string" }
-      let(:integer_like) { "100" }
-
-      it "displays a not an integer error" do
-        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
-
-        expect(io_interface).to receive(:not_an_integer_error).once
-        io_interface.get_row_size
-      end
-
-      it "only returns a row size (converted to integer) once it gets integer-like input" do
-        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
-
-        expect(io_interface.get_row_size).to eq(100)
-      end
-    end
-  end
-
-
-  describe '#get_token' do
-    let(:player) { double("player") }
-
-    it "displays a token solicitation with the name of the player whose token is to be set" do
-      expect(io_interface).to receive(:token_solicitation).with(player)
-      io_interface.get_token(player)
-    end
-
-    it "returns the user input" do
-      token = "X"
-      allow(io).to receive(:solicit_input) { token }
-
-      expect(io_interface.get_token(player)).to equal(token)
-    end
-  end
-
-
-  describe '#get_difficulty' do
-    let(:difficulty) { "HARD" }
-
-    it "displays a difficulty solicitation" do
-      allow(io).to receive(:solicit_input) { difficulty }
-
-      expect(io_interface).to receive(:difficulty_solicitation)
-      io_interface.get_difficulty
-    end
-
-    it "returns the user input (downcased and converted into a symbol)" do
-      allow(io).to receive(:solicit_input) { difficulty }
-
-      expect(io_interface.get_difficulty).to equal(:hard)
-    end
-  end
-
-
-  describe '#draw_board' do
-    it "displays a board string" do
-      board = TicTacToes::Board.new
-      board_string = strings.board(board)
-
-      expect(io).to receive(:display).with(board_string)
-      io_interface.draw_board(board)
-    end
-  end
-
-
-  describe '#invalid_row_size_error' do
-    it "displays a red invalid row size message" do
-      expect(io).to receive(:display_red).with(strings::INVALID_ROW_SIZE)
-      io_interface.invalid_row_size_error
-    end
-  end
-
-
-  describe '#invalid_token_error' do
-    it "displays a red invalid token message" do
-      expect(io).to receive(:display_red).with(strings::INVALID_TOKEN)
-      io_interface.invalid_token_error
-    end
-  end
-
-
-  describe '#invalid_difficulty_error' do
-    it "displays a red invalid difficulty message" do
-      expect(io).to receive(:display_red).with(strings::INVALID_DIFFICULTY)
-      io_interface.invalid_difficulty_error
-    end
-  end
-
-
-  describe '#invalid_move_error' do
-    it "displays a red invalid move message" do
-      expect(io).to receive(:display_red).with(strings::INVALID_MOVE)
-      io_interface.invalid_move_error
-    end
-  end
-
-
-  describe '#thinking_notification' do
-    it "displays a red thinking message" do
-      expect(io).to receive(:display_red).with(strings::THINKING)
-      io_interface.thinking_notification
-    end
-  end
-
-
-  describe '#game_over_notification' do
-    it "displays a game over message with the name of the winner" do
-      winner = :X
-      game_over_message = strings.game_over_notification(winner)
-
-      expect(io).to receive(:display).with(game_over_message)
-      io_interface.game_over_notification(winner)
-    end
-  end
-
-
-  describe '#red' do
-    it "calls its IO's red method with the passed message" do
-      expect(io).to receive(:red).with("message")
-      io_interface.red("message")
-    end
-  end
-
-
-  describe '#blue' do
-    it "calls its IO's blue method with the passed message" do
-      expect(io).to receive(:blue).with("message")
-      io_interface.blue("message")
-    end
-  end
-end

data/spec/tic_tac_toes/medium_ai_spec.rb

@@ -1,22 +0,0 @@
-require 'tic_tac_toes/medium_ai'
-require 'tic_tac_toes/spec_helper'
-
-describe TicTacToes::MediumAI do
-  let(:ai) { TicTacToes::MediumAI }
-  let(:x) { TicTacToes::Player.new("decider", "x", false, "interface") }
-  let(:o) { TicTacToes::Player.new(ai, "o", true, "interface") }
-  let(:players) { [x, o] }
-
-  describe '#make_move' do
-    it "makes a valid move (based on either EasyAI or HardAI)" do
-      structure = [  o, o,   x,
-                   nil, x, nil,
-                   nil, x, nil]
-      board = generate_board(structure)
-      valid_moves = [3, 5, 6, 8]
-
-      move = ai.make_move(board, players)
-      expect(valid_moves).to include(move)
-    end
-  end
-end

data/spec/tic_tac_toes/spec_helper.rb

@@ -1,13 +0,0 @@
-require 'tic_tac_toes/board'
-
-def generate_board(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