liars_dice 0.0.1

data/README.md

@@ -0,0 +1,4 @@
+liars_dice
+==========
+
+Liar's Dice Game

data/lib/liars_dice/bid.rb

@@ -0,0 +1,42 @@
+module LiarsDice
+  class Bid
+    attr_accessor :total, :face_value
+
+    def initialize(total, face_value)
+      self.total = total
+      self.face_value = face_value
+    end
+
+    def bs_called?
+      false
+    end
+
+    def to_s
+      "#{total} #{face_value}#{"s" if total > 1}"
+    end
+
+    def valid?
+      if face_value < 1 || face_value > 6
+        # Can't bid a face_value that doesn't exist
+        return false
+      elsif total < 1
+        # Have to bid a positive total
+        return false
+      end
+      true
+    end
+  end
+
+  class BS < Bid
+    def initialize
+    end
+
+    def bs_called?
+      true
+    end
+
+    def to_s
+      "BS"
+    end
+  end
+end

data/lib/liars_dice/command_line_watcher.rb

@@ -0,0 +1,13 @@
+module LiarsDice
+  class CommandLineWatcher
+    include Watcher
+
+    def initialize
+      append_after_dice_rolled lambda{|dice| puts "Dice Rolled: #{dice.inspect.to_s}" }
+      append_after_bid lambda{|seat, bid| puts "Seat #{seat} bids #{bid}" }
+      append_after_bs lambda{|seat| puts "Seat #{seat} calls BS" }
+      append_after_game lambda{|winner| puts "Game over.  Seat #{winner} wins." }
+      append_after_round lambda{|loser| puts "Seat #{loser} loses a die" }
+    end
+  end
+end

data/lib/liars_dice/engine.rb

@@ -0,0 +1,194 @@
+module LiarsDice
+  class Engine
+    include Watcher
+    attr_accessor :seats, :starting_seat, :bids, :watcher
+    attr_reader :loser, :seat_index
+
+    def initialize(player_classes, dice_per_player, watcher=nil)
+      self.seats = []
+      player_classes.shuffle.each_with_index do |klass, i|
+        player = klass.new(i, player_classes.count, dice_per_player)
+        self.seats << Seat.new(i, player, dice_per_player)
+      end
+      self.seat_index = 0
+      self.watcher = watcher || self
+    end
+
+    def run
+      until winner?
+        roll_dice
+        run_round
+      end
+      notify_winner
+    end
+
+    def get_bid(seat)
+      bid = seat.player.bid
+      unless valid_bid?(bid)
+        raise StandardError.new("Invalid Bid")
+      end
+      bid
+    end
+
+    def next_seat
+      # If no seats are alive, we'd loop forever
+      return nil if alive_seats.empty?
+
+      seat = seats[seat_index]
+      self.seat_index += 1
+
+      # If the seat at seat_index is alive, return it
+      # Otherwise, we've already updated seat_index (and wrapped it, if necessary)
+      # so just call next_seat again
+      seat.alive? ? seat : next_seat
+    end
+
+    def total_dice_with_face_value(face_value)
+      seats.map{|seat| seat.dice.count(face_value) }.reduce(0, :+)
+    end
+
+    def bid_is_correct?(bid, use_wilds)
+      total = total_dice_with_face_value(bid.face_value)
+      total += total_dice_with_face_value(1) if use_wilds
+      total >= bid.total
+    end
+
+    def run_round
+      self.bids = []
+
+      previous_seat = nil
+      aces_wild = true
+      while true
+        seat = next_seat
+        bid = get_bid(seat)
+        aces_wild = false if bid.face_value == 1
+
+        if bid.bs_called?
+          notify_bs(seat)
+          self.loser = bid_is_correct?(previous_bid, aces_wild) ? seat : previous_seat
+          notify_loser(loser)
+          loser.lose_die
+          break
+        end
+
+        self.bids << bid
+        notify_bid(seat, bid)
+        previous_seat = seat
+      end
+    end
+
+    def roll_dice
+      die = (1..6).to_a
+      alive_seats.each do |seat|
+        dice = []
+        seat.dice_left.times do
+          dice << die.sample
+        end
+
+        seat.dice = dice
+      end
+      notify_roll
+    end
+
+    # ===========================================
+    # ====        Notification Events        ====
+    # ===========================================
+    def notify_bid(seat, bid)
+      event = BidMadeEvent.new(seat.number, bid)
+      notify_players(event)
+      notify_watcher(event)
+    end
+
+    def notify_bs(seat)
+      event = BSCalledEvent.new(seat.number, previous_bid)
+      notify_players(event)
+      notify_watcher(event)
+    end
+
+    def notify_loser(seat)
+      dice = seats.map(&:dice)
+      event = LoserEvent.new(seat.number, dice)
+      notify_players(event)
+      notify_watcher(event)
+    end
+
+    def notify_winner
+      event = WinnerEvent.new(winner.number)
+      notify_players(event)
+      notify_watcher(event)
+    end
+
+    def notify_roll
+      dice = seats.map(&:dice)
+      event = DiceRolledEvent.new(dice)
+      notify_watcher(event)
+    end
+
+    def notify_players(event)
+      seats.each{|s| s.player.handle_event(event) }
+    end
+
+    def notify_watcher(event)
+      watcher.handle_event(event)
+    end
+
+    # ===========================================
+    # ====        Validation Methods         ====
+    # ===========================================
+    def valid_bs?(bid)
+      # Cannot bid BS if there isn't a previous bid
+      !!previous_bid
+    end
+
+    def valid_bid?(bid)
+      return false unless bid
+
+      if bid.bs_called?
+        return valid_bs?(bid)
+      end
+
+      if bid.face_value < 1 || bid.face_value > 6
+        # Can't bid a face_value that doesn't exist
+        return false
+      elsif bid.total < 1
+        # Have to bid a positive total
+        return false
+      elsif previous_bid && bid.total < previous_bid.total
+        # The total must be monotonically increasing
+        return false
+      elsif previous_bid && bid.total == previous_bid.total && bid.face_value <= previous_bid.face_value
+        # If the total does not increase, the face_value must
+        return false
+      end
+
+      true
+    end
+
+    def previous_bid
+      bids[-1]
+    end
+
+    def alive_seats
+      seats.select(&:alive?)
+    end
+
+    def winner?
+      alive_seats.count == 1
+    end
+
+    def winner
+      return nil unless winner?
+      alive_seats.first
+    end
+
+    def loser=(seat)
+      @loser = seat
+      self.seat_index = seat.number + 1
+    end
+
+    def seat_index=(index)
+      @seat_index = index
+      @seat_index = 0 if @seat_index == seats.count
+    end
+  end
+end

data/lib/liars_dice/event.rb

@@ -0,0 +1,57 @@
+module LiarsDice
+  class Event
+    attr_accessor :message
+
+    def initialize(message)
+      self.message = message
+    end
+  end
+
+  class BidMadeEvent < Event
+    attr_accessor :seat_number, :bid
+
+    def initialize(seat_number, bid)
+      self.seat_number = seat_number
+      self.bid = bid
+      super("Seat #{seat_number} bid #{bid.to_s}")
+    end
+  end
+
+  class BSCalledEvent < Event
+    attr_accessor :seat_number, :previous_bid
+
+    def initialize(seat_number, previous_bid)
+      self.seat_number = seat_number
+      self.previous_bid = previous_bid
+      super("Seat #{seat_number} called BS")
+    end
+  end
+
+  class DiceRolledEvent < Event
+    attr_accessor :dice
+
+    def initialize(dice)
+      self.dice = dice
+      super("Dice rolled")
+    end
+  end
+
+  class LoserEvent < Event
+    attr_accessor :seat_number, :dice
+
+    def initialize(seat_number, dice)
+      self.seat_number = seat_number
+      self.dice = dice
+      super("Seat #{seat_number} lost a die")
+    end
+  end
+
+  class WinnerEvent < Event
+    attr_accessor :seat_number
+
+    def initialize(seat_number)
+      self.seat_number = seat_number
+      super("Game is over.  Seat #{seat_number} is the winner.")
+    end
+  end
+end

data/lib/liars_dice/human_bot.rb

@@ -0,0 +1,45 @@
+module LiarsDice
+  class HumanBot
+    attr_accessor :prev_bid, :dice
+
+    def initialize(seat_number, number_of_players, number_of_dice)
+      puts "You're playing as HumanBot in seat #{seat_number}"
+      puts "When asked for a bid, either enter <TOTAL> <FACE_VALUE> or BS"
+    end
+
+
+    def handle_event(event)
+      if event.is_a? LiarsDice::BidMadeEvent
+        self.prev_bid = event.bid
+      elsif event.is_a? LiarsDice::LoserEvent
+        self.prev_bid = nil
+      end
+    end
+
+    def dice=(dice)
+      @dice = dice
+      puts "Your dice are #{dice.inspect.to_s}"
+    end
+
+    def bid
+      if prev_bid
+        puts "Previous bid was #{prev_bid}"
+      else
+        puts "You're bidding first"
+      end
+
+      print "What do you bid? "
+      bid_string = gets.chomp
+      if bid_string.downcase == "bs"
+        return BS.new
+      end
+      parts = bid_string.split(" ").map(&:to_i)
+      if parts.length == 2
+        ret = Bid.new(*parts)
+        return ret if ret.valid?
+      end
+      print "Invalid bid"
+      return bid
+    end
+  end
+end

data/lib/liars_dice/random_bot.rb

@@ -0,0 +1,42 @@
+module LiarsDice
+  class RandomBot
+    attr_accessor :prev_bid
+
+    def initialize(seat_number, number_of_players, number_of_dice); end
+
+
+    def handle_event(event)
+      if event.is_a? LiarsDice::BidMadeEvent
+        self.prev_bid = event.bid
+      elsif event.is_a? LiarsDice::LoserEvent
+        self.prev_bid = nil
+      end
+    end
+
+    def dice=(dice); end
+
+    def bid
+      if prev_bid
+        choice = (0...10).to_a.sample
+
+        if choice == 0
+          # Call BS 10% of the time
+          LiarsDice::BS.new
+        elsif choice <= 6
+          # Up the total 50% of the time
+          LiarsDice::Bid.new(prev_bid.total + 1, prev_bid.face_value)
+        else
+          # Up the number 40% of the time
+          r = LiarsDice::Bid.new(prev_bid.total, prev_bid.face_value + 1)
+          if r.face_value > 6
+            r.total += 1
+            r.face_value = 2
+          end
+          r
+        end
+      else
+        LiarsDice::Bid.new(1, 2)
+      end
+    end
+  end
+end

data/lib/liars_dice/seat.rb

@@ -0,0 +1,25 @@
+module LiarsDice
+  class Seat
+    attr_accessor :number, :player
+    attr_reader :dice_left, :dice
+
+    def initialize(number, player, starting_dice)
+      self.number = number
+      @dice_left = starting_dice
+      self.player = player
+    end
+
+    def alive?
+      dice_left > 0
+    end
+
+    def dice=(value)
+      @dice = value
+      player.dice = value
+    end
+
+    def lose_die
+      @dice_left -= 1
+    end
+  end
+end

data/lib/liars_dice/watcher.rb

@@ -0,0 +1,62 @@
+module LiarsDice
+  module Watcher
+    attr_reader :after_roll, :after_bid, :after_round, :after_bs, :after_game, :after_dice_rolled
+
+    def append_after_bid(callback)
+      append_callback(:after_bid, callback)
+    end
+
+    def append_after_round(callback)
+      append_callback(:after_round, callback)
+    end
+
+    def append_after_bs(callback)
+      append_callback(:after_bs, callback)
+    end
+
+    def append_after_game(callback)
+      append_callback(:after_game, callback)
+    end
+
+    def append_after_dice_rolled(callback)
+      append_callback(:after_dice_rolled, callback)
+    end
+
+    def handle_event(event)
+      if event.is_a? BidMadeEvent
+        fire(:after_bid, event.seat_number, event.bid)
+      elsif event.is_a? BSCalledEvent
+        fire(:after_bs, event.seat_number)
+      elsif event.is_a? LoserEvent
+        fire(:after_round, event.seat_number)
+      elsif event.is_a? WinnerEvent
+        fire(:after_game, event.seat_number)
+      elsif event.is_a? DiceRolledEvent
+        fire(:after_dice_rolled, event.dice)
+      end
+    end
+
+    private
+    def allowed_callbacks
+      [:after_bid, :after_bs, :after_dice_rolled, :after_game, :after_round]
+    end
+
+    def append_callback(callback_name, callback)
+      raise ArgumentError.new("Callback does not respond to call") unless callback.respond_to? :call
+      raise ArgumentError.new("Unsupported callback #{callback_name}") unless allowed_callbacks.include? callback_name
+      watcher_callbacks[callback_name] << callback
+    end
+
+    def fire(callback_name, *args)
+      raise ArgumentError.new("Unsupported callback #{callback_name}") unless allowed_callbacks.include? callback_name
+      watcher_callbacks[callback_name].each do |callback|
+        callback.call(*args)
+      end
+    end
+
+    def watcher_callbacks
+      # Create a hash where any missing key returns an empty array
+      @watcher_callbacks ||= Hash.new {|hash, key| hash[key] = [] }
+    end
+  end
+end

data/lib/liars_dice.rb

@@ -0,0 +1,8 @@
+require 'liars_dice/watcher'
+require 'liars_dice/bid'
+require 'liars_dice/engine'
+require 'liars_dice/event'
+require 'liars_dice/seat'
+require 'liars_dice/command_line_watcher'
+require 'liars_dice/random_bot'
+require 'liars_dice/human_bot'

data/spec/bid_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Bid" do
+  describe "#valid?" do
+    it "returns false if total is negative" do
+      bid = Bid.new(-1, 5)
+      bid.should_not be_valid
+    end
+
+    it "returns false if total is negative" do
+      bid = Bid.new(0, 5)
+      bid.should_not be_valid
+    end
+
+    it "returns false for invalid die face_values" do
+      bid = Bid.new(5, 0)
+      bid.should_not be_valid
+
+      bid = Bid.new(5, 10)
+      bid.should_not be_valid
+    end
+
+    it "returns true for valid bids" do
+      bid = Bid.new(5, 3)
+      bid.should be_valid
+    end
+  end
+end

data/spec/engine_spec.rb

@@ -0,0 +1,577 @@
+require 'spec_helper'
+
+describe "Engine" do
+  let(:engine) { Engine.new([], 5) }
+  let(:seat) { Seat.new(0, nil, 5) }
+  let(:bid) { Bid.new(1, 1) }
+
+  describe "run_round" do
+    let(:bid_one) { Bid.new(1, 1) }
+    let(:bid_two) { Bid.new(1, 2) }
+    let(:bs) { BS.new }
+
+    before do
+      engine.stub(:next_seat).and_return(seat)
+      engine.stub(:get_bid).and_return(bid_one, bid_two, bs)
+      engine.stub(:bid_is_correct).and_return(true)
+      engine.stub(:notify_loser)
+      seat.stub(:lose_die)
+    end
+
+    it "properly sets #previous_bid" do
+      engine.run_round
+      engine.previous_bid.should == bid_two
+    end
+
+    context "tracking whether aces are wild" do
+      it "doesn't count aces wild after aces are bet" do
+        engine.should_receive(:bid_is_correct?).with(bid_two, false).and_return(true)
+        engine.run_round
+        end
+
+      it "counts aces wild if aces aren't bet" do
+        engine.stub(:get_bid).and_return(bid_two, bs)
+        engine.should_receive(:bid_is_correct?).with(bid_two, true).and_return(true)
+        engine.run_round
+      end
+    end
+
+    context "bid notification" do
+      it "notifies of each bid" do
+        engine.should_receive(:notify_bid).twice
+        engine.run_round
+      end
+
+      it "notifies of the seat and the bid" do
+        engine.stub(:get_bid).and_return(bid_two, bs)
+        engine.should_receive(:notify_bid).with(seat, bid_two)
+        engine.run_round
+      end
+    end
+
+    it "notifies of a bs" do
+      engine.should_receive(:notify_bs).with(seat)
+      engine.run_round
+    end
+
+    it "notifies of a loser" do
+      engine.should_receive(:notify_loser).with(seat)
+      engine.run_round
+    end
+
+    context "picking a loser" do
+      let (:seat1) { Seat.new(1, nil, 5) }
+      let (:seat2) { Seat.new(2, nil, 5) }
+
+      before do
+        engine.stub(:next_seat).and_return(seat1, seat2)
+        engine.stub(:get_bid).and_return(bid_two, bs)
+        engine.stub_chain(:loser, :lose_die)
+      end
+
+      it "picks the bidder if the bid was incorrect" do
+        engine.stub(:bid_is_correct?).and_return(false)
+        engine.should_receive(:loser=).with(seat1)
+        engine.run_round
+      end
+
+      it "picks the caller if the bid was correct" do
+        engine.stub(:bid_is_correct?).and_return(true)
+        engine.should_receive(:loser=).with(seat2)
+        engine.run_round
+      end
+    end
+
+    it "removes a dice from the loser" do
+      seat1 = Seat.new(1, nil, 5)
+      seat2 = Seat.new(2, nil, 5)
+
+      engine.stub(:next_seat).and_return(seat1, seat2)
+      engine.stub(:get_bid).and_return(bid_two, bs)
+      engine.stub(:bid_is_correct?).and_return(false)
+      seat1.should_receive(:lose_die)
+      engine.run_round
+    end
+  end
+
+  describe "run" do
+    before do
+      engine.stub(:roll_dice)
+      engine.stub(:run_round)
+      engine.stub(:notify_winner)
+      engine.stub(:winner?).and_return(false, true)
+    end
+
+    it "goes until there's a winner" do
+      engine.should_receive(:winner?).exactly(4).times.and_return(false, false, false, true)
+      engine.run
+    end
+
+    it "rolls the dice" do
+      engine.should_receive(:roll_dice)
+      engine.run
+    end
+
+    it "runs a round" do
+      engine.should_receive(:run_round)
+      engine.run
+    end
+
+    it "notifies of a winner" do
+      engine.should_receive(:notify_winner)
+      engine.run
+    end
+  end
+
+  it "correctly advances seats after a round" do
+    bs = BS.new
+    seat0 = Seat.new(0, nil, 5)
+    seat1 = Seat.new(1, nil, 5)
+    seat2 = Seat.new(2, nil, 5)
+    seat3 = Seat.new(3, nil, 5)
+    seat4 = Seat.new(4, nil, 5)
+    seats = [seat0, seat1, seat2, seat3, seat4]
+
+    engine.stub(:winner?).and_return(false, false, false, true)
+    engine.stub(:roll_dice)
+    engine.stub(:notify_bid)
+    engine.stub(:notify_bs)
+    engine.stub(:notify_loser)
+    engine.stub(:notify_winner)
+    engine.stub(:bid_is_correct?).and_return(true, false, true)
+
+    engine.seat_index = 0
+    engine.stub(:seats).and_return(seats)
+    seats.each{|s| s.stub(:lose_die) }
+
+    # We're set up to run 3 rounds:
+    # R1: Seat0 bids, Seat1 calls, Seat1 loses
+    # R2: Seat2 bids, Seat3 calls, Seat2 loses
+    # R3: Seat3 bids, Seat4 calls, Seat4 loses
+    engine.should_receive(:get_bid).with(seat0).ordered.and_return(bid)
+    engine.should_receive(:get_bid).with(seat1).ordered.and_return(bs)
+    engine.should_receive(:get_bid).with(seat2).ordered.and_return(bid)
+    engine.should_receive(:get_bid).with(seat3).ordered.and_return(bs)
+    engine.should_receive(:get_bid).with(seat3).ordered.and_return(bid)
+    engine.should_receive(:get_bid).with(seat4).ordered.and_return(bs)
+
+    engine.run
+  end
+
+  describe "#get_bid" do
+    before do
+      seat.stub_chain(:player, :bid).and_return("bid")
+    end
+
+    it "gets a bid from the seat's user" do
+      engine.stub(:valid_bid?).and_return(true)
+      engine.get_bid(seat).should == "bid"
+    end
+
+    it "raises an error if given an invalid bid" do
+      engine.stub(:valid_bid?).and_return(false)
+      expect { engine.get_bid(seat) }.to raise_error
+    end
+  end
+
+  describe "winner?" do
+    let(:seat0) { OpenStruct.new(:alive? => true) }
+    let(:seat1) { OpenStruct.new(:alive? => true) }
+    let(:seat2) { OpenStruct.new(:alive? => false) }
+    let(:seat3) { OpenStruct.new(:alive? => false) }
+
+    it "returns true if there's one alive seat left" do
+      engine.stub(:seats).and_return([seat0, seat2, seat3])
+      engine.winner?.should be_true
+    end
+
+    it "returns false if there's more than one alive seat left" do
+      engine.stub(:seats).and_return([seat0, seat1, seat2, seat3])
+      engine.winner?.should be_false
+    end
+  end
+
+  describe "winner" do
+    let(:seat0) { OpenStruct.new(:alive? => true) }
+    let(:seat1) { OpenStruct.new(:alive? => true) }
+    let(:seat2) { OpenStruct.new(:alive? => false) }
+    let(:seat3) { OpenStruct.new(:alive? => false) }
+
+    it "returns nil if there isn't a winner" do
+      engine.stub(:seats).and_return([seat0, seat1, seat2, seat3])
+      engine.winner.should == nil
+    end
+
+    it "returns the sole alive seat" do
+      engine.stub(:seats).and_return([seat0, seat2, seat3])
+      engine.winner.should == seat0
+    end
+  end
+
+  describe "#total_dice_with_face_value" do
+    let(:seat0) { OpenStruct.new(dice: [2, 2, 3]) }
+    let(:seat1) { OpenStruct.new(dice: [4, 2, 3]) }
+    let(:seat2) { OpenStruct.new(dice: [2, 4, 5]) }
+    let(:seat3) { OpenStruct.new(dice: []) }
+
+    before do
+      engine.stub(:seats).and_return([seat0, seat1, seat2, seat3])
+    end
+
+    it "returns the correct counts" do
+      engine.total_dice_with_face_value(1).should == 0
+      engine.total_dice_with_face_value(2).should == 4
+      engine.total_dice_with_face_value(3).should == 2
+      engine.total_dice_with_face_value(4).should == 2
+      engine.total_dice_with_face_value(5).should == 1
+      engine.total_dice_with_face_value(6).should == 0
+    end
+  end
+
+  describe "#bid_is_correct?" do
+    let(:bid) { Bid.new(3, 3) }
+
+    before do
+      engine.stub(:total_dice_with_face_value).with(1).and_return(1)
+    end
+
+    context "with wilds" do
+      it "returns false when none of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(0)
+        engine.bid_is_correct?(bid, true).should == false
+      end
+
+      it "returns false when less than total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(1)
+        engine.bid_is_correct?(bid, true).should == false
+      end
+
+      it "returns true when exactly total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(2)
+        engine.bid_is_correct?(bid, true).should == true
+      end
+
+      it "returns true when more than total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(6)
+        engine.bid_is_correct?(bid, true).should == true
+      end
+    end
+
+    context "without wilds" do
+      it "returns false when none of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(0)
+        engine.bid_is_correct?(bid, false).should == false
+      end
+
+      it "returns false when less than total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(1)
+        engine.bid_is_correct?(bid, false).should == false
+      end
+
+      it "returns true when exactly total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(3)
+        engine.bid_is_correct?(bid, false).should == true
+      end
+
+      it "returns true when more than total of the face_values were rolled" do
+        engine.stub(:total_dice_with_face_value).with(3).and_return(6)
+        engine.bid_is_correct?(bid, false).should == true
+      end
+    end
+  end
+
+  describe "#next_seat" do
+    let(:seat1) { Seat.new(0, nil, 1) }
+    let(:seat2) { Seat.new(0, nil, 1) }
+    let(:seat3) { Seat.new(0, nil, 1) }
+
+    it "only returns seats that are alive" do
+      seat1.stub(:alive?).and_return(true)
+      seat2.stub(:alive?).and_return(false)
+      seat3.stub(:alive?).and_return(true)
+
+      engine.stub(:seats).and_return([seat1, seat2, seat3])
+      returned_seats = []
+      3.times { returned_seats << engine.next_seat }
+      returned_seats.should include(seat1)
+      returned_seats.should_not include(seat2)
+      returned_seats.should include(seat3)
+    end
+
+    it "wraps around if necessary" do
+      seat1.stub(:alive?).and_return(true)
+      seat2.stub(:alive?).and_return(false)
+      seat3.stub(:alive?).and_return(true)
+
+      engine.stub(:seats).and_return([seat1, seat2, seat3])
+      returned_seats = []
+      3.times { returned_seats << engine.next_seat }
+      returned_seats.should == [seat1, seat3, seat1]
+    end
+
+    it "returns seats in order" do
+      seat1.stub(:alive?).and_return(true)
+      seat2.stub(:alive?).and_return(true)
+      seat3.stub(:alive?).and_return(true)
+
+      engine.stub(:seats).and_return([seat1, seat2, seat3])
+      returned_seats = []
+      3.times { returned_seats << engine.next_seat }
+      returned_seats.should == [seat1, seat2, seat3]
+    end
+  end
+
+  describe "#roll_dice" do
+    context "randomness" do
+      before do
+        # Roll the dice a bunch of times and capture the result in a hash
+        # keyed by die face_value
+        engine.stub(:alive_seats).and_return([seat])
+        seat.stub(:dice_left).and_return(6000)
+        rolled_dice = []
+        seat.stub(:dice=) { |val| rolled_dice = val }
+        engine.roll_dice
+        @histogram = Hash.new(0)
+        rolled_dice.each{|die| @histogram[die] += 1 }
+      end
+
+      it "chooses valid face_values" do
+        @histogram.keys.sort.should == [1,2,3,4,5,6]
+      end
+
+      it "randomly distributes face_values" do
+        6.times do |i|
+          @histogram[i+1].should > 800
+          @histogram[i+1].should < 1200
+        end
+      end
+    end
+
+    it "only rolls dice for seats that are alive" do
+      s1 = Seat.new(0, {}, 5)
+      s1.stub(:alive?).and_return(false)
+      s2 = Seat.new(1, {}, 5)
+      s2.stub(:alive?).and_return(true)
+      engine.stub(:seats).and_return([s1, s2])
+      s1.should_not_receive(:dice=)
+      s2.should_receive(:dice=)
+      engine.roll_dice
+    end
+
+    it "rolls the correct number of dice for each seat" do
+      s1 = Seat.new(0, {}, 5)
+      s1.stub(:dice_left).and_return(3)
+      s1.stub(:dice=) { |val| val.count.should == 3 }
+      s2 = Seat.new(1, {}, 5)
+      s2.stub(:dice_left).and_return(5)
+      s2.stub(:dice=) { |val| val.count.should == 5 }
+
+      engine.stub(:alive_seats).and_return([s1, s2])
+      engine.roll_dice
+    end
+
+    it "notifies after rolling" do
+      engine.should_receive(:notify_roll)
+      engine.stub(:alive_seats).and_return([])
+      engine.roll_dice
+    end
+  end
+
+  describe "#valid_bid?" do
+    before do
+      engine.stub(:previous_bid).and_return(nil)
+    end
+
+    context "when given a BS object" do
+      it "calls valid_bs?" do
+        engine.should_receive(:valid_bs?)
+        engine.valid_bid?(BS.new)
+      end
+
+      it "returns the result of valid_bs?" do
+        engine.stub(:valid_bs?).and_return("foobar")
+        engine.valid_bid?(BS.new).should == "foobar"
+      end
+    end
+
+    it "returns false if total is negative" do
+      bid = Bid.new(-1, 5)
+      engine.valid_bid?(bid).should == false
+    end
+
+    it "returns false for invalid die face_values" do
+      bid = Bid.new(5, 0)
+      engine.valid_bid?(bid).should == false
+      bid = Bid.new(5, 10)
+      engine.valid_bid?(bid).should == false
+    end
+
+    context "with a previous bid" do
+      before do
+        @prev = Bid.new(3, 3)
+        engine.stub(:previous_bid).and_return(@prev)
+      end
+
+      it "validates all the possible bids correctly" do
+        [[-1, -1, false],
+         [-1, 0, false],
+         [-1, 1, false],
+[-1, -1, false],
+         [-1, 0, false],
+         [-1, 1, false],
+         [-1, -1, false],
+         [-1, 0, false],
+         [-1, 1, false]].each do |total_delta, face_value_delta, result|
+          bid = Bid.new(@prev.total + total_delta, @prev.face_value + face_value_delta)
+          engine.valid_bid?(bid).should == result
+        end
+      end
+    end
+  end
+
+  describe "#valid_bs?" do
+    it "returns true if there's a previous bid" do
+      prev = Bid.new(3, 3)
+      engine.stub(:previous_bid).and_return(prev)
+      engine.valid_bs?(BS.new).should == true
+    end
+
+    it "returns false if there's not a previous bid" do
+      engine.stub(:previous_bid).and_return(nil)
+      engine.valid_bs?(BS.new).should == false
+    end
+  end
+
+  describe "#alive_seats" do
+    it "doesn't return any seats that aren't alive" do
+      s1 = Seat.new(0, nil, 6)
+      s2 = Seat.new(0, nil, 6)
+      s1.stub(:alive?).and_return(true)
+      s2.stub(:alive?).and_return(false)
+      engine.stub(:seats).and_return([s1, s2])
+      engine.alive_seats.should == [s1]
+    end
+  end
+
+  describe "notify_bid" do
+    it "passes a BidMadeEvent to notify_players" do
+      engine.should_receive(:notify_players).with(an_instance_of(BidMadeEvent))
+      engine.notify_bid(seat, nil)
+    end
+
+    it "passes a BidMadeEvent to notify_watcher" do
+      engine.should_receive(:notify_watcher).with(an_instance_of(BidMadeEvent))
+      engine.notify_bid(seat, nil)
+    end
+  end
+
+  describe "notify_bs" do
+    it "passes a BSCalledEvent to notify_players" do
+      engine.stub(:previous_bid).and_return(nil)
+      engine.should_receive(:notify_players).with(an_instance_of(BSCalledEvent))
+      engine.notify_bs(seat)
+    end
+
+    it "passes a BSCalledEvent to notify_watcher" do
+      engine.stub(:previous_bid).and_return(nil)
+      engine.should_receive(:notify_watcher).with(an_instance_of(BSCalledEvent))
+      engine.notify_bs(seat)
+    end
+  end
+
+  describe "notify_loser" do
+    it "passes a LoserEvent to notify_players" do
+      engine.should_receive(:notify_players).with(an_instance_of(LoserEvent))
+      engine.stub(:seats).and_return([])
+      engine.notify_loser(seat)
+    end
+
+    it "passes a LoserEvent to notify_watcher" do
+      engine.should_receive(:notify_watcher).with(an_instance_of(LoserEvent))
+      engine.stub(:seats).and_return([])
+      engine.notify_loser(seat)
+    end
+  end
+
+  describe "notify_winner" do
+    it "passes a WinnerEvent to notify_players" do
+      engine.should_receive(:notify_players).with(an_instance_of(WinnerEvent))
+      engine.stub(:winner).and_return(seat)
+      engine.notify_winner
+    end
+
+    it "passes a WinnerEvent to notify_watcher" do
+      engine.should_receive(:notify_watcher).with(an_instance_of(WinnerEvent))
+      engine.stub(:winner).and_return(seat)
+      engine.notify_winner
+    end
+  end
+
+  describe "notify_players" do
+    let (:player1) { {} }
+    let (:player2) { {} }
+    let (:player3) { {} }
+    let (:watcher) { {} }
+
+    before do
+      player1.stub(:handle_event)
+      player2.stub(:handle_event)
+      player3.stub(:handle_event)
+
+      s1 = Seat.new(0, player1, 5)
+      s2 = Seat.new(0, player2, 5)
+      s3 = Seat.new(0, player3, 5)
+      engine.stub(:seats).and_return([s1, s2, s3])
+      engine.stub(:watcher).and_return(watcher)
+    end
+
+    it "passes the event to all players" do
+      event = WinnerEvent.new(seat)
+      player1.should_receive(:handle_event).with(event)
+      player2.should_receive(:handle_event).with(event)
+      player3.should_receive(:handle_event).with(event)
+
+      engine.notify_players(event)
+    end
+
+    it "does not pass the event to the watcher" do
+      event = WinnerEvent.new(seat)
+      watcher.should_not_receive(:handle_event).with(event)
+
+      engine.notify_players(event)
+    end
+  end
+
+  describe "notify_watcher" do
+    let (:player1) { {} }
+    let (:player2) { {} }
+    let (:player3) { {} }
+    let (:watcher) { {} }
+
+    before do
+      watcher.stub(:handle_event)
+
+      s1 = Seat.new(0, player1, 5)
+      s2 = Seat.new(0, player2, 5)
+      s3 = Seat.new(0, player3, 5)
+      engine.stub(:seats).and_return([s1, s2, s3])
+      engine.stub(:watcher).and_return(watcher)
+    end
+
+    it "does not pass the event to any player" do
+      event = WinnerEvent.new(seat)
+      player1.should_not_receive(:handle_event).with(event)
+      player2.should_not_receive(:handle_event).with(event)
+      player3.should_not_receive(:handle_event).with(event)
+
+      engine.notify_watcher(event)
+    end
+
+    it "passes the event to the watcher" do
+      event = WinnerEvent.new(seat)
+      watcher.should_receive(:handle_event).with(event)
+
+      engine.notify_watcher(event)
+    end
+  end
+end

data/spec/seat_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Seat" do
+  let (:player) { {} }
+  let (:seat) { Seat.new(0, player, 5) }
+
+  before do
+    player.stub(:dice=)
+  end
+
+  describe "#alive?" do
+    it "returns true when there are dice left" do
+      seat.stub(:dice_left).and_return(4)
+      seat.should be_alive
+    end
+
+    it "returns false when there are no dice left" do
+      seat.stub(:dice_left).and_return(0)
+      seat.should_not be_alive
+    end
+  end
+
+  describe "#dice=" do
+    it "passes the dice to the player" do
+      player.should_receive(:dice=).with([1, 2, 3])
+      seat.dice = [1,2,3]
+    end
+
+    it "remembers the dice" do
+      seat.dice = [4, 5, 6]
+      seat.dice.should == [4, 5, 6]
+    end
+  end
+
+  describe "#lose_die" do
+    it "adjusts the dice_left count" do
+      count = seat.dice_left
+      seat.lose_die
+      seat.dice_left.should == (count - 1)
+    end
+  end
+end
+
+
+
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+gem 'rspec'
+require 'ostruct'
+
+require 'liars_dice'
+
+include LiarsDice
+
+RSpec.configure do |c|
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: liars_dice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ben Schmeckpeper
+- Chris Doyle
+- Max Page
+- Molly Struve
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-28 00:00:00.000000000Z
+dependencies: []
+description: A liar's dice botting environment, developed by Aisle50
+email: dev@aisle50.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/liars_dice.rb
+- lib/liars_dice/bid.rb
+- lib/liars_dice/command_line_watcher.rb
+- lib/liars_dice/engine.rb
+- lib/liars_dice/event.rb
+- lib/liars_dice/human_bot.rb
+- lib/liars_dice/random_bot.rb
+- lib/liars_dice/seat.rb
+- lib/liars_dice/watcher.rb
+- spec/bid_spec.rb
+- spec/engine_spec.rb
+- spec/seat_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Liar's Dice game
+test_files:
+- spec/bid_spec.rb
+- spec/engine_spec.rb
+- spec/seat_spec.rb
+- spec/spec_helper.rb