poker 0.0.1

data/ext/handeval/extconf.rb

@@ -0,0 +1,7 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+extension_name = 'handeval'
+dir_config(extension_name)
+have_library 'pokerlib'
+create_makefile(extension_name)

data/ext/handeval/handeval.c

@@ -0,0 +1,21 @@
+#include "ruby.h"
+
+VALUE HandEval = Qnil;
+void Init_handeval();
+
+VALUE HandEval_hand_rank(VALUE self, int val);
+VALUE HandEval_eval(VALUE self, int c1, int c2, int c3, int c4, int c5);
+
+void Init_handeval() {
+	HandEval = rb_define_module("HandEval");
+  rb_define_singleton_method(HandEval, "hand_rank", HandEval_hand_rank, 1);
+  rb_define_singleton_method(HandEval, "eval", HandEval_eval, 5);
+}
+
+VALUE HandEval_hand_rank(VALUE self, int val) {
+  return INT2NUM(hand_rank(val));
+}
+
+VALUE HandEval_eval(VALUE self, int c1, int c2, int c3, int c4, int c5) {
+  return INT2NUM(eval_5cards(c1 / 2, c2 / 2, c3 / 2, c4 / 2, c5 / 2));
+}

data/ext/handeval/poker.h

@@ -0,0 +1,43 @@
+#define	STRAIGHT_FLUSH	1
+#define	FOUR_OF_A_KIND	2
+#define	FULL_HOUSE	3
+#define	FLUSH		4
+#define	STRAIGHT	5
+#define	THREE_OF_A_KIND	6
+#define	TWO_PAIR	7
+#define	ONE_PAIR	8
+#define	HIGH_CARD	9
+
+#define	RANK(x)		((x >> 8) & 0xF)
+
+static char *value_str[] = {
+	"",
+	"Straight Flush",
+	"Four of a Kind",
+	"Full House",
+	"Flush",
+	"Straight",
+	"Three of a Kind",
+	"Two Pair",
+	"One Pair",
+	"High Card"
+};
+
+#define CLUB	0x8000
+#define DIAMOND 0x4000
+#define HEART   0x2000
+#define SPADE   0x1000
+
+#define Deuce	0
+#define Trey	1
+#define Four	2
+#define Five	3
+#define Six	4
+#define Seven	5
+#define Eight	6
+#define Nine	7
+#define Ten	8
+#define Jack	9
+#define Queen	10
+#define King	11
+#define Ace	12

data/ext/handeval/pokerlib.c

@@ -0,0 +1,205 @@
+#include <stdio.h>
+#include "arrays.h"
+#include "poker.h"
+
+// Poker hand evaluator
+//
+// Kevin L. Suffecool
+// suffecool@bigfoot.com
+//
+
+void    srand48();
+double  drand48();
+
+// perform a binary search on a pre-sorted array
+//
+int findit( int key )
+{
+    int low = 0, high = 4887, mid;
+
+    while ( low <= high )
+    {
+        mid = (high+low) >> 1;      // divide by two
+        if ( key < products[mid] )
+            high = mid - 1;
+        else if ( key > products[mid] )
+            low = mid + 1;
+        else
+            return( mid );
+    }
+    fprintf( stderr, "ERROR:  no match found; key = %d\n", key );
+    return( -1 );
+}
+
+//
+//   This routine initializes the deck.  A deck of cards is
+//   simply an integer array of length 52 (no jokers).  This
+//   array is populated with each card, using the following
+//   scheme:
+//
+//   An integer is made up of four bytes.  The high-order
+//   bytes are used to hold the rank bit pattern, whereas
+//   the low-order bytes hold the suit/rank/prime value
+//   of the card.
+//
+//   +--------+--------+--------+--------+
+//   |xxxbbbbb|bbbbbbbb|cdhsrrrr|xxpppppp|
+//   +--------+--------+--------+--------+
+//
+//   p = prime number of rank (deuce=2,trey=3,four=5,five=7,...,ace=41)
+//   r = rank of card (deuce=0,trey=1,four=2,five=3,...,ace=12)
+//   cdhs = suit of card
+//   b = bit turned on depending on rank of card
+//
+init_deck( int *deck )
+{
+    int i, j, n = 0, suit = 0x8000;
+
+    for ( i = 0; i < 4; i++, suit >>= 1 )
+        for ( j = 0; j < 13; j++, n++ )
+            deck[n] = primes[j] | (j << 8) | suit | (1 << (16+j));
+}
+
+
+//  This routine will search a deck for a specific card
+//  (specified by rank/suit), and return the INDEX giving
+//  the position of the found card.  If it is not found,
+//  then it returns -1
+//
+int
+find_card( int rank, int suit, int *deck )
+{
+	int i, c;
+
+	for ( i = 0; i < 52; i++ )
+	{
+		c = deck[i];
+		if ( (c & suit)  &&  (RANK(c) == rank) )
+			return( i );
+	}
+	return( -1 );
+}
+
+
+//
+//  This routine takes a deck and randomly mixes up
+//  the order of the cards.
+//
+shuffle_deck( int *deck )
+{
+    int i, n, temp[52];
+
+    for ( i = 0; i < 52; i++ )
+        temp[i] = deck[i];
+
+    for ( i = 0; i < 52; i++ )
+    {
+        do {
+            n = (int)(51.9999999 * drand48());
+        } while ( temp[n] == 0 );
+        deck[i] = temp[n];
+        temp[n] = 0;
+    }
+}
+
+
+print_hand( int *hand, int n )
+{
+    int i, r;
+    char suit;
+    static char *rank = "23456789TJQKA";
+
+    for ( i = 0; i < n; i++ )
+    {
+        r = (*hand >> 8) & 0xF;
+        if ( *hand & 0x8000 )
+            suit = 'c';
+        else if ( *hand & 0x4000 )
+            suit = 'd';
+        else if ( *hand & 0x2000 )
+            suit = 'h';
+        else
+            suit = 's';
+
+        printf( "%c%c ", rank[r], suit );
+        hand++;
+    }
+}
+
+
+int
+hand_rank( short val )
+{
+    if (val > 6185) return(HIGH_CARD);        // 1277 high card
+    if (val > 3325) return(ONE_PAIR);         // 2860 one pair
+    if (val > 2467) return(TWO_PAIR);         //  858 two pair
+    if (val > 1609) return(THREE_OF_A_KIND);  //  858 three-kind
+    if (val > 1599) return(STRAIGHT);         //   10 straights
+    if (val > 322)  return(FLUSH);            // 1277 flushes
+    if (val > 166)  return(FULL_HOUSE);       //  156 full house
+    if (val > 10)   return(FOUR_OF_A_KIND);   //  156 four-kind
+    return(STRAIGHT_FLUSH);                   //   10 straight-flushes
+}
+
+
+short
+eval_5cards( int c1, int c2, int c3, int c4, int c5 )
+{
+    int q;
+    short s;
+
+    q = (c1|c2|c3|c4|c5) >> 16;
+
+    /* check for Flushes and StraightFlushes
+    */
+    if ( c1 & c2 & c3 & c4 & c5 & 0xF000 )
+	return( flushes[q] );
+
+    /* check for Straights and HighCard hands
+    */
+    s = unique5[q];
+    if ( s )  return ( s );
+
+    /* let's do it the hard way
+    */
+    q = (c1&0xFF) * (c2&0xFF) * (c3&0xFF) * (c4&0xFF) * (c5&0xFF);
+    q = findit( q );
+
+    return( values[q] );
+}
+
+
+short
+eval_5hand( int *hand )
+{
+    int c1, c2, c3, c4, c5;
+
+    c1 = *hand++;
+    c2 = *hand++;
+    c3 = *hand++;
+    c4 = *hand++;
+    c5 = *hand;
+
+    return( eval_5cards(c1,c2,c3,c4,c5) );
+}
+
+
+// This is a non-optimized method of determining the
+// best five-card hand possible out of seven cards.
+// I am working on a faster algorithm.
+//
+short
+eval_7hand( int *hand )
+{
+    int i, j, q, best = 9999, subhand[5];
+
+	for ( i = 0; i < 21; i++ )
+	{
+		for ( j = 0; j < 5; j++ )
+			subhand[j] = hand[ perm7[i][j] ];
+		q = eval_5hand( subhand );
+		if ( q < best )
+			best = q;
+	}
+	return( best );
+}

data/lib/poker.rb

@@ -0,0 +1,3 @@
+require 'poker/card'
+require 'poker/deck'
+require 'poker/hand'

data/lib/poker/card.rb

@@ -0,0 +1,38 @@
+module Poker
+  class Card
+    RANKS = %w{ 2 3 4 5 6 7 8 9 T J Q K A }
+    SUITS = %w{ c d h s }
+    PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
+
+    attr_reader :rank, :rank_value, :suit, :suit_value
+
+    def initialize(str)
+      @str = str
+      @rank, @suit = str.split(//)
+      @rank_value = RANKS.index(@rank)
+      @suit_value = SUITS.index(@suit)
+    end
+
+    # An integer is made up of four bytes. The high-order
+    # bytes are used to hold the rank bit pattern, whereas
+    # the low-order bytes hold the suit/rank/prime value
+    # of the card.
+    #
+    # +--------+--------+--------+--------+
+    # |xxxbbbbb|bbbbbbbb|cdhsrrrr|xxpppppp|
+    # +--------+--------+--------+--------+
+    #
+    # p = prime number of rank (deuce=2,trey=3,four=5,five=7,...,ace=41)
+    # r = rank of card (deuce=0,trey=1,four=2,five=3,...,ace=12)
+    # cdhs = suit of card
+    # b = bit turned on depending on rank of card   # 
+    def value
+      PRIMES[rank_value] | (rank_value << 8) | 0x8000 >> suit_value |
+        (1 << (16 + rank_value))
+    end
+
+    def to_s
+      @str
+    end
+  end
+end

data/lib/poker/deck.rb

@@ -0,0 +1,13 @@
+module Poker
+  class Deck < Array
+    def initialize
+      cards = []
+      Card::SUITS.each { |s|
+        Card::RANKS.each { |r|
+          cards << Card.new(r+s)
+        }
+      }
+      super(cards)
+    end
+  end
+end

data/lib/poker/hand.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../../ext/handeval/handeval'
+
+module Poker
+  class Hand
+    include Enumerable
+    include Comparable
+
+    def self.best(cards)
+      best = nil
+      cards.combination(5).each do |c|
+        hand = Hand.new(*c)
+        best = hand if !best || hand > best
+      end
+      best
+    end
+
+    def initialize(*str_or_ary)
+      if str_or_ary.size == 1
+        @cards = str_or_ary[0].split(/ /).map { |s| Card.new(s) }
+      else
+        if str_or_ary[0].kind_of?(Card)
+          @cards = str_or_ary
+        else
+          @cards = str_or_ary.map { |s| Card.new(s) }
+        end
+      end
+    end
+
+    def value
+      HandEval.eval(*(@cards.map { |c| c.value }))
+    end
+
+    def rank
+      v = value
+      return "High Card"       if v > 6185
+      return "Pair"            if v > 3325
+      return "Two Pair"        if v > 2467
+      return "Three of a Kind" if v > 1609
+      return "Straight"        if v > 1599
+      return "Flush"           if v > 322
+      return "Full House"      if v > 166
+      return "Four of a Kind"  if v > 10
+      return "Straight Flush"  if v > 1
+      return "Royal Flush"     if v == 1
+    end
+
+    def <=>(hand)
+      - (value <=> hand.value)
+    end
+
+    def [](index)
+      @cards[index]
+    end
+
+    def each(&block)
+      @cards.each(&block)
+    end
+
+    def size
+      @cards.size
+    end
+
+    def to_s
+      r = rank
+      if r == "Pair" || r == "Two Pair" || r == "Three of a Kind" ||
+         r == "Full House" || r == "Four of a Kind"
+        h = @cards.inject({}) { |h, c|
+          r = c.rank_value + 1
+          h[r] = h[r] ? h[r] + 1 : 0
+          h
+        }
+        return @cards.sort_by { |c|
+          if h[c.rank_value + 1] > 0
+            - ((h[c.rank_value + 1] * 10_000) + (c.rank_value + 1) * 100) +
+              c.suit_value
+          else
+            - c.rank_value + c.suit_value
+          end
+        }.join(" ")
+      elsif r == "Straight Flush" || r == "Straight"
+        return @cards.sort_by { |c|
+          if c.rank_value == 12
+            10_000
+          else
+            - (c.rank_value + 1) * 100 - c.suit_value
+          end
+        }.join(" ")
+      end
+      @cards.sort_by { |c| - (c.rank_value + 1) * 100 - c.suit_value }.
+        join(" ")
+    end
+
+    def to_str
+      to_s
+    end
+  end
+end

data/lib/poker/version.rb

@@ -0,0 +1,3 @@
+module Poker
+  VERSION = "0.0.1"
+end

data/poker.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "poker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "poker"
+  s.version     = Poker::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Wojciech Mach"]
+  s.email       = ["wojtekmach1@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/poker"
+  s.summary     = %q{Poker hand evaluator}
+  s.description = %q{Poker hand evaluator}
+
+  s.rubyforge_project = "poker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "ext"]
+  s.extensions = ["ext/handeval/extconf.rb"]
+end