Class: Lekanmastermind::GameEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/lekanmastermind/game_engine.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sequence, message) ⇒ GameEngine

Returns a new instance of GameEngine.



8
9
10
11
 
# File 'lib/lekanmastermind/game_engine.rb', line 8

def initialize(sequence,message)
  @message = message
  @computer_sequence = sequence
end

Instance Attribute Details

#computer_sequence ⇒ Object

Returns the value of attribute computer_sequence.



7
8
9
 
# File 'lib/lekanmastermind/game_engine.rb', line 7

def computer_sequence
  @computer_sequence
end

Instance Method Details

#calculate_partials(computer_guess, player_guess, partial_match) ⇒ Object 



49
50
51
52
53
54
55
56
57
 
# File 'lib/lekanmastermind/game_engine.rb', line 49

def calculate_partials(computer_guess, player_guess, partial_match)
  player_guess.each do |a|
    if computer_guess.include? a
      computer_guess.delete_at(computer_guess.index(a))
      partial_match << a
    end
  end
  partial_match.size
end

#cheat ⇒ Object 



21
22
23
 
# File 'lib/lekanmastermind/game_engine.rb', line 21

def cheat
   computer_sequence
end

#combined_guesses(player) ⇒ Object 



24
25
26
27
28
 
# File 'lib/lekanmastermind/game_engine.rb', line 24

def combined_guesses(player)
  guess = player.guess.split('')
  comp = computer_sequence.split('')
  combined_guesses = comp.zip(guess)
end

#comp_number_characters ⇒ Object 



77
78
79
 
# File 'lib/lekanmastermind/game_engine.rb', line 77

def comp_number_characters
  computer_sequence.length
end

#exacts(combined_guesses) ⇒ Object 



38
39
40
 
# File 'lib/lekanmastermind/game_engine.rb', line 38

def exacts(combined_guesses)
  combined_guesses.count { |guess| guess[0] == guess[1] }
end

#input_length_check(guess) ⇒ Object 



59
60
61
62
63
64
65
66
 
# File 'lib/lekanmastermind/game_engine.rb', line 59

def input_length_check(guess)
  character_count = computer_sequence.length
  if guess.length > character_count
     "Your guess is longer than the required length(#{character_count})"
  elsif guess.length < computer_sequence.length
     "Your guess is shorter than the required length(#{character_count})"
  end
end

#invalid_play(player) ⇒ Object 



68
69
70
 
# File 'lib/lekanmastermind/game_engine.rb', line 68

def invalid_play(player)
  not_letters?(player.guess) || !validate_number_of_characters(player.guess)
end

#not_letters?(guess) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
75
 
# File 'lib/lekanmastermind/game_engine.rb', line 72

def not_letters?(guess)
  trimmed_guess = guess.strip
  true if /[^a-z]/ =~ trimmed_guess
end

#partials(combined_guesses) ⇒ Object 



42
43
44
45
46
47
 
# File 'lib/lekanmastermind/game_engine.rb', line 42

def partials(combined_guesses)
  combined_guesses.select! { |guess| guess[0] != guess[1] }
  computer_guess, player_guess = combined_guesses.transpose
  partial_match = []
  calculate_partials(computer_guess, player_guess, partial_match)
end

#print_history(player) ⇒ Object 



13
14
15
 
# File 'lib/lekanmastermind/game_engine.rb', line 13

def print_history(player)
  player.history.empty? ? "No history right now" : player.history
end

#process_guess(player, chances) ⇒ Object 



29
30
31
32
33
34
35
36
 
# File 'lib/lekanmastermind/game_engine.rb', line 29

def process_guess(player, chances)
  combined_guesses = combined_guesses(player)
  exact_numb = exacts(combined_guesses)
  partial_numb = partials(combined_guesses)
  player.save_guess(player.guess, exact_numb, partial_numb)
  @message.guess_process_message(player.guess, exact_numb,
                                  partial_numb, chances)
end

#validate_number_of_characters(guess) ⇒ Object 



81
82
83
 
# File 'lib/lekanmastermind/game_engine.rb', line 81

def validate_number_of_characters(guess)
  guess.length == comp_number_characters
end

#won?(player) ⇒ Boolean

Returns:

  • (Boolean) 


17
18
19
 
# File 'lib/lekanmastermind/game_engine.rb', line 17

def won?(player)
  player.guess == computer_sequence
end