hangman-cli 2.0.2

data/lib/display.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'gallows'
+
+# Module to display all in game text.
+module Display
+  def self.welcome_message
+    puts "Welcome to Hangman.\n\n"
+  end
+
+  def self.instruction_intro
+    puts "If you'd like instructions enter 'i'."
+    puts 'Otherwise press return to continue.'
+  end
+
+  def self.instructions
+    puts <<-MSG
+  Reveal the hidden word before your man is hung.
+
+  You may guess a single letter at a time. 
+  A correct guess will result in that letter being filled in.
+  Incorrect guesses will result in a part of the stick man being drawn.
+  You have 6 incorrect guesses to play with to save your man.
+  You may also guess the whole word at any time. But be careful; an incorrect guess is game over.
+
+  The game is auto saved after each round. 
+  Use the load function at game start to load a previously saved game.
+  Enter 'quit game' at any time to end session.
+
+    MSG
+  end
+
+  def self.enter_name
+    puts 'Enter your name: '
+  end
+
+  def self.play_again
+    puts "Would you like to play again? Enter 'yes' or 'no': "
+  end
+
+  def self.leave
+    puts 'Okay, bye.'
+  end
+
+  def self.validation_errors(errors)
+    puts errors.join(', ') unless errors.empty?
+  end
+
+  def self.thank_player(player)
+    puts "Thanks #{player.name}"
+  end
+
+  def self.word_to_guess(guess_logic)
+    puts " Word to guess: #{guess_logic.guessed_word}"
+  end
+
+  def self.gallows(guess_logic)
+    puts Gallows::GALLOWS[guess_logic.incorrect_guesses]
+  end
+
+  def self.beginning_of_guess_round(guess_logic)
+    puts <<~MSG
+      #{gallows(guess_logic)}
+      #{word_to_guess(guess_logic)}
+      Wrong letters: #{guess_logic.incorrect_letters.join(', ')}
+      Incorrect guesses: #{guess_logic.incorrect_guesses}\n\n
+      Make your guess:
+    MSG
+  end
+
+  def self.end_of_guess_round(guess_logic)
+    puts guess_logic.messages.pop.to_s
+  end
+
+  def self.victory(word_to_guess)
+    puts "\n Yes! The word was #{word_to_guess.word.upcase}."
+    puts "\n  You win!\n\n"
+  end
+
+  def self.defeat(word_to_guess)
+    puts Gallows.finish
+    puts "\n Sorry, you lose!"
+    puts "\n The word was #{word_to_guess.word.upcase}\n\n"
+  end
+
+  def self.load_game
+    puts "Enter 'load' to load previously saved game."
+    puts 'Or press return to start a new game.'
+  end
+end

data/lib/gallows.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# Module to hold Gallow graphics
+module Gallows
+  def self.start
+    <<-GALLOWS
+    ===========
+      |/    |
+      |
+      |
+      |
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.head
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |
+      |
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.body
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |     |
+      |
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.right_arm
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |    /|
+      |
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.left_arm
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |    /|\\
+      |
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.right_leg
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |    /|\\
+      |    /
+      |\\
+    ============
+    GALLOWS
+  end
+
+  def self.finish
+    <<-GALLOWS
+    ===========
+      |/    |
+      |     O
+      |    /|\\
+      |    / \\
+      |\\
+    ============
+    GALLOWS
+  end
+
+  GALLOWS = { 0 => start,
+              1 => head,
+              2 => body,
+              3 => right_arm,
+              4 => left_arm,
+              5 => right_leg,
+              6 => finish }
+            .freeze
+end

data/lib/game.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative 'player'
+require_relative 'dictionary'
+require_relative 'word_to_guess'
+require_relative 'gallows'
+require_relative 'guess_logic'
+require_relative 'guess'
+require_relative 'display'
+require_relative 'player_name'
+require_relative 'game_save'
+require_relative 'answer'
+require 'yaml'
+
+# Class to hold all main game elements and behaviour
+class Game
+  attr_accessor :player, :word_to_guess, :guess_logic
+
+  def initialize
+    @player = nil
+    @word_to_guess = word
+    @guess_logic = GuessLogic.new(word_to_guess)
+  end
+
+  def start
+    welcome
+    load_game
+    instructions
+    player_setup
+    main_game_loop
+  end
+
+  def main_game_loop
+    loop do
+      Gallows::GALLOWS[guess_logic.incorrect_guesses]
+      # puts word_to_guess.word TESTING
+      guess
+      victory if win?
+      defeat if game_over?
+      GameSave.save(self)
+    end
+  end
+
+  def player_setup
+    loop do
+      Display.enter_name
+      player_name = PlayerName.new($stdin.gets)
+      Display.validation_errors(player_name.errors)
+      redo unless player_name.valid?
+      self.player = Player.new(player_name.answer)
+      Display.thank_player(player)
+      break
+    end
+  end
+
+  def guess
+    loop do
+      Display.beginning_of_guess_round(guess_logic)
+      guess = Guess.new($stdin.gets, word_to_guess)
+      Display.validation_errors(guess.errors)
+      redo unless guess.valid?
+      full_word_check(guess) if guess_logic.full_word_guess?(guess)
+      guess_logic.compare(guess)
+      Display.end_of_guess_round(guess_logic)
+      break
+    end
+  end
+
+  private
+
+  def welcome
+    Display.welcome_message
+  end
+
+  def instructions
+    Display.instruction_intro
+    response = Answer.new($stdin.gets)
+    Display.instructions if response.answer == 'i'
+  end
+
+  def load_game
+    Display.load_game
+    response = Answer.new($stdin.gets)
+    begin
+      GameSave.load.main_game_loop if response.answer == 'load'
+    rescue StandardError
+      puts 'No current save game.'
+    end
+  end
+
+  def full_word_check(guess)
+    if guess_logic.correct_word?(guess)
+      victory
+    else
+      defeat
+    end
+  end
+
+  def word
+    dictionary = Dictionary.new('words.txt')
+    WordToGuess.new(dictionary.word)
+  end
+
+  def game_over?
+    guess_logic.incorrect_guesses > 5
+  end
+
+  def win?
+    guess_logic.guessed_word == word_to_guess.word
+  end
+
+  def victory
+    Display.victory(word_to_guess)
+    reload
+  end
+
+  def defeat
+    Display.defeat(word_to_guess)
+    reload
+  end
+
+  def reload
+    Display.play_again
+    answer = $stdin.gets.chomp.downcase
+    if answer == 'yes'
+      Game.new.main_game_loop
+    else
+      Display.leave
+      exit
+    end
+  end
+end

data/lib/game_save.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+# Class to save and load game
+class GameSave
+  def self.save(game)
+    game_data = YAML.dump(game)
+    save_file = File.join(File.dirname(__FILE__), '../lib/save_games/savegame.txt')
+    dirname = File.dirname(save_file)
+
+    FileUtils.mkdir(dirname) unless File.directory?(dirname)
+
+    File.open(save_file, 'w') do |f|
+      f.write game_data
+    end
+  end
+
+  def self.load
+    save_file = File.join(File.dirname(__FILE__), '../lib/save_games/savegame.txt')
+
+    return nil unless File.exist?(save_file)
+
+    game_data = File.open(save_file, 'r', &:read)
+    YAML.load(game_data)
+  end
+end

data/lib/guess.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'answer'
+
+# Class to model answers that are guesses
+class Guess < Answer
+  attr_reader :word_to_guess
+  attr_accessor :errors
+
+  def initialize(answer, word_to_guess)
+    super(answer)
+    @word_to_guess = word_to_guess.word
+    valid?
+  end
+
+  def valid?
+    self.errors = []
+    errors << 'Must be a letter' unless letter?
+    errors << 'Must be a single letter or guessing the full word' unless single_letter? || full_word_guess?
+    errors.empty?
+  end
+
+  private
+
+  def letter?
+    answer.match?(/[a-z]/)
+  end
+
+  def single_letter?
+    answer.size == 1
+  end
+
+  def full_word_guess?
+    answer.size == word_to_guess.size
+  end
+end

data/lib/guess_logic.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Class for processing guesses
+class GuessLogic
+  attr_reader :word_to_guess, :guessed_letters
+  attr_accessor :incorrect_guesses, :incorrect_letters,
+                :messages
+
+  def initialize(word_to_guess)
+    @word_to_guess = word_to_guess.word
+    @guessed_letters = []
+    @incorrect_letters = []
+    @incorrect_guesses = 0
+    @messages = []
+  end
+
+  def guessed_word
+    word_to_guess.chars.map { |char| guessed_letters.include?(char) ? char : '-' }.join
+  end
+
+  def compare(guess)
+    if correct_guess?(guess)
+      add_letters(guessed_letters, guess)
+      messages << "\n That's Correct!"
+    else
+      add_letters(incorrect_letters, guess)
+      self.incorrect_guesses += 1
+      messages << "\n Sorry, that's incorrect."
+    end
+  end
+
+  def full_word_guess?(guess)
+    word_to_guess.length == guess.answer.length
+  end
+
+  def correct_word?(guess)
+    word_to_guess == guess.answer
+  end
+
+  private
+
+  def correct_guess?(guess)
+    word_to_guess.include?(guess.answer)
+  end
+
+  def add_letters(collection, guess)
+    collection << guess.answer
+  end
+end

data/lib/hangman.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler/setup'
+require_relative 'game'
+
+Game.new.start

data/lib/player.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Class to model a player
+class Player
+  attr_reader :name
+
+  def initialize(name = 'anonymous')
+    @name = name.capitalize
+  end
+end