tobi-mastermind 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90c82361b37324c107990abb8336d085795b1dfd
+  data.tar.gz: 38cc4b58d57efcc9066588c0ee0e00e19aa27e36
+SHA512:
+  metadata.gz: bab88ba83c5ca30683d603a55b468b35d7587c4ab228287dbe05d92ec0b2d0064e26582d02add45693b1f826580f9c463e98b317061119ea6b00bf0325f22c3b
+  data.tar.gz: f5f456ec4734be6503cc6441e64ef488b7cd1941588aa03dcfb3aff1fec1c85df3b247c531081033d2f3012a9ff44a089dadb955e571652e8e8f08856638a2b1

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tobi/mastermind"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/mastermind

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'mastermind_start'
+
+MasterMind::Tobi.start

data/bin/setup

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

data/lib/mastermind/tobi/gamehelper.rb

@@ -0,0 +1,106 @@
+require 'ui'
+require 'logic'
+require 'single_game'
+require 'multi_game'
+
+module MasterMind
+  module Tobi
+    module GameHelper
+      def user_choice
+        option_chosen = false
+        
+        while !option_chosen
+          option_chosen = true                              # assume user selects valid option so as to quit loop
+          
+          input = gets.chomp.downcase
+          option_chosen = validate_input?(input)
+        end
+      end
+      
+      def validate_input?(input)
+        case input
+          when "p", "play" then play_game
+          when "r", "read"
+            print_help
+            return false                                     # continue loop after displaying help message
+          when "q", "quit" then exit
+          else                                               # user selects an invalid option
+            print UI::INVALID_MESSAGE
+            return false
+        end
+        return true
+      end
+      
+      def play_game
+        game_logic = GameLogic.new(ask_level); sequence = game_logic.generate_sequence
+        ask_mode(sequence, game_logic)
+        puts ""
+        print UI::OPTIONS_MESSAGE + UI::INPUT_PROMPT
+        user_choice
+      end
+      
+      def ask_mode(sequence, game_logic)
+        print UI::MODE_SELECT
+        option_chosen = false
+        
+        while !option_chosen
+          option_chosen = true                              # assume user selects valid option so as to quit loop
+          
+          input = gets.chomp.downcase
+          case input
+          when "s", "single" then SinglePlayer.new(sequence, game_logic).start_game
+          when "m", "multi"
+            print UI::PASSWORD_MESSAGE
+            hide_guess = MasterMind::Tobi::GameHelper.yes_or_no?
+            MultiPlayer.new(sequence, game_logic, hide_guess).start_game
+          else 
+            print UI::INVALID_MESSAGE
+            option_chosen = false
+          end
+        end
+        
+      end
+      
+      def self.yes_or_no?
+        option_chosen = false
+        
+        while !option_chosen
+          option_chosen = true                              # assume user selects valid option so as to quit loop
+          
+          input = gets.chomp.downcase
+          case input                                        
+          when "y", "yes" then return true
+          when "n", "no" then return false
+          else                                               # user selects an invalid option
+            print UI::INVALID_MESSAGE
+            option_chosen = false
+          end  
+        end
+      end
+      
+      def print_help
+        puts UI::HELP_MESSAGE
+        print UI::OPTIONS_MESSAGE + UI::INPUT_PROMPT
+      end
+      
+      def ask_level
+        print UI::LEVEL_MESSAGE
+        option_chosen = false
+        
+        while !option_chosen
+          option_chosen = true                              # assume user selects valid level so as to quit loop
+          
+          input = gets.chomp.downcase
+          case input                                        
+          when "b", "beginner" then return GameLogic::BEGINNER
+          when "i", "intermediate" then return GameLogic::INTERMEDIATE
+          when "a", "advanced" then return GameLogic::ADVANCED
+          else                                               # user selects an invalid level
+            print UI::INVALID_MESSAGE
+            option_chosen = false
+          end  
+        end
+      end
+    end 
+  end
+end

data/lib/mastermind/tobi/gamemethods.rb

@@ -0,0 +1,91 @@
+require 'ui'
+require 'gamehelper'
+module MasterMind
+  module Tobi
+    module GameMethods
+      
+      def average_string(top_ten_list, current_player)                                    # generates user's performance compared to average
+        time_diff, guess_diff = difference(top_ten_list, current_player)
+        
+        "That's %s %s and %s %s %s the average\n" % [time_convert(time_diff.abs), time_diff < 0 ? "slower" : "faster",
+          guess_diff.abs, guess_diff.abs == 1 ? "guess" : "guesses", guess_diff < 0 ? "more" : "fewer"]
+      end
+      
+      def difference(top_ten_list, current_player)
+        total_time = 0
+        total_guess = 0
+        
+        diff_hash = top_ten_list.each{ |player| 
+          total_time += player.time
+          total_guess += player.guesses 
+        }
+        
+        average_time = (total_time.to_f/top_ten_list.length).round - current_player.time
+        average_guess = (total_guess.to_f/top_ten_list.length).round - current_player.guesses
+        
+        return average_time, average_guess
+      end
+      
+      def print_top_ten(current_player)
+        top_ten_list = get_top_ten
+        
+        puts average_string(top_ten_list, current_player) if top_ten_list.length > 1     # print out user's performance compared to average
+        
+        # print out top ten results
+        if !top_ten_list.nil?
+          puts ""
+          puts UI::TOP_TEN                                                                  
+          top_ten_list.each_with_index{|player, index| puts "#{index+1}. " + player.to_s }
+        end
+      end
+      
+      def get_top_ten
+        YAML.load_stream(File.open(UI::DB_STORE)).sort{|player1, player2|  # load player objects from db and sort by guesses/time
+          by_guess = player1.guesses <=> player2.guesses                                  # first sort by guesses
+          by_guess == 0 ? player1.time <=> player2.time : by_guess                        # then sort by time
+        }[0...10]  if File.file?(UI::DB_STORE)                                            # pick out top ten
+      end
+      
+      def store_game(sequence, guesses, time)      #get player name and store details to file  
+        print UI::NAME_MESSAGE
+        name = get_name
+        current_player = Player.new(name, sequence, time, guesses)  # create new player object
+        
+        # write player object to file if file does not exist, or verify whether to add record from user, and write if it exists
+        File.open(UI::DB_STORE, 'a'){|file| file.write(YAML.dump(current_player))} if user_permits_store?
+         
+        current_player
+      end
+      
+      def user_permits_store?                    # confirm from user to add record to top-scores if file exists
+        return true if !File.exist?(UI::DB_STORE)    # if file does not exist, return true
+        print UI::OVERWRITE_MESSAGE
+        print UI::INPUT_PROMPT
+        option_chosen = false
+        
+        return MasterMind::Tobi::GameHelper.yes_or_no?
+      end
+      
+      def get_name
+        name = ""
+        
+        while name.eql?("")
+          name = gets.chomp.capitalize
+          print UI::INVALID_MESSAGE if name.eql?("")  
+        end
+        
+        name
+      end
+         
+      def print_history(history)
+        if history.empty?
+          print "No history yet. Enter a guess"  + UI::INPUT_PROMPT
+        else
+          puts ""
+          puts history
+          print UI::INPUT_PROMPT 
+        end
+      end
+    end
+  end
+end

data/lib/mastermind/tobi/gameplay.rb

@@ -0,0 +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
+end

data/lib/mastermind/tobi/logic.rb

@@ -0,0 +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
+end

data/lib/mastermind/tobi/multi_game.rb

@@ -0,0 +1,97 @@
+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

data/lib/mastermind/tobi/player.rb

@@ -0,0 +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
+end

data/lib/mastermind/tobi/single_game.rb

@@ -0,0 +1,117 @@
+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
+end

data/lib/mastermind/tobi/store.yaml

@@ -0,0 +1,137 @@
+--- !ruby/object:Player
+name: tobiloba
+sequence:
+- b
+- g
+- r
+- y
+time: 5
+guesses: 1
+--- !ruby/object:Player
+name: tben
+sequence:
+- r
+- r
+- y
+- y
+- g
+time: 13
+guesses: 1
+--- !ruby/object:Player
+name: tobi2
+sequence:
+- y
+- b
+- r
+- g
+- y
+time: 7
+guesses: 1
+--- !ruby/object:Player
+name: tobi3
+sequence:
+- y
+- g
+- g
+- y
+time: 3
+guesses: 1
+--- !ruby/object:Player
+name: tobi4
+sequence:
+- r
+- y
+- y
+- y
+time: 5
+guesses: 1
+--- !ruby/object:Player
+name: tbaba
+sequence:
+- r
+- r
+- g
+- y
+time: 3
+guesses: 1
+--- !ruby/object:Player
+name: tboss
+sequence:
+- b
+- y
+- g
+- b
+time: 15
+guesses: 1
+--- !ruby/object:Player
+name: madara
+sequence:
+- r
+- r
+- b
+- y
+time: 27
+guesses: 1
+--- !ruby/object:Player
+name: 7jsdf
+sequence:
+- b
+- g
+- b
+- r
+time: 3
+guesses: 1
+--- !ruby/object:Player
+name: asdf
+sequence:
+- y
+- r
+- b
+- b
+time: 4
+guesses: 1
+--- !ruby/object:Player
+name: babatee
+sequence:
+- g
+- g
+- b
+- r
+time: 2
+guesses: 1
+--- !ruby/object:Player
+name: Tbff
+sequence:
+- r
+- g
+- y
+- b
+time: 74
+guesses: 2
+--- !ruby/object:Player
+name: Toisdaf
+sequence:
+- r
+- g
+- y
+- b
+time: 8
+guesses: 2
+--- !ruby/object:Player
+name: Yuo
+sequence:
+- r
+- g
+- y
+- b
+time: 9
+guesses: 2
+--- !ruby/object:Player
+name: Ttiosd
+sequence:
+- r
+- g
+- y
+- b
+time: 24
+guesses: 2

data/lib/mastermind/tobi/timehelper.rb

@@ -0,0 +1,31 @@
+module MasterMind
+  module Tobi
+    module TimeHelper
+      def time_convert(time_int)
+        hours = time_int / 3600
+        minutes = (time_int % 3600) / 60
+        seconds = (time_int % 3600) % 60
+        time_string = construct_string(hours, minutes, seconds)
+      end
+      
+      def construct_string(hours, minutes, seconds)
+        time_string = '' 
+        if hours >= 1
+          time_string << (hours.to_s + (time == 1 ? ' hour' :' hours'))
+          time_string << ', ' if minutes > 0
+        end    
+         
+        if minutes >= 1
+          time_string << (minutes.to_s + (minutes == 1 ? ' minute' : ' minutes'))
+          time_string << ', ' if seconds > 0
+        end
+         
+        if seconds >= 1
+          time_string << (seconds.to_s + (seconds == 1 ? ' second' : ' seconds'))
+        elsif seconds == 0 && time_string == ''
+          time_string << '0 seconds'
+        end
+      end
+    end
+  end
+end

data/lib/mastermind/tobi/ui.rb

@@ -0,0 +1,71 @@
+module MasterMind
+  module Tobi
+    module UI
+      
+      GUESS_MAX = 12
+      
+      WELCOME_MESSAGE = "\nWelcome to the Classy MasterMind game by Tobi\n"
+      
+      INPUT_PROMPT = "\n>>  "
+      
+      OPTIONS_MESSAGE = "\nWould you like to (p)lay, (r)ead the instructions or (quit) ?"
+        
+      HELP_MESSAGE = "\nOnce game starts, a random code is generated and you're asked to guess what the code is.
+    Every code is a four/five/six digit word made up by the letters [r, g, b, y]/[r, g, b, y, o]/[r, g, b, y, o, v] 
+    depending on difficulty levels beginner/intermediate/advanced levels. You have twelve guesses per game.
+    On every guess, you are presented with a message identifying the number of elements you got correctly, and in what positions.
+    To view entry history, enter h or history at any time
+    To view sequence generated, enter c or cheat at any time
+    To quit the game at any point enter q or quit\n\n"
+      
+      BEGINNER_COLOR = "(r)ed, (g)reen, (b)lue and (y)ellow"
+      
+      INTERMEDIATE_COLOR = "(r)ed, (g)reen, (b)lue, (y)ellow, and (o)range"
+      
+      ADVANCED_COLOR = "(r)ed, (g)reen, (b)lue, (y)ellow, (o)range and (v)iolet"
+     
+      COLOR_STRINGS = [BEGINNER_COLOR, INTERMEDIATE_COLOR, ADVANCED_COLOR]
+      
+      GENERATE_MESSAGE = "\nI have generated %s sequence with %s elements made \
+    up of: %s\nUse (q)uit at any time to end the game. \nWhat's your guess?"
+      
+      INVALID_MESSAGE = "\nEntry invalid! Please try again" + INPUT_PROMPT
+      
+      INPUT_SHORT_MESSAGE = "Input too short. Please enter guess correctly" + INPUT_PROMPT
+      
+      INPUT_LONG_MESSAGE = "Input too long. Please enter guess correctly." + INPUT_PROMPT
+      
+      SEQUENCE_MESSAGE = "The sequence is %s" + INPUT_PROMPT
+      
+      CONGRATS_MESSAGE = "\n%s, You guessed the sequence '%s' in %s %s over %s"
+      
+      INFO_MESSAGE = "'%s' has %s of the correct elements with %s in the correct positions."
+      
+      END_MESSAGE = "Do you want to (p)lay again or (q)uit?"
+      
+      GUESSES_MESSAGE = "You've taken %s %s"
+      
+      LEVEL_MESSAGE = "\nDifficulty level: (b)eginner, (i)ntermediate or (a)dvanced? " + INPUT_PROMPT
+      
+      NAME_MESSAGE = "\nCongratulations! You've guessed the sequence! What's your name?" + INPUT_PROMPT
+      
+      DB_STORE = 'store.yaml'
+      
+      TOP_TEN = '=== TOP TEN ==='
+      
+      OVERWRITE_MESSAGE = 'Data file already exists. Do you want to add your score to top scores? (y)es or (n)o..'
+      
+      MODE_SELECT = "\nPlease choose mode >>> (s)ingle or (m)ulti player mode?" + INPUT_PROMPT
+      
+      MULTI_START_MESSAGE = "Welcome to the MultiPlayer Challenge. How many users will be playing today?" + INPUT_PROMPT
+      
+      PLAYER_MESSAGE = "********Player %s's turn" + INPUT_PROMPT
+      
+      SORRY_SINGLE_MESSAGE = "Sorry, You lost. The sequence is %s"
+      
+      SORRY_MULTI_MESSAGE = "Sorry, You all lost. The sequence is %s"
+      
+      PASSWORD_MESSAGE = "\nWould you like to hide each player's guesses? (y)es or (n)o ?" + INPUT_PROMPT 
+    end
+  end
+end

data/lib/mastermind_start.rb

@@ -0,0 +1,17 @@
+lib_master = File.expand_path('../mastermind/tobi', __FILE__)
+$LOAD_PATH.unshift(lib_master) unless $LOAD_PATH.include?(lib_master)
+require 'ui'
+require 'gamehelper'
+
+module MasterMind
+  module Tobi
+    extend GameHelper
+    VERSION = 1.0
+    
+    def self.start
+      puts UI::WELCOME_MESSAGE
+      print UI::OPTIONS_MESSAGE + UI::INPUT_PROMPT
+      user_choice
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: tobi-mastermind
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Tobi Oduah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MasterMind game implemented in a fun way
+email:
+- tobi.oduah@andela.com
+executables:
+- console
+- mastermind
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/mastermind
+- bin/setup
+- lib/mastermind/tobi/gamehelper.rb
+- lib/mastermind/tobi/gamemethods.rb
+- lib/mastermind/tobi/gameplay.rb
+- lib/mastermind/tobi/logic.rb
+- lib/mastermind/tobi/multi_game.rb
+- lib/mastermind/tobi/player.rb
+- lib/mastermind/tobi/single_game.rb
+- lib/mastermind/tobi/store.yaml
+- lib/mastermind/tobi/timehelper.rb
+- lib/mastermind/tobi/ui.rb
+- lib/mastermind_start.rb
+homepage: http://github.com/andela-toduah
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: MasterMind
+test_files: []