paitin_hangman 0.1.0

data/lib/paitin_hangman/extra_methods.rb

@@ -0,0 +1,80 @@
+require_relative "messages"
+
+module PaitinHangman
+module SimpleMethods
+  
+  def verify_name_integrity
+    name = gets.chomp.upcase.strip
+    while name.scan(/[^A-Z\s-]/).empty? == false || name.empty?
+      Message.verify_name
+      name = STDIN.gets.chomp.upcase.strip
+    end
+    name
+  end
+
+  # => This technically begins the game
+  def play(name)
+    Message.game_type
+    option_integrity
+    if @option == "2"
+      Computer.new.level_integrity(name)
+    else
+      Player.new.first_player_name(name)
+    end
+  end
+  # => The method makes sure a valid option is picked
+
+  def option_integrity
+    @option = gets.chomp
+    until @option == "1" || @option == "2"
+      puts "Enter either a '1' or a '2'"
+      @option = STDIN.gets.chomp
+    end
+    @option
+  end
+
+  def length_one?(parameter)
+    if parameter.length == 1
+      return true
+    else
+      puts "Enter just one letter or an hyphen or an apostrophe"
+      return false
+    end
+  end
+
+  def unique?(parameter)
+    if @misses.include?(parameter) || @right_guesses.include?(parameter)
+      puts "You have used #{parameter} already, try again"
+      return false
+    else
+      return true
+    end
+  end
+
+  def number?(parameter)
+    if parameter.scan(/\d/).empty?
+      return true
+    else
+      puts "You cannot enter a number! Try again"
+      return false
+    end
+  end
+  
+  def choice_integrity
+    choice = gets.chomp.downcase
+    until choice == "r" || choice == "q" || choice == "quit"
+      puts "You must enter either a 'r' or 'q' or type 'quit'"
+      choice = STDIN.gets.chomp.downcase
+    end
+    decide(choice)
+  end
+
+  def decide(choice)
+    if choice == "r"
+      @player1 ? play(@player1) : play(@player2)
+    else
+      exit
+    end
+  end
+end
+end

data/lib/paitin_hangman/game_data.rb

@@ -0,0 +1,20 @@
+module PaitinHangman
+class GameData
+  attr_accessor :player_name, :misses, :right_guesses, :chances, :word_control, :game_word, :count
+
+  def initialize(player_name, misses, right_guesses, chances, word_control, game_word, count)
+    @player_name = player_name
+    @misses = misses
+    @right_guesses = right_guesses
+    @chances = chances
+    @word_control = word_control
+    @game_word = game_word
+    @count = count
+  end
+
+  def to_s
+    "#{player_name}  ===>>>     #{word_control.upcase.gsub('_', '__ ')}\n"\
+		"\t   #{chances} chances left and you have used #{misses.join(', ')}\n"
+  end
+end
+end

data/lib/paitin_hangman/game_engine.rb

@@ -0,0 +1,73 @@
+require_relative "messages"
+require_relative "levels"
+require_relative "extra_methods"
+# => This class only ensures the smooth transfer of control to the levels
+module PaitinHangman
+class Computer
+  def initialize
+    Message.level_choice
+  end
+
+  def level_integrity(name)
+    choice = gets.chomp
+    until choice == "1" || choice == "2" || choice == "3"
+      puts "Please press either '1', '2' or '3'"
+      choice = STDIN.gets.chomp
+    end
+    level(choice, name)
+  end
+
+  def level(choice, name)
+    case choice
+    when "1" then Levels.new(name, 4, 8, 10)
+    when "2" then Levels.new(name, 9, 12, 12)
+    when "3" then Levels.new(name, 13, 25, 15)
+    end
+  end
+end
+
+class Player
+  include SimpleMethods
+
+  def first_player_name(name)
+    player1 = name
+    get_friend_name(player1)
+  end
+
+  def get_friend_name(player1)
+    puts "Hi #{player1}, what is the name of your friend"
+    player2 = verify_name_integrity
+    puts "Hello, #{player1} and #{player2}, who will like to challenge"
+    game(player1, player2)
+  end
+
+  def game(player1, player2)
+    begin 
+      puts "Please enter one of your names: #{player1} or #{player2}"
+      name = verify_name_integrity
+    end until name == player1 || name == player2
+    other_player = player2 if name == player1
+    other_player = player1 if name == player2
+    Message.level_choice
+    level_integrity(name, other_player)
+  end
+
+  def level_integrity(name, other_player)
+    choice = gets.chomp
+    until choice == "1" || choice == "2" || choice == "3"
+      puts "Please press either '1', '2' or '3'"
+      choice = STDIN.gets.chomp
+    end
+    select_level(choice, name, other_player)
+  end
+
+  def select_level(choice, name, other_player)
+    case choice
+    when "1" then Levels.new(other_player, 4, 8, 10, name)
+    when "2" then Levels.new(other_player, 9, 12, 12, name)
+    when "3" then Levels.new(other_player, 13, 25, 15, name)
+    end
+  end
+
+end
+end

data/lib/paitin_hangman/levels.rb

@@ -0,0 +1,180 @@
+require "colorize"
+require "io/console"
+require "yaml"
+require_relative "extra_methods"
+require_relative "messages"
+require_relative "game_data"
+module PaitinHangman
+class Levels
+  attr_reader :player2, :min, :max, :chances, :player1, :game_word
+  include SimpleMethods
+  def initialize(player, min, max, chances, another_player = nil)
+    @misses = []
+    @right_guesses = []
+    initialize_specs(player, min, max, chances, another_player)
+    puts "\t\tWelcome #{@player2}, In this level, you will have #{@chances}
+    chances to guess the word correctly"
+    word_generator(@min, @max) if @player1.nil?
+    challenge_word(@min, @max) if @player1.nil? == false
+    trials(@chances)
+  end
+
+  def initialize_specs(player, min, max, chances, another_player)
+    @player2 = player
+    @min = min
+    @max = max
+    @chances = chances
+    @player1 = another_player
+  end
+
+  def word_generator(min, max, path = "")
+    words = File.open(path + "dictionary.txt", "r").readlines.map!(&:chomp)
+    level_words = words.select { |i| i.length >= min && i.length <= max }
+    random_index = rand(level_words.length)
+    @game_word = level_words[random_index]
+  end
+
+  def challenge_word(min, max)
+    puts "Now, enter your challenge_word #{@player1}, it will be hidden"
+    @game_word = STDIN.noecho(&:gets).chomp.downcase.delete(" ")
+    until @game_word.length >= min && @game_word.length <= max &&
+          number?(@game_word)
+      puts "Word length not correct!Make it between #{min} & #{max} characters"
+      @game_word = STDIN.noecho(&:gets).chomp.downcase.delete(" ")
+    end
+    puts "The stage is set #{@player2}"
+  end
+
+  def trials(chances)
+    setup
+    chances.times do |counter|
+      @counter = counter
+      verify_guess
+      compare_guess
+      win_game(chances, counter)
+    end
+    end_game
+  end
+
+  def compare_guess
+    if @game_word.include?(@guess) == false
+      wrong_guess
+    else
+      correct_guess
+    end
+  end
+
+  def setup
+    @word_control = ""
+    @game_word.length.times { @word_control << "_" }
+    @count = 0
+    puts @word_control.gsub("_", "__ ")
+  end
+
+  def wrong_guess
+    @misses << @guess
+    puts "Bad guess, the noose tightens".red
+    puts "Try again"
+    puts @word_control.gsub("_", " __ ").upcase
+  end
+
+  def correct_guess
+    @game_word.each_char.with_index do |letter, index|
+      right_guess(letter, index)
+    end
+    @right_guesses << @guess
+    puts @word_control.gsub("_", " __ ").upcase
+  end
+
+  def right_guess(letter, index)
+    if letter == @guess
+      if @word_control.include?(@guess) == false
+        @count += 1
+        puts "Nice one!".green
+      end
+      @word_control[index] = @guess
+    end
+  end
+
+  def verify_guess
+    puts "Enter a guess"
+    @guess = gets.chomp.downcase
+    cheat_or_quit_or_history
+    until length_one?(@guess) && unique?(@guess) && number?(@guess)
+      @guess = STDIN.gets.chomp.downcase
+      puts @game_word if @guess == ":c"
+      puts "Your missed guesses: #{@misses.join(', ')}" if @guess == ":h"
+    end
+  end
+
+  def cheat_or_quit_or_history
+    if @guess == ":c"
+      puts @game_word
+      verify_guess
+    elsif @guess == "quit" || @guess == ":q"
+      quit_or_save
+    elsif @guess == ":h" || @guess == "history"
+      history_verify_guess
+    end
+  end
+
+  def history_verify_guess
+    history
+    verify_guess
+  end
+
+  def quit_or_save
+    exit if @player1.nil? == false
+    puts "Do you want to save your game? type 'Yes' or 'No'"
+    choice = STDIN.gets.chomp.downcase
+    until choice == "yes" || choice == "no"
+      puts "Please type a 'Yes' or a 'No'"
+      choice = STDIN.gets.chomp.downcase
+    end
+    choice == "no" ? exit : save_game
+  end
+
+  def save_game
+    game_data = GameData.new(@player2, @misses, @right_guesses,
+                             @chances - @counter, @word_control,
+                             @game_word, @count)
+    File.open("games.yml", "a") { |data| YAML.dump(game_data, data) }
+    puts "Goodbye, your game has been saved successfully".green
+    exit
+  end
+
+  def history
+    if @misses.empty? && @right_guesses.empty?
+      puts "you have not entered any guesses"
+    else
+      print_history
+    end
+  end
+
+  def print_history
+    if @misses.empty? && @right_guesses.empty? == false
+      puts "your right guesses are #{@right_guesses.join(', ')} but no misses"
+    elsif @misses.empty? == false && @right_guesses.empty?
+      puts "your misses are #{@misses.join(', ')} & you have no right guesses"
+    else
+      puts "\tyour misses are #{@misses.join(', ')} and your
+      right guesses are #{@right_guesses.join(', ')}"
+    end
+  end
+
+  def win_game(chances, counter, player = @player2)
+    if @count == @game_word.chars.uniq.length
+      puts "Congratulations #{player}! You have won the game".green
+      exit
+    end
+    puts "You have #{chances - 1 - counter} chance(s) left"
+  end
+
+  def end_game(player = @player2)
+    puts "Game over! You have been HANGED! Sorry #{player}".red
+    puts "The word is #{@game_word.upcase}"
+    Message.end_games
+    choice_integrity
+  end
+end
+end

data/lib/paitin_hangman/messages.rb

@@ -0,0 +1,75 @@
+
+# This Message class basically supplies the game with
+# messages to guide the user
+
+require "colorize"
+module PaitinHangman
+class Message
+  # => The welcome message introduces the game to the player
+  def self.welcome
+    puts "\tWelcome to Hangman, the no-nonsense game
+    Be smart, then you live. if not, you'll have to die by Hanging.
+    You have a couple of options to pick from.....
+    Press 'P' or 'play' if you think you are ready for the challenge,
+    You may press 'I' or 'instructions' for a short explanation of how to play
+    You may continue a previously saved game by pressing 'L' or 'load'
+    Or you could just quit by pressing a 'Q' or typing 'quit'".green
+  end
+  # => The instruction tells the user what the game is about
+
+  def self.instruction
+    puts "\tThe word to guess is represented by a row of dashes
+    These dashes represent each letter of the word.
+    Words you cannot use include proper nouns such as names, places, and brands.
+    If the guessing player suggests a letter which occurs in the word,
+    the other player writes it in all its correct positions.".yellow
+    Message.instruction_continue
+  end
+
+  def self.instruction_continue
+    puts "\tThe guessing player wins the game if he gets all letters correctly
+    within number of chances afforded. He loses if he exhausts all his chances
+    without getting all the letters of the word completely".yellow
+    puts "\tNow decide whether you want to 'p'lay or 'q'uit.
+    Please do keep in mind that you can press ':h' or 'history' at any time
+    during the game to show your guess history or ':q'/'quit' to exit the game
+    While quitting the game, you may quit directly or decide to save your
+    session to resume at a later time at which point you must press 's'".yellow
+  end
+  # => This method basically instructs the player to pick a valid option
+
+  def self.valid_option
+    puts "Try and enter a valid option: 'p', 'i', 'l' or 'q'".yellow
+  end
+  # => game logic
+
+  def self.game_intro
+    puts "Now that you have chosen to play".green
+    print "What is your name: ".green
+  end
+  # => Instructs the user to enter a valid name
+
+  def self.verify_name
+    puts "Please enter your real name, I don't think it is just a".red
+    puts "space or it contains numbers.".red
+  end
+  # => game logic
+
+  def self.game_type
+    puts "1)\tPlay against a Human Player, press 1\n"\
+    "2)\tPlay against Computer, press 2"
+  end
+  # informs the player of the levels available & their respective difficulties
+
+  def self.level_choice
+    puts "    Enter the Level you would like to play. You may press...
+    1 for Beginner (4 - 8 character word)
+    2 for Intermediate (9 - 12 character word)
+    3 for Advanced (word has above 12 characters)".yellow
+  end
+
+  def self.end_games
+    puts "Press 'r' to restart the game or 'q' to quit."
+  end
+end
+end

data/lib/paitin_hangman/saved_games.rb

@@ -0,0 +1,89 @@
+require_relative "levels"
+module PaitinHangman
+class GameResumption
+  def initialize
+    @all_games = YAML.load_stream(File.open("games.yml", "a+"))
+    puts "Enter the name you used to store the game"
+    name = STDIN.gets.chomp.upcase
+    @saved_game = @all_games.select do |game|
+      game.player_name == name
+    end
+    initialize_cont(name)
+  end
+
+  def initialize_cont(name)
+    if @saved_game.empty?
+      puts "You have no saved game with that name".red
+      puts "START A NEW GAME INSTEAD".yellow
+      exit
+    end
+    puts "Here are the saved games found for #{name}\n\n"
+    print_function
+    choice_integrity
+  end
+
+  def choice_integrity
+    puts "Now enter the number for the game you want to play"
+    @choice = STDIN.gets.chomp.to_i
+    until @choice > 0 && @choice <= @saved_game.length
+      puts "Enter a number that has a game please"
+      @choice = STDIN.gets.chomp.to_i
+    end
+    @choice -= 1
+    load_properties
+  end
+
+  def load_properties
+    @game_object = @saved_game[@choice]
+    @name = @game_object.player_name
+    @misses = @game_object.misses
+    @right_guesses = @game_object.right_guesses
+    @chances = @game_object.chances
+    @word_control = @game_object.word_control
+    @game_word = @game_object.game_word
+    load_properties_cont
+  end
+
+  def load_properties_cont
+    count = @game_object.count
+    Saved.new(@name, @chances, @word_control, @game_word,
+              @misses, @right_guesses, count).trials(@chances)
+  end
+
+  def print_function
+    @saved_game.length.times do |index|
+      print "#{index + 1}.\t"
+      puts @saved_game[index], "\n"
+    end
+  end
+end
+
+class Saved < Levels
+  def initialize(name, chances, word_control, game_word, misses, right_guesses,
+                 count)
+    @player_name = name
+    @chances = chances
+    @word_control = word_control
+    @game_word = game_word
+    @misses = misses
+    @right_guesses = right_guesses
+    @count = count
+  end
+
+  def trials(chances)
+    setup
+    chances.times do |counter|
+      @counter = counter
+      verify_guess
+      compare_guess
+      win_game(chances, counter, @player_name)
+    end
+    end_game(@player_name)
+  end
+
+  def setup
+    puts "Now, continue playing..."
+    puts @word_control.gsub("_", "__ ").upcase
+  end
+end
+end

data/lib/paitin_hangman/version.rb

@@ -0,0 +1,3 @@
+module PaitinHangman
+  VERSION = "0.1.0"
+end

data/lib/paitin_hangman.rb

@@ -0,0 +1,46 @@
+require_relative "paitin_hangman/messages"
+require_relative "paitin_hangman/saved_games"
+require_relative "paitin_hangman/version"
+require_relative "paitin_hangman/game_engine"
+module PaitinHangman
+  class Paitin
+    include SimpleMethods
+    def game_control
+      Message.welcome
+      process
+    end
+
+    def process
+      choice = gets.chomp.downcase
+      choice_integrity(choice)
+    end
+
+    def choice_integrity(choice)
+      case choice
+      when "p", "play" then new_game
+      when "i", "instruction" then instruction
+      when "q", "quit" then exit
+      when "l", "load" then GameResumption.new
+      else
+        try_again
+      end
+    end
+
+    def try_again
+      Message.valid_option
+      process
+    end
+
+    def instruction
+      Message.instruction
+      process
+    end
+
+    def new_game
+      Message.game_intro
+      name = verify_name_integrity
+      puts "Hi #{name}, Select a mode"
+      play(name)
+    end
+  end
+end

data/paitin_hangman.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'paitin_hangman/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "paitin_hangman"
+  spec.version       = PaitinHangman::VERSION
+  spec.authors       = ["Mayowa Pitan"]
+  spec.email         = ["mayowa.pitan@andela.com"]
+
+  spec.summary       = %q{A Classic implementation of the hangman game}
+  spec.description   = %q{The no-nonsense game, guess right and you live!}
+  spec.homepage      = "https://www.github.com/andela-mpitan/paitin_hangman"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ["paitin_hangman"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency "colorize"
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'simplecov'
+end