bridge 0.1.4 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ca2211c5c71ea895f0b08a0935c1cde3bd1484f
+  data.tar.gz: 5b26a6b5e274921f8998f6a4a53534552fe7d339
+SHA512:
+  metadata.gz: e362c05b670256d1775688b1ddef92cdce322d9f5f1fd16d1fb4be30739570ac4845ce8ade56fccfee0876eaedf65a3e6d72b3f34a09ac265a37b8bb047df2eb
+  data.tar.gz: a892d881741108bc8ec4e71b729c36fec846b826bb5121a7718df76bcdb469b7cb63f00b92817d32ee0788d5d1c27e011e2267ccd553d00e5afe06440a6ba2fa

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+notifications:
+  disabled: true
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -1,4 +1,3 @@
-source :rubygems
+source "https://rubygems.org"
 
-gem "rake"
-gem "test-unit", ">=2", :require => "test/unit"
+gemspec

data/README.md

@@ -0,0 +1,56 @@
+# bridge
+
+Contract bridge utils.
+
+## Bid
+
+## Card
+
+## Deal
+
+## Trick
+
+## Score
+
+You can create Score object passing 3 arguments:
+```
+Bridge::Score.new("6NTXN", "BOTH", "=")
+```
+
+Arguments:
+
+* contract -- String, where first sign is level, second suit (C D H S NT), optional double or redouble (X or XX) and declarer at the end
+* vulnerable -- String, ["NONE", "EW", "NS", "BOTH"]
+* tricks -- Integer or String, when Integer is passed it's number of tricks taken by declarer side, String can be relative to contract level i.e. "+1", "-2", "="
+
+Methods:
+
+* Score#made? -- Boolean
+* Score#result -- Integer, relative to contract level i.e. -1 (one down), 1 (overtrick), 0 (contract made)
+* Score#result_string -- String, relative to contract level i.e "+1", "=", "-3"
+* Score#points -- Integer, calculated full value
+
+You can also ask for all possible contracts finished with given points:
+```
+Bridge::Score.with_points(980)
+#=> ["1NTX+4v", "2C/DX+4v", "6H/S="]
+```
+
+## Points
+
+### Chicago
+
+You can calculate how many IMP points you won by:
+```
+Bridge::Points::Chicago.new(:hcp => 25, :points => 420, :vulnerable => false).imps
+```
+
+Arguments:
+
+* :hcp -- Integer (range between 20 and 40), which means how many honour card points has side
+* :vulnerable -- Boolean, side with given hcp is vulnerable?
+* :points -- Integer, the result at the end of board (can be calculated by Bridge::Score)
+
+## Copyright
+
+Copyright (c) 2010 Jakub Kuźma. See LICENSE for details.

data/Rakefile

@@ -1,11 +1,10 @@
-require "bundler"
-Bundler::GemHelper.install_tasks
-Bundler.setup
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
 
 require "rake/testtask"
 Rake::TestTask.new(:test) do |test|
   test.libs << "lib" << "test"
-  test.pattern = "test/**/test_*.rb"
+  test.pattern = "test/**/*_test.rb"
   test.verbose = true
 end
 

data/bridge.gemspec

@@ -1,23 +1,24 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+# 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 |s|
-  s.name        = "bridge"
-  s.version     = Bridge::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.summary     = "Contract bridge utilities"
-  s.description = "Useful contract bridge utilities - deal generator, id to deal and deal to id conversion"
-  s.email       = "qoobaa+github@gmail.com"
-  s.homepage    = "http://github.com/qoobaa/bridge"
-  s.authors     = ["Jakub Kuźma", "Wojciech Wnętrzak"]
+Gem::Specification.new do |spec|
+  spec.name        = "bridge"
+  spec.version     = Bridge::VERSION
+  spec.summary     = "Contract bridge utilities"
+  spec.description = "Useful contract bridge utilities - deal generator, id to deal and deal to id conversion"
+  spec.email       = "qoobaa+github@gmail.com"
+  spec.homepage    = "https://github.com/qoobaa/bridge"
+  spec.authors     = ["Jakub Kuźma", "Wojciech Wnętrzak"]
+  spec.license     = "MIT"
 
-  s.required_rubygems_version = ">= 1.3.6"
-  s.rubyforge_project         = "bridge"
+  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.required_ruby_version = ">= 1.9.3"
 
-  s.add_development_dependency "bundler", ">= 1.0.0"
-
-  s.files        = `git ls-files`.split("\n")
-  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
-  s.require_path = 'lib'
+  spec.add_development_dependency "bundler", ">= 1.3"
+  spec.add_development_dependency "rake"
 end

data/lib/bridge.rb

@@ -1,7 +1,9 @@
+require "bridge/constants"
 require "bridge/bid"
 require "bridge/card"
-require "bridge/constants"
+require "bridge/auction"
 require "bridge/deal"
+require "bridge/play"
 require "bridge/points"
 require "bridge/points/chicago"
 require "bridge/points/duplicate"

data/lib/bridge/auction.rb

@@ -0,0 +1,77 @@
+module Bridge
+  class Auction
+    attr_reader :dealer, :bids
+
+    def initialize(dealer, bids)
+      raise ArgumentError, "invalid direction: #{dealer}" unless Bridge.direction?(dealer)
+      @dealer = dealer
+      @bids = bids.map { |bid| Bid.new(bid.to_s) }
+    end
+
+    def finished?
+      bids.length > 3 && bids[-3..-1].all?(&:pass?)
+    end
+
+    def contract
+      if last_contract_index
+        modifier = bids[last_contract_index..-1].select(&:modifier?).last
+        bids[last_contract_index].to_s + modifier.to_s + declarer
+      end
+    end
+
+    def bid_allowed?(bid)
+      bid = Bid.new(bid.to_s)
+      return false if finished?
+      case
+      when bid.pass?     then true
+      when bid.contract? then contract_allowed?(bid)
+      when bid.double?   then double_allowed?
+      when bid.redouble? then redouble_allowed?
+      end
+    end
+
+    def declarer
+      direction = dealer
+      last_contract_index.times { direction = Bridge.next_direction(direction) }
+      direction
+    end
+
+    def directions
+      @directions ||= begin
+        return [] if bids.none?
+        directions = [dealer]
+        (bids.count - 1).times { directions << Bridge.next_direction(directions.last) }
+        directions
+      end
+    end
+
+    def next_direction
+      @next_direction ||= directions.none? ? dealer : Bridge.next_direction(directions.last)
+    end
+
+    private
+
+    def last_contract_index
+      return @last_contract_index if defined?(@last_contract_index)
+      @last_contract_index = bids.rindex(&:contract?)
+    end
+
+    def contract_allowed?(bid)
+      last_contract_index ? bids[last_contract_index] < bid : true
+    end
+
+    def double_allowed?
+      return false unless last_contract_index
+      after_contract_bids = bids[(last_contract_index + 1)..-1]
+      after_contract_bids.all?(&:pass?) && !after_contract_bids.one?
+    end
+
+    def redouble_allowed?
+      return false unless last_contract_index
+      return false unless last_double_index = bids.rindex(&:double?)
+      return false if last_double_index < last_contract_index
+      after_double_bids = bids[(last_double_index + 1)..-1]
+      after_double_bids.all?(&:pass?) && !after_double_bids.one?
+    end
+  end
+end

data/lib/bridge/bid.rb

@@ -12,7 +12,7 @@ module Bridge
 
     # Returns the level of the bid
     def level
-      bid[0..0] if contract?
+      bid[0] if contract?
     end
 
     # Returns the suit of the bid

data/lib/bridge/card.rb

@@ -12,12 +12,12 @@ module Bridge
 
     # Returns the suit of the card
     def suit
-      card[0..0]
+      card[0]
     end
 
     # Returns the suit of the card
     def value
-      card[1..1]
+      card[1]
     end
 
     # Returns the honour card points

data/lib/bridge/constants.rb

@@ -50,33 +50,51 @@ module Bridge
   # All possible vullnerabilites
   VULNERABILITIES = ["NONE", SIDES, "BOTH"].flatten
 
+  # Matches 2S, 7NT, 1C
+  BID_REGEXP = Regexp.new %q{(?<bid>([1-7])([CDHS]|NT))}
+
+  # Matches X, XX
+  MODIFIER_REGEXP = Regexp.new %q{(?<modifier>(X{1,2}))}
+
+  # Matches X, XX
+  DIRECTION_REGEXP = Regexp.new %q{(?<direction>([NESW]))}
+
+  # Matches =, -12, +4
+  RESULT_REGEXP = Regexp.new %q{(?<result>(=|\+[1-6]|-\d{1,2}))}
+
+  # Matches 7NTXE, 1SXXS
+  CONTRACT_REGEXP = Regexp.new %Q{(?<contract>#{BID_REGEXP}#{MODIFIER_REGEXP}?#{DIRECTION_REGEXP})}
+
+  # Matches 1SE=, 7NTXXS-2
+  SCORE_REGEXP = Regexp.new %Q{(?<score>#{CONTRACT_REGEXP}#{RESULT_REGEXP})}
+
   module Points
     IMPS =
       {
-        0..10      => 0,
-        20..40     => 1,
-        50..80     => 2,
-        90..120    => 3,
-        130..160   => 4,
-        170..210   => 5,
-        220..260   => 6,
-        270..310   => 7,
-        320..360   => 8,
-        370..420   => 9,
-        430..490   => 10,
-        500..590   => 11,
-        600..740   => 12,
-        750..890   => 13,
-        900..1090  => 14,
-        1100..1290 => 15,
-        1300..1490 => 16,
-        1500..1740 => 17,
-        1750..1990 => 18,
-        2000..2240 => 19,
-        2250..2490 => 20,
-        2500..2990 => 21,
-        3000..3490 => 22,
-        3500..3990 => 23,
+        0..10       => 0,
+        20..40      => 1,
+        50..80      => 2,
+        90..120     => 3,
+        130..160    => 4,
+        170..210    => 5,
+        220..260    => 6,
+        270..310    => 7,
+        320..360    => 8,
+        370..420    => 9,
+        430..490    => 10,
+        500..590    => 11,
+        600..740    => 12,
+        750..890    => 13,
+        900..1090   => 14,
+        1100..1290  => 15,
+        1300..1490  => 16,
+        1500..1740  => 17,
+        1750..1990  => 18,
+        2000..2240  => 19,
+        2250..2490  => 20,
+        2500..2990  => 21,
+        3000..3490  => 22,
+        3500..3990  => 23,
         4000..15200 => 24
       }
     class Chicago

data/lib/bridge/deal.rb

@@ -1,5 +1,4 @@
 module Bridge
-
   # Class representing bridge deal
   class Deal
     include Comparable
@@ -112,8 +111,7 @@ module Bridge
 
     # Returns hash with hands
     def to_hash
-      # use map to be 1.8.6 compatible
-      { "N" => n.map{ |c| c.to_s }, "E" => e.map{ |c| c.to_s }, "S" => s.map{ |c| c.to_s }, "W" => w.map{ |c| c.to_s } }
+      {"N" => n.map(&:to_s), "E" => e.map(&:to_s), "S" => s.map(&:to_s), "W" => w.map(&:to_s)}
     end
 
     def inspect
@@ -121,9 +119,8 @@ module Bridge
     end
 
     def honour_card_points(side = nil)
-      hash = DIRECTIONS.inject({}) do |h, direction|
+      hash = DIRECTIONS.each_with_object({}) do |direction, h|
         h[direction] = self[direction].inject(0) { |sum, card| sum += card.honour_card_points }
-        h
       end
       if side
         side.to_s.upcase.split("").inject(0) { |sum, direction| sum += hash[direction] }
@@ -141,20 +138,18 @@ module Bridge
     end
 
     def sort_by_color(trump = nil)
-      DIRECTIONS.inject({}) do |sorted, direction|
+      DIRECTIONS.each_with_object({}) do |direction, sorted|
         splitted_colors = cards_for(direction)
-        splitted_colors.reject! { |trump, cards| cards.empty? }
+        splitted_colors.reject! { |color, cards| cards.empty? }
         sorted_colors = sort_colors(splitted_colors.keys, trump)
         sorted[direction] = sorted_colors.map { |color| splitted_colors.delete(color) }.flatten
-        sorted
       end
     end
 
     def cards_for(direction)
-      TRUMPS.inject({}) do |colors, trump|
+      TRUMPS.each_with_object({}) do |trump, colors|
         cards = self[direction].select { |card| card.suit == trump }
         colors[trump] = cards
-        colors
       end
     end
 

data/lib/bridge/play.rb

@@ -0,0 +1,80 @@
+module Bridge
+  class Play
+    attr_reader :deal_id, :contract, :cards
+
+    def initialize(deal_id, contract, cards)
+      @deal_id = deal_id
+      @contract = contract
+      @cards = cards.map { |card| Card.new(card.to_s) }
+    end
+
+    def finished?
+      cards.length == 52
+    end
+
+    def declarer
+      contract[-1] if contract
+    end
+
+    def dummy
+      Bridge.partner_of(declarer) if contract
+    end
+
+    def left_hand_opponent
+      Bridge.next_direction(declarer) if contract
+    end
+    alias :lho :left_hand_opponent
+
+    def right_hand_opponent
+      Bridge.partner_of(left_hand_opponent) if contract
+    end
+    alias :rho :right_hand_opponent
+
+    def trump
+      contract[1] if Bridge.trump?(contract[1])
+    end
+
+    def card_allowed?(card)
+      card = Card.new(card.to_s)
+      case
+      when !contract, cards.include?(card), !deal[next_direction].include?(card) then false
+      when tricks.none?, tricks.last.complete? then true
+      else (deal[next_direction] - cards).map(&:suit).uniq.include?(last_lead.suit) ? card.suit == last_lead.suit : true
+      end
+    end
+
+    def directions
+      @directions ||= tricks.map { |trick| trick.cards }.flatten.map { |card| deal.owner(card) }
+    end
+
+    def next_direction
+      case
+      when tricks.none? then Bridge.next_direction(declarer)
+      when tricks.last.complete? then deal.owner(tricks.last.winner(trump))
+      else Bridge.next_direction(directions.last)
+      end
+    end
+
+    def declarer_tricks_number
+      tricks.map { |trick| deal.owner(trick.winner(trump)) }.count { |direction| [declarer, dummy].include?(direction) }
+    end
+
+    def deal
+      @deal ||= Deal.from_id(deal_id)
+    end
+
+    def tricks
+      @tricks ||= begin
+        tricks = []
+        cards.each_slice(4) { |trick| tricks << Trick.new(*trick) }
+        tricks
+      end
+    end
+
+    private
+
+    def last_lead
+      @last_lead ||= tricks.last.cards.first
+    end
+  end
+end