studio_game23 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37806bd0d73ee8d7c0199ed023bdaf142dfcc4678ce738242451da61b45d1f61
+  data.tar.gz: 79b3ae4e9da9145a2b1c5c43100420d1b95046927c4ebdfa7e028a52c13cab3b
+SHA512:
+  metadata.gz: 11a2e4f56f886cfcd954b7ea45d0cd1194f44737e6e1f100333b8d4f03f80408ecf574b144d27400798a58601f0d01acd982829e4be6f38008e553a0245e19b7
+  data.tar.gz: c6a062436e33927a0a1333f43fbae8cd4a53a1709c71e156ef68145ad789cda5c5c9f83d24073222837c562e1aa5ace2ebae29c7c910d854cd8e26e11e9484cb

data/LICENSE

@@ -0,0 +1 @@
+MIT License

data/README

@@ -0,0 +1 @@
+This is just a simple gem, created during a Ruby online course for learning purposes.

data/bin/my_favorite_players.csv

@@ -0,0 +1,4 @@
+Anna, 150
+Konrad, 40
+Crispin, 80
+Juni, 99

data/bin/players.csv

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

data/bin/studio_game23

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby
+
+require_relative '../lib/studio_game23/game'
+
+game1 = StudioGame23::Game.new("Test")
+default_player_file = File.join(File.dirname(__FILE__), 'players.csv')
+game1.load_players(ARGV.shift || default_player_file)
+
+
+clumsy_player = StudioGame23::ClumsyPlayer.new("klutz", 100, 3)
+game1.add_player(clumsy_player)
+
+berserk_player = StudioGame23::BerserkPlayer.new("berserker", 50)
+game1.add_player(berserk_player)
+
+loop do
+  puts "\nHow many game rounds? ('quit' to exit)" 
+  rounds = gets.chomp.downcase
+  case rounds
+    when /^\d+$/
+      game1.play(rounds.to_i) do
+        game1.total_points >= 2000 
+      end
+    when 'quit', 'exit'
+      game1.print_stats
+      break
+    else
+      puts "Please enter a number or 'quit'."
+  end
+
+end
+
+game1.save_high_scores

data/lib/studio_game23/auditable.rb

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

data/lib/studio_game23/berserk_player.rb

@@ -0,0 +1,32 @@
+require_relative 'player'
+
+module StudioGame23
+  class BerserkPlayer < Player
+
+    def initialize(name, health=100)
+      super(name, health)
+      @w00t_count = 0
+    end
+
+    def berserk?
+      @w00t_count > 5
+    end
+
+    def w00t
+      super
+      @w00t_count += 1
+      puts "#{name} is berserk!" if berserk?
+    end
+
+    def blam
+      berserk? ? w00t : super
+    end
+  end
+
+  if __FILE__ == $0
+    berserker = BerserkPlayer.new("berserker", 50)
+    6.times { berserker.w00t }
+    2.times { berserker.blam }
+    puts berserker.health
+  end
+end

data/lib/studio_game23/clumsy_player.rb

@@ -0,0 +1,43 @@
+require_relative 'player'
+
+module StudioGame23
+  class ClumsyPlayer < Player
+
+    attr_reader :boost_factor
+
+    def initialize(name, health, boost_factor=1)
+      super(name, health)
+      @boost_factor = boost_factor.to_i
+    end
+
+    def found_treasure(treasure)
+      damaged_treasure = Treasure.new(treasure.name, treasure.points / 2.0)
+      super(damaged_treasure)
+    end
+
+    def w00t
+      @boost_factor.times { super }
+    end
+  end
+
+  if __FILE__ == $0
+    clumsy = ClumsyPlayer.new("klutz", 100, 2)
+
+    hammer = Treasure.new(:hammer, 50)
+    3.times {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
+
+# __FILE__ is a reference to the current file name
+
+# $0 contains the name of the script being executed
+
+# $ on a variable's name indicates a global variable

data/lib/studio_game23/die.rb

@@ -0,0 +1,20 @@
+require_relative 'auditable'
+
+module StudioGame23
+  class Die
+
+    include Auditable
+
+    attr_reader :number
+
+    def initialize
+      roll
+    end
+
+    def roll
+      @number = rand(1..6)
+      audit
+      @number
+    end
+  end
+end

data/lib/studio_game23/game.rb

@@ -0,0 +1,115 @@
+require_relative 'player'
+require_relative 'clumsy_player'
+require_relative 'berserk_player'
+require_relative 'die'
+require_relative 'game_turn'
+require_relative 'treasure_trove'
+require 'csv'
+
+module StudioGame23
+  class Game
+    attr_reader :title 
+    
+    def initialize(title)
+      @title = title
+      @players = []
+    end
+
+    def add_player(player)
+      @players << player
+    end
+
+    def print_stats
+      strong, wimpy = @players.partition{|player| player.strong?}
+
+       puts "\n#{title} Statistics:"
+
+      puts "\n#{strong.size} Strong players: "
+      print_name_and_health(strong)
+
+      puts "\n#{wimpy.size} Wimpy players:"
+      print_name_and_health(wimpy)
+
+      #sorted_players = @players.sort
+
+      puts "\n#{title} High Scores:"
+      high_score_entry { |line| puts line }
+
+      puts "\nPlayer's points:"
+      @players.each do |player|
+        puts "\n#{player.name}'s points total:"
+        player.each_found_treasure do |treasure|
+          puts "#{treasure.points} total #{treasure.name} points"
+        end
+        puts "#{player.points} grand total points"
+      end
+
+      puts "\n#{total_points} total points from treasures found"
+    end
+
+    def print_name_and_health(players)
+      players.each do |player|
+        puts "#{player.name} (#{player.health})"
+      end
+    end
+
+    def load_players(from_file)
+      #File.readlines(from_file).each do |line|
+      #  player = Player.from_csv(line)
+      #  add_player(player)
+      #end
+
+      CSV.foreach(from_file) do |row|
+        player = Player.new(row[0], Integer(row[1]))
+        add_player(player)
+      end
+    end
+
+    def high_score_entry
+      sorted_players = @players.sort
+      sorted_players.each do |player|
+        line_to_save = "#{player.name}...........#{player.score}"
+        yield line_to_save
+      end
+    end
+
+    def save_high_scores(to_file = 'high_scores.txt')
+      File.open(to_file, 'w') do |file|
+        file.puts "#{@title} High Scores:"
+        high_score_entry do |line|
+          file.puts line
+        end
+      end
+    end
+
+    def total_points
+      @players.reduce(0) { |total_points, player| total_points + player.points }
+    end
+
+    def play(rounds)
+      puts "There are #{@players.size} players in #{title.capitalize}:"
+      puts @players
+
+      treasures = TreasureTrove::TREASURES
+      puts "\nThere are #{treasures.size} treasures in the trove:"
+
+      treasures.each do |treasure| 
+        puts "A #{treasure.name} is worth #{treasure.points} points"
+      end
+
+      1.upto(rounds) do |round| 
+        if block_given?
+          if !yield
+            puts "\nRound: #{round}"
+            @players.each do |player|
+              GameTurn.take_turn(player)
+              puts player
+            end
+          else
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/studio_game23/game_turn.rb

@@ -0,0 +1,24 @@
+require_relative 'die'
+require_relative 'player'
+require_relative 'treasure_trove'
+
+module StudioGame23
+  module GameTurn
+    def self.take_turn(player)
+      die = Die.new
+      number_rolled = die.roll
+
+      case number_rolled
+      when 1..2
+        player.blam
+      when 3..4
+        puts "#{player.name} was skipped."
+      else
+        player.w00t
+      end
+
+      treasure = TreasureTrove.random
+      player.found_treasure(treasure)
+    end
+  end
+end

data/lib/studio_game23/loaded_die.rb

@@ -0,0 +1,17 @@
+require_relative 'auditable'
+
+module StudioGame23
+  class LoadedDie
+
+    include Auditable
+
+    attr_reader :number
+
+    def roll
+      numbers = [1, 1, 2, 5, 6, 6]
+      @number = numbers.sample
+      audit
+      @number
+    end
+  end
+end

data/lib/studio_game23/playable.rb

@@ -0,0 +1,17 @@
+module StudioGame23
+  module Playable
+    def blam
+      self.health -= 10
+      puts "#{name} got blammed!"
+    end
+
+    def w00t
+      self.health += 15
+      puts "#{name} got w00ted!"
+    end
+
+    def strong?
+      health >= 100
+    end
+  end
+end

data/lib/studio_game23/player.rb

@@ -0,0 +1,68 @@
+require_relative 'treasure_trove'
+require_relative 'playable'
+
+module StudioGame23
+  class Player
+
+    include Playable
+
+    attr_accessor :name, :health
+
+    def initialize(name, health=100)
+      @name = name.capitalize
+      @health = health
+      @found_treasures = Hash.new(0)
+    end
+
+    def name=(new_name)
+      @name = new_name.capitalize
+    end
+
+    def to_s
+      "I'm #{@name} with a health = #{@health}, points = #{points}, and score = #{score}."
+    end
+
+    def score
+      @health + points
+    end
+
+    def <=>(other)
+      other.score <=> score
+    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
+
+    def points
+      @found_treasures.values.reduce(0, :+)
+    end
+
+    def each_found_treasure
+      @found_treasures.each do |name, points|
+        yield Treasure.new(name, points)
+      end   
+    end
+
+    def self.from_csv(csv_string)
+      name, health = csv_string.split(', ')
+      player = Player.new(name, Integer(health))
+    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
+  else
+    puts "FILE: #{__FILE__.to_s}"
+    puts "$0: #{$0.to_s}"
+  end
+end

data/lib/studio_game23/treasure_trove.rb

@@ -0,0 +1,19 @@
+module StudioGame23
+  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),
+      Treasure.new(:crowbar, 400)
+    ]
+
+    def self.random
+      TREASURES.sample
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.syntax = [:should, :expect]
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+    mocks.syntax = [:should, :expect]
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://relishapp.com/rspec/rspec-core/docs/configuration/zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/studio_game23/berserk_player_spec.rb

@@ -0,0 +1,31 @@
+require 'studio_game23/berserk_player'
+
+module StudioGame23
+  describe BerserkPlayer do 
+
+    before do
+      @initial_health = 50
+      @player = BerserkPlayer.new("berserker", @initial_health)
+    end
+
+    it "does not go berserk when w00ted up to 5 times" do
+
+      1.upto(5) {@player.w00t}
+
+      expect(@player.berserk?).to be false
+    end
+
+    it "goes berserk when w00ted more than 5 times" do
+      1.upto(6) {@player.w00t}
+
+      expect(@player.berserk?).to be true
+    end
+
+    it "gets w00ted instead of blammed when it's gone berserk" do 
+      1.upto(6) {@player.w00t}
+      1.upto(2) {@player.blam}
+
+      expect(@player.health).to eq @initial_health + (8 * 15)
+    end
+  end
+end

data/spec/studio_game23/clumsy_player_spec.rb

@@ -0,0 +1,45 @@
+require 'studio_game23/clumsy_player'
+
+module StudioGame23
+  describe ClumsyPlayer do 
+
+    before do
+      @initial_health = 105
+      @boost_factor = 3
+      @player = ClumsyPlayer.new('klutz', @initial_health, @boost_factor)
+    end
+
+    it "only gets half the point value for each treasure" do
+
+      expect(@player.points).to eq 0
+
+      hammer = Treasure.new(:hammer, 50)
+      @player.found_treasure(hammer)
+      @player.found_treasure(hammer)
+      @player.found_treasure(hammer)
+
+      expect(@player.points).to eq 75
+
+      crowbar = Treasure.new(:crowbar, 400)
+      @player.found_treasure(crowbar)
+
+      expect(@player.points).to eq 275
+
+      yielded = []
+      @player.each_found_treasure do |treasure|
+        yielded << treasure
+      end
+
+      expect(yielded).to eq [Treasure.new(:hammer, 75), Treasure.new(:crowbar, 200)]
+    end
+
+    it "has a boost_factor" do 
+      expect(@player.boost_factor).to eq 3
+    end
+
+    it "gets a boost_factor boost in health when w00ted" do 
+      @player.w00t
+      expect(@player.health).to eq (@initial_health + 3 * 15)
+    end
+  end
+end

data/spec/studio_game23/game_spec.rb

@@ -0,0 +1,66 @@
+require 'studio_game23/game'
+
+module StudioGame23
+  describe Game do
+
+    before do 
+      @game = Game.new("Knuckleheads")
+
+      @initial_health = 100
+      @player = Player.new("moe", @initial_health)
+
+      @game.add_player(@player)
+    end
+
+    it "w00t the player if a high number is rolled" do 
+      Die.any_instance.stub(:roll).and_return(5)
+
+      @game.play(2) { }
+      puts @player.health
+      expect(@player.health).to eq @initial_health + (15*2)
+      #@player.health.should == @initial_health + 15
+    end
+
+    it "skips the player if a medium number is rolled" do 
+      Die.any_instance.stub(:roll).and_return(3)
+
+      @game.play(2) { }
+      expect(@player.health).to eq @initial_health
+      #@player.health.should == @initial_health
+    end
+
+    it "blams a player if a low number is rolled" do 
+      Die.any_instance.stub(:roll).and_return(1)
+
+      @game.play(2) { }
+      expect(@player.health).to eq @initial_health - (10*2)
+      #@player.health.should == @initial_health - 10
+    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) { false }
+
+      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)
+
+      2.times { player1.found_treasure(Treasure.new(:hammer, 50)) }
+      player2.found_treasure(Treasure.new(:crowbar, 400))
+
+      expect(game.total_points).to eq 500
+    end
+  end
+end

data/spec/studio_game23/player_spec.rb

@@ -0,0 +1,132 @@
+require 'studio_game23/player'
+require 'studio_game23/treasure_trove'
+
+module StudioGame23
+  describe Player do 
+
+    before do 
+      @initial_health = 150
+      @player = Player.new("larry", @initial_health)
+      $stdout = StringIO.new
+    end
+
+    it "has a capitalized name" do 
+      expect(@player.name).to eq "Larry"
+      #@player.name.should == "Larry"
+    end
+      
+    it "has an initial health" do 
+      expect(@player.health).to eq 150
+      #@player.health.should == 150
+    end
+
+    it "has a string representation" do
+      2.times { @player.found_treasure(Treasure.new(:hammer, 50)) }
+      expect(@player.to_s).to eq "I'm Larry with a health = 150, points = 100, and score = 250."
+      #@player.to_s.should == "I'm Larry with a health of 150 and a score of 155."
+    end
+
+    it "computes a score as the sum of its health and points" do 
+      2.times { @player.found_treasure(Treasure.new(:hammer, 50)) }
+      expect(@player.score).to eq @player.health + (2 * 50)
+      #@player.score.should == "larry".length + 150
+    end
+
+    it "increases health by 15 when w00ted" do 
+
+      @player.w00t
+      expect(@player.health).to be @initial_health + 15
+      #@player.health.should == @initial_health + 15
+    end
+
+    it "decreases health by 10 when blammed" do 
+      @player.blam
+      expect(@player.health).to eq @initial_health - 10
+      #@player.health.should == @initial_health - 10
+    end
+
+    it "computes points as the sum of all treasure points" do 
+      expect(@player.points).to eq 0
+
+      @player.found_treasure(Treasure.new(:hammer, 50))
+
+      expect(@player.points).to eq 50
+
+      @player.found_treasure(Treasure.new(:crowbar, 400))
+
+      expect(@player.points).to eq 450
+
+      @player.found_treasure(Treasure.new(:hammer, 50))
+
+      expect(@player.points).to eq 500
+    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
+
+      expect(yielded).to eq [Treasure.new(:skillet, 200), Treasure.new(:hammer, 50), Treasure.new(:bottle, 25)]
+    end
+
+    context "with a health greater than 100" do 
+
+      before do
+        @initial_health = 150 
+        @player = Player.new("Strong Player", @initial_health)
+      end
+
+      it "has a strong status" do 
+        expect(@player).to be_strong
+        #@player.should be_strong
+      end
+    end
+
+    context "with a health less than 100" do 
+
+      before do 
+        @initial_health = 90
+        @player = Player.new("Wimpy Player", @initial_health) 
+      end
+
+      it "is wimpy" do 
+        expect(@player).not_to be_strong
+        #@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
+
+    context "receiving information about a player as a csv_line" do
+
+      it "creates a new player from csv information" do
+        player1 = Player.from_csv("Alwin, 100")
+        player2 = Player.new("Alwin", 100)
+        expect(player1.name).to eq player2.name
+        expect(player1.health).to eq player2.health
+      end
+    end
+  end
+end

data/spec/studio_game23/treasure_trove_spec.rb

@@ -0,0 +1,54 @@
+require 'studio_game23/treasure_trove'
+
+module StudioGame23
+  describe Treasure do
+    before do
+      @treasure = Treasure.new(:hammer, 50)
+    end
+
+    it "has a name attribute" do
+      expect(@treasure.name).to eq :hammer
+    end
+
+    it "has a points attribute" do
+      expect(@treasure.points).to eq 50
+    end
+  end
+
+  describe TreasureTrove do
+
+    it "has six treasures" do
+      expect(TreasureTrove::TREASURES.size).to eq 6
+    end
+
+    it "has a pie worth 5 points" do
+      expect(TreasureTrove::TREASURES[0]).to eq Treasure.new(:pie, 5)    
+    end
+    
+    it "has a bottle worth 25 points" do
+      expect(TreasureTrove::TREASURES[1]).to eq Treasure.new(:bottle, 25)
+    end  
+
+    it "has a hammer worth 50 points" do
+      expect(TreasureTrove::TREASURES[2]).to eq Treasure.new(:hammer, 50)
+    end
+
+    it "has a skillet worth 100 points" do 
+      expect(TreasureTrove::TREASURES[3]).to eq Treasure.new(:skillet, 100)
+    end
+
+    it "has a broomstick worth 200 points" do 
+      expect(TreasureTrove::TREASURES[4]).to eq Treasure.new(:broomstick, 200)
+    end
+
+    it "has a crowbar worth 400 points" do 
+      expect(TreasureTrove::TREASURES[5]).to eq Treasure.new(:crowbar, 400)
+    end
+
+    it "returns a random treasure" do
+      treasure = TreasureTrove.random
+
+      expect(TreasureTrove::TREASURES).to include(treasure)
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: studio_game23
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Anna
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-05 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: 'This is just a simple gem, created during a Ruby online course for learning
+  purposes.
+
+  '
+email: njutik@web.de
+executables:
+- studio_game23
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README
+- bin/my_favorite_players.csv
+- bin/players.csv
+- bin/studio_game23
+- lib/studio_game23/auditable.rb
+- lib/studio_game23/berserk_player.rb
+- lib/studio_game23/clumsy_player.rb
+- lib/studio_game23/die.rb
+- lib/studio_game23/game.rb
+- lib/studio_game23/game_turn.rb
+- lib/studio_game23/loaded_die.rb
+- lib/studio_game23/playable.rb
+- lib/studio_game23/player.rb
+- lib/studio_game23/treasure_trove.rb
+- spec/spec_helper.rb
+- spec/studio_game23/berserk_player_spec.rb
+- spec/studio_game23/clumsy_player_spec.rb
+- spec/studio_game23/game_spec.rb
+- spec/studio_game23/player_spec.rb
+- spec/studio_game23/treasure_trove_spec.rb
+homepage: ''
+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.4.6
+signing_key:
+specification_version: 4
+summary: A Studio Game for learning purposes only
+test_files:
+- spec/spec_helper.rb
+- spec/studio_game23/berserk_player_spec.rb
+- spec/studio_game23/clumsy_player_spec.rb
+- spec/studio_game23/game_spec.rb
+- spec/studio_game23/player_spec.rb
+- spec/studio_game23/treasure_trove_spec.rb