mastermind-cmdline 0.0.0

data/bin/mastermind

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require '../lib/mastermind'
+
+
+game_text = Mastermind::GameText.new
+terminal = Mastermind::Terminal.new
+
+Mastermind::Game.new(game_text, terminal).play_game

data/lib/mastermind.rb

@@ -0,0 +1,70 @@
+require_relative './mastermind/GameRules'
+require_relative './mastermind/TerminalInterface'
+require_relative './mastermind/GameStatus'
+require_relative './mastermind/AIsolver'
+
+module Mastermind
+  class Game
+    def initialize(game_text, terminal)
+      @game_text = game_text
+      @terminal = terminal
+      @code_length = 4
+    end
+    
+    def play_game
+      @terminal.display(@game_text.message(:welcome))
+      colors = get_color_scheme
+      code = get_input(colors)
+      set_up_board(code, colors)
+      result = run_ai_player(colors)
+      end_of_game(result)
+    end
+    
+    private
+    
+    def get_color_scheme
+      @terminal.display(@game_text.message(:color_scheme))
+      colors = @terminal.formatted_input 
+      Colors.new(colors).valid_colors
+    end
+   
+    def get_input(colors)
+      @terminal.display(@game_text.message(:prompt) )
+      input = @terminal.formatted_input
+      unless Validator.new(input, @code_length, colors ).valid? 
+        get_input
+      else
+        input
+      end
+    end
+ 
+    def set_up_board(code, colors)
+      @board = GameStatus.new(code, colors)
+    end
+
+    def run_ai_player(colors)
+      algorithm = NaiveAlgorithm.new(colors)
+      player = AIPlayer.new(@board, algorithm)
+      result = player.solve
+      until @board.end_of_game?(result)
+        result = player.solve
+        print_guess(result)
+      end
+      print_guess(result)
+      result
+    end
+
+    def print_guess(result)
+      @terminal.display(@game_text.message(:guess, result))
+    end
+
+    def end_of_game(result)
+      if(result.correct?)
+        @terminal.display(@game_text.message(:win, result))
+      else
+        @terminal.display(@game_text.message(:lose, result))
+      end
+    end
+  end 
+end
+

data/lib/mastermind/AIsolver.rb

@@ -0,0 +1,36 @@
+module Mastermind
+  class NaiveAlgorithm
+    attr_accessor :possible_guesses
+
+    def initialize(valid_letters)
+      @valid_letters = valid_letters
+      @possible_guesses = valid_letters.repeated_permutation(4).to_a
+    end
+   
+    def next_guess
+       @possible_guesses[rand(@possible_guesses.size)]
+    end
+
+    def discard_invalid_guesses(incorrect_guess)
+      discarded_guesses = @possible_guesses.select do |guess|
+        compare_result = CodeComparer.new(incorrect_guess.guess, guess).compare
+        compare_result != incorrect_guess.result_hash
+      end
+      @possible_guesses -= discarded_guesses
+    end
+  end
+
+  class AIPlayer
+    def initialize(board, algorithm)
+      @board = board
+      @algorithm = algorithm
+    end
+   
+    def solve
+      next_guess = @algorithm.next_guess
+      result = @board.process_guess(next_guess)
+      @algorithm.discard_invalid_guesses(result)
+      result
+    end
+  end
+end

data/lib/mastermind/GameRules.rb

@@ -0,0 +1,73 @@
+module Mastermind 
+  DEFAULT_COLORS = %w{R G O Y B P}
+  class CodeComparer
+    def initialize(code, guess)
+      @code = code
+      @guess = guess
+    end
+
+    def compare
+      correct_colors = total_correct_colors - correct_positions
+      {
+        correct_positions: correct_positions, 
+        correct_colors: correct_colors
+      }
+    end
+   
+    private
+ 
+    def correct_positions 
+      code_with_indeces = @code.each_with_index.to_a
+      guess_with_indeces = @guess.each_with_index.to_a
+      intersection = code_with_indeces & guess_with_indeces
+      intersection.size
+    end
+
+    def total_correct_colors 
+      correct_color = 0
+      @code.uniq.each do |letter|
+        correct_color += [@code.count(letter), @guess.count(letter)].min
+      end
+      correct_color
+    end
+  end
+
+  class Validator
+    def initialize(code, code_length, valid_letters)
+      @code = code
+      @code_length = code_length
+      @valid_letters = valid_letters
+    end
+   
+    
+    def valid?
+      correct_length? && valid_letters?
+    end  
+    
+    private
+	
+    def correct_length?
+      @code.size == @code_length
+    end
+
+    def valid_letters?
+      @code.uniq.all? do |letter|
+      @valid_letters.include?letter
+      end
+    end
+  end
+
+  class Colors
+    def initialize(colors = [])
+      if(colors.empty? || colors.size != 6)
+        @colors = DEFAULT_COLORS
+      else 
+        @colors = colors
+      end 
+    end
+    
+    def valid_colors
+      @colors
+    end
+  end
+end

data/lib/mastermind/GameStatus.rb

@@ -0,0 +1,52 @@
+module Mastermind
+  WIN_HASH = {correct_positions: 4, correct_colors:0}
+
+  class GameStatus
+    def initialize(code, colors)
+      @code = code
+      @num_of_tries = 0
+      @colors = colors
+    end
+    
+    def valid_letters
+      @colors
+    end
+
+    def process_guess(guess)
+      @num_of_tries += 1
+      if win?(guess)
+        #Is it worth checking win separately here?
+        result_hash = WIN_HASH 
+      else
+        result_hash = CodeComparer.new(@code, guess).compare
+      end
+      CurrentResult.new(guess, @num_of_tries, result_hash) 
+    end
+
+    def end_of_game?(result)
+      win?(result.guess) || result.num_of_tries == 10
+    end
+
+   
+    private
+ 
+    def win?(guess)
+      @code == guess
+    end
+  end
+
+  class CurrentResult
+    attr_reader :result_hash
+    attr_reader :num_of_tries, :guess
+
+    def initialize(guess, num_of_tries, result_hash)
+      @guess = guess
+      @num_of_tries = num_of_tries
+      @result_hash = result_hash
+    end
+
+    def correct?   
+      @result_hash == WIN_HASH
+    end
+  end
+end

data/lib/mastermind/TerminalInterface.rb

@@ -0,0 +1,37 @@
+module Mastermind
+  class Terminal
+    def display(message)
+      puts message 
+    end 
+
+    def formatted_input(stdin = $stdin)
+       stdin.gets.upcase.split(%r{\s*} )
+    end
+  end
+
+  class GameText 
+    def message(message_type, game_result = [])
+     case message_type
+      when :welcome
+        "Welcome To Mastermind"
+      when :prompt
+        "Please Enter the Code: "
+      when :guess
+        "#{game_result.guess}"
+      when :win
+        if(game_result.num_of_tries == 1)
+          "Solved in #{game_result.num_of_tries} try!"
+        else
+          "Solved in #{game_result.num_of_tries} tries!"
+        end
+      when :lose
+        "Game over. Unable to solve in 10 turns."
+      when :color_scheme
+        "Enter a 6 letter color scheme or press Enter to use default"  
+      else 
+        "Come again?"
+     end
+   end
+ end
+
+end 

data/lib/mastermind/UserInterface.rb

@@ -0,0 +1,25 @@
+module Mastermind
+  class CodeGenerator
+    def initialize(colors, code_length)
+      @colors = colors
+      @code_length = code_length
+      @terminal = Terminal.new
+      @game_text = GameText.new
+    end
+    
+    def get_valid_code
+      input = get_input
+      unless Validator.new(input, @code_length, @colors ).valid? 
+        get_valid_code
+      else
+        input
+      end
+    end
+
+    def get_input
+      @terminal.display(@game_text.message(:prompt) )
+      @terminal.formatted_input
+    end
+      
+  end
+end 

data/test/mastermind_spec.rb

@@ -0,0 +1,256 @@
+require 'rspec'
+require_relative '../lib/mastermind'
+require_relative '../lib/mastermind/AIsolver'
+require_relative '../lib/mastermind/GameRules'
+require_relative '../lib/mastermind/GameStatus'
+require_relative '../lib/mastermind/TerminalInterface'
+
+include Mastermind
+
+DEFAULT_COLORS = %w{R G O Y B P}
+
+describe 'Mastermind' do
+  WIN_HASH = {correct_positions: 4, correct_colors: 0}
+
+  let(:code){ %w{R R R R} }
+  let (:default_colors){ %w{R G O Y B P} }
+
+  describe 'GameStatus' do
+    let (:code){ %w{A B C D} }
+    let (:incorrect_guess){ %w{A C B E} }
+    let (:board){GameStatus.new(code, DEFAULT_COLORS)}
+
+    it 'stores the valid letters' do
+      expect(board.valid_letters).to eq(default_colors)
+    end
+
+    it 'returns a CurrentResult after tries a guess'
+
+    it 'returns an incorrect result when incorrect guess' do
+      expect(board.process_guess(incorrect_guess).correct?).to eq(false)
+    end
+
+    it 'returns a correct result when correct guess (win)' do
+      expect(board.process_guess(code).correct?).to eq(true)
+    end
+    
+    it 'detects the end of game on a win' do
+      result = CurrentResult.new(code, nil, nil)
+      expect(board.end_of_game?(result)).to eq(true)
+    end
+
+    it 'detects the end of game on a loss' do
+      result = CurrentResult.new(nil, 10, nil)
+      expect(board.end_of_game?(result)).to eq(true)
+    end
+  end
+
+  describe 'CurrentResult' do
+    it 'returns correct when winning result hash' do
+      correct_hash = {correct_positions: 4 , correct_colors:0}
+      expect(CurrentResult.new(nil, nil, correct_hash).correct?).to eq(true)
+    end
+
+    it 'returns incorrect when incorrect guess' do
+      incorrect_hash = {correct_positions: 1 , correct_colors:0}
+      expect(CurrentResult.new(nil, nil, incorrect_hash).correct?).to eq(false)
+    end
+
+    it 'stores the hash, num_of_tries and guess'
+  end
+
+  describe 'CodeComparer' do
+    let (:code){ %w{A B C D} }
+    let (:incorrect_guess){ %w{A C B E} }
+    let (:code_comparer){CodeComparer.new(code,incorrect_guess)}
+
+    it 'returns a hash with number of positions/colors' do
+      result_hash = {correct_positions: 1, correct_colors:2}
+      expect(code_comparer.compare).to eq(result_hash)
+    end
+  end
+
+  describe 'Colors' do
+    let(:default_colors){%w{R G O Y B P}}
+    it 'returns default colors if incorrect size of input array' do
+      custom_colors = %w{Q Z F R}
+      expect(Colors.new(custom_colors).valid_colors).to match_array(default_colors)
+    end
+
+    it 'returns default colors if no arguments' do
+      expect(Colors.new.valid_colors).to match_array(default_colors)
+    end
+  end 
+
+  describe 'NaiveAlgorithm' do
+    let (:naive_algorithm){NaiveAlgorithm.new(default_colors)}
+    before(:all) do
+      result_hash = {correct_positions: 0, correct_colors: 0}
+      guess = %w{R R R R}
+      @incorrect_guess = CurrentResult.new(guess, nil, result_hash )
+    end 
+
+    it 'initializes possible guesses to all permutations' do
+      expect(naive_algorithm.possible_guesses.size).to eq(1296)
+    end
+
+    it 'chooses a valid next_guess' do
+      expect(naive_algorithm.next_guess).to be
+    end
+
+    it 'randomizes the next guess' do
+      first_guess = naive_algorithm.next_guess
+      second_guess = naive_algorithm.next_guess
+      expect(first_guess).not_to eq(second_guess)
+    end
+
+    it 'discards invalid guesses based on previous result' do
+      expect(naive_algorithm.discard_invalid_guesses(@incorrect_guess)).not_to include( %w{R R R R} )
+    end
+
+    it 'keeps guesses that are still valid' do
+      expect(naive_algorithm.discard_invalid_guesses(@incorrect_guess)).to include( %w{G G G G} )
+    end  
+  end
+
+  describe 'AIPlayer' do
+    let(:algorithm){NaiveAlgorithm.new(DEFAULT_COLORS)}
+    let(:board){GameStatus.new(code, DEFAULT_COLORS)}
+    let(:ai_player){AIPlayer.new(board, algorithm)}
+    let(:solution){CurrentResult.new(code, 1, WIN_HASH )}
+    
+
+    it 'calls process_guess once if wins on first try' do
+      allow(algorithm).to receive(:next_guess){ code }    
+      expect(board).to receive(:process_guess).with(code).and_return(solution)
+      ai_player.solve
+    end
+  end   
+
+  describe 'GameText' do
+    let(:game_text){GameText.new}
+
+    it 'displays welcome message' do
+      expect(game_text.message(:welcome)).to eq("Welcome To Mastermind")
+    end
+
+    it 'prompts user for input' do
+      expect(game_text.message(:prompt)).to eq("Please Enter the Code: ")
+    end
+
+    it 'displays winning message' do
+      code = %w{R R R R}
+      result = CurrentResult.new(code, 1, WIN_HASH)
+      expect(game_text.message(:win, result)).to eq("Solved in 1 try!")
+    end
+   
+    it 'pluralizes winning message' do
+      code = %w{R R R R}
+      result = CurrentResult.new(code, 2, WIN_HASH)
+      expect(game_text.message(:win, result)).to eq("Solved in 2 tries!")
+    end
+  
+    it 'displays losing message' do
+      expect(game_text.message(:lose)).to eq("Game over. Unable to solve in 10 turns.")
+    end
+
+    it 'prompts user for color scheme' do
+      expect(game_text.message(:color_scheme)).to eq("Enter a 6 letter color scheme or press Enter to use default")
+    end
+  end
+    
+
+  describe 'Game' do 
+    let(:game_text){GameText.new}
+    let(:terminal_obj){double('terminal_obj') }
+    let(:game){ Game.new(game_text, terminal_obj) }
+
+#
+#    it 'returns input when valid' do
+#      allow(Terminal).to receive(:new){terminal_obj}
+#      expect(terminal_obj).to receive(:formatted_input).once.ordered.and_return(%w{R R R R} )
+#      expect(terminal_obj).to receive(:display)
+#
+#      result = game.get_input
+#      expect(Validator.new(result).valid?).to eq(true)
+#    end
+#
+#    it 'calls the function until valid' do
+#      allow(Terminal).to receive(:new){terminal_obj}
+#      expect(terminal_obj).to receive(:formatted_input).once.ordered.and_return(%w{Z Z Z Z} )
+#      expect(terminal_obj).to receive(:formatted_input).once.ordered.and_return(%w{R R R R} )
+#      expect(terminal_obj).to receive(:display)
+#      expect(terminal_obj).to receive(:display)
+#
+#      result = game.get_input
+#      expect(Validator.new(result).valid?).to eq(true)
+#    end 
+#
+#    it 'gets a Solution from winning AIPlayer' do 
+#      game.set_up_board(%w{R R R R})
+#      expect(game.run_ai_player.correct?).to eq(true)
+#    end 
+#    it 'prints winning end message if win' do
+#      code = %w{R R R R}
+#      result = CurrentResult.new(code, 1, WIN_HASH)
+#      expect{game.end_of_game(result)}.to output("You win!\n").to_stdout
+#    end
+#
+#    it 'prints losing end message if lose' do
+#      result = CurrentResult.new(nil, nil, nil)
+#      game.set_up_board(%w{R R R R})
+#      expect{game.end_of_game(result)}.to output("Haha! You lost!\n").to_stdout
+#    end
+
+    it 'runs through the game' do
+      allow(terminal_obj).to receive(:display){}
+      allow(game_text).to receive(:message)
+      expect(game).to receive(:get_input).and_return(%w{R O Y B} )
+      expect(game).to receive(:get_color_scheme).and_return(%w{ R G O Y B P})
+      game.play_game
+    end 
+  end
+
+  describe 'Terminal' do
+    let(:terminal){Terminal.new}
+
+    it 'displays message' do
+      expect{terminal.display('test message')}.to output("test message\n").to_stdout
+    end
+
+    it 'returns array of input letters' do
+      uppercase_input = StringIO.new("ABCD\n")
+      expect(terminal.formatted_input(uppercase_input)).to eq( %w{A B C D} )
+    end
+
+    it 'converts input to uppercase' do
+      lowercase_input = StringIO.new("abcd\n") 
+      expect(terminal.formatted_input(lowercase_input)).to eq(%w{A B C D})
+    end
+
+    it 'ignores whitespace' do
+      whitespace_input = StringIO.new("a  b c  d\n")
+      expect(terminal.formatted_input(whitespace_input)).to eq(%w{A B C D})
+    end 
+  end
+
+
+  describe 'Validator' do
+    it 'accepts a correct code' do
+      correct_validator = Validator.new( %w{R G O Y}, 4, DEFAULT_COLORS)
+      expect(correct_validator.valid?).to eq(true)
+    end 
+  
+    it 'fails if code length is incorrect' do 
+      wrong_length = Validator.new( %w{R R R R R R}, 4, DEFAULT_COLORS)
+      expect(wrong_length.valid?).to eq(false)
+    end
+
+    
+
+    it 'fails if either letters or code length are incorrect' do
+      wrong_letters = Validator.new( %w{R G O Y}, 4, %w{Q W E R T Y})
+      expect(wrong_letters.valid?).to eq(false) 
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: mastermind-cmdline
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Samantha Wojtowicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies: []
+description: Naive Mastermind AI
+email: 
+executables:
+- mastermind
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mastermind.rb
+- lib/mastermind/TerminalInterface.rb
+- lib/mastermind/GameStatus.rb
+- lib/mastermind/AIsolver.rb
+- lib/mastermind/UserInterface.rb
+- lib/mastermind/GameRules.rb
+- test/mastermind_spec.rb
+- bin/mastermind
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: mastermind-cmdline
+test_files: []