j_studio_game 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e324e4bc2c5f5801d1b97bb0cf4ac6b2f8d6f965acde0d1a597d0e9668838aec
+  data.tar.gz: 5e84ec2a489fb3b6318945dff4b1089b39a286551e552fe8c32389c6ff3b506a
+SHA512:
+  metadata.gz: 73d84d9f020fb59f3497d60befc532bb47c4c99e388b365b1073e3339eaae5ae7663a6c5369b534dfab7a0bea5fc921cc11fdd300b6eb31c989ce95dd3773a8b
+  data.tar.gz: de28412ac8315b8c13e2427b7af5b1d3771a51df2c7c4621d7a2ce7c15cd7854552c2cc49cc44c834829aa498dcf78bf195a16ccf3b9bb3b113ceeab4c38b8a5

data/LICENSE.txt

@@ -0,0 +1 @@
+

data/README.txt

@@ -0,0 +1,17 @@
+BASIC INSTRUCTIONS 
+
+INSTALLATION EXAMPLE (For older version of 1.0.1):
+gem install jamies_studio_game-1.0.1.gem
+
+TO RUN DEFAULT CSV SHEET PLAYERS:
+ruby bin/game.rb
+
+TO RUN A CUSTOM CSV FILE:
+You can also drop your own game csv file with the name and health of players.
+Have a csv file in your current directory. 
+FORMATTING
+Column 1 for names and column 2 initial health values (integers only)
+
+Call your own CSV file from cmd line like this:
+ruby bin/game.rb yourfile.csv
+Try running ruby bin/game.rb bin/sideshow.csv

data/bin/game

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require_relative '../lib/game_class'
+require_relative '../lib/clumsy_player_class'
+require_relative '../lib/berserk_player_class'
+
+# ************************************** Final Code ***************************************
+ #type 'ruby bin/game.rb' to start a game
+
+game = StudioGame::Game.new("Three (Or More) Stooges")
+# knuckleheads.load_players("players.csv")
+# knuckleheads.load_players(ARGV.shift || "players.csv") 
+default_player_file = File.join(File.dirname(__FILE__), 'players.csv')
+
+the_file_option = (ARGV.shift || default_player_file) #extracting the or statement to be its own variable
+game.load_players(the_file_option) #subbing in the variable here
+
+if the_file_option == default_player_file # if the variable takes the form of the default file (no user csv file is specified)
+    klutz = StudioGame::ClumsyPlayer.new("klutz", 105) #then a clumsy player "Klutz" will be added
+    game.add_player(klutz) 
+
+    berserker = StudioGame::BerserkPlayer.new("berserker", 50) #and a berserker player "Klutz" will be added
+    game.add_player(berserker) 
+else # otherwise (if the user specifies their own csv file, berserker and klutz players will not interfere/be added!!)
+end
+
+loop do
+    puts "\nHow many rounds? (Type 'quit' or 'exit' to end the game.)"
+    answer = gets.chomp.downcase #gets takes user input from cmd (must run from cmd now). chomp removes line break caused by ENTER key.
+    case answer
+    when /^\d+$/
+        game.play(answer.to_i) #the line that starts the game (altered 11th commit)
+    when 'quit', 'exit', 'stop'
+        game.print_stats #the line that prints the stats (altered 11th commit)
+        break
+    else 
+        puts "Please enter a number or type 'quit' to end the game."
+    end
+end
+
+game.save_high_scores #prints high scores to a .txt file

data/bin/players.csv

@@ -0,0 +1,3 @@
+Alvin,100
+Simon,60
+Theo,125

data/bin/sideshow.csv

@@ -0,0 +1,5 @@
+Daisy,100
+Violet,60
+Terry,125
+Buddy,36
+Sir,500

data/lib/auditable.rb

@@ -0,0 +1,7 @@
+module StudioGame
+    module Auditable
+        def audit
+            puts "Rolled a #{self.number} (#{self.class})" 
+        end
+    end
+end

data/lib/berserk_player_class.rb

@@ -0,0 +1,36 @@
+require_relative 'player_class'
+module StudioGame
+    class BerserkPlayer < Player
+        def initialize(name, health=100) #overwrites the default method when Player.new is created! Default health is now 100.
+            super(name, health)
+            @w00t_count = 0
+        end
+
+        def berserk? 
+            @w00t_count > 5
+        end 
+
+        def w00t
+            super #kind of like "apply all" here where super calls and applies the whole regular Player w00t method.
+            @w00t_count +=1 #additional w00t method instructions specific to berserker subclass.
+            puts "#{@name} is berserk!" if berserk? #fancy if statement (prints a warning when statement is true!)
+        end
+
+        def blam
+            berserk? ? w00t : super #ternary operator rocks. woot if berserk is true, super if false
+        end
+
+    end
+        # let's get some visible output on how a BerserkPlayer behaves at this point
+        # if __FILE__ == $0
+        #     berserker = BerserkPlayer.new("berserker", 50)
+        #     6.times { berserker.w00t }
+        # end
+
+        if __FILE__ == $0
+            berserker = BerserkPlayer.new("berserker", 50)
+            6.times { berserker.w00t }
+            2.times { berserker.blam }
+            puts berserker.health
+        end
+    end

data/lib/clumsy_player_class.rb

@@ -0,0 +1,32 @@
+require_relative 'player_class'
+
+module StudioGame
+  class ClumsyPlayer < Player
+      def found_treasure(treasure)
+          # points = treasure.points / 2.0 #the only difference that makes someone clumsy is that they get half the points
+          # @found_treasures[treasure.name] += treasure.points
+          # puts "#{@name} found a #{treasure.name} worth #{treasure.points} points."
+
+          damaged_treasure = Treasure.new(treasure.name, treasure.points / 2.0) #critical that this yields a floating point result/value! 
+          super(damaged_treasure)
+        end
+  end 
+
+  # let's get some visible output on how a ClumsyPlayer behaves at this point.
+  if __FILE__ == $0
+      clumsy = ClumsyPlayer.new("klutz")
+    
+      hammer = Treasure.new(:hammer, 50)
+      clumsy.found_treasure(hammer)
+      clumsy.found_treasure(hammer)
+      clumsy.found_treasure(hammer)
+    
+      crowbar = Treasure.new(:crowbar, 400)
+      clumsy.found_treasure(crowbar)
+    
+      clumsy.each_found_treasure do |treasure|
+        puts "#{treasure.points} total #{treasure.name} points"
+      end
+      puts "#{clumsy.points} grand total points"
+    end
+  end

data/lib/die.rb

@@ -0,0 +1,26 @@
+require_relative 'auditable'
+module StudioGame
+    class Die
+        include Auditable
+        attr_reader :number #makes die remember the number it rolled
+
+        def roll
+            @number = rand(1..6)
+            audit
+            @number #Lastly, return the @number value as the last expression in the method since the game expects roll to return a number.
+        end
+
+    end
+end
+
+#my own code showing that the die contains a readable attribute, its number!
+#all you have to do is tack on ".number" for the number of the die to come up.
+#note that the number attribute is stored in / sourced from the @number instance variable.
+
+if __FILE__ == $0
+    die = Die.new()
+    die.roll # displays "Rolled a # (Die)" because ROLL calls the audit as defined within the roll method
+             # note that this die.roll is also testing that the audit method (mixin) from the Auditable module works.
+    puts "\nThis is the number: #{die.number}" #with the die object, you can call the readable number attribute with .number
+    puts "This is the class: #{die.class}" #with the die object, you can call the object class with .class
+  end

data/lib/game_class.rb

@@ -0,0 +1,121 @@
+# ****************** GAME CLASS ******************
+require_relative 'player_class'
+require_relative 'die'
+require_relative 'game_turn'
+require_relative 'treasure_trove'
+require 'csv'
+
+module StudioGame
+  class Game
+      attr_reader :title
+
+      def initialize(title)
+          @title = title
+          @players = []
+      end
+
+      # def load_players(from_file)
+      #   File.readlines(from_file).each do |line|
+      #     name, health = line.split(',')
+      #     player = Player.new(name, Integer(health))
+      #     add_player(player)
+      #   end
+      # end
+
+      # *** easier approach than the solution above using Ruby's CSV library (MUST use require 'csv' at the top) ***
+      def load_players(from_file)
+        CSV.foreach(from_file) do |row|
+          player = Player.new(row[0], row[1].to_i)  # immediately sends row[0] and row[1] values to local variables name and health (line 8 of player_class.rb)
+          add_player(player) # adds to the player array (stored in local variable @players)
+        end
+      end
+
+      def high_score_entry(player)
+        formatted_name = player.name.ljust(20, '.')
+        "#{formatted_name} #{player.score}"
+      end
+
+      def save_high_scores(to_file="high_scores.txt")
+        File.open(to_file, "w") do |file|
+          file.puts Time.new.strftime("File updated/created on %m/%d/%Y at %I:%M %p.") #me printing the time!
+          file.puts "\n#{@title} High Scores:"
+          @players.sort.each do |player|
+            file.puts high_score_entry(player)
+          end
+        end
+      end
+
+      def add_player(a_player)
+          @players.push(a_player)   #use @players since @players refers to the array u created in the initialize method
+      end
+
+      def total_points
+        @players.reduce(0) { |sum, player| sum + player.points }
+      end
+
+      def play(rounds)
+        puts "There are #{@players.size} players in the game '#{@title}': " 
+        
+        @players.each do |player|
+          puts player
+        end
+
+        treasures = TreasureTrove::TREASURES
+        puts "\nThere are #{treasures.size} treasures to be found:"
+
+        treasures.each do |treasure|
+          puts "A #{treasure.name} is worth #{treasure.points} points."
+        end
+
+        1.upto(rounds) do |round|
+          puts "\nRound #{round}:"
+          @players.each do |player|
+            GameTurn.take_turn(player) 
+            puts player
+          end
+        end 
+      end
+
+      def print_name_and_health(player)
+        puts "#{player.name} (#{player.health})"
+      end
+
+      def print_stats
+        strong_players, wimpy_players = @players.partition { |player| player.strong? }
+      
+      puts "\n#{title} Statistics:"
+      puts "\n#{strong_players.size} strong players:"
+      strong_players.each do |player|
+        print_name_and_health(player)
+      end
+    
+      puts "\n#{wimpy_players.size} wimpy players:"
+      wimpy_players.each do |player|
+        print_name_and_health(player)
+      end
+
+      sorted_players = @players.sort{ |a, b| b.score <=> a.score}
+      puts "\n#{title} High Scores:"
+      sorted_players.each do |player|
+        puts high_score_entry(player)
+      end
+      puts "\n(High scores have been saved to 'high_scores.txt')"
+
+      @players.each do |player|
+        puts "\n#{player.name}'s point totals:"
+        puts "#{player.points} grand total points"
+      end
+
+      puts "\n#{total_points} total points from treasures found."
+
+      @players.sort.each do |player|
+        puts "\n#{player.name}'s point totals:"
+        player.each_found_treasure do |treasure|
+          puts "#{treasure.points} total #{treasure.name} points"
+        end
+        puts "#{player.points} grand total points"
+      end
+
+    end
+  end
+end

data/lib/game_turn.rb

@@ -0,0 +1,32 @@
+# ****************** MODULE GAMETURN ************************
+require_relative 'player_class'
+require_relative 'die'
+require_relative 'treasure_trove'
+require_relative 'loaded_die'
+
+module StudioGame
+  module GameTurn
+      def self.take_turn(player) 
+          die = Die.new #replace Die with LoadedDie to see the loaded die exposed by its class! (since audit was implemented in the roll method)
+            case die.roll
+            when 1..2
+              player.blam
+            when 3..4
+              puts "#{player.name} was skipped."
+            else
+              player.w00t
+            end
+            treasure = TreasureTrove.random
+            player.found_treasure(treasure)
+            # puts "#{player.name} found a #{treasure.name} worth #{treasure.points} points."
+      end
+
+      # def self.take_turn(player)
+      #   # code to roll die and w00t or blam
+      
+      #   treasure = TreasureTrove.random
+      #   player.found_treasure(treasure)
+      # end
+      
+  end
+end

data/lib/loaded_die.rb

@@ -0,0 +1,22 @@
+# ********** LOADED DIE ******************
+require_relative 'auditable'
+module StudioGame
+  class LoadedDie
+      include Auditable
+      attr_reader :number
+    
+      def roll
+        numbers = [1, 1, 2, 5, 6, 6]
+        @number = numbers.sample
+        audit 
+        @number # Lastly, return the @number value as the last expression in the method since the game expects roll to return a number.
+      end
+  end
+end
+  if __FILE__ == $0
+    die = LoadedDie.new()
+    die.roll # displays "Rolled a # (Die)" because ROLL calls the audit as defined within the roll method
+             # note that this die.roll is also testing that the audit method (mixin) from the Auditable module works.
+    puts "\nThis is the number: #{die.number}" #with the die object, you can call the readable number attribute with .number
+    puts "This is the class: #{die.class}" #with the die object, you can call the object class with .class
+  end

data/lib/playable_module.rb

@@ -0,0 +1,18 @@
+
+module StudioGame
+   module Playable #needs to write to health and read name
+      def blam
+         self.health -= 10           # the .self is REQUIRED on writable attributes (health)
+         puts "#{name} got blammed!" # the .self is optional on readable attributes (name)
+      end
+
+      def w00t
+         self.health += 15
+         puts "#{name} got w00ted!"
+      end
+
+      def strong?
+         health > 100
+      end
+   end
+end

data/lib/player_class.rb

@@ -0,0 +1,61 @@
+require_relative 'treasure_trove'
+require_relative 'playable_module'
+
+module StudioGame
+  class Player
+      attr_accessor :health
+      attr_accessor :name
+
+      # or combine into one line like this......  attr_accessor :name, :health
+
+      include Playable
+  
+      def initialize(name, health=100) #overwrites the default method when Player.new is created! Default health is now 100.
+          @name = name.capitalize
+          @health = health
+          @found_treasures = Hash.new(0)
+      end
+
+      def found_treasure(treasure)
+          @found_treasures[treasure.name] += treasure.points
+          puts "#{@name} found a #{treasure.name} worth #{treasure.points} points."
+          puts "#{@name}'s treasures: #{@found_treasures}"
+      end
+  # POINTS *********************
+      def points
+        @found_treasures.values.reduce(0, :+)
+      end
+  # SCORE *********************
+      def score
+        points + @health
+      end 
+  
+      def name=(new_name)
+        @name = new_name.capitalize
+      end
+  
+      def to_s #to_s overwrites/defines the default method for PUTS.
+          "I'm #{@name} with health = #{@health}, points = #{points}, and score = #{score}."   
+        end
+
+        def <=>(other) #this overrides default for whenever the compare <=> operator is used on player class object.
+          other.score <=> score
+        end
+
+        def each_found_treasure
+            @found_treasures.each do |name, points|
+              yield Treasure.new(name, points)
+          end
+        end
+  end
+end
+
+ if __FILE__ == $0
+    player = Player.new("moe")
+    puts player.name
+    puts player.health
+    player.w00t
+    puts player.health
+    player.blam
+    puts player.health
+  end

data/lib/treasure_trove.rb

@@ -0,0 +1,20 @@
+
+module StudioGame
+    Treasure = Struct.new(:name, :points)
+
+    module TreasureTrove
+        TREASURES = [
+            Treasure.new(:pie, 5),
+            Treasure.new(:bottle, 25),
+            Treasure.new(:hammer, 50),
+            Treasure.new(:skillet, 100),
+            Treasure.new(:broomstick, 200), #dont forget these commas after
+            Treasure.new(:crowbar, 400)
+        ]
+
+        def self.random
+            TREASURES.sample
+        end
+
+    end 
+end

data/spec/berserk_player_spec.rb

@@ -0,0 +1,32 @@
+require 'berserk_player_class'
+
+module StudioGame
+
+  describe BerserkPlayer do
+
+    before do
+      @ih = 50 #it was at initial_health not ih
+      @player = BerserkPlayer.new("berserker", @ih)
+    end
+
+    it "does not go berserk when w00ted up to 5 times" do
+      1.upto(5) { @player.w00t }
+
+      @player.berserk?.should be_falsey #correct syntax 4 rspec 3.0
+    end
+
+    it "goes berserk when w00ted more than 5 times" do
+      1.upto(6) { @player.w00t }
+      
+      @player.berserk?.should be_truthy #correct syntax 4 rspec 3.0
+    end
+
+    it "gets w00ted instead of blammed when it's gone berserk" do
+      1.upto(6) { @player.w00t } #6 woots
+      1.upto(2) { @player.blam } #2 blams
+
+      @player.health.should == @ih + (8 * 15)
+    end
+
+  end
+end

data/spec/clumsy_player_spec.rb

@@ -0,0 +1,34 @@
+require 'clumsy_player_class'
+
+module StudioGame
+
+  describe ClumsyPlayer do
+    before do
+      @player = ClumsyPlayer.new("klutz")
+    end
+  #Upon creation and given found three hammers, one crowbar, point total should be 275.
+    it "only gets half the point value for each treasure" do
+      @player.points.should == 0
+
+      hammer = Treasure.new(:hammer, 50)
+      @player.found_treasure(hammer)
+      @player.found_treasure(hammer)
+      @player.found_treasure(hammer)
+
+      @player.points.should == 75
+
+      crowbar = Treasure.new(:crowbar, 400)
+      @player.found_treasure(crowbar)
+
+      @player.points.should == 275
+
+      yielded = []
+      @player.each_found_treasure do |treasure|
+        yielded << treasure #append?
+      end
+
+      yielded.should == [Treasure.new(:hammer, 75), Treasure.new(:crowbar, 200)]
+    end
+
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,63 @@
+require 'game_class'
+
+module StudioGame
+  describe Game do
+    before do
+      @game = Game.new("Knuckleheads")
+
+      @ih = 100 # literally my only mistake lmao
+      @player = Player.new("moe", @ih)
+
+      @game.add_player(@player)
+    end
+
+    it "w00t for high die roll" do
+      Die.any_instance.stub(:roll).and_return(5)
+      @game.play(2)
+      @player.health.should == @ih + (15 * 2)
+    end
+
+    it "skip for mid die roll" do
+      Die.any_instance.stub(:roll).and_return(3)
+      @game.play(2)
+      @player.health.should == @ih
+    end
+    
+    it "blams for low die roll" do
+      Die.any_instance.stub(:roll).and_return(1)
+      @game.play(2)
+      @player.health.should == (@ih - 10 * 2)
+    end
+    
+    it "assigns a treasure for points during a player's turn" do
+      game = Game.new("Knuckleheads")
+      player = Player.new("moe")
+    
+      game.add_player(player)
+    
+      game.play(1)
+    
+      player.points.should_not be_zero
+    
+      # or use alternate expectation syntax:
+      # expect(player.points).not_to be_zero
+    end
+
+    it "computes total points as the sum of all player points" do
+      game = Game.new("Knuckleheads")
+    
+      player1 = Player.new("moe")
+      player2 = Player.new("larry")
+    
+      game.add_player(player1)
+      game.add_player(player2)
+    
+      player1.found_treasure(Treasure.new(:hammer, 50))
+      player1.found_treasure(Treasure.new(:hammer, 50))
+      player2.found_treasure(Treasure.new(:crowbar, 400))
+    
+      game.total_points.should == 500
+    end
+
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,139 @@
+require 'player_class'
+require 'spec_helper'
+require 'treasure_trove'
+
+module StudioGame
+  describe Player do
+      before do
+          @ih = 150
+          @player = Player.new("larry", @ih)
+        end
+    # examples go here
+      it "has a capitalized name" do
+
+          @player.name.should == "Larry"
+      end
+
+      it "has an initial health" do 
+
+          @player.health.should == 150
+      end
+
+
+      it "has a string representation" do
+        @player.found_treasure(Treasure.new(:hammer, 50))
+        @player.found_treasure(Treasure.new(:hammer, 50))
+      
+        # @player.to_s.should == "I'm Larry with a health of 150 and a score of 250." #<<< this is the old printout format
+        @player.to_s.should == "I'm Larry with health = 150, points = 100, and score = 250." 
+        
+      end
+
+      it "computes a score as the sum of its health and length of name" do
+        @player.found_treasure(Treasure.new(:hammer, 50))
+        @player.found_treasure(Treasure.new(:hammer, 50))
+
+        @player.score.should == (250) #altered from 155 to 250 bc the way score has been defined was updated (health of 150 plus two hammers: 100points)
+      end
+
+      it "increases health by 15 when w00ted" do
+          @ih = 150
+          @player.w00t
+
+          @player.health.should == (@ih + 15)
+      end
+
+
+      it "decreases health by 10 when blammed" do
+          @ih = 150
+          @player.blam
+
+          @player.health.should == (@ih - 10)
+      end
+
+      context "with health greater than 100" do
+          before do
+              @player = Player.new("larry", 150)
+            end
+          it "is strong" do
+              @player.should be_strong 
+          end
+      end
+      context "with health less than / equal to 100" do
+          before do
+              @player = Player.new("larry", 100)
+            end
+          it "is wimpy" do
+              @player.should_not be_strong 
+          end
+      end
+
+      context "in a collection of players" do
+          before do
+            @player1 = Player.new("moe", 100)
+            @player2 = Player.new("larry", 200)
+            @player3 = Player.new("curly", 300)
+        
+            @players = [@player1, @player2, @player3]
+          end
+        
+          it "is sorted by decreasing score" do
+            @players.sort.should == [@player3, @player2, @player1]
+          end
+        end
+        
+        it "computes points as the sum of all treasure points" do
+          @player.points.should == 0
+        
+          @player.found_treasure(Treasure.new(:hammer, 50))
+        
+          @player.points.should == 50
+        
+          @player.found_treasure(Treasure.new(:crowbar, 400))
+        
+          @player.points.should == 450
+        
+          @player.found_treasure(Treasure.new(:hammer, 50))
+        
+          @player.points.should == 500
+        end  
+
+        it "computes a score as the sum of its health and points" do
+          @player.found_treasure(Treasure.new(:hammer, 50))
+          @player.found_treasure(Treasure.new(:hammer, 50))
+        
+          @player.score.should == 250
+        end
+
+        it "yields each found treasure and its total points" do
+          @player.found_treasure(Treasure.new(:skillet, 100))
+          @player.found_treasure(Treasure.new(:skillet, 100))
+          @player.found_treasure(Treasure.new(:hammer, 50))
+          @player.found_treasure(Treasure.new(:bottle, 5))
+          @player.found_treasure(Treasure.new(:bottle, 5))
+          @player.found_treasure(Treasure.new(:bottle, 5))
+          @player.found_treasure(Treasure.new(:bottle, 5))
+          @player.found_treasure(Treasure.new(:bottle, 5))
+        
+          yielded = []
+          @player.each_found_treasure do |treasure|
+            yielded << treasure
+          end
+        
+          yielded.should == [
+            Treasure.new(:skillet, 200),
+            Treasure.new(:hammer, 50),
+            Treasure.new(:bottle, 25)
+        ]
+        end
+  end
+end
+
+
+# expect(player.name).to eq("Larry") <<<<<< the new expectation line syntax
+
+
+
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+RSpec.configure do |config|
+    config.expect_with :rspec do |c|
+      c.syntax = [:should, :expect]
+    end
+    config.mock_with :rspec do |c|
+      c.syntax = [:should, :expect]
+    end
+  end

data/spec/treasure_trove_spec.rb

@@ -0,0 +1,62 @@
+# ************** COPIED SPEC ************************
+require 'treasure_trove'
+
+module StudioGame
+describe Treasure do
+
+  before do
+    @treasure = Treasure.new(:hammer, 50)
+  end
+
+  it "has a name attribute" do
+    @treasure.name.should == :hammer
+  end
+
+  it "has a points attribute" do
+    @treasure.points.should == 50
+  end
+
+end
+end
+
+module StudioGame
+  describe TreasureTrove do
+
+    it "has six treasures" do
+      TreasureTrove::TREASURES.size.should == 6
+    end
+
+    it "has a pie worth 5 points" do
+      TreasureTrove::TREASURES[0].should == Treasure.new(:pie, 5)
+    end
+
+    it "has a bottle worth 25 points" do
+      TreasureTrove::TREASURES[1].should == Treasure.new(:bottle, 25)
+    end
+
+    it "has a hammer worth 50 points" do
+      TreasureTrove::TREASURES[2].should == Treasure.new(:hammer, 50)
+    end
+
+    it "has a skillet worth 100 points" do
+      TreasureTrove::TREASURES[3].should == Treasure.new(:skillet, 100)
+    end
+
+    it "has a broomstick worth 200 points" do
+      TreasureTrove::TREASURES[4].should == Treasure.new(:broomstick, 200)
+    end
+
+    it "has a crowbar worth 400 points" do
+      TreasureTrove::TREASURES[5].should == Treasure.new(:crowbar, 400)
+    end
+
+    it "returns a random treasure" do
+      treasure = TreasureTrove.random
+    
+      TreasureTrove::TREASURES.should include(treasure)
+    
+      # or use alternate expectation syntax:
+      # expect(TreasureTrove::TREASURES).to include(treasure)
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: j_studio_game
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Jamie Clark
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+description: "BASIC INSTRUCTIONS \n\nINSTALLATION EXAMPLE (For older version of 1.0.1):\ngem
+  install jamies_studio_game-1.0.1.gem\n\nTO RUN DEFAULT CSV SHEET PLAYERS:\nruby
+  bin/game.rb\n\nTO RUN A CUSTOM CSV FILE:\nYou can also drop your own game csv file
+  with the name and health of players.\nHave a csv file in your current directory.
+  \nFORMATTING\nColumn 1 for names and column 2 initial health values (integers only)\n\nCall
+  your own CSV file from cmd line like this:\nruby bin/game.rb yourfile.csv\nTry running
+  ruby bin/game.rb bin/sideshow.csv\n"
+email: clarkcjamie@gmail.com
+executables:
+- game
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.txt
+- bin/game
+- bin/players.csv
+- bin/sideshow.csv
+- lib/auditable.rb
+- lib/berserk_player_class.rb
+- lib/clumsy_player_class.rb
+- lib/die.rb
+- lib/game_class.rb
+- lib/game_turn.rb
+- lib/loaded_die.rb
+- lib/playable_module.rb
+- lib/player_class.rb
+- lib/treasure_trove.rb
+- spec/berserk_player_spec.rb
+- spec/clumsy_player_spec.rb
+- spec/game_spec.rb
+- spec/player_spec.rb
+- spec/spec_helper.rb
+- spec/treasure_trove_spec.rb
+homepage: http://pragmaticstudio.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Text based game with rounds and treasures
+test_files:
+- spec/berserk_player_spec.rb
+- spec/clumsy_player_spec.rb
+- spec/game_spec.rb
+- spec/player_spec.rb
+- spec/spec_helper.rb
+- spec/treasure_trove_spec.rb