ro_sham_bo 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6ebceb13a58c7ff84e66be32d08b422a57f41b37d361d591c69d88fbfbc9898
-  data.tar.gz: b574f3923921bce52e828b177b950277c8983ec3eb12b2d83f2948e8010963c4
+  metadata.gz: b6d7272df4c4bb07d3cb42f6f8f8c53cab4df3c90de0845eb114f33324d6776f
+  data.tar.gz: a2d1afeea2ea0dc7dcc5a59081a2bd1a68d68055b759a06bd37b5ee89654deb8
 SHA512:
-  metadata.gz: '084251e4644082549a1526be1a9d827b0aca60f7fa739b1db62258f5d31a4f4c259f4baea97f421ef1313ebbc6e8a1ca309764dbac3231c2e7ca86f1708d30e8'
-  data.tar.gz: 264a793620438584bbe4ef70f7641a6aa287d43cd571baaaade783175a17f31ec35bcd07f654497289afeb1236184c9b2a330d5586c8c10870b7be90f8ffbf16
+  metadata.gz: 4a3c15a28d03029167282ce16bb04b57da8507ec7e957dc88c95c5a70dec2fbb69dc9a75d531d722f3a0043e386a82c37907e249fa243a24135aab11afc197d2
+  data.tar.gz: 48737233a2a9ed372df508dda9b4086d83eebaa9ee2a94ac4d77b3671bc0c1975b502a9c1a8b04e6b4c02fc76eba05f084e8560264c2d0a9c64ee5a7bb30e829

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    ro_sham_bo (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.3)
+
+PLATFORMS
+  x86_64-darwin-20
+
+DEPENDENCIES
+  rake (~> 13.0, >= 13.0.1)
+  ro_sham_bo!
+
+BUNDLED WITH
+   2.2.16

data/README.md

@@ -28,11 +28,18 @@ Once you hit `[return]`, your choice will be compared to the computer's choice,
 and a winner for that round will be chosen based off the classic rules of the
 game.
 
+Cheating is possible, both for the user and the computer. Pass `-c` (or `-c
+user`) for the user to always win. Pass `-c computer` to make the computer win.
+It will still look real; cheating only actually happens when the non-cheater has
+one less point than is needed to win. Even then, it can still return a draw for
+that round.
+
 ### Rules
 The rules are standard rock, paper, scissors rules.
 - Rock beats Scissors
 - Scissors beats Paper
 - Paper beats Rock
+- Two of a kind results in a draw
 
 ## Reporting Bugs
 This was just a fun project for me to work on, but if you find problems, please

data/bin/ro_sham_bo

@@ -2,41 +2,55 @@
 require 'optparse'
 require_relative '../lib/ro_sham_bo.rb'
 
-options = {rounds: 3}
+clear = false
+options = {}
 OptionParser.new do |o|
-  o.on('-c', '--[no-]clear', "Clear screen after every turn") do |f|
-    options[:clear] = f
+  o.on('-c', '--[no-]clear', 'Clear screen after every turn') do |f|
+    clear = f
   end
-  o.on('-r', '--rounds=N', Integer, "Best of N rounds", "Default is 3") do |f|
+  o.on('-r', '--rounds N', Integer, 'Best of N rounds', 'Default is 3') do |f|
     abort("Please use an odd number") if f.even?
     options[:rounds] = f
   end
+  o.on('-c', '--cheater [USER]', 'Choose who wins', 'user/computer') do |f|
+    options[:cheater] =
+      if f.nil?
+        :user
+      elsif !%w[user computer].include?(f)
+        abort('Invalid cheater [user, computer]')
+      else
+        f.intern
+      end
+  end
 end.parse!(ARGV)
 
-game = RoShamBo.new(options)
+system('clear') if clear
 
-system('clear') if options[:clear]
+game = RoShamBo.new(**options)
 
 puts ">> FIRST TO #{game.points_to_win} WINS! <<"
 
-until game.game_winner?
+until game.over?
   puts "\nCurrent score: #{game.score.inspect}"
   print "What is your choice? (r)ock, (p)aper, or (s)cissors?: "
-  u_choice = game.user_choice($stdin.gets.chomp.downcase)
-  c_choice = game.computer_choice
 
-  if u_choice == :exit
-    break
-  elsif !u_choice
-    puts "Please enter a valid choice!"
+  begin
+    input = $stdin.gets.chomp.downcase
+    break if %w[x q exit quit].include?(input)
+    game.play(input)
+  rescue ArgumentError
+    puts 'Invalid choice [rpsx]'
     next
   end
 
-  {user: u_choice, computer: c_choice}.each { |k,v| puts "> #{k} chose #{v}" }
-  system('clear') if options[:clear]
+  { user: game.user_choice, computer: game.computer_choice }.each do |k, v|
+    puts "> #{k} chose #{v}"
+  end
+  system('clear') if clear
 
-  puts "Round winner: #{game.round_winner(u_choice, c_choice)}"
+  puts "Round winner: #{game.round_winner}"
 end
 
-puts game.game_winner ? "\nGame over! #{game.game_winner} won!" :
-  "\nGame was quit. Score was #{game.score.inspect}"
+puts game.over? ? "\nGame over! #{game.winner.capitalize} won!" :
+  "\nGame was quit."
+puts "Score was #{game.score.inspect}"

data/lib/ro_sham_bo.rb

@@ -5,28 +5,40 @@ class RoShamBo
     scissors: {rock: :lose, paper: :win,  scissors: :draw}.freeze,
   }.freeze
 
-  attr_reader :score, :points_to_win
+  attr_reader :cheater
+  attr_reader :rounds
+  attr_reader :score
+  attr_reader :points_to_win
+  attr_reader :user_choice
+  attr_reader :computer_choice
+  attr_reader :round_winner
+  attr_reader :winner
 
-  def initialize(options = {rounds: 3})
-    @options = options
+  def initialize(cheater: nil, rounds: 3)
+    @cheater = cheater
+    @rounds = rounds
     @score = {user: 0, computer: 0}
-    @points_to_win = (options[:rounds].to_f / 2).ceil
+    @points_to_win = (rounds.to_f / 2).ceil
   end
 
-  def user_choice(user_input)
-    case user_input
-    when 'r', 'rock'              then :rock
-    when 'p', 'paper'             then :paper
-    when 's', 'scissors'          then :scissors
-    when 'x', 'exit', 'q', 'quit' then :exit
-    end
+  def play(input)
+    raise 'Game Over!' if over?
+
+    @user_choice = sanitized_choice(input)
+    @computer_choice = computer_turn(user_choice)
+    @round_winner = determine_round_winner(@user_choice, @computer_choice)
+    @winner = score.key(points_to_win) if score.value?(points_to_win)
+
+    self
   end
 
-  def computer_choice
-    RULES.keys.sample
+  def over?
+    !winner.nil?
   end
 
-  def round_winner(u_choice, c_choice)
+  private
+
+  def determine_round_winner(u_choice, c_choice)
     winner =
       case RULES[u_choice][c_choice]
       when :win  then :user
@@ -37,11 +49,30 @@ class RoShamBo
     winner
   end
 
-  def game_winner
-    score.key(points_to_win).capitalize if score.value?(points_to_win)
+  def sanitized_choice(input)
+    case input
+    when 'r', 'rock', :r, :rock then :rock
+    when 'p', 'paper', :p, :paper then :paper
+    when 's', 'scissors', :s, :scissors then :scissors
+    else raise ArgumentError, 'Invalid choice [rpsx]'
+    end
+  end
+
+  def computer_turn(input)
+    if cheater == :user && about_to_win?(:computer)
+      cheat(input, :win)
+    elsif cheater == :computer && about_to_win?(:user)
+      cheat(input, :win)
+    else
+      RULES.keys.sample
+    end
+  end
+
+  def cheat(input, win_or_lose)
+    rand >= 0.33 ? RULES[input].key(win_or_lose) : RULES[input].key(:draw)
   end
 
-  def game_winner?
-    !game_winner.nil?
+  def about_to_win?(user)
+    score[user] == points_to_win - 1
   end
 end

data/lib/ro_sham_bo/version.rb

@@ -16,7 +16,7 @@ class RoShamBo
 
     ##
     # Patch version.
-    PATCH = 1
+    PATCH = 2
 
     ##
     # Version as +MAJOR.MINOR.PATCH+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ro_sham_bo
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Evan Gray
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-30 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,6 +38,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile