tobi-mastermind 1.0 → 1.1

data/lib/mastermind/tobi/gameplay.rb

@@ -1,15 +1,15 @@
-module MasterMind
-  module Tobi
-    class GamePlay
-      attr_reader :entry; attr_reader :correct_elements; attr_reader :correct_positions
-     
-      def initialize(entry, correct_elements, correct_positions)
-        @entry = entry; @correct_elements = correct_elements; @correct_positions = correct_positions
-      end
-      
-      def to_s
-        "#{entry} ::: #{correct_elements} correct #{correct_elements > 1 ? 'elements' : 'element'} ::: #{correct_positions} in correct #{correct_positions > 1 ? 'positions' : 'position'}"
-      end
-    end
-  end
+module MasterMind
+  module Tobi
+    class GamePlay
+      attr_reader :entry; attr_reader :correct_elements; attr_reader :correct_positions
+     
+      def initialize(entry, correct_elements, correct_positions)
+        @entry = entry; @correct_elements = correct_elements; @correct_positions = correct_positions
+      end
+      
+      def to_s
+        "#{entry} ::: #{correct_elements} correct #{correct_elements > 1 ? 'elements' : 'element'} ::: #{correct_positions} in correct #{correct_positions > 1 ? 'positions' : 'position'}"
+      end
+    end
+  end
 end

data/lib/mastermind/tobi/logic.rb

@@ -1,38 +1,38 @@
-module MasterMind
-  module Tobi
-    class GameLogic
-      attr_reader :level; attr_reader :length; attr_reader :color_array; attr_reader :sequence_type
-      
-      BEGINNER, INTERMEDIATE, ADVANCED = 0, 1, 2
-      SEQUENCE_TYPES = ['a beginner', 'an intermediate', 'an advanced']
-      COLORS = [['r', 'g', 'b', 'y'], ['r', 'g', 'b', 'y', 'o'], ['r', 'g', 'b', 'y', 'o', 'v']]
-      
-      def initialize(level)
-        @level = level
-        @color_array = COLORS[level]
-        @length = color_array.length
-        @sequence_type = SEQUENCE_TYPES[level]
-      end
-      
-      def generate_sequence
-        (color_array * (rand() * 1000).to_i).shuffle[0...color_array.length]                  # generate random combination of r/g/b/y
-      end
-      
-      def self.check_input(sequence, input)
-        verify_values(input.split(''), sequence, sequence[0..-1])
-      end
-      
-      def self.verify_values(split_input, sequence, sequence_copy)
-        result_values = {correct_elements: 0, correct_position: 0}
-        split_input.each_with_index{ |element, index| 
-          result_values[:correct_position] += 1 if split_input[index] == sequence[index] # if element in correct position
-          if sequence_copy.include?(element)
-            result_values[:correct_elements] += 1
-            sequence_copy.delete_at(sequence_copy.index(element))         # if in sequence, delete first occurrence so as to counter duplicates
-          end 
-        }
-        result_values
-      end   
-    end
-  end
+module MasterMind
+  module Tobi
+    class GameLogic
+      attr_reader :level; attr_reader :length; attr_reader :color_array; attr_reader :sequence_type
+      
+      BEGINNER, INTERMEDIATE, ADVANCED = 0, 1, 2
+      SEQUENCE_TYPES = ['a beginner', 'an intermediate', 'an advanced']
+      COLORS = [['r', 'g', 'b', 'y'], ['r', 'g', 'b', 'y', 'o'], ['r', 'g', 'b', 'y', 'o', 'v']]
+      
+      def initialize(level)
+        @level = level
+        @color_array = COLORS[level]
+        @length = color_array.length
+        @sequence_type = SEQUENCE_TYPES[level]
+      end
+      
+      def generate_sequence
+        (color_array * (rand() * 1000).to_i).shuffle[0...color_array.length]                  # generate random combination of r/g/b/y
+      end
+      
+      def self.check_input(sequence, input)
+        verify_values(input.split(''), sequence, sequence[0..-1])
+      end
+      
+      def self.verify_values(split_input, sequence, sequence_copy)
+        result_values = {correct_elements: 0, correct_position: 0}
+        split_input.each_with_index{ |element, index| 
+          result_values[:correct_position] += 1 if split_input[index] == sequence[index] # if element in correct position
+          if sequence_copy.include?(element)
+            result_values[:correct_elements] += 1
+            sequence_copy.delete_at(sequence_copy.index(element))         # if in sequence, delete first occurrence so as to counter duplicates
+          end 
+        }
+        result_values
+      end   
+    end
+  end
 end

data/lib/mastermind/tobi/multi_game.rb

@@ -1,97 +1,98 @@
-require 'single_game'
-require 'logic'
-require 'ui'
-require 'io/console'
-
-module MasterMind
-  module Tobi
-    class MultiPlayer < SinglePlayer
-      attr_reader :hide_guess
-      
-      def initialize(sequence, game_logic, hide_guess)
-        super(sequence, game_logic)
-        @hide_guess = hide_guess  
-      end
-      
-      def start_game
-        number = num_of_players
-        end_guess = 12*number + 1
-        
-        puts UI::GENERATE_MESSAGE % [game_logic.sequence_type, game_logic.length, UI::COLOR_STRINGS[game_logic.level]]
-        history_hash = {}
-        guesses_hash = {}
-        (1..number).each {|x| 
-          history_hash[x] = []
-          guesses_hash[x] = 0 
-        }
-        
-        multi_start_game(number, history_hash, guesses_hash)    
-      end  
-      
-      def multi_start_game(number, history_hash, guesses_hash)
-        total_guesses = 0                                       # total guesses of all players
-        catch :player_wins do
-          while total_guesses < (UI::GUESS_MAX * number)        # until all players have exhausted their guesses
-            for index in (1..number)                                # loop through to allow each player have a guess
-              total_guesses += 1
-              multi_helper(guesses_hash, index, history_hash)
-            end
-          end
-        end
-        puts UI::SORRY_MULTI_MESSAGE % sequence.join.upcase if total_guesses == UI::GUESS_MAX * number # guesses exhausted with no winner
-      end
-      
-      def multi_helper(guesses_hash, index, history_hash)
-        last_guess = guesses_hash[index]                      # to store player's last guess
-        print "************"
-        print UI::PLAYER_MESSAGE % index
-        while guesses_hash[index] == last_guess               # to counter situations where user enters invalid input, guess would still be same
-          guesses_hash[index] = get_guess(history_hash, guesses_hash, index)
-          throw(:player_wins) if guesses_hash[index] == end_guess # if there is a win
-        end
-      end
-      
-      def get_guess(history_hash, guesses_hash, index)
-        input = hide_guess ? STDIN.noecho(&:gets).chomp : gets.chomp
-        
-        length_or_option = false
-        length_or_option = invalid_length?(input)                            # invalid length for entry
-        
-        if !length_or_option
-          length_or_option = treat_option?(input, history_hash[index])             # entry is a game option
-        end
-        
-        if !length_or_option
-          guesses_hash[index] = check_help(input, guesses_hash, history_hash, index)
-        end
-        
-        guesses_hash[index]
-      end
-      
-      def check_help(input, guesses_hash, history_hash, index)
-        treat_guess(input, guesses_hash[index], history_hash[index])  # player enters a guess
-      end
-      
-      def wrong_guess(sequence, guesses, input, history)
-        result = GameLogic.check_input(sequence, input)                                       # get results from input
-        history << GamePlay.new(input, result[:correct_elements], result[:correct_position])  # add game play to history
-        
-        puts UI::INFO_MESSAGE % [hide_guess ? "Your Guess" : input.upcase, result[:correct_elements], result[:correct_position]]
-        puts UI::GUESSES_MESSAGE % [guesses, guesses > 1 ? "guesses" : "guess"]
-        print UI::INPUT_PROMPT
-      end
-      
-      def num_of_players
-        print UI::MULTI_START_MESSAGE
-        input = gets.chomp
-        
-        while (input.to_i <= 1)
-          print UI::INVALID_MESSAGE
-          input = gets.chomp
-        end
-        
-        return input.to_i
-      end
-    end
-  end
-end
+require 'single_game'
+require 'logic'
+require 'ui'
+require 'io/console'
+
+module MasterMind
+  module Tobi
+    class MultiPlayer < SinglePlayer
+      attr_reader :hide_guess
+      
+      def initialize(sequence, game_logic, hide_guess)
+        super(sequence, game_logic)
+        @hide_guess = hide_guess  
+      end
+      
+      def start_game
+        number = num_of_players
+        end_guess = 12*number + 1
+        
+        puts UI::GENERATE_MESSAGE % [game_logic.sequence_type, game_logic.length, UI::COLOR_STRINGS[game_logic.level]]
+        history_hash = {}
+        guesses_hash = {}
+        (1..number).each {|x| 
+          history_hash[x] = []
+          guesses_hash[x] = 0 
+        }
+        
+        multi_start_game(number, history_hash, guesses_hash)    
+      end  
+      
+      def multi_start_game(number, history_hash, guesses_hash)
+        total_guesses = 0                                       # total guesses of all players
+        catch :player_wins do
+          while total_guesses < (UI::GUESS_MAX * number)        # until all players have exhausted their guesses
+            for index in (1..number)                                # loop through to allow each player have a guess
+              total_guesses += 1
+              multi_helper(guesses_hash, index, history_hash)
+            end
+          end
+        end
+        puts UI::SORRY_MULTI_MESSAGE % sequence.join.upcase if total_guesses == UI::GUESS_MAX * number # guesses exhausted with no winner
+        total_guesses
+      end
+      
+      def multi_helper(guesses_hash, index, history_hash)
+        last_guess = guesses_hash[index]                      # to store player's last guess
+        print "************"
+        print UI::PLAYER_MESSAGE % index
+        while guesses_hash[index] == last_guess               # to counter situations where user enters invalid input, guess would still be same
+          guesses_hash[index] = get_guess(history_hash, guesses_hash, index)
+          throw(:player_wins) if guesses_hash[index] == end_guess # if there is a win
+        end
+      end
+      
+      def get_guess(history_hash, guesses_hash, index)
+        input = hide_guess ? STDIN.noecho(&:gets).chomp : gets.chomp
+        
+        length_or_option = false
+        length_or_option = invalid_length?(input)                            # invalid length for entry
+        
+        if !length_or_option
+          length_or_option = treat_option?(input, history_hash[index])             # entry is a game option
+        end
+        
+        if !length_or_option
+          guesses_hash[index] = check_help(input, guesses_hash, history_hash, index)
+        end
+        
+        guesses_hash[index]
+      end
+      
+      def check_help(input, guesses_hash, history_hash, index)
+        treat_guess(input, guesses_hash[index], history_hash[index])  # player enters a guess
+      end
+      
+      def wrong_guess(sequence, guesses, input, history)
+        result = GameLogic.check_input(sequence, input)                                       # get results from input
+        history << GamePlay.new(input, result[:correct_elements], result[:correct_position])  # add game play to history
+        
+        puts UI::INFO_MESSAGE % [hide_guess ? "Your Guess" : input.upcase, result[:correct_elements], result[:correct_position]]
+        puts UI::GUESSES_MESSAGE % [guesses, guesses > 1 ? "guesses" : "guess"]
+        print UI::INPUT_PROMPT
+      end
+      
+      def num_of_players
+        print UI::MULTI_START_MESSAGE
+        input = gets.chomp
+        
+        while (input.to_i <= 1)
+          print UI::INVALID_MESSAGE
+          input = gets.chomp
+        end
+        
+        return input.to_i
+      end
+    end
+  end
+end

data/lib/mastermind/tobi/player.rb

@@ -1,21 +1,21 @@
-require 'timehelper'
-
-module MasterMind
-  module Tobi
-    class Player
-      attr_reader :name
-      attr_reader :sequence
-      attr_reader :time
-      attr_reader :guesses
-      include TimeHelper
-      
-      def initialize(name, sequence, time, guesses)
-        @name = name; @sequence = sequence; @time = time; @guesses = guesses
-      end
-      
-      def to_s
-        "%s solved '%s' in %s %s over %s" % [name, sequence.join.upcase, guesses, guesses > 1 ? "guesses" : "guess", time_convert(time)]  
-      end
-    end
-  end
+require 'timehelper'
+
+module MasterMind
+  module Tobi
+    class Player
+      attr_reader :name
+      attr_reader :sequence
+      attr_reader :time
+      attr_reader :guesses
+      include TimeHelper
+      
+      def initialize(name, sequence, time, guesses)
+        @name = name; @sequence = sequence; @time = time; @guesses = guesses
+      end
+      
+      def to_s
+        "%s solved '%s' in %s %s over %s" % [name, sequence.join.upcase, guesses, guesses > 1 ? "guesses" : "guess", time_convert(time)]  
+      end
+    end
+  end
 end

data/lib/mastermind/tobi/single_game.rb

@@ -1,117 +1,118 @@
-require 'ui'
-require 'timehelper'
-require 'player'
-require 'yaml'
-require 'gameplay'
-require 'gamemethods'
-
-module MasterMind
-  module Tobi
-    class SinglePlayer
-      include GameMethods
-      include TimeHelper
-      
-      attr_reader :start_time
-      attr_reader :history
-      attr_reader :sequence
-      attr_reader :game_logic
-      attr_accessor :end_guess
-      
-      ALLOWED = ['c', 'h', 'q', 'cheat', 'history', 'quit']
-      
-      def initialize(sequence, game_logic)
-        @start_time = Time.now
-        @history = []
-        @sequence = sequence
-        @game_logic = game_logic
-        @end_guess = 13
-      end
-      
-      # generate game sequence and start game play
-      def start_game
-        print UI::GENERATE_MESSAGE % [game_logic.sequence_type, game_logic.length, UI::COLOR_STRINGS[game_logic.level]]
-        print UI::INPUT_PROMPT
-        
-        # allow the user guess up to twelve times before ending game
-        guesses = 0
-        while guesses < UI::GUESS_MAX
-          guesses = process_input(guesses, history)
-        end
-        puts UI::SORRY_SINGLE_MESSAGE % sequence.join.upcase if guesses == UI::GUESS_MAX   
-      end
-      
-      def process_input(guesses, history)
-        input = gets.chomp.downcase
-        length_or_option = false
-        
-        length_or_option = invalid_length?(input)
-        
-        if !length_or_option
-          length_or_option = treat_option?(input, history)
-        end
-        
-        if !length_or_option
-          guesses = treat_guess(input, guesses, history)
-        end
-        guesses
-      end
-      
-      # check if user's guess is longer or fewer than the required length
-      def invalid_length?(input)   
-        if input.length < game_logic.length && !(ALLOWED.include?(input))
-          print UI::INPUT_SHORT_MESSAGE
-          return true
-          
-        elsif input.length > game_logic.length && !(ALLOWED.include?(input)) 
-          print UI::INPUT_LONG_MESSAGE
-          return true
-        end
-        
-        return false
-      end
-      
-      # check if user selects an option
-      def treat_option?(input, history)
-        case input
-        when "h", "history" then print_history(history)
-        when "q", "quit" then exit(0)
-        when "c", "cheat" then print UI::SEQUENCE_MESSAGE % sequence.join.upcase
-        else return false
-        end
-        return true
-      end
-      
-      # treat guesses entered by user
-      def treat_guess(input, guesses, history)
-        guesses += 1
-        if input == sequence.join                         # right guess entered
-          right_guess(start_time, sequence, guesses)
-          guesses = end_guess                             # sentinel value to end guess loop
-        else
-          wrong_guess(sequence, guesses, input, history)  # wrong guess entered
-        end
-        
-        return guesses
-      end
-      
-      def right_guess(start_time, sequence, guesses)
-        time_elapsed = (Time.now - start_time).to_i                                       # time used by user in seconds
-        current_player = store_game(sequence, guesses, time_elapsed)                      # store user data to top-scores file
-        
-        puts UI::CONGRATS_MESSAGE % [current_player.name, sequence.join.upcase, guesses, guesses > 1 ? "guesses" : "guess", 
-          time_convert(time_elapsed) << '.']
-        print_top_ten(current_player)
-      end
-      
-      def wrong_guess(sequence, guesses, input, history)
-        result = GameLogic.check_input(sequence, input)                                       # get results from input
-        history << GamePlay.new(input, result[:correct_elements], result[:correct_position])  # add game play to history
-        
-        puts UI::INFO_MESSAGE % [input.upcase, result[:correct_elements], result[:correct_position]]
-        puts UI::GUESSES_MESSAGE % [guesses, guesses > 1 ? "guesses" : "guess"]
-        print UI::INPUT_PROMPT
-      end
-      
-    end
-  end
+require 'ui'
+require 'timehelper'
+require 'player'
+require 'yaml'
+require 'gameplay'
+require 'gamemethods'
+
+module MasterMind
+  module Tobi
+    class SinglePlayer < GameMethods
+      #include GameMethods
+      include TimeHelper
+      
+      attr_reader :start_time
+      attr_reader :history
+      attr_reader :sequence
+      attr_reader :game_logic
+      attr_accessor :end_guess
+      
+      ALLOWED = ['c', 'h', 'q', 'cheat', 'history', 'quit']
+      
+      def initialize(sequence, game_logic)
+        @start_time = Time.now
+        @history = []
+        @sequence = sequence
+        @game_logic = game_logic
+        @end_guess = 13
+      end
+      
+      # generate game sequence and start game play
+      def start_game
+        print UI::GENERATE_MESSAGE % [game_logic.sequence_type, game_logic.length, UI::COLOR_STRINGS[game_logic.level]]
+        print UI::INPUT_PROMPT
+        
+        # allow the user guess up to twelve times before ending game
+        guesses = 0
+        while guesses < UI::GUESS_MAX
+          guesses = process_input(guesses, history)
+        end
+        puts UI::SORRY_SINGLE_MESSAGE % sequence.join.upcase if guesses == UI::GUESS_MAX
+        guesses   
+      end
+      
+      def process_input(guesses, history)
+        input = gets.chomp.downcase
+        length_or_option = false
+        
+        length_or_option = invalid_length?(input)
+        
+        if !length_or_option
+          length_or_option = treat_option?(input, history)
+        end
+        
+        if !length_or_option
+          guesses = treat_guess(input, guesses, history)
+        end
+        guesses
+      end
+      
+      # check if user's guess is longer or fewer than the required length
+      def invalid_length?(input)   
+        if input.length < game_logic.length && !(ALLOWED.include?(input))
+          print UI::INPUT_SHORT_MESSAGE
+          return true
+          
+        elsif input.length > game_logic.length && !(ALLOWED.include?(input)) 
+          print UI::INPUT_LONG_MESSAGE
+          return true
+        end
+        
+        return false
+      end
+      
+      # check if user selects an option
+      def treat_option?(input, history)
+        case input
+        when "h", "history" then print_history(history)
+        when "q", "quit" then exit(0)
+        when "c", "cheat" then print UI::SEQUENCE_MESSAGE % sequence.join.upcase
+        else return false
+        end
+        return true
+      end
+      
+      # treat guesses entered by user
+      def treat_guess(input, guesses, history)
+        guesses += 1
+        if input == sequence.join                         # right guess entered
+          right_guess(start_time, sequence, guesses)
+          guesses = end_guess                             # sentinel value to end guess loop
+        else
+          wrong_guess(sequence, guesses, input, history)  # wrong guess entered
+        end
+        
+        return guesses
+      end
+      
+      def right_guess(start_time, sequence, guesses)
+        time_elapsed = (Time.now - start_time).to_i                                       # time used by user in seconds
+        current_player = store_game(sequence, guesses, time_elapsed)                      # store user data to top-scores file
+        
+        puts UI::CONGRATS_MESSAGE % [current_player.name, sequence.join.upcase, guesses, guesses > 1 ? "guesses" : "guess", 
+          time_convert(time_elapsed) << '.']
+        print_top_ten(current_player)
+      end
+      
+      def wrong_guess(sequence, guesses, input, history)
+        result = GameLogic.check_input(sequence, input)                                       # get results from input
+        history << GamePlay.new(input, result[:correct_elements], result[:correct_position])  # add game play to history
+        
+        puts UI::INFO_MESSAGE % [input.upcase, result[:correct_elements], result[:correct_position]]
+        puts UI::GUESSES_MESSAGE % [guesses, guesses > 1 ? "guesses" : "guess"]
+        print UI::INPUT_PROMPT
+      end
+      
+    end
+  end
 end