ruby-poker 0.1.1

data/CHANGELOG

@@ -0,0 +1,5 @@
+2008-01-10 (0.1.0)
+    * Initial version
+2008-01-11 (0.1.1)
+    * Ranks are now a class.
+    * Added gem packaging

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2008, Robert Olson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,40 @@
+= Poker hand evaluator for Ruby
+
+== Author
+
+Robert Olson mailto:rko618@gmail.com
+
+== License
+
+This is free software; you can redistribute it and/or modify it under the
+terms of the BSD license. See LICENSE for more details.
+
+== Download
+
+The latest version of <b>ruby poker</b> can be found at
+
+* http://rubyforge.org/frs/?group_id=5257
+
+The homepage of this project is located at
+
+* http://rubyforge.org/projects/rubypoker
+
+== Description
+
+This class handles poker logic for 5 card poker hands.
+
+Card representations can be passed to the PokerHand constructor as a string or an array.
+Face cards (cards ten, jack, queen, king, and ace) can be created using their
+value (10, 11, 12, 13, 14) or letter representation (T, J, Q, K, A)
+
+== Examples
+
+In this section some examples show what can be done with this class.
+
+    hand1 = PokerHand.new("8H 9C TC JD QH")
+    hand2 = PokerHand.new(["3D", "3C", "3S", "13D", "14H"])
+    puts hand1                => 8H 9C 10C 11D 12H
+    puts hand1.rank           => Straight
+    puts hand2                => 3D 3C 3S 13D 14H
+    puts hand2.rank           => Three of a Kind
+    puts hand1 > hand2        => true

data/lib/array_helper.rb

@@ -0,0 +1,25 @@
+module ArrayHelper
+  class Array < ::Array
+    # Returns array of elements that only occur once
+    # [1, 1, 2, 3] => [2, 3]
+    def singles
+      counts = Hash.new(0)
+      self.each do |value|
+        counts[value] += 1
+      end
+
+      return counts.collect {|key,value| value == 1 ? key : nil }.compact.sort
+    end
+  
+    # Returns an array containing values that we duplicated in the original array
+    # [1, 2, 3, 1] => [1]
+    def duplicates
+      counts = Hash.new(0)
+      self.each do |value|
+        counts[value] += 1
+      end
+
+      return counts.collect {|key,value| value > 1 ? key : nil }.compact.sort
+    end
+  end # class Array
+end # module ArrayHelper

data/lib/card.rb

@@ -0,0 +1,22 @@
+class PokerHand
+  
+  class Card
+    include Comparable
+    attr_reader :suit, :value
+
+    def initialize card_str
+      card_str = card_str.gsub("T","10").gsub("J","11").gsub("Q","12").gsub("K","13").gsub("A","14")
+      @value = card_str[0, card_str.length-1].to_i
+      @suit = card_str[-1,1]
+    end
+
+    def <=> card2
+      @value <=> card2.value
+    end
+
+    def to_s
+      @value.to_s + @suit
+    end
+  end # class Card
+  
+end # class PokerHand

data/lib/poker_hand.rb

@@ -0,0 +1,161 @@
+# poker_hand.rb
+
+require 'array_helper.rb'
+require 'rank.rb'
+require 'card.rb'
+
+class PokerHand
+    
+  include ArrayHelper
+  include Comparable
+  attr_reader :cards, :values_hash
+  
+  def initialize cards
+    @cards = Array.new
+    @values_hash = Hash.new(0)
+
+    begin
+      if cards.class == String
+        cards = cards.split
+      end
+
+      cards.each {|c| @cards << Card.new(c)}
+      
+      @cards.each {|c| @values_hash[c.value] += 1}
+    rescue
+      raise "Unable to process cards input. Please check the documentation for acceptable input formats"
+    end
+  end
+  
+  def rank
+    @rank ||= self.determine_rank
+  end
+  
+  # Returns an array of all the values in the hand. Does not
+  # sort the values before returning them so Array#sort should
+  # be called on the return value if sorting is desired.
+  def values
+    @cards.collect {|c| c.value}
+  end
+  
+  # Flush if the cards are all the same suit.
+  def flush?
+    @cards.collect {|c| c.suit}.uniq.size == 1
+  end
+  
+  # Straight if all cards are consecutive values.
+  def straight?
+    straight = true   # innocent until proven guilty
+    c_values = self.values.sort
+    i = c_values.first
+    c_values.each do |v|
+      straight &&= (v == i)
+      i += 1
+    end
+    return straight
+  end
+
+  # Royal Flush: Ten, Jack, Queen, King, Ace, in same suit.  
+  def royal_flush?
+    self.flush? and self.values.sort == [10,11,12,13,14]
+  end
+    
+  # Straight Flush: All cards are consecutive values of same suit.
+  def straight_flush?    
+    self.flush? and self.straight?
+  end
+  
+  # Full House: Three of a kind and a pair.
+  def full_house?
+    @values_hash.has_value?(3) and @values_hash.has_value?(2)
+  end
+  
+  # Three of a Kind: Three cards of the same value.
+  def three_of_a_kind?
+    @values_hash.has_value?(3) and not full_house?
+  end    
+  
+  # Four of a Kind: Four cards of the same value.  
+  def four_of_a_kind?
+    @values_hash.has_value?(4)
+  end
+  
+  # Two Pair: Two different pairs.
+  def two_pair?
+    @values_hash.select {|k, v| v == 2}.size == 2   # check if two seperate values have two occurances
+  end
+  
+  # One Pair: Two cards of the same value.
+  def one_pair?
+    @values_hash.select {|k, v| v == 2}.size == 1
+  end
+
+  def <=> hand2
+    if self.rank != hand2.rank
+      self.rank <=> hand2.rank
+    else  # we have a tie... do a tie breaker
+      case self.rank.value    # both hands have the same rank
+      when 0, 4, 5, 8  # highest card, straight, flush, straight flush
+        # check who has the highest card, if same move to the next card, etc
+        self.values.sort.reverse <=> hand2.values.sort.reverse
+      when 1  # two people with one pair
+        # check which pair is higher, if the pairs are the same then remove the pairs and check
+        # for highest card
+        hand1_pair = @values_hash.index(2)  # get key(card value) of the duplicate pair
+        hand2_pair = hand2.values_hash.index(2)
+        if hand1_pair == hand2_pair
+          return self.values.singles.reverse <=> hand2.values.singles.reverse
+        else
+          return hand1_pair <=> hand2_pair
+        end
+      when 2  # two people with two pairs
+        # check who has the higher pair, if the pairs are the same
+        # then remove the pairs and check for highest card
+        hand1_pairs = self.values.duplicates.reverse
+        hand2_pairs = hand2.values.duplicates.reverse
+        if hand1_pairs == hand2_pairs
+          return self.values.singles <=> hand2.values.singles   # there will be only one card remaining
+        else
+          return hand1_pairs <=> hand2_pairs
+        end
+      when 3, 6  # three_of_a_kind, full house
+        @values_hash.index(3) <=> hand2.values_hash.index(3)
+      when 7  # four of a kind
+        @values_hash.index(4) <=> hand2.values_hash.index(4)
+      when 9  # royal flush
+        return 0  # royal flushes always tie
+      end
+    end
+  end
+  
+  def to_s
+    @cards.inject("") {|str, c| str << "#{c.to_s} "}.rstrip
+  end
+  
+  protected
+  
+  def determine_rank
+    if royal_flush?
+      r = Rank::ROYAL_FLUSH
+    elsif straight_flush?
+      r = Rank::STRAIGHT_FLUSH
+    elsif four_of_a_kind?
+      r = Rank::FOUR_OF_A_KIND
+    elsif full_house?
+      r = Rank::FULL_HOUSE
+    elsif flush?
+      r = Rank::FLUSH
+    elsif straight?
+      r = Rank::STRAIGHT
+    elsif three_of_a_kind?
+      r = Rank::THREE_OF_A_KIND
+    elsif two_pair?
+      r = Rank::TWO_PAIR
+    elsif one_pair?
+      r = Rank::PAIR
+    else
+      r = Rank::HIGH_CARD
+    end
+    return Rank.new(r)
+  end
+end # class PokerHand

data/lib/rank.rb

@@ -0,0 +1,48 @@
+class PokerHand
+
+  # Rank objects maintain the poker value of the hand. Ex. Full House
+  class Rank
+    include Comparable
+    attr_accessor :value  
+    
+    HIGH_CARD = 0
+    PAIR = 1
+    TWO_PAIR = 2
+    THREE_OF_A_KIND = 3
+    STRAIGHT = 4
+    FLUSH = 5
+    FULL_HOUSE = 6
+    FOUR_OF_A_KIND = 7
+    STRAIGHT_FLUSH = 8
+    ROYAL_FLUSH = 9
+  
+    # Creates a new Rank instance of <code>value</code>
+    # Values can be 0-9. Consider using the Rank constants
+    # for the hand values.
+    def initialize value
+      @value = value
+    end
+  
+    # Returns the text representation of the poker rank. Ex. "Two Pair"
+    def to_s
+      case @value
+        when 0: "High Card"
+        when 1: "Pair"
+        when 2: "Two Pair"
+        when 3: "Three of a Kind"
+        when 4: "Straight"
+        when 5: "Flush"
+        when 6: "Full House"
+        when 7: "Four of a Kind"
+        when 8: "Straight Flush"
+        when 9: "Royal Flush"
+        else "Unknown"
+      end
+    end
+  
+    def <=> other
+      @value <=> other.value
+    end
+  end   # class Rank
+
+end

data/lib/ruby-poker.rb

@@ -0,0 +1 @@
+require 'poker_hand'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-poker
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Robert Olson
+autorequire: ruby-poker
+bindir: bin
+cert_chain: []
+
+date: 2008-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: rko618@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+files: 
+- lib/array_helper.rb
+- lib/card.rb
+- lib/poker_hand.rb
+- lib/rank.rb
+- lib/ruby-poker.rb
+- README
+- CHANGELOG
+- LICENSE
+has_rdoc: true
+homepage: http://rubyforge.org/projects/rubypoker/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubypoker
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Ruby library for determining the winner in a game of poker.
+test_files: []
+