leonardo-bridge 0.4.3

data/lib/bridge/hand.rb

@@ -0,0 +1,25 @@
+module Bridge
+  class Hand
+    attr_accessor :cards, :played, :current
+  
+    def initialize
+      self.cards = []
+    end
+  
+    def method_missing(m, *args, &block)
+      if cards.respond_to?(m)
+        cards.send(m, *args, &block)
+      else
+        super
+      end
+    end
+  
+    def to_s
+      cards.to_s
+    end
+    
+    def to_json opts = {}
+      cards.to_json
+    end
+  end
+end

data/lib/bridge/leonardo_result.rb

@@ -0,0 +1,7 @@
+require Pathname.new(__FILE__).dirname.join('result')
+
+module Bridge
+  # custom leonardo bridge result logic
+  class LeonardoResult < DuplicateResult
+  end
+end

data/lib/bridge/player.rb

@@ -0,0 +1,49 @@
+module Bridge
+  # Actor representing a player's view of a BridgeGame object.
+  # ref: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/game.py
+  class Player < RedisModel
+    def initialize(game)
+      @game = game  # Access to game is private to this object.
+    end
+
+    def get_hand
+      position = game.players[self]
+      return game.get_hand(position)
+    end
+    alias :hand :get_hand
+
+    def make_call(call)
+      begin
+        return game.make_call(call, player = self)
+      rescue Exception => e
+        if Bridge::DEBUG
+          puts e.backtrace.first(8).join("\n").red
+          puts "\n"
+        end
+        raise GameError, e.message
+      end
+    end
+    
+    def play_card(card)
+      begin
+        return self.game.play_card(card, self)
+      rescue Exception => e
+        if Bridge::DEBUG
+          puts e.backtrace.first(8).join("\n").red
+          puts "\n"
+        end
+        raise GameError, e.message
+      end
+    end
+
+    def start_next_game
+      raise GameError, "Not ready to start game" unless game.next_game_ready?
+      game.start!
+    end
+    
+  protected
+    def game
+      @game
+    end
+  end
+end

data/lib/bridge/result.rb

@@ -0,0 +1,290 @@
+
+module Bridge
+# Represents the result of a completed round of bridge.
+# Swiped from: https://svn.code.sf.net/p/pybridge/code/trunk/pybridge/pybridge/games/bridge/result.py
+  class Result
+    VULN_MAP = {
+      Vulnerability.none => [],
+      Vulnerability.north_south => [Direction.north, Direction.south],
+      Vulnerability.east_west => [Direction.east, Direction.west],
+      Vulnerability.all => [
+        Direction.north, Direction.east,
+        Direction.west, Direction.south
+      ]
+    }
+    
+    def _get_score
+      raise NoMethodError  # Expected to be implemented by subclasses.
+    end
+
+    # @type board: Board
+    # @type contract: Contract
+    # @type tricks_made: int or None
+    attr_accessor :board, :contract, :tricks_made, :is_vulnerable, :score
+    attr_accessor :is_doubled, :is_redoubled, :is_vulnerable, :is_major,
+      :contract_level, :tricks_made, :tricks_required, :trump_suit, :claimed, :claimed_by
+    
+    def initialize(board, contract, tricks_made = nil, opts = {})
+      self.board = board
+      self.contract = contract
+      self.tricks_made = tricks_made
+      
+      # a claim has been made. Let's modify the trick count accordingly
+      if opts[:claim].is_a?(Array)
+        self.claimed_by = opts[:claim][0]
+        self.claimed = opts[:claim][1]
+        defender_tricks = opts[:claim][2]
+        if [self.contract[:declarer],(self.contract[:declarer] + 2) % 4].include?(claimed_by)
+          self.tricks_made += claimed # if declarer claimed, add claim to tally
+        else # if defender claimed, add what remains to tally
+          self.tricks_made = 13 - (defender_tricks + claimed)
+        end
+        self.tricks_made
+      end
+      
+      self.is_vulnerable = nil
+      if self.contract
+        vuln = self.board.vulnerability || Vulnerability.none
+        self.is_vulnerable = VULN_MAP[vuln].include?(self.contract[:declarer])
+      end
+      
+      self.score = self._get_score
+    end
+
+    # Compute the component values which contribute to the score.
+    # Note that particular scoring schemes may ignore some of the components.
+    # Scoring values: http://en.wikipedia.org/wiki/Bridge_scoring
+    # @return: a dict of component values.
+    # @rtype: dict
+    def _get_score_components
+      components = {}
+
+      self.is_doubled      = self.contract[:double_by] ? true : false
+      self.is_redoubled    = self.contract[:redouble_by] ? true : false
+      self.contract_level  = self.contract[:bid].level + 1
+      self.tricks_required = contract_level + 6
+      self.trump_suit      = self.contract[:bid].strain
+      self.is_major        = [Strain.spade, Strain.heart].include?(self.contract[:bid].strain)
+      
+      if tricks_made >= tricks_required  # Contract successful.
+        #### Contract tricks (bid and made) ####
+        if is_major || self.contract[:bid].strain == Strain.no_trump # Hearts, Spades and NT score 30 for each odd trick.
+          components['odd'] = contract_level * 30
+          if trump_suit == Strain.no_trump
+            components['odd'] += 10  # For NT, add a 10 point bonus.
+          end
+        else
+          components['odd'] = contract_level * 20
+        end
+        
+        if is_redoubled
+          components['odd'] *= 4  # Double the doubled score.
+        elsif is_doubled
+          components['odd'] *= 2  # Double score.
+        end
+
+
+        #### over_tricks ####
+        over_tricks = tricks_made - tricks_required
+        
+        if is_redoubled
+          # 400 for each overtrick if vulnerable, 200 if not.
+          if is_vulnerable
+            components['over'] = over_tricks * 400
+          else
+            components['over'] = over_tricks * 200
+          end
+        elsif is_doubled
+          # 200 for each overtrick if vulnerable, 100 if not.
+          if is_vulnerable
+            components['over'] = over_tricks * 200
+          else
+            components['over'] = over_tricks * 100
+          end
+        else  # Undoubled contract.
+          if is_major || self.contract[:bid].strain == Strain.no_trump
+            # Hearts, Spades and NT score 30 for each overtrick.
+            components['over'] = over_tricks * 30
+          else
+            # Clubs and Diamonds score 20 for each overtrick.
+            components['over'] = over_tricks * 20
+          end
+        end
+
+        #### Premium bonuses ####
+
+        if tricks_required == 13
+          # 1500 for grand slam if vulnerable, 1000 if not.
+          if is_vulnerable
+            components['slambonus'] = 1500
+          else
+            components['slambonus'] = 1000
+          end
+        elsif tricks_required == 12
+          # 750 for small slam if vulnerable, 500 if not.
+          if is_vulnerable
+            components['slambonus'] = 750
+          else
+            components['slambonus'] = 500
+          end
+        elsif components['odd'] >= 100 # Game contract (non-slam).
+          # 500 for game if vulnerable, 300 if not.
+          if is_vulnerable
+            components['gamebonus'] = 500
+          else
+            components['gamebonus'] = 300
+          end
+        else  # Non-game contract.
+          components['partscore'] = 50
+        end
+
+        #### Insult bonus ####
+        if is_redoubled
+          components['insultbonus'] = 100
+        elsif is_doubled
+          components['insultbonus'] = 50
+        end
+      else  # Contract not successful.
+        under_tricks = tricks_required - tricks_made
+        if is_redoubled
+          if is_vulnerable
+            # -400 for first, then -600 each.
+            components['under'] = -400 + (under_tricks - 1) * -600
+          else
+            # -200 for first, -400 for second and third, then -600 each.
+            components['under'] = -200 + (under_tricks - 1) * -400
+            if under_tricks > 3
+              components['under'] += (under_tricks - 3) * -200
+            end
+          end
+        elsif is_doubled
+          if is_vulnerable
+            # -200 for first, then -300 each.
+            components['under'] = -200 + (under_tricks - 1) * -300
+          else
+            # -100 for first, -200 for second and third, then -300 each.
+            components['under'] = -100 + (under_tricks - 1) * -200
+            if under_tricks > 3
+              components['under'] += (under_tricks - 3) * -100
+            end
+          end
+        else
+          if is_vulnerable
+            # -100 each.
+            components['under'] = under_tricks * -100
+          else
+            # -50 each.
+            components['under'] = under_tricks * -50
+          end
+        end
+      end
+      components
+    end
+    
+    def to_a
+      { 
+        score: _get_score,
+        tricks_made: tricks_made,
+        tricks_required: tricks_required,
+        contract_level: contract_level,
+        trump_suit: trump_suit,
+        vulnerable: is_vulnerable,
+        major: is_major,
+        doubled: is_doubled,
+        redoubled: is_redoubled,
+        claimed: claimed,
+        claimed_by: claimed_by
+      }
+    end
+  end
+
+
+#Represents the result of a completed round of duplicate bridge.
+  class DuplicateResult < Result
+    # Duplicate bridge scoring scheme.
+    # @return: score value: positive for declarer, negative for defenders.
+    def _get_score
+      score = 0
+      if self.contract and self.tricks_made
+        self._get_score_components.each do |key, value|
+          if ['odd', 'over', 'under', 'slambonus', 'gamebonus', 'partscore', 'insultbonus'].include?(key)
+            score += value
+          end
+        end
+      end
+      score
+    end
+  end
+  
+  # Represents the result of a completed round of rubber bridge.
+  class RubberResult < Result
+    # Rubber bridge scoring scheme.
+    # @return: 2-tuple of numeric scores (above the line, below the line): positive for
+    # declarer, negative for defenders.
+    def _get_score
+      above, below = 0, 0
+      if self.contract and self.tricks_made
+        self._get_score_components.items.each do |key, value|
+          # Note: gamebonus/partscore are not assigned in rubber bridge.
+          if ['over', 'under', 'slambonus', 'insultbonus'].include?(key)
+            above += value
+          elsif key == 'odd'
+            below += value
+          end
+        end
+      end
+      return [above, below]
+    end
+  end
+
+
+
+  # A rubber set, in which pairs compete to make two consecutive games.
+  # A game is made by accumulation of 100+ points from below-the-line scores
+  # without interruption from an opponent's game.
+  class Rubber < Array
+    attr_accessor :games, :winner
+
+    # Returns a list of completed (ie. won) 'games' in this rubber, in the
+    # order of their completion.
+        
+    # A game is represented as a list of consecutive results from this rubber,
+    # coupled with the identifier of the scoring pair.
+    def _get_games
+      games = []
+
+      thisgame = []
+      belowNS, belowEW = 0, 0  # Cumulative totals for results in this game.
+
+      self.each do |result|
+        thisgame << result
+        if [Direction.north, Direction.south].include?(result.contract.declarer)
+          belowNS += result.score[1]
+          if belowNS >= 100
+            games << [thisgame, [Direction.north, Direction.south]]
+          else
+            belowEW += result.score[1]
+            if belowEW >= 100
+              games << [thisgame, [Direction.east, Direction.west]]
+            end
+          end
+          # If either total for this game exceeds 100, proceed to next game.
+          if belowNS >= 100 or belowEW >= 100  
+            thisgame = []
+            belowNS, belowEW = 0, 0  # Reset accumulators.
+          end
+        end
+      end
+      return games
+    end
+    
+    # The rubber is won by the pair which have completed two games.
+    def _get_winner
+      pairs = self.games.map { |game, pair| pair }
+      [[Direction.north, Direction.south], [Direction.east, Direction.west]].each do |pair|
+        pair if pairs.count(pair) >= 2
+      end
+    end
+  end
+end
+          

data/lib/bridge/trick.rb

@@ -0,0 +1,28 @@
+module Bridge
+  class Trick
+    REQUIRED_CARDS = 4
+    attr_accessor :cards
+    attr_accessor :leader
+    def initialize(params = {})
+      params.map { |k,v| self.send(:"#{k}=",v) }
+      self.cards = [] if self.cards.nil?
+    end
+    
+    def done?
+      self.cards.compact.size >= REQUIRED_CARDS
+    end
+    
+    def leader_card
+      self.cards[self.leader]
+    end
+    
+    def method_missing(method, *args, &block)
+      begin
+        self.cards = self.cards.to_s.split(' ').map { |c| Card.from_string(c) } unless self.cards.class == Array
+        self.cards.send(method, *args, &block)
+      rescue Exception => e
+        super
+      end
+    end
+  end
+end

data/lib/bridge/trick_play.rb

@@ -0,0 +1,219 @@
+module Bridge
+  # This class models the trick-taking phase of a game of bridge.
+  # This code is generalised, and could easily be adapted to support a
+  # variety of trick-taking card games.
+  # Swiped from: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/auction.py
+  class TrickPlay
+    attr_accessor :trumps, :declarer, :dummy, :lho, :rho, :played, :winners, :history
+    
+    # TODO: tricks, leader, winner properties?
+    
+    # @param declarer: the declarer from the auction.
+    # @type declarer: Direction
+    # @param trump_suit: the trump suit from the auction.
+    # @type trump_suit: Suit or None      
+    def initialize(declarer, trump_suit)
+      raise TypeError, "Expected Direction, got #{declarer.inspect}" unless Direction[declarer]
+      raise TypeError, "Expected Suit, got #{trump_suit.inspect}" if !trump_suit.nil? and Suit[trump_suit].nil?
+      
+      self.trumps = trump_suit
+      self.declarer = declarer
+      self.dummy = Direction[(declarer + 2) % 4]
+      self.lho = Direction[(declarer + 1) % 4]
+      self.rho = Direction[(declarer + 3) % 4]
+      # Each trick corresponds to a cross-section of lists.
+      self.played = {}
+      self.history = []
+      Direction.each do |position|
+        self.played[position] = []
+      end
+      self.winners = []  # Winning player of each trick.
+    end
+    
+    # Playing is complete if there are 13 complete tricks.
+    # @return: True if playing is complete, False if not.
+    def complete?
+      self.winners.size == 13
+    end
+    
+    # A trick is a set of cards, one from each player's hand.
+    # The leader plays the first card, the others play in clockwise order.
+    # @param: trick index, in range 0 to 12.
+    # @return: a trick object.
+    def get_trick(index)
+      raise ArgumentError unless 0 <= index and index < 13
+      if index == 0  # First trick.
+        leader = self.lho  # Leader is declarer's left-hand opponent.
+      else  # Leader is winner of previous trick.
+        leader = self.winners[index - 1]
+      end
+      
+      cards = []
+      
+      Direction.each do |position|
+        # If length of list exceeds index value, player's card in trick.
+        if self.played[position].size > index
+          cards[position] = self.played[position][index]
+        end
+      end
+      
+      Trick.new(:leader => leader, :cards => cards)
+    end
+
+    # Returns the getTrick() tuple of the current trick.
+    # @return: a (leader, cards) trick tuple.
+    def get_current_trick
+      # Index of current trick is length of longest played list minus 1.
+      index = [0, (self.played.map { |dir,cards| cards.size }.max - 1)].max
+      self.get_trick(index)
+    end
+    
+    # Returns the number of tricks won by declarer/dummy and by defenders.
+    # @return: the declarer trick count, the defender trick count.
+    # @rtype: tuple
+    def get_trick_count
+      declarer_count, defender_count = 0, 0
+      
+      (0..self.winners.size-1).each do |i|
+        trick = self.get_trick(i)
+        winner = self.who_played?(self.winning_card(trick))
+        if [self.declarer, self.dummy].include?(winner)
+          declarer_count += 1
+        else
+          defender_count += 1
+        end
+      end
+      
+      [declarer_count, defender_count]
+    end
+    
+    def get_tricks
+      (0..self.winners.size-1).map do |i|
+        self.get_trick(i)
+      end
+    end
+
+    # Plays card to current trick.
+    # Card validity should be checked with isValidPlay() beforehand.
+    # @param card: the Card object to be played from player's hand.
+    # @param player: the player of card, or None.
+    # @param hand: the hand of player, or [].
+    def play_card(card, player=nil, hand=nil)
+      Bridge.assert_card(card)
+      
+      player = player || self.whose_turn
+      hand = hand || [card]  # Skip hand check.
+      
+      raise ArgumentError, 'Not valid play' unless self.valid_play?(card, player, hand)
+      self.played[player] << card
+      self.history << card
+      
+      # If trick is complete, determine winner.
+      trick = self.get_current_trick
+      if trick.cards.compact.size == 4
+        winner = self.who_played?(self.winning_card(trick))
+        self.winners << winner
+      end
+      return true
+    end
+
+    # Card is playable if and only if:
+    # - Play session is not complete.
+    # - Direction is on turn to play.
+    # - Card exists in hand.
+    # - Card has not been previously played.
+    # In addition, if the current trick has an established lead, then
+    # card must follow lead suit OR hand must be void in lead suit.
+    # Specification of player and hand are required for verification.
+    def valid_play?(card, player=nil, hand=[])
+      Bridge.assert_card(card)
+      
+      if self.complete?
+        return false
+      elsif hand and !hand.include?(card)
+        return false  # Playing a card not in hand.
+      elsif player and self.whose_turn != self.dummy and player != self.whose_turn
+        return false  # Playing out of turn.
+      elsif self.who_played?(card)
+        return false  # Card played previously.
+      end
+      trick = self.get_current_trick
+      # 0 if start of playing, 4 if complete trick.
+      if [0, 4].include?(trick.cards.compact.size)
+        return true # Card will be first in next trick.
+      else # Current trick has an established lead: check for revoke.
+        leadcard = trick.leader_card
+        # Cards in hand that match suit of leadcard.
+        followers = hand.select { |c| c.suit == leadcard.suit and !self.who_played?(c) }
+        # Hand void in lead suit or card follows lead suit.
+        return (followers.size == 0 or followers.include?(card))
+      end
+    end
+
+    # Returns the player who played the specified card.
+    # @param card: a Card.
+    # @return: the player who played card.
+    def who_played?(card)
+      Bridge.assert_card(card) unless card.nil?
+      self.played.each do |player,cards|
+        return player if cards.include?(card)
+      end
+      false
+    end
+
+    # If playing is not complete, returns the player who is next to play.
+    # @return: the player next to play.
+    def whose_turn
+      unless self.complete?
+        trick = self.get_current_trick
+        if trick.cards.compact.size == 4  # If trick is complete, trick winner's turn.
+          return self.who_played?(self.winning_card(trick))
+        else  # Otherwise, turn is next (clockwise) player in trick.
+          return Direction[(trick.leader + trick.cards.compact.size) % 4]
+        end
+      end
+      return false
+    end
+          
+    # Determine which card wins the specified trick:
+    # - In a trump contract, the highest ranked trump card wins.
+    # - Otherwise, the highest ranked card of the lead suit wins.
+    # @param: a complete (leader, cards) trick tuple.
+    # @return: the Card object which wins the trick.
+    def winning_card(trick)
+      if trick.cards.compact.size == 4  # Trick is complete.
+        if self.trumps  # Suit contract.
+          trumpcards = trick.cards.compact.select { |c| c.suit_i == self.trumps }
+          if trumpcards.size > 0 # Highest ranked trump.
+            return trumpcards.max 
+          else # we re in trump contract but play didn't have a trump.
+            followers = trick.cards.compact.select { |c| c.suit == trick.leader_card.suit }
+            return followers.max # Highest ranked card in lead suit.
+          end
+        else
+          # No Trump contract, or no trump cards played.
+          followers = trick.cards.compact.select { |c| c.suit == trick.leader_card.suit }
+          return followers.max # Highest ranked card in lead suit.
+        end
+      else
+        return false
+      end
+    end
+    
+    def to_a
+      trick_counts = self.get_trick_count
+      {
+        trumps: self.trumps,
+        declarer: self.declarer,
+        dummy: self.dummy,
+        lho: self.lho,
+        rho: self.rho,
+        played: self.played,
+        winners: self.winners,
+        declarer_trick_count: trick_counts.first,
+        defender_trick_count: trick_counts.last,
+        tricks: self.get_tricks
+      }
+    end
+  end
+end