codebreaker_rg 0.1.0

data/database/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

data/lib/app/entities/data_storage.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class DataStorage
+  FILE_NAME = 'database/data.yml'
+
+  def create
+    File.new(FILE_NAME, 'w')
+    File.write(FILE_NAME, [].to_yaml)
+  end
+
+  def load
+    YAML.load(File.open(FILE_NAME), [Menu]) if storage_exist?
+  end
+
+  def save(object)
+    File.open(FILE_NAME, 'w') { |file| file.write(YAML.dump(object)) }
+  end
+
+  def storage_exist?
+    File.exist?(FILE_NAME)
+  end
+
+  def save_game_result(object)
+    create unless storage_exist?
+    save(load.push(object))
+  end
+end

data/lib/app/entities/game.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class Game
+  DIGITS_COUNT = 4
+  DIFFICULTIES = {
+    easy: {
+      attempts: 15,
+      hints: 2
+    },
+    medium: {
+      attempts: 10,
+      hints: 1
+    },
+    hell: {
+      attempts: 5,
+      hints: 1
+    }
+  }.freeze
+  RANGE = (1..6).freeze
+
+  attr_reader :attempts, :hints, :code
+
+  def initialize
+    @process = Processor.new
+  end
+
+  def generate(difficulty)
+    @difficulty = difficulty
+    @code = generate_secret_code
+    @hints = @code.sample(difficulty[:hints])
+    @attempts = difficulty[:attempts]
+  end
+
+  def start_process(command)
+    @process.secret_code_proc(code.join, command)
+  end
+
+  def win?(guess)
+    code.join == guess
+  end
+
+  def decrease_attempts!
+    @attempts -= 1
+  end
+
+  def to_h(name)
+    {
+      name: name,
+      difficulty: DIFFICULTIES.key(@difficulty),
+      all_attempts: @difficulty[:attempts],
+      all_hints: @difficulty[:hints],
+      attempts_used: @difficulty[:attempts] - @attempts,
+      hints_used: @difficulty[:hints] - @hints.length
+    }
+  end
+
+  def hints_spent?
+    hints.empty?
+  end
+
+  def take_a_hint!
+    hints.pop
+  end
+
+  private
+
+  def generate_secret_code
+    Array.new(DIGITS_COUNT) { rand(RANGE) }
+  end
+end

data/lib/app/entities/menu.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+class Menu
+  include Validator
+  attr_reader :storage, :renderer, :game, :guess
+
+  COMMANDS = {
+    start: 'start',
+    exit: 'exit',
+    rules: 'rules',
+    stats: 'stats'
+  }.freeze
+  CHOOSE_COMMANDS = {
+    yes: 'yes'
+  }.freeze
+  HINT_COMMAND = 'hint'
+  MIN_SIZE_VALUE = 3
+  MAX_SIZE_VALUE = 20
+
+  def initialize
+    @storage = DataStorage.new
+    @renderer = Renderer.new
+    @game = Game.new
+    @statistics = Statistics.new
+  end
+
+  def game_menu
+    renderer.start_message
+    choice_menu_process(ask(:choice_options, commands: COMMANDS.keys.join(' | ')))
+  end
+
+  private
+
+  def rules
+    renderer.rules
+    game_menu
+  end
+
+  def start
+    @name = registrate_user
+    level_choice
+    game_process
+  end
+
+  def stats
+    scores = storage.load
+    render_stats(@statistics.stats(scores)) if scores
+    game_menu
+  end
+
+  def ask(phrase_key = nil, options = {})
+    renderer.message(phrase_key, options) if phrase_key
+    gets.chomp
+  end
+
+  def save_result
+    storage.save_game_result(game.to_h(@name)) if ask(:save_results_message) == CHOOSE_COMMANDS[:yes]
+  end
+
+  def registrate_user
+    loop do
+      name = ask(:registration)
+
+      return name if name_valid?(name)
+
+      renderer.registration_name_length_error
+    end
+  end
+
+  def name_valid?(name)
+    !check_emptyness(name) && check_length(name, MIN_SIZE_VALUE, MAX_SIZE_VALUE)
+  end
+
+  def level_choice
+    loop do
+      level = ask(:hard_level, levels: Game::DIFFICULTIES.keys.join(' | '))
+
+      return generate_game(Game::DIFFICULTIES[level.to_sym]) if Game::DIFFICULTIES[level.to_sym]
+      return game_menu if level == COMMANDS[:exit]
+
+      renderer.command_error
+    end
+  end
+
+  def generate_game(difficulty)
+    game.generate(difficulty)
+    renderer.message(:difficulty,
+                     hints: difficulty[:hints],
+                     attempts: difficulty[:attempts])
+  end
+
+  def game_process
+    while game.attempts.positive?
+      @guess = ask
+      return handle_win if game.win?(guess)
+
+      choice_code_process
+    end
+    handle_lose
+  end
+
+  def choice_code_process
+    case guess
+    when HINT_COMMAND then hint_process
+    when COMMANDS[:exit] then game_menu
+    else handle_command
+    end
+  end
+
+  def handle_command
+    return renderer.command_error unless check_command_range(guess)
+
+    p game.start_process(guess)
+    renderer.round_message
+    game.decrease_attempts!
+  end
+
+  def handle_win
+    renderer.win_game_message
+    save_result
+    game_menu
+  end
+
+  def handle_lose
+    renderer.lost_game_message(game.code)
+    game_menu
+  end
+
+  def hint_process
+    return renderer.no_hints_message? if game.hints_spent?
+
+    renderer.print_hint_number(game.take_a_hint!)
+  end
+
+  def exit_from_game
+    renderer.goodbye_message
+    exit
+  end
+
+  def choice_menu_process(command_name)
+    case command_name
+    when COMMANDS[:start] then start
+    when COMMANDS[:exit] then exit_from_game
+    when COMMANDS[:rules] then rules
+    when COMMANDS[:stats] then stats
+    else
+      renderer.command_error
+      game_menu
+    end
+  end
+
+  def render_stats(list)
+    list.each_with_index do |key, index|
+      puts "#{index + 1}: "
+      key.each { |param, value| puts "#{param}:#{value}" }
+    end
+  end
+end

data/lib/app/entities/processor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Processor
+  MATCHED_DIGIT_CHAR = '+'
+  UNMATCHED_DIGIT_CHAR = '-'
+
+  attr_reader :guess, :code, :result
+
+  def secret_code_proc(code, guess)
+    @code = code.split('')
+    @guess = guess.split('')
+    handle_matched_digits.join + handle_matched_digits_with_wrong_position.join
+  end
+
+  private
+
+  def handle_matched_digits
+    code.map.with_index do |_, index|
+      next unless code[index] == guess[index]
+
+      @guess[index], @code[index] = nil
+      MATCHED_DIGIT_CHAR
+    end
+  end
+
+  def handle_matched_digits_with_wrong_position
+    guess.compact.map do |number|
+      next unless @code.include?(number)
+
+      @code.delete_at(code.index(number))
+      UNMATCHED_DIGIT_CHAR
+    end
+  end
+end

data/lib/app/entities/renderer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Renderer
+  def message(msg_name, hashee = {})
+    puts I18n.t(msg_name, hashee)
+  end
+
+  def start_message
+    message(:start_message)
+  end
+
+  def rules
+    message(:rules)
+  end
+
+  def goodbye_message
+    message(:goodbye_message)
+  end
+
+  def save_results_message
+    message(:save_results_message)
+  end
+
+  def win_game_message
+    message(:win_game_message)
+  end
+
+  def round_message
+    message(:round_message)
+  end
+
+  def lost_game_message(code)
+    message(:lost_game_message, code: code)
+  end
+
+  def no_hints_message?
+    message(:have_no_hints_message)
+  end
+
+  def print_hint_number(code)
+    message(:print_hint_number, code: code)
+  end
+
+  def registration_name_emptyness_error
+    message(:registration_name_emptyness_error)
+  end
+
+  def registration_name_length_error
+    message(:registration_name_length_error)
+  end
+
+  def command_error
+    message(:command_error)
+  end
+
+  def command_length_error
+    message(:command_length_error)
+  end
+
+  def command_int_error
+    message(:command_int_error)
+  end
+end

data/lib/app/entities/statistics.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Statistics
+  def stats(list)
+    difficulties = list.group_by { |score| score[:difficulty] }
+    %w[hell medium easy].reduce([]) do |sorted_difficulties, difficulty_name|
+      if difficulties[difficulty_name]
+        sorted_difficulties + stats_sort(difficulties[difficulty_name])
+      else
+        sorted_difficulties
+      end
+    end
+  end
+
+  private
+
+  def stats_sort(scores)
+    scores.sort_by! { |score| [score[:attempts_used], score[:hints_used]] }.reverse
+  end
+end

data/lib/app/i18n_config.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+I18n.load_path << Dir[File.expand_path('lib/app/locales/') + '/*.yml']
+I18n.config.available_locales = :en

data/lib/app/locales/en.yml

@@ -0,0 +1,39 @@
+en:
+  start_message: "Welcome to CodeBreaker"
+  choice_options: "Choose option:
+  %{commands}"
+  hard_level: "Which level you do you want to play?
+  %{levels}"
+  goodbye_message: "We are waiting for you. Come back!"
+  command_error: "You have passed unexpected command. Please choose one from listed commands"
+  rules: "Codebreaker is a logic game in which a code-breaker tries to break a secret code created by a code-maker. The codemaker, which will be played by the application we’re going to write, creates a secret code of four numbers between 1 and 6.
+  The codebreaker gets some number of chances to break the code (depends on chosen difficulty). In each turn, the codebreaker makes a guess of 4 numbers. The codemaker then marks the guess with up to 4 signs - + or - or empty spaces.
+
+  A + indicates an exact match: one of the numbers in the guess is the same as one of the numbers in the secret code and in the same position. For example:
+  Secret number - 1234
+  Input number - 6264
+  Number of pluses - 2 (second and fourth position)
+
+  A - indicates a number match: one of the numbers in the guess is the same as one of the numbers in the secret code but in a different position. For example:
+  Secret number - 1234
+  Input number - 6462
+  Number of minuses - 2 (second and fourth position)
+
+  An empty space indicates that there is not a current digit in a secret number.
+
+  If codebreaker inputs the exact number as a secret number - codebreaker wins the game. If all attempts are spent - codebreaker loses.
+
+  Codebreaker also has some number of hints(depends on chosen difficulty). If a user takes a hint - he receives back a separate digit of the secret code.
+"
+  registration: "Before start, enter your name, please "
+  difficulty: "You had to %{hints} hints and %{attempts} attempts"
+  round_message: "1. Enter your secret code
+  2. hint
+  3. exit "
+  guess: "Opps, secret code must to be from four digits in range from 1 to 6"
+  lost_game_message: "Oh, your attempts ended... Your code was: %{code}"
+  win_game_message: "Yayy, u won the game! Congrats!"
+  save_results_message: "Do you want to save result? 1. yes 2. no"
+  have_no_hints_message: "Oh, your hints ended"
+  print_hint_number: "Hint number: %{code}"
+  registration_name_length_error: "It must be more than 3 and less than 20 symbols."

data/lib/app/modules/validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Validator
+  VALUE_FORMAT = /^[1-6]{4}$/.freeze
+
+  def check_emptyness(value)
+    value.empty?
+  end
+
+  def check_length(value, min_size, max_size)
+    value.size.between?(min_size, max_size)
+  end
+
+  def check_command_range(command)
+    command =~ VALUE_FORMAT
+  end
+end