rbcalc 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWRlMjgwYzBkM2U3NTQyOTNjNWI2YWNmZTM5ODc1ZjhhMjUxZjMyMA==
+  data.tar.gz: !binary |-
+    Y2EyZGZhZDIxYmZkOWMzMmQ2MzZkMWM0ZDNhM2VlNWUyMGM4YjQ4ZA==
+SHA512:
+  metadata.gz: !binary |-
+    YjJiYmJhYWE0YzM0YmZkNzQxOTFhYTM0ODVmN2U5MWE4YjVhNzIzOTExNTZm
+    YTZjMTRlODU1NjBiNWZhZWVjMjUyOTM3NGZjMjkxM2E3ZTZmODM4ZWU5YzRl
+    YzUxZmFmMWZmYWJiMTJmZTg4NDY0NGIxZTBhNTVjY2E3YWJjMDE=
+  data.tar.gz: !binary |-
+    ZTc3YjAzZjRkM2QzZmU3NDJkY2QxMTRiOWYyYjc3ODBiZWUzNDcwZGExYTkz
+    MWY2YWEwYTdiNDU0NTdiMmY0NWM5MTQwYTA2NTE4NWIyMGYyN2NiMjg0MDY0
+    ZWNlOWMzMGFhYzAzOWU3NjZlOGU3ZTNlZWFhZjViZTcxZGY2OTg=

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Achilles Charmpilas
+
+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,17 @@
+# Rbcalc
+
+Ruby bindings for Piotr Beling's [Bridge Calculator](http://bcalc.w8.pl/)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rbcalc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rbcalc

data/Rakefile

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

data/lib/rbcalc.rb

@@ -0,0 +1,57 @@
+require 'rbconfig'
+require 'pathname'
+require 'fileutils'
+
+module Rbcalc
+  def self.os
+    @os ||= (
+      host_os = RbConfig::CONFIG['host_os']
+      case host_os
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        :windows
+      when /darwin|mac os/
+        :macosx
+      when /linux/
+        :linux
+      when /solaris|bsd/
+        :unix
+      else
+        raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+      end
+    )
+  end
+  
+  def self.home
+    Pathname.new(__FILE__).dirname
+  end
+  
+  def self.init!
+    vpath = self.home.join('..','vendor','bcalc')
+    incpath = Pathname('/usr/local/include')
+    libpath = Pathname('/usr/local/lib')
+    # prepare library for linking
+    case Rbcalc.os
+    when :macosx
+      unless File.exists?(libpath.join('libbcalcdds.dylib'))
+        FileUtils.ln_s(vpath.join('libbcalcdds.dylib'),libpath.join('libbcalcdds.dylib')) 
+      end
+      unless File.exists?(incpath.join('bcalcdds.h'))
+        FileUtils.ln_s(vpath.join('bcalcdds.h'),incpath.join('bcalcdds.h')) 
+      end
+    when :linux
+      unless File.exists?(libpath.join('libbcalcdds.so'))
+        FileUtils.ln_s(vpath.join('libbcalcdds.so'),libpath.join('libbcalcdds.so')) 
+      end
+      unless File.exists?(incpath.join('bcalcdds.h'))
+        FileUtils.ln_s(vpath.join('bcalcdds.h'),incpath.join('bcalcdds.h')) 
+      end
+    else
+      raise Error::WebDriverError, "Rbcalc cannot currently run on #{Rbcalc.os}"
+    end
+  end
+end
+
+Rbcalc.init!
+
+require "rbcalc/version"
+require "rbcalc/engine"

data/lib/rbcalc/engine.rb

@@ -0,0 +1,42 @@
+require 'inline'
+require 'pathname'
+
+=begin rdoc
+  require 'rbcalc'
+  e = Rbcalc::Engine.new(
+    hands: 'S2579H38AD458QC26,S4H24569TJQKD9CJK,S36TQH7D23TKC379Q,SAKJ8HDAJ76CAT854',
+    played: 'e', leader: 0, trump_suit: 2
+  )
+=end
+module Rbcalc
+  class Engine
+    attr_accessor :hands, :leader, :trump_suit, :played, :tricks_made
+    
+    def initialize params = {}
+      params.map { |k,v| self.send(:"#{k}=",v) }
+    end
+    
+    def parse!
+      if hands.nil? || hands.empty? || leader.nil? || trump_suit.nil?
+        raise ArgumentError, 'Rbcalc needs at least the hands, dealer direction and trump suit'
+      end
+      
+      self.tricks_made = solve(hands, "#{played.to_s} e", trump_suit, leader)
+    end
+    
+    inline do |b|
+      b.add_compile_flags "-l bcalcdds"
+      b.include '<stdio.h>'
+      b.include '<bcalcdds.h>'
+      b.c %{int solve(const char * hands, const char * played, int strain, int leader){
+        int res;
+        BCalcDDS* solver = bcalcDDS_new("LIN", hands, strain, leader);
+        if (solver == 0) exit(1); //out of memory error
+        bcalcDDS_exec(solver, played);
+        res = bcalcDDS_getTricksToTake(solver);
+        bcalcDDS_delete(solver);
+        return res;
+      }}
+    end
+  end
+end

data/lib/rbcalc/version.rb

@@ -0,0 +1,3 @@
+module Rbcalc
+  VERSION = "0.1.0"
+end

data/rbcalc.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rbcalc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbcalc"
+  spec.version       = Rbcalc::VERSION
+  spec.authors       = ["Achilles Charmpilas"]
+  spec.email         = ["ac@humbuckercode.co.uk"]
+  spec.description   = %q{Ruby bindings for Piotr Beling's Bridge Calculator}
+  spec.summary       = %q{Ruby bindings for Piotr Beling's Bridge Calculator}
+  spec.homepage      = ""
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_dependency "RubyInline", "~> 3.12"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "fuubar"
+end

data/spec/rbcalc_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Rbcalc do
+  it 'can detect os' do # my dev machine
+    Rbcalc.os.should eq(:macosx)
+  end
+end
+
+describe Rbcalc::Engine do
+  it 'raises error is an invalid parse is requested' do
+    expect { subject.parse! }.to raise_error
+    subject.hands = 'S2579H38AD458QC26,S4H24569TJQKD9CJK,S36TQH7D23TKC379Q,SAKJ8HDAJ76CAT854'
+    expect { subject.parse! }.to raise_error
+    subject.leader = 0
+    expect { subject.parse! }.to raise_error
+    subject.trump_suit = 2
+    expect { subject.parse! }.to_not raise_error
+  end
+  
+  context 'with valid game' do
+    subject { 
+      Rbcalc::Engine.new(
+        hands: 'S2579H38AD458QC26,S4H24569TJQKD9CJK,S36TQH7D23TKC379Q,SAKJ8HDAJ76CAT854',
+        leader: 0, trump_suit: 2
+      )
+    }
+    
+    it 'solves a game' do
+      subject.parse!
+      t1 = subject.tricks_made
+      subject.tricks_made.should be_a(Integer)
+    
+      # if we swap leaders, tricks should be inversed
+      subject.leader = 1
+      subject.parse!
+      (t1 + subject.tricks_made).should eq(13)
+    
+      subject.leader = 0
+      subject.trump_suit = 2
+      subject.parse!
+      t1 = subject.tricks_made
+      subject.tricks_made.should be_a(Integer)
+    
+      subject.leader = 1
+      subject.parse!
+      (t1 + subject.tricks_made).should eq(13)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rbcalc'
+root = File.dirname(__FILE__)
+
+#Dir[File.join(root,'support', '**','*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.mock_with :rspec
+  config.order = "random"
+end

data/vendor/bcalc/bcalcdds.h

@@ -0,0 +1,307 @@
+#ifndef __BELING__BCALC_BRIDGE_SOLVER__
+#define __BELING__BCALC_BRIDGE_SOLVER__
+
+/** @file
+ * Bridge Calculator API header file.
+ */
+
+/*! \mainpage Bridge Calculator (C API)
+
+\section about About
+This is documentation for C API (and library) for Bridge Calculator engine, a fast double dummy solver.
+
+Bridge Calculator and its C API are develop by Piotr Beling.
+More information can be found on a program web-page: http://bcalc.w8.pl/
+
+\section license License
+Bridge Calculator (and its C API) is freeware for private and non-commercial use (use to develop freeware applications)
+and it's distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+Each distributed product which use this API/library should includes readable for end-user information about this fact
+and link to Bridge Calculator web-page: http://bcalc.w8.pl/
+
+If you need license to develop commercial (payment) application, please contact with me: qwak82@gmail.com
+
+\section example Example
+@code
+//create solver
+BCalcDDS* solver = bcalcDDS_new("PBN", "N:.63.AKQ987.A9732 A8654.KQ5.T.QJT6 J973.J98742.3.K4 KQT2.AT.J6542.85", BCALC_NT, BCALC_PLAYER_NORTH);
+if (solver != 0) exit(1);	//out of memory error
+//use it, print player to play, and how many tricks his line can take:
+printf("%c playes, and he with partner will be able to take %d tricks.\n",
+	bcalc_playerSymbol(bcalcDDS_getPlayerToPlay(solver)),
+	bcalcDDS_getTricksToTake(solver)
+);
+bcalcDDS_exec(solver, "7D x x");	//play 7 of dimamonds, and two smallest diamonds
+//print current situation:
+printf("%c playes, and he with partner will be able to take %d tricks.\n",
+	bcalc_playerSymbol(bcalcDDS_getPlayerToPlay(solver)),
+	bcalcDDS_getTricksToTake(solver)
+);
+bcalcDDS_delete(solver);	//and delete (free memory)
+@endcode
+
+\section names Names
+All names defined by library have prefixes:
+- BCALC_ - consts (defines)
+- BCalc - types (for example: BCalcDDS)
+- bcalc - functions and macros
+	- bcalcDDS - functions which operates on BCalcDDS (almost all takes BCalcDDS* as first argument)
+
+\section changes Changes and Backward Compatibility
+- ver. 14020 (5 II 2014):
+	- compatibility: API - yes (changes of application source are not required), ABI - yes (recompilation of application is not required),
+	- new function bcalcDDS_getTricksToTakeEx, this is extendend version of bcalcDDS_getTricksToTake and takes new, optional arguments: tricks_target and card,
+	- new function bcalcDDS_clone,
+	- in many places, the ASCII symbols of the suits, strains or players are accepted (as well as BCALC_* constants)
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+Version of bcalc engine API.
+
+Bridge Calculator program version (unsigned integer in form YYMMN) on which base engine.
+Note that engine is released less often than program (in some program release engine is not changed).
+@see @ref bcalc_runtimeVersion
+*/
+#define BCALC_VERSION 14020
+
+/**
+Handler to bcalc double dummy solver.
+
+Double dummy solver represents game with history of play.
+It also stores many values which was calculated for it.
+
+Usualy you should only use pointer to this type.
+*/
+typedef struct BCalcDDS BCalcDDS;
+
+#define BCALC_PLAYER_NORTH 0	///<North player
+#define BCALC_PLAYER_EAST 1		///<East player
+#define BCALC_PLAYER_SOUTH 2	///<South player
+#define BCALC_PLAYER_WEST 3		///<West player
+
+/**
+Convert player number to player symbol.
+@param player player number, one of BCALC_PLAYER_*
+@return player symbol, one of 'N', 'E', 'S', 'W'
+*/
+#define bcalc_playerSymbol(player) ("NESW"[player])
+
+/**
+Calculate hand relative to given one.
+@param hand one of BCALC_PLAYER_*
+@param delta clock-wise delta, +1 to next player (in clock-wise)
+@return calculated hand, one of BCALC_PLAYER_* value
+*/
+#define bcalc_nextHand(hand, delta) (((hand)+(delta))&3)    //or (((hand)+(delta))%4)
+
+/**
+Calculate leader hand using @p declarer hand.
+@param declarer
+@return player on lead in deal where @p declarer is declarer
+*/
+#define bcalc_declarerToLeader(declarer) bcalc_nextHand(declarer, 3)
+
+#define BCALC_SUIT_CLUBS 0		///<Club suit number
+#define BCALC_SUIT_DIAMONDS 1	///<Diamond suit number
+#define BCALC_SUIT_HEARTS 2		///<Hearts suit number
+#define BCALC_SUIT_SPADES 3		///<Spades suit number
+
+#define BCALC_NT 4			///<No trump
+
+/**
+Convert @p suit number to its ASCII symbol.
+@param suit suit, one of BCALC_SUIT_*
+@return suit symbol, one of 'C', 'D', 'H', 'S', 'N' (for NT)
+*/
+#define bcalc_suitSymbol(suit) ("CDHSN"[suit])
+
+/**
+Get the version of the API used by the runtime library.
+@return the version of the API used by the (typically: dynamic) runtime library
+@see @ref BCALC_VERSION
+*/
+unsigned bcalc_runtimeVersion();
+
+/**
+Construct new solver.
+
+Each solver has own memory and it is thread safety to operate on multiple solvers at the same time,
+but it is not safety to call more than one bcalcDDS_* function for one solver at the same time.
+@param format Format of @p hands, for example "NESW", "ESWN", ..., "PBN", "LIN":
+- "PBN" is Portable Bridge Notation like format,
+- "lin" is BBO .lin like format,
+- rest show order of hands.
+@param hands Players hands. Each player must have the same number of cards.
+    To get situation inside trick, you should create trick's beginning situation and call bcalcDDS_exec to play cards included in current trick.
+@param strain one of BCALC_SUIT_* or BCALC_NT constant or ASCII symbol of strain (one of: 'c', 'C', 'd', 'D', 'h', 'H', 's', 'S', 'n', 'N')
+@param leader player on lead, one of BCALC_PLAYER_* constant or player ASCII symbol (one of: 'n', 'N', 'e', 'E', 's', 'S', 'w', 'W')
+@return Constructed solver or NULL in case of out of memory.
+Returned solver can have error set in case of deal parser error, invalidate strain or leader (see @ref bcalcDDS_getLastError)
+and in such case you should not use that solver.
+In all cases constructed solver should be freed, after use, by @ref bcalcDDS_delete.
+*/
+extern BCalcDDS* bcalcDDS_new(const char* format, const char* hands, int strain, int leader);
+
+/**
+ * Clone the state of the solver @p to_clone.
+ * @param to_clone solver to clone
+ * @return copy of @p to_clone or NULL (in case of out of memory, or if @p to_clone is NULL).
+ * Returned copy, as well as @p to_clone, must by freed, after use, by @ref bcalcDDS_delete
+ */
+extern BCalcDDS* bcalcDDS_clone(BCalcDDS* to_clone);
+
+/**
+Delete double dummy solver, free its memory.
+@param solver constructed by @ref bcalcDDS_new, double dummy solver to delete, it is safe to pass NULL pointer (function do nothing in such a case)
+*/
+extern void bcalcDDS_delete(BCalcDDS* solver);
+
+/**
+Get last error string.
+@param solver bcalc double dummy solver
+@return last error message or NULL if no error, pointer to internal solver buffer (valid up to next bcalcDDS_* call for solver passed as argument)
+*/
+extern const char* bcalcDDS_getLastError(const BCalcDDS* solver);
+
+/**
+Clear error message.
+
+After call, bcalcDDS_getLastError(solver) will return NULL.
+@param solver bcalc double dummy solver
+*/
+extern void bcalcDDS_clearError(BCalcDDS* solver);
+
+/**
+Execute commands which can modify the state of given @p solver (current situation in game represented by it).
+@param solver bcalc double dummy solver
+@param cmds commands to execute
+
+Commands should be separated by spaces and each can be one of:
+- \<C\>\<S\> - where \<C\> is card symbol (like: A, Q, T, 6), \<S\> is suit symbol (one of: C, D, H, S), play choosen card
+- x - play smallest possible card following played suit
+- u - unplay one card
+- ut - unplay last trick
+- ua - unplay all tricks
+*/
+extern void bcalcDDS_exec(BCalcDDS* solver, const char* cmds);
+
+/**
+Calculate number of tricks possible to take (same as bcalcDDS_getTricksToTakeEx(solver, -1, 0)).
+@param solver bcalc double dummy solver
+@return number of tricks possible to take (in future) by line which plays in current situation
+*/
+extern int bcalcDDS_getTricksToTake(BCalcDDS* solver);
+
+/**
+If @p tricks_target == -1, calculate number of tricks possible to take.
+If @p tricks_target >= 0 check if @p tricks_target number of tricks are possible to take.
+Optionaly, if @c card != 0: it suppose that player to play starts with playing @c card.
+@param solver bcalc double dummy solver
+@param tricks_target (optional, -1 to ignore) target number of tricks to take by player to play
+@param card if not 0 must include description of one card, held by player to play, in format: \<C\>\<S\> - where \<C\> is card symbol, \<S\> is suit symbol (can also be 'x' for smallest possible card following played suit)
+@return
+    - If @p tricks_target == -1, it returns number of tricks possible to take (in future) by line which plays in current situation.
+    - If @p tricks_target >= 0, it returns 1 only if line which plays in current situation can take @p tricks_target tricks in future.
+    - In case of error (possible when @p card has wrong format) it returns -1.
+*/
+extern int bcalcDDS_getTricksToTakeEx(BCalcDDS* solver, int tricks_target, const char* card);
+
+/**
+Get strain.
+@param solver bcalc double dummy solver
+@return strain of game connected with @p solver
+*/
+extern int bcalcDDS_getTrump(BCalcDDS* solver);
+
+/**
+Set new strain and reset deal to initial state (undo all tricks).
+@param solver bcalc double dummy solver
+@param new_trump new strain to set for game connected with @p solver, one of BCALC_SUIT_* or BCALC_NT constant or ASCII symbol (one of: 'c', 'C', 'd', 'D', 'h', 'H', 's', 'S', 'n', 'N')
+*/
+extern void bcalcDDS_setTrumpAndReset(BCalcDDS* solver, int new_trump);
+
+/**
+Reset deal to initial state (undo all tricks) and change player on lead.
+
+Note that this doesn't clear transposition table, so calculation results which was colecting with an other player on lead will be still use.
+So if you need to iterate over all leader-strains pairs, and calculate number of tricks to take for each,
+it is much more effective to iterate over strains in outer loop and over leaders in inner loop.
+@param solver bcalc double dummy solver
+@param new_leader player on lead, one of BCALC_PLAYER_* constant or player ASCII symbol (one of: 'n', 'N', 'e', 'E', 's', 'S', 'w', 'W')
+*/
+extern void bcalcDDS_setPlayerOnLeadAndReset(BCalcDDS* solver, int new_leader);
+
+/**
+Get numbers of tricks which have been already taken by players in game connected with @p solver.
+@param solver bcalc double dummy solver
+@param result buffer, array of minimum length of 4, place to store calculated numbers of tricks
+@return @p result array, number of tricks taken by players, use BCALC_PLAYER_* as this array indexes
+*/
+extern int* bcalcDDS_getTricksTaken(BCalcDDS* solver, int* result);
+
+/**
+Get number of cards which left to play in game connected with @p solver.
+@param solver bcalc double dummy solver
+@return how many cards left to play to deal end, integer from 0 to 52
+*/
+extern int bcalcDDS_getCardsLeftCount(BCalcDDS* solver);
+
+/**
+Get cards owned by given @p player in given @p suit.
+@param solver bcalc double dummy solver
+@param player player, one of BCALC_PLAYER_* or player ASCII symbol (one of: 'n', 'N', 'e', 'E', 's', 'S', 'w', 'W')
+@param suit suit, one of BCALC_SUIT_* or suit symbol in ASCII (one of: 'c', 'C', 'd', 'D', 'h', 'H', 's', 'S')
+@param result buffer, place for results, safe length is 14 (13 cards and terminated zero)
+@return @p result, zero-ended string, suits written using symbols from: AKQJT98765432,
+ in case of error @p result in unchanged form
+*/
+extern char* bcalcDDS_getCards(BCalcDDS* solver, char* result, int player, int suit);
+
+/**
+Get player which should play now.
+@param solver bcalc double dummy solver
+@return player which should play now in game connected with given @p solver
+*/
+extern int bcalcDDS_getPlayerToPlay(BCalcDDS* solver);
+
+/**
+Get cards possible to play in given @p suit by player who should play.
+@param solver bcalc double dummy solver
+@param result buffer, place for results, safe length is 14 (13 cards and terminated zero)
+@param suit suit, one of BCALC_SUIT_* or suit symbol in ASCII (one of: 'c', 'C', 'd', 'D', 'h', 'H', 's', 'S')
+@return @p result, zero-ended string, suits written using symbols from: AKQJT98765432,
+ in case of error @p result in unchanged form
+*/
+extern char* bcalcDDS_getCardsToPlay(BCalcDDS* solver, char* result, int suit);
+
+/**
+Get card played as a @p whenIndex (when card played on first lead has index 0).
+@param solver bcalc double dummy solver
+@param whenIndex card index, from 0 to @ref bcalcDDS_getPlayedCardsCount "bcalcDDS_getPlayedCardsCount(solver)"-1
+@param suit place to save suit (if not NULL), one of BCALC_SUIT_*
+@param cardSymbol place to store card symbol (if not NULL)
+@return
+- @c 1 only if card with given index was played,
+- @c 0 if index is larger than @ref bcalcDDS_getPlayedCardsCount "bcalcDDS_getPlayedCardsCount(solver)"-1
+ (error is not set in such situation and @p suit and @p cardSymbol are not changed).
+*/
+extern int bcalcDDS_getPlayedCard(BCalcDDS* solver, unsigned whenIndex, int* suit, char* cardSymbol);
+
+/**
+Get number of cards which have been already played.
+@param solver bcalc double dummy solver
+@return number of cards which have been already played
+*/
+extern int bcalcDDS_getPlayedCardsCount(BCalcDDS* solver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	//__BELING__BCALC_BRIDGE_SOLVER__

data/vendor/bcalc/test.c

@@ -0,0 +1,88 @@
+#include "bcalcdds.h"
+#include <stdio.h>
+//check if solver is in error state, and if it is, print error message
+void print_on_error(BCalcDDS* solver) {
+	const char* err = bcalcDDS_getLastError(solver);
+	if (err) printf("ERROR %s\n", err);
+}
+
+//print which player play now and how many tricks he can take
+void print_tricks(BCalcDDS* solver) {
+	printf("%c playes, and he with partner will be able to take %d tricks.\n",
+	 bcalc_playerSymbol(bcalcDDS_getPlayerToPlay(solver)),
+	 bcalcDDS_getTricksToTake(solver)
+	);
+	print_on_error(solver);
+}
+
+//play all card in given suit and call print_tricks for situation after each play
+void play(BCalcDDS* solver, int suit) {
+	char to_play[14];
+	bcalcDDS_getCardsToPlay(solver, to_play, suit);
+	printf("Cards possible to play in suit %c: %s\n", bcalc_suitSymbol(suit), to_play);
+	char play_cmd[3];   //string chars: card symbol, suit symbol, string termination zero
+	play_cmd[1] = bcalc_suitSymbol(suit);
+	play_cmd[2] = 0;
+	int i;
+	for (i = 0; to_play[i] != 0; ++i) {
+		play_cmd[0] = to_play[i];
+		printf(" After play %s: ", play_cmd);
+		bcalcDDS_exec(solver, play_cmd);
+		print_tricks(solver);
+		bcalcDDS_exec(solver, "u");	//undo
+	}
+}
+
+//call play for all suits
+void play_all_suits(BCalcDDS* solver) {
+	print_tricks(solver);
+	int suit;
+	for (suit = 0; suit < 4; ++suit)
+		play(solver, suit);
+}
+
+//print number of tricks possible to take and all best moves
+void find_best_moves(BCalcDDS* solver) {
+	int target = bcalcDDS_getTricksToTake(solver);
+	printf("%c playes, and he with partner will be able to take %d tricks by play:",
+	 bcalc_playerSymbol(bcalcDDS_getPlayerToPlay(solver)), target
+	);
+	int suit;
+	char card_to_play[3];	//<rank><suit><null>
+	card_to_play[2] = 0;
+	for (suit = 0; suit < 4; ++suit) {
+		card_to_play[1] = bcalc_suitSymbol(suit);
+		char all_cards_to_play[14];
+		bcalcDDS_getCardsToPlay(solver, all_cards_to_play, suit);
+		int i;
+		for (i = 0; all_cards_to_play[i] != 0; ++i) {
+			card_to_play[0] = all_cards_to_play[i];
+			if (bcalcDDS_getTricksToTakeEx(solver, target, card_to_play))
+				printf(" %s", card_to_play);
+		}
+	}
+	printf("\n");
+}
+
+int main() {
+	BCalcDDS* solver = bcalcDDS_new("PBN", "N:.63.AKQ987.A9732 A8654.KQ5.T.QJT6 J973.J98742.3.K4 KQT2.AT.J6542.85", BCALC_NT, BCALC_PLAYER_NORTH);
+	if (!solver) {
+		printf("Can't create solver!");
+		return 1;
+	}
+	print_on_error(solver);
+
+	play_all_suits(solver);
+	find_best_moves(solver);
+
+	char* to_play = "7D x x";
+	printf("\nPlay some cards: %s\n", to_play);
+	bcalcDDS_exec(solver, to_play);
+	print_on_error(solver);
+	play_all_suits(solver);
+	find_best_moves(solver);
+
+	bcalcDDS_delete(solver);
+
+	return 0;
+}

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rbcalc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Achilles Charmpilas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: RubyInline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby bindings for Piotr Beling's Bridge Calculator
+email:
+- ac@humbuckercode.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rbcalc.rb
+- lib/rbcalc/engine.rb
+- lib/rbcalc/version.rb
+- rbcalc.gemspec
+- spec/rbcalc_spec.rb
+- spec/spec_helper.rb
+- vendor/bcalc/bcalcdds.h
+- vendor/bcalc/libbcalcdds.dylib
+- vendor/bcalc/libbcalcdds.so
+- vendor/bcalc/test.c
+- vendor/bcalc/win32/libbcalcdds.dll
+- vendor/bcalc/win64/libbcalcdds.dll
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for Piotr Beling's Bridge Calculator
+test_files:
+- spec/rbcalc_spec.rb
+- spec/spec_helper.rb