master_mind 0.1.2

data/lib/mastermind/extensions/savegame.rb

@@ -0,0 +1,69 @@
+module Mastermind
+  class SaveGame
+    attr_reader :datastore, :game_file, :saved_record
+    SAVE_GAME_FILE = 'game_file.yml'
+    def initialize(datastore: Datastore::YmlStore.instance, game_file: SAVE_GAME_FILE)
+      @datastore = datastore
+      @game_file = game_file
+
+      @datastore.filename=@game_file
+      load_records
+    end
+
+    def load_records
+      @save_record = fetch_all_records || []
+      @save_record.flatten!
+      @save_record
+    end
+
+    def save_record(player)
+      if player.is_a? Player
+        player = player.to_h
+      elsif player.is_a? Hash
+        player
+      else
+        raise ArgumentError, 'Invalid player'
+      end
+      @datastore.save(@game_file, player, 'a+')
+      load_records
+    end
+
+    def fetch_all_records
+     @save_record = @datastore.fetch_multiple_records @game_file
+     @save_record
+    end
+
+    def fetch_player(player_name)
+      if player_name.is_a? Integer
+        record = @save_record[player_name - 1]
+      elsif player_name.is_a? String
+        record = @save_record.select{ |record|
+          record[:name].downcase == player_name.downcase
+        }.first
+      end
+      return set_player_attr(record) if record
+      false
+    end
+
+    def set_player_attr(record)
+      player = Player.new
+      player.set_save_attr(record)
+
+      remove_data_from_save_record(record)
+      player
+    end
+
+    def remove_data_from_save_record(record)
+      @save_record.delete(record)
+      save
+    end
+
+    def save
+      @datastore.save(@game_file, @save_record)
+    end
+
+    def fetch_record(user_name)
+
+    end
+  end
+end

data/lib/mastermind/game.rb

@@ -0,0 +1,194 @@
+module Mastermind
+  class Game
+    include Helper
+    attr_reader :colors, :trial_count, :response, :character_count, :player, :top_ten_record
+    ALLOWED_TRIALS = 12
+    @@all_colors_hash = { 'R' => '(r)ed',
+                          'G' => '(g)reen',
+                          'B' => '(b)lue',
+                          'Y' => '(y)ellow'
+                        }
+    @@color_array = @@all_colors_hash.keys # %w{ R G B Y }
+
+    def initialize(response, character_count = 4, top_ten_record: TopTen.new)
+      @response = response
+      @character_count = character_count
+      @top_ten_record = top_ten_record
+    end
+
+    def play
+      generate_colors
+      @trial_count = 0
+      get_player if @player.nil?
+      @response.start.message
+      @time_started = Time.now.to_i
+
+      game_process
+    end
+
+    def generate_colors
+      @colors = @@color_array.sample(@character_count)
+      shuffle_colors_hash
+    end
+
+    def shuffle_colors_hash
+      @color_values_from_all_colors_array = @colors.map{|color| @@all_colors_hash[color] }
+      @color_values_from_all_colors_array.shuffle!
+    end
+
+    def game_process
+      until @response.status == :won || @response.status == :lost || @trial_count >= ALLOWED_TRIALS
+        input = get_game_input
+        if actions.keys.include? input
+          method(actions[input]).call
+          break unless actions[input] =~ /instructions/
+        else
+          next if the_input_is_too_long_or_too_short?(input)
+          @trial_count += 1
+          analyzed = analyze_guess(input)
+          break if check_correct?(analyzed)
+          send_message(@response.analyzed_guess(analyzed[:match_position], analyzed[:almost_match]).message)
+        end
+      end
+      what_do_you_want_to_do_next
+    end
+
+    def analyze_guess(current_guess)
+      current_guess = current_guess.upcase.split('')
+      current_sprint = Hash.new(0)
+      current_guess.each_with_index{ |value, index|
+        if value == @colors[index]
+          current_sprint[:match_position] += 1
+        elsif @colors.include? value
+          # near matches should be a counter that
+          # counts the unique elements in the colors array
+          current_sprint[:almost_match] += 1
+        end
+      }
+      current_sprint
+    end
+
+    def get_player
+      @player ||= Player.new
+      player = Hash.new(nil)
+      while player[:name].nil? || player[:name].empty?
+        player_name = get_input(@response.player.message)
+        player[:name] = player_name
+        @player.set_attr player
+      end
+    end
+
+    def too_short?(input)
+      if input.length < @character_count
+        send_message(@response.shorter_input.message)
+        true
+      end
+    end
+
+    def too_long?(input)
+      if input.length > @character_count
+        send_message(@response.longer_input.message)
+        true
+      end
+    end
+
+    def the_input_is_too_long_or_too_short?(input)
+      true if too_long?(input) || too_short?(input)
+    end
+
+    def what_do_you_want_to_do_next
+      loser_play_again_or_quit if @response.status == :lost || @trial_count >= ALLOWED_TRIALS
+      winner_play_again_or_quit if @response.status == :won
+    end
+
+    def get_game_input
+      input = get_input(@response.trial_count(@trial_count, @colors.join, @color_values_from_all_colors_array).message)
+      input
+    end
+
+    def loser_play_again_or_quit
+      input = get_game_input
+      method(actions[input]).call if actions.keys.include? input
+    end
+
+    def winner_play_again_or_quit
+      if @response.status == :won
+        input = get_input(@response.message)
+        method(actions[input]).call if actions.keys.include? input
+      end
+    end
+
+    def check_correct?(analysis)
+      if analysis[:match_position] == @character_count
+        won(@time_started)
+        true
+      end
+    end
+
+    def actions
+      action_s = {
+        'q' => 'quit_game',
+        'quit' => 'quit_game',
+        'i' => 'instructions',
+        'instructions' => 'instructions',
+        'c' => 'cheat',
+        'cheat' => 'cheat'
+      }
+
+      supported_actions = {'p' => 'play', 'play' => 'play', 'top_players' => 'top_players', 't' => 'top_players'}
+      action_s = action_s.merge(supported_actions) if @trial_count >= ALLOWED_TRIALS || @response.status == :won
+
+      action_s
+    end
+
+    def instructions
+      send_message(@response.instructions(@color_values_from_all_colors_array).message)
+      @response.message
+    end
+
+    def quit_game
+      @trial_count = 0
+      @colors = []
+      send_message(@response.exit_game.message)
+      @response.message
+    end
+
+    def won(start_time)
+      @time_taken = Time.now.to_i - start_time
+      time = {}
+      time[:mins] = @time_taken/60
+      time[:secs] = @time_taken%60
+
+      save_if_top_ten
+
+      @response.won(@trial_count, time)
+    end
+
+    def lost
+
+    end
+
+    def save_if_top_ten
+      game_attr = {time_taken: @time_taken, guesses: @trial_count, date_played: Date.today}
+      @player.set_attr game_attr
+
+      @top_ten_record.add_record(@player)
+    end
+
+    def cheat
+      send_message(@response.cheat(@colors.join).message)
+      @response.message
+    end
+
+    def top_players
+      @top_ten_record.fetch_all.each{ |player|
+        send_message(player.winner_response)
+      }
+
+      game_process
+    end
+
+    private
+
+  end
+end

data/lib/mastermind/helper.rb

@@ -0,0 +1,13 @@
+module Mastermind
+  module Helper
+    def send_message(message)
+      puts message
+    end
+
+    def get_input(message)
+      send_message message
+      input = gets.chomp
+      input
+    end
+  end
+end

data/lib/mastermind/main.rb

@@ -0,0 +1,51 @@
+module Mastermind
+  class Main
+    include Helper
+    attr_reader :game, :response
+
+    def initialize
+      @response = Message.new
+    end
+
+    def start
+      action = get_input(@response.start.message)
+      if supported_actions.keys.include? action
+        @game ||= Game.new(@response)
+        method(supported_actions[action]).call
+      else
+        send_message @response.unsupported_game_action.message
+      end
+        start if supported_actions[action] =~ /instructions|background/ || @response.status == :unsupported_action
+    end
+
+  private
+    def instructions
+      send_message(@response.gameplay_instructions.message)
+    end
+
+    def background
+      send_message(@response.main_message.message)
+    end
+
+    def play
+      @game.play
+    end
+
+    def quit_game
+      @game.quit_game
+    end
+
+    def supported_actions
+      {
+        'p' => 'play',
+        'play' => 'play',
+        'q' => 'quit_game',
+        'quit' => 'quit_game',
+        'i' => 'instructions',
+        'instructions' => 'instructions',
+        'b' => 'background',
+        'background' => 'background'
+      }
+    end
+  end
+end

data/lib/mastermind/message.rb

@@ -0,0 +1,117 @@
+module Mastermind
+
+  class Message
+    attr_reader :message, :status
+
+    def initialize(input = nil)
+      if input
+        set_attr input
+      else
+        start
+      end
+    end
+
+    def set_attr(input)
+      @message = input[:message]
+      @status = input[:status]
+      self
+    end
+
+    def cheat(color)
+      set_attr(message: "Hmm! You just cheated. The colors generated were: #{color}.", status: :cheated)
+    end
+
+    def won(tries, time={})
+      set_attr(message: "#{'Congratulations!'.colorize(:green)}\nYou won the game in #{(tries.to_s + ' try'.pluralize(tries)).colorize(:blue)} and #{(time[:mins].to_s + 'm' + time[:secs].to_s + 's').colorize(:blue)}.\nDo you want to (p)lay again or (q)uit or (t)op_players?", status: :won)
+    end
+
+    def instructions(colors = ['(r)ed', '(g)reen', '(b)lue', '(y)ellow'])
+      color_count = colors.length
+      colors_generated_to_word = turn_array_to_string_list(colors, color_count)
+      example_gameplay = sample_instructions_arrangement(colors)
+      set_attr(message: "I have generated a beginner sequence with #{color_count.humanize + ' element'.pluralize(color_count)} made up of:\n#{colors_generated_to_word}. You are to guess the sequence in which these colors appeared e.g #{example_gameplay.colorize(:white)} for #{colors_generated_to_word}. You have #{Game::ALLOWED_TRIALS} guesses to get these colors or you lose the game. Use #{'(q)uit'.colorize(:red)} at any time to end the game.\nReady to play? \nWhat's your guess? ", status: :instructions)
+    end
+    # def instructions
+    #   set_attr(message: "I have generated a beginner sequence with four elements made up of:\n#{'(r)ed'.colorize(:red)}, #{'(g)reen'.colorize(:green)}, #{'(b)lue'.colorize(:blue)}, and #{'(y)ellow'.colorize(:yellow)}. Use #{'(q)uit'.colorize(:red)} at any time to end the game.\nWhat's your guess? ", status: :instructions)
+    # end
+
+    def shorter_input
+      set_attr(message: "Your input is too short.".colorize(:red), status: :shorter_input)
+    end
+
+    def longer_input
+      set_attr(message: "Your input is too long.".colorize(:red), status: :longer_input)
+    end
+
+    def start
+      set_attr(message: "Welcome to MASTERMIND!\nWould you like to #{'(p)lay'.colorize(:green)}, read the #{'(i)nstructions'.colorize(:blue)}, read a little #{'(b)ackground'.colorize(:yellow)} on Mastermind or #{'(q)uit'.colorize(:red)}?", status: :main_start)
+    end
+
+    def exit_game
+      set_attr(message: "Thank you for playing Mastermind!\nGoodbye!".colorize(:red), status: :quitted)
+    end
+
+    def unsupported_game_action(message: nil, status: nil)
+      set_attr(
+        message: message || "You entered an unsupported action, try again! ".colorize(:red),
+        status: status || :unsupported_action
+        )
+    end
+
+    def wrong_guess
+      set_attr(message: "Your guess was wrong! Guess again: ".colorize(:red), status: :wrong)
+    end
+
+    def analyzed_guess(matched_position, included)
+      set_attr(message: "You had #{(matched_position.to_s + ' position'.pluralize(matched_position)).colorize(:green)} exactly matched and #{(included.to_s + ' near match'.pluralize(included)).colorize(:blue)}", status: :running)
+    end
+
+    def trial_count(trial_count, correct_sequence, colors = nil)
+      remaining_trials = Game::ALLOWED_TRIALS - trial_count
+      if trial_count == 0
+        instructions(colors)
+      elsif(trial_count < Game::ALLOWED_TRIALS)
+        set_attr(message: "You have tried #{trial_count.to_s + ' time'.pluralize(trial_count)}. You have #{remaining_trials.to_s + ' attempt'.pluralize(remaining_trials)} left.\nTry again: ", status: :wrong_guess)
+      else
+        set_attr(message: "You tried, but lost.\nThe colors generated were #{correct_sequence}.\nWant to try again? (p)lay to start again or (q)uit to exit or (t)op_players to view the top ten players. ".colorize(:red), status: :lost)
+      end
+    end
+
+    def player
+      set_attr(message: "So you would like to play!\nStart by telling me your name: ".colorize(:green), status: :player_name)
+    end
+
+    def gameplay_instructions(color_count = 4)
+      set_attr(message: "Enter a sequence of #{color_count} colors containing the generated colors e.g RYBG or YGRB.\nIf you enter fewer than #{color_count} or more than #{color_count} colors, you would receive an error message", status: :main_instructions)
+    end
+
+    def main_message
+      message = <<-EOS
+      #{%q{Just a little background on MASTERMIND}.colorize(:red)} Mastermind is a board game with an interesting history (or rather a legend?). Some game books report that it was invented in 1971 by Mordecai Meirowitz, an Israeli postmaster and telecommunications expert. After many rejections by leading toy companies, the rights were obtained by a small British firm, Invicta Plastics Ltd. The firm originally manufactured the game itself, though it has since licensed its manufacture to Hasbro in most of the world. However, Mastermind is just a clever readaptation of an old similar game called 'Bulls and cows' in English, and 'Numerello' in Italian... Actually, the old British game 'Bulls and cows' was somewhat different from the commercial version. It was played on paper, not on a board... Over 50 million copies later, Mastermind is still marketed today!
+      The idea of the game is for one player (the code-breaker) to guess the secret code chosen by the other player (the code-maker). The code is a sequence of 4 colored pegs chosen from six colors available. The code-breaker makes a serie of pattern guesses - after each guess the code-maker gives feedback in the form of 2 numbers, the number of pegs that are of the right color and in the correct position, and the number of pegs that are of the correct color but not in the correct position - these numbers are usually represented by small black and white pegs.
+      In 1977, the mathematician Donald Knuth demonstrated that the code-breaker can solve the pattern in five moves or less, using an algorithm that progressively reduced the number of possible patterns.
+EOS
+      set_attr(message: message, status: :background_message)
+    end
+
+    def winner(winner, trials, time_taken)
+      set_attr(message: "#{winner} completed mastermind in #{trials} #{'guess'.pluralize(trials)} and #{time_taken}", status: :top_players)
+    end
+
+    private
+      def turn_array_to_string_list colors, array_count
+        if array_count >= 2
+          string_list = ''
+          string_list << colors[0..-2].map{|c| c.colorize(c.scan(/([[:alpha:]]+)/).join.to_sym)}.join(', ')
+          string_list << " and #{colors[-1].colorize(colors[-1].scan(/([[:alpha:]]+)/).join.to_sym)}"
+          string_list
+        else
+          colors.join
+        end
+      end
+
+      def sample_instructions_arrangement colors
+        colors.map{|c| c[1]}.join.upcase
+      end
+  end
+end