studio_game_mike_brooks 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe286b338f71c3270ab2bddde31ea0cf37c73eb0
+  data.tar.gz: 1ae846ce68014c4e95ef9f4ed051673f29be878c
+SHA512:
+  metadata.gz: dfda0df4248ab9eabf1fc1e9ef3ed640101cd3a5bbb52652e7cf93cc4544026aa3581a77bd41be2ff1f287a65ba6f52c3280888ab83ecceb7f93c1cc5310be55
+  data.tar.gz: db9915e6a1f0bd1ad58b2e6bfcaf84ac2e3afd52c7fe4ba20db1d4b46236e9cfda73df84216c904885960c457350155ab32627adce7f363c6c781a10a9873876

data/LICENSE

@@ -0,0 +1 @@
+The LICENSE file should contain, well, the license under which you're distributing your source code. If you're unsure or just need a reasonable, no-lawyers-required example, check out the short terms of the MIT license. Choose whatever you like, just don't release your code without some kind of license, otherwise folks won't know if they can use it. 

data/README

@@ -0,0 +1 @@
+The README should contain a short description of what your gem does and how to use it.

data/bin/high_scores.txt

@@ -0,0 +1,4 @@
+Knuckleheads High Scores:
+Alvin............... 550
+Simon............... 525
+Theo................ 350

data/bin/my_favourite_players.csv

@@ -0,0 +1,3 @@
+Rocky,50
+Rambo,40
+Bambo,70

data/bin/players.csv

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

data/bin/studio_game

@@ -0,0 +1,269 @@
+#!/usr/bin/env ruby
+
+# require_relative 'player'
+# require_relative 'game'
+# require_relative 'clumsy_player'
+# require_relative 'berserk_player'
+
+# require 'studio_game/player'
+require_relative '../lib/studio_game/game'
+require_relative '../lib/studio_game/clumsy_player'
+require_relative '../lib/studio_game/berserk_player'
+
+
+# player1 = Player.new("moe")
+# player2 = Player.new("larry", 60)
+# player3 = Player.new("curly", 125)
+
+knuckleheads = StudioGame::Game.new("Knuckleheads")
+puts knuckleheads.title; puts
+
+# knuckleheads.load_players(ARGV.shift || "players.csv")
+
+default_player_file = File.join(File.dirname(__FILE__), 'players.csv')
+knuckleheads.load_players(ARGV.shift || default_player_file)
+
+# klutz = ClumsyPlayer.new("klutz", 105)
+# knuckleheads.add_player(klutz)
+# 
+# berserk = BerserkPlayer.new("berserk", 50)
+# knuckleheads.add_player(berserk)
+
+knuckleheads.play(2)
+
+# loop do
+#   puts "\nHow many rounds? or 'quit'/'exit' to finish."
+#   answer = gets.chomp.downcase
+#   case answer
+#   when 'quit', 'exit'
+#     knuckleheads.print_stats
+#     break
+#   when /^\d+$/
+#     knuckleheads.play(answer.to_i)
+#     # {knuckleheads.total_points >= 2000}
+#   else
+#     puts "Input error: enter either number of rounds or type in 'quit' or 'exit'"
+#   end
+# end
+
+knuckleheads.save_high_scores
+
+#knuckleheads.print_stats
+#knuckleheads.high_scores
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# puts
+# 
+# player4 = Player.new("alvin", 100)
+# player5 = Player.new("simon", 60)
+# player6 = Player.new("theodore", 125)
+# 
+# chipmunks = Game.new("Chipmunks")
+# puts chipmunks.title
+# chipmunks.add_player(player4)
+# chipmunks.add_player(player5)
+# chipmunks.add_player(player6)
+# chipmunks.add_player(player1)
+# chipmunks.play
+
+
+
+
+
+# players = [player1, player2, player3]
+# 
+# puts "There are #{players.size} players in the game:"
+# 
+# players.each do |player|
+#   puts player
+# end
+# 
+# puts
+# 
+# players.each do |player|
+#   puts player.health
+# end
+# 
+# puts
+# 
+# players.each do |player|
+#   player.blam
+#   player.w00t
+#   player.w00t
+#   puts player
+# end
+# 
+# puts
+# 
+# puts players
+# 
+# puts
+# 
+# players.pop
+# player4 = Player.new("Shemp", 90)
+# players.push(player4)
+# 
+# puts
+# 
+# puts players
+
+# players.each do
+
+
+
+
+# puts
+
+# puts player1
+# puts player2
+# puts player3
+
+# puts player1.health
+# puts player2.health
+# puts player3.health
+# puts
+# 
+# player2.name = "lawrence"
+# puts player2.name
+# puts
+# 
+# puts player1.score
+# puts player1
+# puts player2
+# puts player3
+
+# puts
+# puts player1.inspect
+# puts player2.inspect
+# puts player3.inspect
+# puts
+
+
+# puts player3.say_hello
+# player3.blam
+# puts player3.say_hello
+# player3.w00t
+# puts player3.say_hello
+# puts
+# 
+# puts player1.say_hello
+# player1.blam
+# player1.blam
+# player1.blam
+# player1.blam
+# player1.blam
+# puts player1.say_hello
+# player1.w00t
+# player1.w00t
+# player1.w00t
+# player1.w00t
+# player1.w00t
+# puts player1.say_hello
+# puts
+# 
+# puts player2.say_hello
+# player2.blam
+# player2.blam
+# player2.blam
+# player2.blam
+# player2.blam
+# player2.blam
+# player2.blam
+# player2.blam
+# puts player2.say_hello
+# puts
+# 
+# 
+# puts player1.say_hello
+# puts player2.say_hello
+# puts player3.say_hello
+# 
+# puts player1
+
+
+
+# def time
+#   current_time = Time.new
+#   current_time.strftime("%H:%M:%S")
+# end
+# 
+# def say_hello(name, health=100)
+#   "I'm #{name.capitalize} with a health of #{health} as of #{time}."
+# end
+# 
+# puts say_hello("larry", 60)
+# puts say_hello("curly", 125)
+# puts say_hello("moe")
+# puts say_hello("shemp", 90)
+
+
+# name1 = "larry"
+# health1 = 60
+# 
+# puts "#{name1.capitalize} has a health of #{health1}" 
+# 
+# name2 = "curly"
+# health2 = 125
+# 
+# puts "#{name2.upcase} has a health of #{health2}"
+# 
+# health2 = health1
+# puts "#{name2.upcase} has a health of #{health2}"
+# 
+# health1 = 30
+# puts "#{name1.capitalize} has a health of #{health1}"
+# puts "#{name2.upcase} has a health of #{health2}"
+# 
+# name3 = "moe"
+# health3 = 100
+# 
+# puts "#{name3.capitalize} has a health of #{health3}.".center(50, '*')
+# 
+# text = "#{name3.capitalize} has a health of #{health3}."
+# puts text.center(50, '*')
+# 
+# name4 = "shemp"
+# health4 = 90
+# 
+# puts "#{name4.capitalize.ljust(30, '.')} #{health4} health"
+# 
+# current_time = Time.new
+# puts "The game started on #{current_time.strftime("%A %d/%m/%y at%l:%M%p")}"
+# 
+# # puts name1 +'\'s health is ' + health1.to_s
+# # puts "#{name1}'s health is #{health1 * 3 / 9.0}"
+# # 
+# # puts "Players:\n\tlarry\n\tcurly\n\tmoe"
+# # 
+# # puts "Players:\n\t#{name1}\n\t#{name2}\n\t#{name3}"

data/lib/studio_game/auditable.rb

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

data/lib/studio_game/berserk_player.rb

@@ -0,0 +1,72 @@
+require_relative 'player'
+
+module StudioGame
+  class BerserkPlayer < Player
+  
+    def initialize(name, health=100)
+      super(name, health)
+      @w00t_counter = 0
+    end
+  
+    def berserk?
+      @w00t_counter > 5
+    end
+  
+    def w00t
+      super
+      @w00t_counter += 1
+      if berserk?
+        puts "Watch out! player #{@name} has been w00ted #{@w00t_counter} times."
+      else
+        puts "Current w00t count of player #{@name}: #{@w00t_counter}"
+      end
+    end
+     
+    def blam
+      if berserk?
+        puts "Ooops! Player #{@name} went beserk! And instead of being blammed, he will be w00ted! (current w00t count: #{@w00t_counter})"
+        w00t
+      else
+        super
+      end
+    end 
+    
+      # @w00t_counter >= 5 ? puts "Watch out! This player has been w00ted 5 or more times, to precise - #{@w00t_counter} times." : puts "Current w00t count: #{@w00t_counter}"
+
+      # or use the ternary operator:
+
+      # def blam
+        # berserk? ? w00t : super
+      # end
+  end
+end
+
+
+if __FILE__ == $0
+player = BerserkPlayer.new("berserk")
+puts player.name
+puts player.health
+player.w00t
+player.w00t
+player.w00t
+player.w00t
+player.w00t
+player.w00t
+puts player.health
+player.blam
+puts player.health
+player.w00t
+puts player.health
+player.found_treasure(TreasureTrove::random)
+puts player
+player.practice
+
+puts
+puts
+puts
+
+berserker = BerserkPlayer.new("berserker", 50)
+6.times { berserker.w00t }
+2.times { berserker.blam }
+puts berserker.health
+end

data/lib/studio_game/clumsy_player.rb

@@ -0,0 +1,95 @@
+require_relative 'player'
+
+module StudioGame
+  class ClumsyPlayer < Player
+  
+    attr_reader :boost_factor
+  
+    def initialize(name, health=100, boost_factor=1)
+      super(name, health)
+      @boost_factor = boost_factor
+    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}
+      puts "SUPERBOOSTED"
+    end
+
+  end
+end
+
+
+if __FILE__ == $0
+  clumsy = ClumsyPlayer.new("klutz", 105, 3)  
+  
+  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"
+  
+
+  puts
+  puts
+  puts
+  
+  
+  puts clumsy.health
+  clumsy.w00t
+  puts clumsy.health
+end
+
+
+=begin
+
+Klutz found a hammer worth 25 points.
+Klutz's treasures: {:hammer=>25}.
+hammer - 25
+Klutz found a hammer worth 25 points.
+Klutz's treasures: {:hammer=>50}.
+hammer - 50
+Klutz found a hammer worth 25 points.
+Klutz's treasures: {:hammer=>75}.
+hammer - 75
+Klutz found a crowbar worth 200 points.
+Klutz's treasures: {:hammer=>75, :crowbar=>200}.
+hammer - 75
+crowbar - 200
+75 total hammer points
+200 total crowbar points
+275 grand total points
+
+
+Klutz found a hammer worth 50 points.
+Klutz's treasures: {:hammer=>50}.
+hammer - 50
+Klutz found a hammer worth 50 points.
+Klutz's treasures: {:hammer=>100}.
+hammer - 100
+Klutz found a hammer worth 50 points.
+Klutz's treasures: {:hammer=>150}.
+hammer - 150
+Klutz found a crowbar worth 400 points.
+Klutz's treasures: {:hammer=>150, :crowbar=>400}.
+hammer - 150
+crowbar - 400
+150 total hammer points
+400 total crowbar points
+550 grand total points
+
+=end
+

data/lib/studio_game/die.rb

@@ -0,0 +1,51 @@
+require_relative 'auditable'
+
+module StudioGame
+  class Die
+    include Auditable
+    attr_reader :number
+
+    def initialize
+      roll
+    end
+
+    def roll
+      @number = rand(1..6)
+      audit
+      @number
+    end
+  end
+
+
+
+  class LoadedDie
+    include Auditable
+    attr_reader :number
+  
+    # def initialize
+    #   roll
+    # end
+  
+    def roll
+      numbers = [1, 1, 2, 5, 6, 6]
+      @number = numbers.sample
+      audit
+      @number
+    end
+  
+  end
+end
+
+
+
+
+if __FILE__ == $0
+  
+  die = Die.new
+  
+  die = LoadedDie.new
+  puts die.roll
+  puts die.roll
+  puts die.roll
+  
+end

data/lib/studio_game/game.rb

@@ -0,0 +1,150 @@
+require_relative 'player'
+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 print_name_and_health(player)
+      puts "#{player.name} (#{player.health})"
+    end
+  
+    def print_stats
+      puts "\n#{@title} Statistics:\n"
+      # strong_players, wimpy_players = @players.partition { |player| player.strong? }
+      # 
+      # 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
+    
+      @players.each do |player|
+        puts "#{player.name}'s point totals:"
+      
+        # B
+        player.each_found_treasure do |treasure|
+          puts "#{treasure.points} total #{treasure.name} points"
+        end
+      
+        # another way (alternative for player.each_found_treasure above)
+        player.practice
+      
+        puts "#{player.points} GRAND TOTAL points\n\n"
+      end
+    
+    
+      puts "\n#{title} High Scores:"
+      @players.sort.each do |player|
+        puts print_high_scores(player)
+      end
+    
+    
+      puts "Total found treasures by all players: #{total_points}"
+      puts "\n----------------------------------------------------------"
+
+    end
+  
+  
+    def total_points
+      @players.reduce(0){|sum, player| sum + player.points}
+    end
+     
+  
+    def add_player(a_player)
+      @players << a_player
+    end
+  
+    def play(rounds)
+
+      puts "There are #{@players.size} players in #{@title}:\n\n"
+     
+      @players.each do |player|
+        puts player
+      end
+    
+      treasures = TreasureTrove::TREASURES
+    
+      puts "There are #{treasures.size} treasures to be found:"
+      treasures.each do |treasure|
+        puts "A #{treasure.name} is worth #{treasure.points} points"
+      end
+    
+      puts "\n*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *"
+    
+      1.upto(rounds) do |round|
+      
+        if block_given?
+          break if yield
+        end
+      
+        puts "\nRound #{round}:\n\n"
+        @players.each do |player|
+          GameTurn.take_turn(player)  
+          puts player
+        
+        end
+        print_stats
+      end
+    end
+  
+    # Input / Output
+  
+    def print_high_scores(player)
+      formatted_name = player.name.ljust(20, '.')
+      "#{formatted_name} #{player.score}"
+    end
+  
+  
+    # def turning_CSV_string_into_a_Player_object(line)
+    #   name, health = line.split(',')
+    #   player = Player.new(name, Integer(health))
+    # end
+  
+    def load_players(from_file)
+      CSV.foreach(from_file) do |row|
+        player = Player.new(row[0], row[1].to_i)
+        add_player(player)
+    
+      # File.readlines(from_file).each do |line|
+      # add_player(turning_CSV_string_into_a_Player_object(line))
+      
+      end
+    end
+  
+    def save_high_scores(to_file="high_scores.txt")
+      File.open(to_file, "w") do |file|
+        file.puts "#{@title} High Scores:"
+        @players.sort.each do |player|
+          file.puts print_high_scores(player)
+        end
+      end
+    end
+  end
+end
+
+
+if __FILE__ == $0
+player1 = Player.new("moe")
+player2 = Player.new("larry", 60)
+knuckleheads = Game.new("Knuckleheads")
+puts knuckleheads.title
+knuckleheads.add_player(player1)
+knuckleheads.add_player(player2)
+#knuckleheads.print_name_and_health(player1)
+
+knuckleheads.play(1)
+end

data/lib/studio_game/game_turn.rb

@@ -0,0 +1,25 @@
+require_relative 'player'
+require_relative 'die'
+require_relative 'treasure_trove'
+
+module StudioGame
+  module GameTurn
+  
+    def self.take_turn(player)
+      die = Die.new
+      case die.roll
+      when 1..2
+        player.blam
+      when 3..4
+        puts "#{player.name} was skipped."        
+      else
+        player.w00t
+      end
+    
+      random_treasure = TreasureTrove.random
+      # puts "#{player.name} found a #{random_treasure.name} worth #{random_treasure.points} points."
+      player.found_treasure(random_treasure)
+  
+    end
+  end
+end

data/lib/studio_game/playable.rb

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

data/lib/studio_game/player.rb

@@ -0,0 +1,74 @@
+require_relative 'treasure_trove'
+require_relative 'playable'
+
+module StudioGame
+  class Player
+    include Playable
+  
+    attr_accessor :name
+    attr_accessor :health
+
+    def initialize(name, health=100)
+      @name = name.capitalize
+      @health = health
+      @found_treasures = Hash.new(0)
+    end
+  
+    def to_s
+      "I'm #{@name} with health = #{@health}, points = #{points}, and score = #{score}.\n\n"
+    end
+  
+  
+    def score
+      self.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}."
+      practice
+      # puts "#{treasure.name} accumulated #{treasure.points} points."
+    end
+  
+    def points
+      @found_treasures.values.reduce(0, :+)
+    end
+  
+    # A
+    def each_found_treasure
+      @found_treasures.each do |name, points|
+        treasure = Treasure.new(name, points)
+        yield treasure     # or in one line: yield Treasure.new(name, points)
+      end
+    end
+  
+  # another way (alternative for def each_found_treasure)
+    def practice
+      @found_treasures.each do |key, value|
+        print "#{key} - #{value}\n"
+      end
+    end
+  
+  end
+end
+
+#some example code
+
+if __FILE__ == $0
+player = StudioGame::Player.new("moe")
+puts player.name
+puts player.health
+player.w00t
+puts player.health
+player.blam
+puts player.health
+player.found_treasure(TreasureTrove::random)
+puts player
+puts player.score
+player.practice
+end

data/lib/studio_game/treasure_trove.rb

@@ -0,0 +1,30 @@
+module StudioGame
+  Treasure = Struct.new(:name, :points)
+
+# attr_reader :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
+
+
+if __FILE__ == $0
+# puts TreasureTrove::TREASURES
+
+puts TreasureTrove::random.name
+
+end

data/spec/studio_game/berserk_player_spec.rb

@@ -0,0 +1,31 @@
+# require_relative 'berserk_player'
+require 'studio_game/berserk_player'
+
+module StudioGame
+  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 }
+    
+      @player.berserk?.should be_false
+    end
+  
+    it "goes berserk when w00ted more than 5 times" do
+      1.upto(6) { @player.w00t }
+    
+      @player.berserk?.should 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 }
+    
+      @player.health.should == @initial_health + (8 * 15)
+    end
+  end
+end

data/spec/studio_game/clumsy_player_spec.rb

@@ -0,0 +1,51 @@
+# require_relative 'clumsy_player'
+require 'studio_game/clumsy_player'
+
+module StudioGame
+  describe ClumsyPlayer do
+    before do
+      @player = ClumsyPlayer.new("klutz")
+    end
+  
+    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
+      end
+
+      yielded.should == [Treasure.new(:hammer, 75), Treasure.new(:crowbar, 200)]    
+    end
+
+    context "with a boost factor" do
+      before do
+        @initial_health = 100
+        @boost_factor = 5  
+        @player = ClumsyPlayer.new("klutz", @initial_health, @boost_factor)
+      end
+  
+      it "has a boost factor" do
+        @player.boost_factor.should == 5
+      end
+
+      it "gets boost factor number of w00ts when w00ted" do
+        @player.w00t
+
+        @player.health.should == @initial_health + (15 * @boost_factor)
+      end
+    end
+  end
+end

data/spec/studio_game/game_spec.rb

@@ -0,0 +1,77 @@
+# require_relative 'game'
+require 'studio_game/game'
+
+module StudioGame
+  describe Game do
+
+    before do
+      @game = Game.new("Knuckleheads")
+    
+      @initial_health = 100
+      @player = Player.new("moe", @initial_health)
+    
+      @game.add_player(@player)
+    
+      #$stdout = StringIO.new
+    end
+  
+    it "has a title" do
+      @game.title.should == "Knuckleheads"
+    end
+  
+    it "w00ts the player if a high number is rolled" do
+        Die.any_instance.stub(:roll).and_return(5)
+      
+        @game.play(2)
+      
+        @player.health.should == @initial_health + (15 * 2)
+    end
+
+    it "skips the player if a medium number is rolled" do
+      Die.any_instance.stub(:roll).and_return(3)
+    
+      @game.play(2)
+    
+      @player.health.should == @initial_health
+    end
+  
+    it "blams the player if a low number is rolled" do
+      Die.any_instance.stub(:roll).and_return(1)
+    
+      @game.play(2)
+    
+      @player.health.should == @initial_health - (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/studio_game/player_spec.rb

@@ -0,0 +1,121 @@
+# require_relative '../../lib/studio_game/player'
+require 'studio_game/player'
+
+module StudioGame
+  describe Player do
+  
+    before do
+      @initial_health = 150
+      @player = Player.new("larry", @initial_health)
+      $stdout = StringIO.new
+    end
+
+    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))
+      puts @player.to_s.should == "I'm Larry with health = 150, points = 100, and score = 250.\n\n"
+    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 "increases health by 15 when w00ted" do
+      @player.w00t
+    
+      @player.health.should == (@initial_health + 15)
+    end
+  
+    it "decreases health by 10 when blammed" do
+      @player.blam
+    
+      @player.health.should == (@initial_health - 10)
+    end
+
+    context "with a health greater than 100" do
+      before do  
+        @player = Player.new("larry", 150)
+      end
+  
+      it "is strong" do
+        @player.should be_strong #instead of: strong?.should be_true
+      end
+    end
+  
+    context "with a health of 100 or less" do
+      before do
+        @player = Player.new("larry", 100)
+      end
+    
+      it "is wimpy" do
+        @player.should_not be_strong #(instead of: @player.strong?.should_not be_true)
+      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 "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

data/spec/studio_game/project_unit_testing.rb

@@ -0,0 +1,12 @@
+require_relative 'project'
+require 'test/unit'
+
+module StudioGame
+  class TestProject < Test::Unit::TestCase
+  
+    def test1
+      assert_equal(200, Project.new("SPC", 200, 800).funding)
+    end
+
+  end
+end

data/spec/studio_game/treasure_trove_spec.rb

@@ -0,0 +1,61 @@
+# require_relative 'treasure_trove'
+require 'studio_game/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
+
+
+  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,86 @@
+--- !ruby/object:Gem::Specification
+name: studio_game_mike_brooks
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mike Brooks
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The README should contain a short description of what your gem does and
+  how to use it.
+email: brooksbrisbane@gmail.com
+executables:
+- studio_game
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README
+- bin/high_scores.txt
+- bin/my_favourite_players.csv
+- bin/players.csv
+- bin/studio_game
+- lib/studio_game/auditable.rb
+- lib/studio_game/berserk_player.rb
+- lib/studio_game/clumsy_player.rb
+- lib/studio_game/die.rb
+- lib/studio_game/game.rb
+- lib/studio_game/game_turn.rb
+- lib/studio_game/playable.rb
+- lib/studio_game/player.rb
+- lib/studio_game/treasure_trove.rb
+- spec/studio_game/berserk_player_spec.rb
+- spec/studio_game/clumsy_player_spec.rb
+- spec/studio_game/game_spec.rb
+- spec/studio_game/player_spec.rb
+- spec/studio_game/project_unit_testing.rb
+- spec/studio_game/treasure_trove_spec.rb
+homepage: http://www.brooksmike.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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: gem created only for practice purposes
+test_files:
+- spec/studio_game/berserk_player_spec.rb
+- spec/studio_game/clumsy_player_spec.rb
+- spec/studio_game/game_spec.rb
+- spec/studio_game/player_spec.rb
+- spec/studio_game/project_unit_testing.rb
+- spec/studio_game/treasure_trove_spec.rb