andrii_codebreaker 0.1.3 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e172f73161a1701928e49af4747bcb8f85867ef2c9a135fb04488774b542b9b0
-  data.tar.gz: e30f119ccda4eeafdb8b9904b9f20e3b748bcbdbaa5456429c2d18a012ae00b5
+  metadata.gz: 614726c17f68e0208588be0daa78170ff2dca52f3cbb48017faa565b96673a0c
+  data.tar.gz: fd3c636ff49aaace2fda7055aa2ce90155709e0c56edb889cad671d6e4f43105
 SHA512:
-  metadata.gz: d6b1f4b5af1f965f5bce17e022948005851bfd688c1b2a9de73d69f135a0be932cd15c9e1793da4772abdb62a2f97e31c89f967b0b37a86cd66bae093291fa6b
-  data.tar.gz: c0a7e048a4d875e0d65166de7354f5e67d439a929f0763b67ec3b9c40f88c9b89b77299a2d5618a06a024d914cefaf4f60062671897aa375d30f3778ecfd2e1a
+  metadata.gz: 0c5603c20de947e67d699355cec83a2f4160da98d133c8516b10bd45cff5ccfc76600092f9ef74ab040d05631ae8032ec08147908dcee0775e4a2f202e618cc3
+  data.tar.gz: b6ae17bb6609a3ea2b6dbe9dd78e024d425c31b1428dce613660ab004389bd93d17dd2235b222fe591db4fa6fb2aea3c2b08717f39009a4ecb9ba13f61d96ebc

data/Gemfile.lock

@@ -1,13 +1,12 @@
 PATH
   remote: .
   specs:
-    andrii_codebreaker (0.1.2)
+    andrii_codebreaker (0.1.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    coderay (1.1.3)
     colorize (0.8.1)
     concurrent-ruby (1.1.9)
     diff-lcs (1.4.4)
@@ -17,13 +16,9 @@ GEM
       ruby_parser (>= 3.14.1)
     i18n (1.8.11)
       concurrent-ruby (~> 1.0)
-    method_source (1.0.0)
     parallel (1.21.0)
     parser (3.0.2.0)
       ast (~> 2.4.1)
-    pry (0.14.1)
-      coderay (~> 1.1)
-      method_source (~> 1.0)
     rainbow (3.0.0)
     rake (13.0.6)
     regexp_parser (2.1.1)
@@ -73,7 +68,6 @@ DEPENDENCIES
   andrii_codebreaker!
   fasterer
   i18n
-  pry
   rake
   rspec
   rubocop

data/lib/andrii_codebreaker/constants.rb

@@ -13,5 +13,8 @@ module AndriiCodebreaker
       hell: { attempts: 5, hints: 1 }
     }.freeze
     DIFFICULTY_SORT = { easy: 1, medium: 2, hell: 3 }.freeze
+    WIN = '++++'
+    MINUS = '-'
+    PLUS = '+'
   end
 end

data/lib/andrii_codebreaker/difficulty.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AndriiCodebreaker
+  class Difficulty
+    include Constant
+
+    attr_reader :difficulty
+
+    def initialize(difficulty)
+      @difficulty = difficulty
+    end
+
+    def hint
+      difficult[:hints]
+    end
+
+    def attempts
+      difficult[:attempts]
+    end
+
+    def difficult
+      DIFFICULTY[@difficulty.to_sym]
+    end
+  end
+end

data/lib/andrii_codebreaker/game.rb

@@ -1,85 +1,97 @@
 # frozen_string_literal: true
 
-require_relative '../andrii_codebreaker'
-require_relative '../../config/i18n'
-
 module AndriiCodebreaker
   class Game
-    include Validate
     include Statistic
     include Constant
 
-    attr_reader :player_name, :difficulty, :attempts_total, :hints_total, :secret_code
-    attr_accessor :hints_left, :attempts_left
+    attr_reader :player_name, :difficulties, :attempts_total, :hints_total, :secret_code
+    attr_accessor :hints_left, :attempts_left, :secret_code_copy
 
     CONST_COMMAND = {
-      start: I18n.t('start'),
-      rules: I18n.t('rules'),
-      stats: I18n.t('stats'),
-      exit: I18n.t('exit')
+      start: 'start',
+      rules: 'rules',
+      stats: 'stats',
+      exit: 'exit'
     }.freeze
 
     def initialize(player_name, difficulty)
       @player_name = player_name
-      @difficulty = difficulty
+      @difficulties = Difficulty.new(difficulty)
       @attempts_left = 0
       @hints_left = 0
-      initialize_class
     end
 
-    def initialize_class
-      difficult = DIFFICULTY[@difficulty.to_sym]
-      @hints_total = difficult[:hints]
-      @attempts_total = difficult[:attempts]
+    def start
       @secret_code = generate_code
+      @secret_code_copy = @secret_code.chars
+      @hints_total = @difficulties.hint
+      @attempts_total = @difficulties.attempts
     end
 
-    def show_hints
-      hints_left
+    def hints
+      return unless @hints_total > @hints_left
+
+      @hints_left += 1
+      @secret_code_copy.pop
     end
 
     def compare_codes(guess)
-      return '++++' if exact_match(guess)
+      return '' if !guess.match(/^[1-6]{4}$/) && !guess.match(/^\?$/)
+      return WIN if guess == @secret_code
+
+      result = ''
+      index = []
+      code_guess = string_to_integer(guess)
+      secret_code = string_to_integer(@secret_code)
+
+      result, index = check_plus(code_guess, result, secret_code, index)
 
-      ('+' * pluses(guess)) + ('-' * minuses(guess))
+      delete_index(code_guess, index)
+      delete_index(secret_code, index)
+
+      check_minus(code_guess, result, secret_code, index)
     end
 
     private
 
-    def exact_match(guess)
-      @secret_code == guess
-    end
+    def check_plus(*info)
+      code_guess, result, secret_code, index = info
 
-    def pluses(guess)
-      zipped(guess)
-        .select { |el| el[0] == el[1] }
-        .count
+      code_guess.each_index do |i|
+        if code_guess[i] == secret_code[i]
+          result += '+'
+          index << i
+        end
+      end
+      [result, index]
     end
 
-    def minuses(guess)
-      return 0 if exact_match(guess)
-
-      arr = delete_pairs(guess)
-      arr[1].each do |number|
-        next unless arr[0].include?(number)
+    def check_minus(*info)
+      code_guess, result, secret_code, index = info
+      code_guess.each do |i|
+        next unless secret_code.include?(i)
 
-        arr[0].delete_at(arr[0].index(number))
+        result << MINUS
+        index = secret_code.index(i)
+        secret_code.delete_at(index)
       end
-      arr[1].size - arr[0].size
+      result
     end
 
-    def zipped(guess)
-      @secret_code.chars.zip(guess.chars)
+    def string_to_integer(input_code)
+      array_int = []
+      array_chars = input_code.chars
+      array_chars.each { |i| array_int << i.to_i }
+      array_int
     end
 
-    def delete_pairs(guess)
-      zipped(guess)
-        .delete_if { |el| el[0] == el[1] }
-        .transpose
+    def delete_index(array, index)
+      array.map!.with_index { |item, i| item unless index.include?(i) }.compact!
     end
 
     def generate_code
-      (Array.new(CODE_LENGTH_COUNT) { rand(CODE_START_LENGTH..CODE_LENGTH) }).join.to_s
+      (CODE_START_LENGTH..CODE_LENGTH_COUNT).map { rand(CODE_START_LENGTH..CODE_LENGTH) }.join
     end
   end
 end

data/lib/andrii_codebreaker/user.rb

@@ -2,25 +2,22 @@
 
 module AndriiCodebreaker
   class User
-    include AndriiCodebreaker::Validate
+    include Constant
 
     attr_reader :name
 
     def initialize(name)
-      @name = name
-      validate_name
+      @name = validates_name(name)
     end
 
-    def hints(user)
-      return unless user.hints_total > user.hints_left
+    private
 
-      user.hints_left += 1
+    def validates_name(name)
+      name if valid_name?(name)
     end
 
-    private
-
-    def validate_name
-      @name = validates_name(name)
+    def valid_name?(name)
+      name.length >= NAME_MIN_LENGTH && name.length <= NAME_MAX_LENGTH
     end
   end
 end

data/lib/andrii_codebreaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AndriiCodebreaker
-  VERSION = '0.1.3'
+  VERSION = '0.1.7'
 end

data/lib/andrii_codebreaker.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'i18n'
-require_relative 'andrii_codebreaker/validate/validate'
+require_relative 'andrii_codebreaker/constants'
 require_relative 'andrii_codebreaker/model'
 require_relative 'andrii_codebreaker/user'
+require_relative 'andrii_codebreaker/difficulty'
 require_relative 'andrii_codebreaker/statistic'
 require_relative 'andrii_codebreaker/version'
 require_relative 'andrii_codebreaker/game'
-require_relative 'andrii_codebreaker/constants'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: andrii_codebreaker
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.7
 platform: ruby
 authors:
 - Andrii
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-13 00:00:00.000000000 Z
+date: 2021-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fasterer
@@ -130,15 +130,13 @@ files:
 - andrii_codebreaker.gemspec
 - bin/console
 - bin/setup
-- config/i18n.rb
-- config/locales/en.yml
 - lib/andrii_codebreaker.rb
 - lib/andrii_codebreaker/constants.rb
+- lib/andrii_codebreaker/difficulty.rb
 - lib/andrii_codebreaker/game.rb
 - lib/andrii_codebreaker/model.rb
 - lib/andrii_codebreaker/statistic.rb
 - lib/andrii_codebreaker/user.rb
-- lib/andrii_codebreaker/validate/validate.rb
 - lib/andrii_codebreaker/version.rb
 homepage: https://github.com/Andrii-RubyGarage/Codebreker-Gem
 licenses:

data/config/i18n.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-I18n.config.load_path << Dir[File.expand_path('config/locales').concat('/*.yml')]

data/config/locales/en.yml

@@ -1,5 +0,0 @@
-en:
-  start: start
-  rules: rules
-  stats: stats
-  exit: exit

data/lib/andrii_codebreaker/validate/validate.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../constants'
-
-module AndriiCodebreaker
-  module Validate
-    include Constant
-
-    def validates_name(name)
-      name if valid_name?(name)
-    end
-
-    def validate_guess(code)
-      code = string_to_integer(code)
-      true if check_code_length?(code) && check_numbers?(code)
-    end
-
-    private
-
-    def string_to_integer(input_code)
-      array_int = []
-      array_chars = input_code.chars
-      array_chars.each { |i| array_int << i.to_i }
-      array_int
-    end
-
-    def valid_name?(name)
-      name.length >= NAME_MIN_LENGTH && name.length <= NAME_MAX_LENGTH
-    end
-
-    def check_code_length?(code)
-      code.length == CODE_LENGTH_COUNT
-    end
-
-    def check_numbers?(code)
-      code.all? { |value| value.between?(CODE_START_LENGTH, CODE_LENGTH) }
-    end
-  end
-end