leonardo-bridge 0.4.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWRjMmJjOGYwNTVlZmU3OGQ3ZDVkNTlhODg5NWVmOWZhMjllMGE3MA==
+  data.tar.gz: !binary |-
+    OGI1YTBkY2QwZjI0NjcwMDIyMzYxMDE1NzQzZDRkOTYzYTdmYTU5Ng==
+SHA512:
+  metadata.gz: !binary |-
+    OGRmMDkzZjMzNGVjYjMxY2E4OTFlNTBjNzMwMzY1YmRhYjU0ZDQ3YTFmZTE2
+    ZDNjOWMzYzA0ZWY0NjY5MDM0NWZmODllZjM0NmU5NzEwZGI3MjhjMjBkYWQy
+    YmZhYjdmZWQ0NzdhZmZkNjlhMGM3MTE4MzZmM2FiOTk2YWQ2MmE=
+  data.tar.gz: !binary |-
+    OGY2OGRiOGIzYTJkMzg5MGZhNzcxODdjMWRhMGQwYmU5NTYyMWVkYTU3NjIz
+    MjhlNDU5NjRiZTk5ZjcyNzA1YzE5ODZiZjcwN2RjMTEzYmM1MDEwM2YwZmMz
+    NjgzNjM3MzcyNTU2OGVmY2Y3OGI1NjQzMjRlODE2MjFjZGE5MjI=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.rvmrc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bridge.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Achilles Charmpilas
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Bridge
+
+A lean mean bridge playing machine.
+Large portions of this gem have been ported from [pybridge](http://sourceforge.net/projects/pybridge/)
+
+Bridge is the bridge playing engine sitting behind the Leonardo Bridge API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    #!ruby
+    gem 'bridge'
+
+And then execute:
+    
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bridge
+
+## Usage
+
+You can have a look at `bin/play` for an example of interaction with the Bridge::Game class.
+
+Here's a quick run-through:
+
+    #!ruby
+    require 'rubygems'  
+    require 'bridge'
+    include Bridge
+    
+    game = Game.new # start game
+    players = [] # keep players somewhere handy
+    Direction.each { |d| players[d] << game.add_player(d) }
+    # you're ready to start playing
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/leo-console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+libs = ['-rubygems']
+libs << '-r irb/completion'
+libs << '-r pp'
+libs << '-r ./lib/bridge'
+libs << '-r ./bridge.rc.rb'
+exec "irb #{libs.join(' ')}"

data/bin/leo-play

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+require './lib/bridge'
+
+[:INT, :TERM].each do |sig|
+  trap(sig) { 
+    puts clear_line
+    puts 'Shutting down, bye!'.yellow
+    exit
+  }
+end
+
+def cursor
+  '> '
+end
+
+def put string, prompt = '> '
+  puts cursor + string
+end
+
+def put_contract c
+  if c
+    #puts c.inspect.red
+    print "#{Direction.name(c.declarer)} won auction with ".yellow
+    print "#{Level.name(c.bid.level)} #{Strain.name(c.bid.strain)}".yellow 
+    print "double by #{Direction.name(c.double_by)}".yellow unless c.double_by.nil?
+    print "redouble by #{Direction.name(c.redouble_by)}".yellow unless c.redouble_by.nil?
+    puts ""
+  end
+end
+
+include Bridge
+@history = []
+@game = Game.new
+@players = []
+Direction.each do |position|
+  @players[position] = @game.add_player(position)
+end
+@game.start!(Board.first)
+
+puts clear_screen
+puts 'Started game on first board'.green
+puts "\t#{Direction.name(@game.board.dealer)} deals".white
+puts "\t#{Vulnerability.name(@game.board.vulnerability)} is vulnerable".white
+
+
+print "#{Direction.name(@game.get_turn).to_s.upcase}> " if @game.in_progress?
+
+def rush_auction
+  @players[@game.get_turn].make_call(Call.from_string('bid two club'))
+  @players[@game.get_turn].make_call(Pass.new)
+  @players[@game.get_turn].make_call(Pass.new)
+  @players[@game.get_turn].make_call(Pass.new)
+  
+  put_contract @game.auction.contract
+end
+
+def rush_trick
+  @players[@game.get_turn].play_card(@players[@game.get_turn].get_hand.sample)
+  
+  3.times do
+    if @game.get_turn == @game.play.dummy
+      player = @players[@game.play.declarer]
+      hand = @players[@game.play.dummy].get_hand
+    else
+      player = @players[@game.get_turn]
+      hand = @players[@game.get_turn].get_hand
+    end
+    
+    begin
+      player.play_card(hand.sample)
+    rescue Bridge::GameError => e
+      puts e.message.red
+      retry
+    end
+    
+  end
+end
+
+while cmd = gets.strip
+  case cmd
+  when 'bye','exit','leave'
+    break
+  when 'rush trick' # play an automatic trick
+    rush_auction unless @game.auction.complete?
+    rush_trick
+  when 'rush auction' # play a canned auction
+    rush_auction
+  when 'history'
+    put 'Move history:'.yellow
+    put @history.join("\n")
+    
+  when 'hand'
+    put @game.get_hand(@game.get_turn).inspect.white
+    print cursor
+    
+  else
+    ary = cmd.split
+    if @game.in_progress?
+      position_i = @game.get_turn
+      position = Direction.name(position_i)
+      @history << [position, ary.join(' ')]
+      
+      if @game.auction.complete?
+        card = nil
+        
+        begin
+          if ary.size == 2 # overriding player
+            position = ary.first
+            position_i = Direction.send(position.to_sym)
+            card = Card.from_string(ary.last)
+          else
+            card = Card.from_string(ary.first)
+          end
+          
+          @players[position_i].play_card(card)
+          print "#{position.white} plays #{card.to_s.magenta} ~> "
+          puts @game.play.get_current_trick.cards.compact.inspect.white
+        rescue Exception => e
+          put e.message.red
+        end
+      else
+        begin
+          @players[position_i].make_call(Call.from_string(ary.join(' ')))
+          put "#{position.white} calls #{ary.join(' ').green}"
+        rescue Exception => e
+          put e.message.red
+        end
+      
+        if @game.auction.passed_out?
+          put 'Auction phase complete, @game passed out'.red
+          exit
+        elsif @game.auction.complete?
+          put 'Auction phase complete'.yellow
+          put_contract @game.auction.contract
+        end
+      end
+    end # if @game.in_progress?
+  end
+  
+  print "#{Direction.name(@game.get_turn).to_s.upcase}> " if @game.in_progress?
+end
+
+puts 'Shutting down, bye!'.yellow

data/bridge.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bridge/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "leonardo-bridge"
+  spec.version       = Bridge::VERSION
+  spec.authors       = ["Achilles Charmpilas"]
+  spec.email         = ["ac@humbuckercode.co.uk"]
+  spec.description   = %q{A lean mean bridge playing machine}
+  spec.summary       = %q{Encapsulates all the necessary logic that allows 4 players to play a bridge game. Also supports rubber scoring.}
+  spec.homepage      = "http://bridge.leonardogames.net/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "redis"
+  spec.add_dependency "nutrun-string"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "fuubar"
+  spec.add_development_dependency "geminabox"
+  spec.add_development_dependency "gem-release"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+end

data/bridge.rc.rb

@@ -0,0 +1,11 @@
+IRB.conf[:PROMPT][:CUSTOM] = {
+  :PROMPT_I => "Bridge >> ",
+  :PROMPT_S => "%l>> ",
+  :PROMPT_C => ">>",
+  :PROMPT_N => ">>",
+  :RETURN => "=> %s\n"
+}
+IRB.conf[:PROMPT_MODE] = :CUSTOM
+IRB.conf[:AUTO_INDENT] = true
+include Bridge
+puts ">> I am Bridge Console".white.bg_black

data/lib/bridge.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'ostruct'
+require 'pathname'
+require 'nutrun-string'
+
+root = File.dirname(__FILE__)
+
+%W{ uuid redis_model enum }.each { |r| require File.join(root,r) }
+
+module Bridge
+  DEBUG = false
+  
+  module Direction 
+    extend Enum
+    set_values :north, :east, :south, :west
+  end
+  
+  module Vulnerability
+    extend Enum
+    set_values :none, :north_south, :east_west, :all
+  end
+  
+  def root
+    File.dirname(__FILE__)
+  end
+  
+  def assert_card card
+    raise CardError, "Card #{card.inspect} is not valid" unless card.is_a?(Card)
+  end
+  
+  module_function :assert_card
+  public :assert_card
+end
+
+Dir[File.join(root,'bridge','*.rb')].each { |r| require r }

data/lib/bridge/auction.rb

@@ -0,0 +1,182 @@
+module Bridge
+  class DuplicateCallError < StandardError; end
+  class InvalidCallError < StandardError; end
+  class InvalidCallClassError < StandardError; end
+  
+  # The auction (bidding phase) of a game of bridge.
+  # Swiped from: https://pybridge.svn.sourceforge.net/svnroot/pybridge/trunk/pybridge/pybridge/games/bridge/auction.py
+  class Auction
+    attr_accessor :dealer, :calls, :contract
+  
+    # @param dealer: who distributes the cards and makes the first call.
+    # @type dealer: Direction
+    def initialize dealer
+      self.dealer = dealer
+      self.contract = nil
+      self.calls = []
+    end
+  
+    # Auction is complete if all players have called (ie. 4 or more calls)
+    # and the last 3 calls are Pass calls.
+    # @return: True if bidding is complete, False if not.
+    # @rtype: bool
+    def complete?
+      passes = self.calls.last(3).select { |c| c.is_a?(Pass) }.size
+      self.calls.size >= 4 and passes == 3
+    end
+  
+    # Auction is passed out if each player has passed on their first turn.
+    # In this case, the bidding is complete, but no contract is established.
+    # @return: True if bidding is passed out, False if not.
+    # @rtype: bool
+    def passed_out?
+      passes = calls.select { |c| c.is_a?(Pass) }.size
+      self.calls.size == 4 and passes == 4
+    end
+    
+    # When the bidding is complete, the contract is the last and highest
+    # bid, which may be doubled or redoubled.
+    # Hence, the contract represents the "final state" of the bidding.
+    # @return: a dict containing the keywords:
+    # @keyword bid: the last and highest bid.
+    # @keyword declarer: the partner who first bid the contract strain.
+    # @keyword doubleBy: the opponent who doubled the contract, or None.
+    # @keyword redoubleBy: the partner who redoubled an opponent's double
+    # on the contract, or None.
+    def get_contract
+      if self.complete? and not self.passed_out?
+        bid = self.get_current_call(Bid)
+        double = self.get_current_call(Double)
+        redouble = self.get_current_call(Redouble)
+        declarer_bid = nil
+        # Determine partnership.
+        caller = self.who_called?(bid)
+        partnership = [caller, Direction[(caller + 2) % 4]]
+        # Determine declarer.
+        self.calls.each do |call|
+          if call.is_a?(Bid) and call.strain == bid.strain and partnership.include?(self.who_called?(call))
+            declarer_bid = call
+            break
+          end
+        end
+                  
+        {
+          :bid => bid,
+          :declarer => declarer_bid.nil? ? nil : self.who_called?(declarer_bid),
+          :double_by => double.nil? ? nil : self.who_called?(double),
+          :redouble_by => redouble.nil? ? nil : self.who_called?(redouble) 
+        }
+      else
+        nil  # Bidding passed out or not complete, no contract.
+      end
+    end
+    
+    # Appends call from position to the calls list.
+    # Please note that call validity should be checked with isValidCall()
+    # before calling this method!
+    # @param call: a candidate call.
+    def make_call call, player = nil
+      assert_call(call.class)
+      # Calls must be distinct.
+      raise InvalidCallError, "#{call.inspect} is invalid" unless self.valid_call?(call)
+
+      self.calls << call
+      if self.complete? and not self.passed_out?
+        self.contract = Contract.new(self)
+      end
+      true
+    end
+
+    # Check that call can be made, according to the rules of bidding.
+    # @param call: the candidate call.
+    # @param position: if specified, the position from which the call is made.
+    # @return: True if call is available, False if not.
+    def valid_call? call, position = nil
+      # The bidding must not be complete.
+      return false if complete?
+    
+      # Position's turn to play.
+      return false if position and position != whose_turn
+    
+      # A pass is always available.
+      return true if call.is_a?(Pass)
+    
+      # A bid must be greater than the current bid.
+      if call.is_a?(Bid)
+        return (!current_bid or call > current_bid)
+      end
+    
+      # Doubles and redoubles only when a bid has been made.
+      if current_bid
+        bidder = who_called?(current_bid)
+      
+        # A double must be made on the current bid from opponents,
+        # which has not been already doubled by partnership.
+        if call.is_a?(Double)
+          opposition = [Direction[(whose_turn + 1) % 4], Direction[(whose_turn + 3) % 4]]
+          return (opposition.include?(bidder) and !current_double)
+      
+        # A redouble must be made on the current bid from partnership,
+        # which has been doubled by an opponent.
+        elsif call.is_a?(Redouble)
+          partnership = [whose_turn, Direction[(whose_turn + 2) % 4]]
+          return (partnership.include?(bidder) and current_double and !current_redouble)
+        end
+      end
+    
+      false  # Otherwise unavailable.
+    end
+  
+    # Returns the position from which the specified call was made.
+    # @param call: a call made in the auction.
+    # @return: the position of the player who made call, or None.
+    def who_called? call
+      raise ArgumentError, "#{call.inspect} is not a call" unless call.is_a?(Call)
+      return nil unless calls.include?(call) # Call not made by any player.
+      Direction[(self.dealer + calls.find_index(call)) % 4]
+    end
+  
+    # Returns the position from which the next call should be made.
+    # @return: the next position to make a call, or None.
+    def whose_turn
+      return nil if complete?
+      return Direction[(self.dealer + calls.size) % 4]
+    end
+  
+    # Returns most recent current call of specified class, or None.
+    # @param callclass: call class, in (Bid, Pass, Double, Redouble).
+    # @return: most recent call matching type, or None.
+    def get_current_call callclass
+      assert_call(callclass)
+      
+      self.calls.reverse.each do |call|
+        if call.is_a?(callclass)
+          return call
+        elsif call.is_a?(Bid)
+          break  # Bids cancel all preceding calls.
+        end
+      end
+      nil
+    end
+    
+    def current_bid
+      get_current_call(Bid)
+    end
+    
+    def current_double
+      get_current_call(Double)
+    end
+    
+    def current_redouble
+      get_current_call(Redouble)
+    end
+    
+    def assert_call callclass
+      raise InvalidCallClassError unless [Bid, Pass, Double, Redouble].include?(callclass)
+    end
+    
+    def to_a
+      self.calls
+    end
+  end
+end