leonardo-bridge 0.4.3

data/lib/bridge/board.rb

@@ -0,0 +1,84 @@
+module Bridge
+  # Swiped from https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/board.py
+  # An encapsulation of board information.
+  # @keyword deal: the cards in each hand.
+  # @type deal: Deal
+  # @keyword dealer: the position of the dealer.
+  # @type dealer: Direction
+  # @keyword event: the name of the event where the board was played.
+  # @type event: str
+  # @keyword num: the board number.
+  # @type num: int
+  # @keyword players: a mapping from positions to player names.
+  # @type players: dict
+  # @keyword site: the location (of the event) where the board was played.
+  # @type site: str
+  # @keyword time: the date/time when the board was generated.
+  # @type time: time.struct_time
+  # @keyword vuln: the board vulnerability.
+  # @type vuln: Vulnerable
+  class Board
+    attr_accessor :vulnerability, :players, :dealer, :deal, :number
+    attr_accessor :created_at
+    
+    def initialize opts = {}
+      opts = {
+        :deal => Deal.new,
+        :number => 1,
+        :dealer => Direction.north,
+        :vulnerability => Vulnerability.none
+      }.merge(opts)
+      
+      opts.map { |k,v| self.send(:"#{k}=",v) if self.respond_to?(k) }
+      self.created_at = Time.now
+    end
+    
+    # Builds and returns a successor board to this board.
+    # The dealer and vulnerability of the successor board are determined from
+    # the board number, according to the rotation scheme for duplicate bridge.
+    # @param deal: if provided, the deal to be wrapped by next board.
+    # Otherwise, a randomly-generated deal is wrapped.
+    def self.first deal = nil
+      self.new(
+        :deal => deal || Deal.new,
+        :number => 1,
+        :dealer => Direction.north,
+        :vulnerability => Vulnerability.none
+      )
+    end
+
+    # Builds and returns a successor board to this board.
+    # The dealer and vulnerability of the successor board are determined from
+    # the board number, according to the rotation scheme for duplicate bridge.
+    # @param deal: if provided, the deal to be wrapped by next board.
+    # Otherwise, a randomly-generated deal is wrapped.
+    def next deal = nil
+      board = Board.new
+      board.deal = deal || Deal.new
+      board.number = self.number + 1
+      board.created_at = Time.now
+
+      # Dealer rotates clockwise.
+      board.dealer = Direction.next(self.dealer)
+
+      # Map from duplicate board index range 1..16 to vulnerability.
+      # See http://www.d21acbl.com/References/Laws/node5.html#law2
+      i = (board.number - 1) % 16
+      board.vulnerability = Vulnerability[(i%4 + i/4)%4]
+
+      return board
+    end
+    
+    def to_json(opts = {})
+      h = {}
+      [:vulnerability, :players, :dealer, :deal, :number, :created_at].each do |a|
+        h[a] = send(a)
+      end
+      h.to_json
+    end
+    
+    def copy
+      self.clone
+    end
+  end
+end

data/lib/bridge/call.rb

@@ -0,0 +1,98 @@
+# ref: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/call.py
+module Bridge
+  module Level
+    extend Enum
+    set_values :one, :two, :three, :four, :five, :six, :seven
+  end
+  
+  module Suit
+    extend Enum
+    set_values :club, :diamond, :heart, :spade
+  end
+  
+  module Rank
+    extend Enum
+    set_values :two, :three, :four, :five, :six, :seven, :eight, :nine, :ten, :jack, :queen, :king, :ace
+  end
+  
+  module Strain
+    extend Enum
+    set_values :club, :diamond, :heart, :spade, :no_trump
+  end
+  
+  class CallError < StandardError; end
+  
+  # Abstract class, inherited by Bid, Pass, Double and Redouble.
+  class Call
+    def self.from_string string
+      string ||= ''
+      call = nil
+      case string.downcase
+      when 'p','pass'
+        call = Pass.new
+      when 'd', 'double'
+        call = Double.new
+      when 'r', 'redouble'
+        call = Redouble.new
+      when /^bi?d? [a-z]{3,5} [a-z\s\_]{4,8}$/i
+        bid = string.split
+        bid.shift # get rid of 'bid'
+        level = bid.shift
+        strain = bid.join('_')
+        call = Bid.new(level,strain)
+      end
+      raise CallError.new, "'#{string}' is not a call" if call.nil?
+      call
+    end
+    
+    def self.all
+      calls = Strain.all.map { |s| Level.all.map { |l| Bid.new(l,s) } }.flatten
+      calls << Double.new
+      calls << Redouble.new
+      calls << Pass.new
+      calls
+    end
+    
+    def to_s
+      self.class.to_s.downcase.gsub('bridge::','')
+    end
+  end
+
+  # A Bid represents a statement of a level and a strain.
+  # @param level: the level of the bid.
+  # @type level: L{Level}
+  # @param strain: the strain (denomination) of the bid.
+  # @type strain: L{Strain}
+  class Bid < Call
+    attr_accessor :level, :strain
+    
+    def initialize(level, strain)
+      self.level  = level.is_a?(Integer)  ? level : Level.send(level.to_sym)
+      self.strain = strain.is_a?(Integer) ? strain : Strain.send(strain.to_sym)
+    end
+    
+    include Comparable
+    def <=>(other)
+      if other.is_a?(Bid) # Compare two bids.
+        s_size = Strain.values.size
+        # puts "#{self.level*s_size + self.strain} <=> #{other.level*s_size + other.strain}"
+        (self.level*s_size + self.strain) <=> (other.level*s_size + other.strain)
+      else # Comparing non-bid calls returns true.
+        1
+      end
+    end
+    
+    def to_s
+      "#{Level.name(level)} #{Strain.name(strain)}"
+    end
+  end
+
+  # A Pass represents an abstention from the bidding.
+  class Pass < Call; end
+
+  # A Double over an opponent's current bid.
+  class Double < Call; end
+  
+  # A Redouble over an opponent's double of partnership's current bid.
+  class Redouble < Call; end
+end

data/lib/bridge/card.rb

@@ -0,0 +1,54 @@
+module Bridge
+  class CardError < ArgumentError; end
+  
+  class Card
+    include Comparable
+    
+    RANKS = %w(2 3 4 5 6 7 8 9 10 J Q K A)
+    SUITS = %w(C D H S)
+    
+    def initialize(rank, suit)
+      raise CardError.new "'#{rank}' is not a card rank" unless RANKS.include?(rank)
+      raise CardError.new "'#{suit}' is not a card suit" unless SUITS.include?(suit)
+      @rank = rank
+      @suit = suit
+    end
+    attr_reader :rank, :suit
+    
+    def <=>(other)
+      # this ordering sorts first by rank, then by suit
+      (Card::SUITS.find_index(self.suit) <=> Card::SUITS.find_index(other.suit)).nonzero? or
+        (Card::RANKS.find_index(self.rank) <=> Card::RANKS.find_index(other.rank))
+    end
+ 
+    def to_s
+      @rank + @suit
+    end
+  
+    def honour
+      case rank
+      when 'J'
+        1
+      when 'Q'
+        2
+      when 'K'
+        3
+      when 'A'
+        4
+      else
+        0
+      end
+    end
+    
+    def suit_i
+      SUITS.index(suit)
+    end
+    
+    def self.from_string string
+      raise CardError.new, "'#{string}' is not a card" if string.size < 2
+      suit = string[string.size-1]
+      rank = string.chop
+      new(rank.upcase, suit.upcase)
+    end
+  end
+end

data/lib/bridge/contract.rb

@@ -0,0 +1,51 @@
+module Bridge
+  class InvalidAuctionError < StandardError; end
+  
+  # Represents the result of an auction.
+  # Swiped from: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/auction.py
+  class Contract
+    attr_accessor :redouble_by, :double_by, :bid, :declarer
+    
+    # @param auction: a completed, but not passed out, auction.
+    # @type auction: Auction
+    def initialize auction
+      raise InvalidAuctionError unless auction.complete? and !auction.passed_out?
+      # The contract is the last (and highest) bid.
+      self.bid = auction.current_bid
+      
+      # The declarer is the first partner to bid the contract denomination.
+      caller = auction.who_called?(self.bid)
+      partnership = [caller, Direction[(caller + 2) % 4]]
+      # Determine which partner is declarer.
+      auction.calls.each do |call|
+        if call.is_a?(Bid) and call.strain == self.bid.strain
+          bidder = auction.who_called?(call)
+          if partnership.include?(bidder)
+            self.declarer = bidder
+            break
+          end
+        end
+      end
+
+      self.double_by, self.redouble_by = [nil, nil]
+      
+      if auction.current_double
+        # The opponent who doubled the contract bid.
+        self.double_by = auction.who_called?(auction.current_double)
+        if auction.current_redouble
+          # The partner who redoubled an opponent's double.
+          self.redouble_by = auction.who_called?(auction.current_redouble)
+        end
+      end
+    end
+    
+    def to_hash
+      {
+        :bid => bid,
+        :declarer => declarer,
+        :double_by => double_by,
+        :redouble_by => redouble_by
+      }
+    end
+  end
+end

data/lib/bridge/db.rb

@@ -0,0 +1,27 @@
+require 'redis'
+
+
+module Bridge
+  class DB < Redis
+    # retrieves all values in a given namespace
+    # e.g. server:name, server:port and server:location all belong in the server namespace
+    def namespace ns
+      ns_keys = keys("#{ns.to_s}:*")
+      ns_keys = ns_keys.inject({}) { |h,k| h.update(k => type(k)) }
+      pipelined do
+        ns_keys.each do |key,type|
+          case type
+          when 'hash'
+            hgetall(key)
+          else
+            get(key)
+          end
+        end
+      end
+    end
+    
+    def open_tables
+      lrange('opentables',0,llen('opentables')).map(&:to_i)
+    end
+  end
+end

data/lib/bridge/deal.rb

@@ -0,0 +1,33 @@
+module Bridge
+  # deal, not game
+  # bidding create the contract
+  # bidding is also persistent
+  # bidding finishes after 3 passes
+  
+  class Deal
+    attr_accessor :hands, :deck
+  
+    def initialize
+      @hands = []
+      @deck = Deck.new
+      Direction.values.each do |dir|
+        @hands[Direction.send(dir)] = Hand.new
+      end
+      deal!
+      self
+    end
+  
+    # deals one card per hand on a cycle until we run out of cards
+    def deal!
+      hands.cycle(deck.size/hands.size) { |hand| hand << deck.shift }
+    end
+    
+    def method_missing(m, *args, &block)
+      if hands.respond_to?(m)
+        hands.send(m, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/bridge/deck.rb

@@ -0,0 +1,22 @@
+module Bridge
+  class Deck
+    attr_accessor :cards
+  
+    def initialize
+      @cards = Card::RANKS.product(Card::SUITS).map { |a| Card.new(a[0],a[1]) }
+      @cards.shuffle!
+    end
+  
+    def inspect
+      cards.inspect
+    end
+  
+    def method_missing(method, *args, &block)
+      begin
+        @cards.send(method, *args, &block)
+      rescue Exception => e
+        super
+      end
+    end
+  end
+end

data/lib/bridge/game.rb

@@ -0,0 +1,372 @@
+#require File.join(File.dirname(__FILE__),'result')
+
+module Bridge
+  # Raised by game in response to an unsatisfiable or erroneous request.
+  # ref: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/network/error.py
+  class GameError < StandardError
+  end
+
+  # A bridge game sequences the auction and trick play.
+  # The methods of this class comprise the interface of a state machine.
+  # Clients should only use the class methods to interact with the game state.
+  # Modifications to the state are typically made through BridgePlayer objects.
+  # Methods which change the game state (make_call, playCard) require a player
+  # argument as "authentication".
+  class Game < RedisModel
+    use_timestamps
+    
+    attr_accessor :auction, :play, :players, :options, :number
+    attr_accessor :board, :board_queue, :results, :visible_hands
+    attr_accessor :trump_suit, :result, :contract, :state
+    attr_accessor :rubbers, :rubber_mode, :leonardo_mode
+    
+    def initialize opts = {}
+      # Valid @positions (for Table).
+      @positions = Direction.values
+
+      # Mapping from Strain symbols (in auction) to Suit symbols (in play).
+      @trump_map = {
+        Strain.club => Suit.club, 
+        Strain.diamond => Suit.diamond,
+        Strain.heart => Suit.heart, 
+        Strain.spade => Suit.spade,
+        Strain.no_trump => nil
+      }
+      
+      opts = {
+        :auction => nil, 
+        :play => nil,
+        :players => {}, # One-to-one mapping from BridgePlayer to Direction
+        :options => {},
+        :board => nil, 
+        :board_queue => [], # Boards for successive rounds.
+        :results => [], # Results of previous rounds.
+        :visible_hands => {}, # A subset of deal, containing revealed hands.
+        :state => :new, 
+        :rubber_mode => false
+      }.merge(opts)
+      
+      opts.map { |k,v| self.send(:"#{k}=",v) if self.respond_to?(k) }
+      
+      if self.rubber_mode  # Use rubber scoring?
+        self.rubbers = []  # Group results into Rubber objects.
+      end
+      
+      self.contract = self.auction.nil? ? nil : self.auction.contract
+      trump_suit = self.play.nil? ? nil : self.play.trump_suit
+      result = self.in_progress? ? nil : self.results.last
+    end
+
+    # Implementation of ICardGame.
+    # ref: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/interfaces/game.py
+    def start! board = nil
+      raise GameError, "Game in progress" if self.in_progress?
+
+      if board  # Use specified board.
+        self.board = board
+      elsif !self.board_queue.empty?  # Use pre-specified board.
+        self.board = self.board_queue.pop
+      elsif self.board  # Advance to next round.
+        self.board = self.board.next
+      else  # Create an initial board.
+        self.board = Board.first
+      end
+      
+      if self.rubber_mode
+        # Vulnerability determined by number of games won by each pair.
+        if self.rubbers.size == 0 or self.rubbers.last.winner
+          self.board.vulnerability = Vulnerability.none  # First round, new rubber.
+        else
+          pairs = self.rubbers.last.games.map { |game, pair| pair }
+          
+          if pairs.count([Direction.north, Direction.south]) > 0
+            if pairs.count([Direction.east, Direction.west]) > 0
+              self.board.vulnerability = Vulnerability.all
+            else
+              self.board.vulnerability = Vulnerability.north_south
+            end
+          else
+            if pairs.count([Direction.east, Direction.west]) > 0
+              self.board.vulnerability = Vulnerability.east_west
+            else
+              self.board.vulnerability = Vulnerability.none
+            end
+          end
+        end # if self.rubbers.size == 0 or self.rubbers[-1].winner
+      end # if self.rubber_mode
+      self.auction = Auction.new(self.board.dealer)  # Start auction.
+      self.play = nil
+      self.visible_hands.clear
+
+      # Remove deal from board, so it does not appear to clients.
+      visible_board = self.board.copy
+      visible_board.deal = self.visible_hands
+      
+      self.state = :auction
+      true
+    end
+
+
+    def in_progress?
+      if !self.play.nil?
+        !self.play.complete?
+      elsif !self.auction.nil?
+        !self.auction.passed_out?
+      else
+        false
+      end
+    end
+
+    def next_game_ready?
+      !self.in_progress? and self.players.size == 4
+    end
+
+    def get_state
+      state = {}
+      
+      state[:options] = self.options
+      state[:results] = self.results
+      state[:state] = self.state
+      state[:contract] = self.contract
+      state[:calls] = Call.all
+      state[:available_calls] = []
+      begin
+        state[:turn] = self.get_turn
+      rescue Exception => e
+        state[:turn] = nil
+      end
+      
+      if self.in_progress?
+        if state[:state] == :auction
+          state[:available_calls] = Call.all.select { |c| self.auction.valid_call?(c) }.compact
+        end
+        # Remove hidden hands from deal.
+        visible_board = self.board.copy
+        visible_board.deal = self.visible_hands
+        state[:board] = visible_board
+      end
+      
+      state[:auction] = self.auction.to_a unless self.auction.nil?
+      state[:play] = self.play.to_a unless self.play.nil?
+      
+      state
+    end
+
+    def add_player(position)
+      raise TypeError, "Expected valid Direction, got #{position}" unless Direction[position]
+      raise GameError, "Position #{position} is taken" if self.players.values.include?(position)
+      
+      player = Player.new(self)
+      self.players[player] = position
+
+      return player
+    end
+
+    def remove_player(position)
+      raise TypeError, "Expected valid Direction, got #{position}" unless Direction[position]
+      raise GameError, "Position #{position} is vacant" unless self.players.values.include?(position)
+      
+      self.players.reject! { |player,pos| pos == position }
+    end
+
+
+    # Bridge-specific methods.
+  
+    # Make a call in the current auction.
+    # This method expects to receive either a player argument or a position.
+    # If both are given, the position argument is disregarded.
+    # @param call: a Call object.
+    # @type call: Bid or Pass or Double or Redouble
+    # @param player: if specified, a player object.
+    # @type player: BridgePlayer or nil
+    # @param position: if specified, the position of the player making call.
+    # @type position: Direction or nil
+    def make_call(call, player=nil, position=nil)
+      raise TypeError, "Expected Call, got #{call}" unless [Bid, Pass, Double, Redouble].include?(call.class)
+        
+      if player
+        raise GameError, "Player unknown to this game" unless self.players.include?(player)
+        position = self.players[player]
+      end
+      
+      raise TypeError, "Expected Direction, got #{position.class}" if position.nil? or Direction[position].nil?
+      
+      # Validate call according to game state.
+      raise GameError, "No game in progress" if self.auction.nil?
+      raise GameError, "Auction complete" if self.auction.complete?
+      raise GameError, "Call made out of turn" if self.get_turn != position
+      raise GameError, "Call cannot be made" unless self.auction.valid_call?(call, position)
+
+      self.auction.make_call(call)
+      
+      if self.auction.complete? and !self.auction.passed_out?
+        self.state = :playing
+        self.contract = self.auction.get_contract
+        trump_suit = @trump_map[self.contract[:bid].strain]
+        self.play = TrickPlay.new(self.contract[:declarer], trump_suit)
+      elsif self.auction.passed_out?
+        self.state = :finished
+      end
+      
+      # If bidding is passed out, game is complete.
+      self._add_result(self.board, contract=nil) if not self.in_progress? and self.board.deal
+
+      if !self.in_progress? and self.board.deal
+        # Reveal all unrevealed hands.
+        Direction.each do |position|
+          hand = self.board.deal.hands[position]
+          self.reveal_hand(hand, position) if hand and !self.visible_hands.include?(position)
+        end
+      end
+    end
+    
+    def signal_alert(alert, position)
+      pass  # TODO
+    end
+
+    # Play a card in the current play session.
+    # This method expects to receive either a player argument or a position.
+    # If both are given, the position argument is disregarded.
+    # If position is specified, it must be that of the player of the card:
+    # declarer plays cards from dummy's hand when it is dummy's turn.
+    # @param card: a Card object.
+    # @type card: Card
+    # @param player: if specified, a player object.
+    # @type player: BridgePlayer or nil
+    # @param position: if specified, the position of the player of the card.
+    # @type position: Direction or nil
+    def play_card(card, player=nil, position=nil)
+      Bridge.assert_card(card)
+        
+      if player
+        raise GameError, "Invalid player reference" unless self.players.include?(player)
+        position = self.players[player]
+      end
+      
+      raise TypeError, "Expected Direction, got #{position}" unless Direction[position]
+      raise GameError, "No game in progress, or play complete" if self.play.nil? or self.play.complete?
+
+      playfrom = position
+
+      # Declarer controls dummy's turn.
+      if self.get_turn == self.play.dummy
+        if self.play.declarer == position
+          playfrom = self.play.dummy  # Declarer can play from dummy.
+        elsif self.play.dummy == position
+          raise GameError, "Dummy cannot play hand"
+        end
+      end
+      
+      raise GameError, "Card played out of turn" if self.get_turn != playfrom
+      
+      hand = self.board.deal[playfrom] || []
+      # If complete deal known, validate card play.
+      if self.board.deal.size == Direction.size
+        unless self.play.valid_play?(card, position, hand)
+          raise GameError, "Card #{card} cannot be played from hand"
+        end
+      end
+      
+      self.play.play_card(card)
+      hand.delete(card)
+      
+      # Dummy's hand is revealed when the first card of first trick is played.
+      if self.play.get_trick(0).cards.compact.size == 1
+        dummyhand = self.board.deal[self.play.dummy]
+        # Reveal hand only if known.
+        self.reveal_hand(dummyhand, self.play.dummy) if dummyhand
+      end
+
+      # If play is complete, game is complete.
+      if !self.in_progress? and self.board.deal
+        self.state = :finished
+        tricks_made, _ = self.play.get_trick_count
+        self._add_result(self.board, self.contract, tricks_made)
+      end
+
+      if !self.in_progress? and self.board.deal
+        # Reveal all unrevealed hands.
+        Direction.each do |position|
+          hand = self.board.deal[position]
+          if hand and !self.visible_hands.include?(position)
+            self.reveal_hand(hand, position)
+          end
+        end
+      end
+      
+      true
+    end
+    
+    def _add_result(board, contract=nil, tricks_made=nil, opts = {})
+      if self.rubber_mode
+        result = RubberResult.new(board, contract, tricks_made, opts)
+        if self.rubbers.size > 0 and self.rubbers[-1].winner.nil?
+          rubber = self.rubbers[-1]
+        else   # Instantiate new rubber.
+          rubber = Rubber()
+          self.rubbers << rubber
+          rubber << result
+        end
+      elsif self.leonardo_mode
+        result = LeonardoResult.new(board, contract, tricks_made, opts)
+      else
+        result = DuplicateResult.new(board, contract, tricks_made, opts)
+      end
+      
+      self.results << result
+    end
+    
+    # Reveal hand to all observers.
+    # @param hand: a hand of Card objects.
+    # @type hand: list
+    # @param position: the position of the hand.
+    # @type position: Direction
+    def reveal_hand(hand, position)
+      raise TypeError, "Expected Direction, got #{position}" unless Direction[position]
+      
+      self.visible_hands[position] = hand
+      # Add hand to board only if it was previously unknown.
+      self.board.deal.hands[position] = hand unless self.board.deal.hands[position]
+    end
+
+    # If specified hand is visible, returns the list of cards in hand.
+    # @param position: the position of the requested hand.
+    # @type position: Direction
+    # @return: the hand of player at position.
+    def get_hand(position)
+      raise TypeError, "Expected Direction, got #{position}" unless Direction[position]
+
+      if self.board and self.board.deal.hands[position]
+        self.board.deal.hands[position]
+      else
+        raise GameError, "Hand unknown"
+      end
+    end
+
+    def get_turn
+      if self.in_progress?
+        if self.auction.complete?  # In trick play.
+          self.play.whose_turn
+        else  # Currently in the auction.
+          self.auction.whose_turn
+        end
+      else  # Not in game.
+        raise GameError, "No game in progress"
+      end
+    end
+    
+    def claim direction, tricks
+      if self.in_progress?
+        if self.auction.complete?  # In trick play.
+          self.state = :finished
+          declarer_tricks, defender_tricks = self.play.get_trick_count
+          _add_result(self.board, self.contract, declarer_tricks, claim: [direction, tricks, defender_tricks])
+        else  # Currently in the auction.
+          raise GameError, "Cannot claim during auction"
+        end
+      else  # Not in game.
+        raise GameError, "No game in progress"
+      end
+    end
+  end
+end