rholdem 0.0.1

data/lib/hand.rb

@@ -0,0 +1,236 @@
+require File.dirname(__FILE__) + "/deck"
+
+module Holdem
+  class Hand
+    RANKINGS = [
+      :straight_flush,
+      :four_of_a_kind,
+      :full_house,
+      :flush,
+      :straight,
+      :three_of_a_kind,
+      :two_pair,
+      :pair,
+      :high_card
+    ]
+  
+    attr_reader :cards, :sorted_cards, :ranking, :high_card
+  
+    def initialize(*cards)
+      @cards = []
+      if(cards.length == 1 && cards[0].is_a?(String))
+        # a string to split up, Card class takes care of raising errors.
+        cards[0].split(' ').map { |c| @cards << Card.new(c) }
+      else
+        # an array of cards, need to verify class.
+        cards = cards[0] if cards.length == 1 && cards[0].is_a?(Array)
+        cards.map { |c| c.is_a?(Card) ? @cards << c : 
+          raise("Cannot initialize Hand from #{c.class} objects") }
+      end
+    
+      unless (2..7).include? @cards.length
+        raise "#{@cards.length} cards given (2 to 7 cards required)"
+      end
+    
+      @cards.sort!
+    
+      find_best(@cards)
+      @high_card = @sorted_cards[@sorted_cards.length-1]
+    end
+  
+    def >(compare_to)
+      return true if (self <=> compare_to) == 1
+      false
+    end
+  
+    def <(compare_to)
+      return true if (self <=> compare_to) == -1
+      false
+    end
+  
+    def ==(compare_to)
+      return true if (self <=> compare_to) == 0
+      false
+    end
+  
+    def <=>(compare_to)
+      # must have 5 sorted cards or be same length.
+      if(@sorted_cards.length != 5 && compare_to.sorted_cards.length != 5)
+        unless @sorted_cards.length == compare_to.sorted_cards.length
+          raise "Cannot compare mismatched, less then 5 card hand lengths"
+        end
+      end
+    
+      my_rank = RANKINGS.index(@ranking)
+      comp_rank = RANKINGS.index(compare_to.ranking)
+    
+      return  1 if my_rank < comp_rank
+      return -1 if my_rank > comp_rank
+    
+      # otherwise must compare by cards.
+      i = @sorted_cards.length-1
+      while(i >= 0)
+        return  1 if @sorted_cards[i] > compare_to.sorted_cards[i]
+        return -1 if @sorted_cards[i] < compare_to.sorted_cards[i]
+        i -= 1
+      end
+    
+      return 0
+    end
+  
+  private
+  
+    def find_best(cards)
+      case cards.length
+      
+      when 7
+        (0..6).each do |i|
+          copy = cards.dup
+          copy.delete_at(i)
+          find_best(copy)
+        end
+      
+      when 6
+        (0..5).each do |i|
+          copy = cards.dup
+          copy.delete_at(i)
+          find_best(copy)
+        end
+      
+      else
+        # testing a hand of 5 or less      
+        new_rank = find_ranking(cards)
+        cards = sort_by_ranking(cards, new_rank)
+
+        if(@ranking.nil? || RANKINGS.index(new_rank) < RANKINGS.index(@ranking))
+          update_ranking(new_rank, cards)
+        elsif(RANKINGS.index(new_rank) == RANKINGS.index(@ranking))
+          (0...cards.length).each do |i|
+            if(cards[i].rank > @sorted_cards[i].rank)
+              update_ranking(new_rank, cards)
+              break
+            end
+          end
+        end
+      end
+    end
+  
+    def find_ranking(cards)
+      RANKINGS.each do |r|
+        return r if method(r.to_s + '?').call(cards)
+      end
+    end
+  
+    def sort_by_ranking(cards, ranking)
+      case ranking
+    
+      when :straight_flush, :straight
+        if(cards[4].rank - cards[0].rank == 12)
+          card = cards.delete_at(4)
+          cards.insert(0, card)
+        end
+    
+      when :four_of_a_kind, :full_house
+        over_rank = cards[2].rank
+        cards = cards.sort_by do |card|
+          card.rank == over_rank ? 1 : 0
+        end
+    
+      when :three_of_a_kind
+        trips_rank = cards[2].rank
+        cards = cards.sort_by do |card|
+          card.rank == trips_rank ? 100 : card.rank
+        end
+      
+      when :two_pair, :pair
+        rank_counts = Hash.new
+        cards.each do |c|
+          rank_counts[c.rank] ||= 0
+          rank_counts[c.rank] += 1
+        end
+      
+        cards = cards.sort_by do |card|
+          rank_counts[card.rank] > 1 ? card.rank+100 : card.rank
+        end
+      end
+      cards
+    end
+  
+    def update_ranking(ranking, cards)
+      @sorted_cards = cards
+      @ranking = ranking
+    end
+  
+    ##
+    # Evaluators
+    #
+  
+    def straight_flush?(cards)
+      return false if cards.length != 5
+      return true if (straight?(cards) && flush?(cards))
+      false
+    end
+  
+    def four_of_a_kind?(cards)
+      return false unless (4..5).include?(cards.length)
+      return true if cards.join(' ') =~ /(.). \1. \1. \1./
+      false
+    end
+  
+    def full_house?(cards)
+      return false if cards.length != 5
+      return true if cards.join(' ') =~ /(.). \1. \1. (.). \2./
+      return true if cards.join(' ') =~ /(.). \1. (.). \2. \2./
+    
+      false
+    end
+  
+    def flush?(cards)
+      return false if cards.length != 5
+      return true if cards.join(' ') =~ /(.)(.) (.)\2 (.)\2 (.)\2 (.)\2/
+    
+      false
+    end
+  
+    def straight?(cards)
+      return false if cards.length != 5
+    
+      ranks = cards.map { |card| card.rank }
+      return true if ranks == [0, 1, 2, 3, 12]
+    
+      result = true
+      (0..3).each do |i|
+        if(ranks[i+1] - ranks[i] != 1)
+          result = false
+          break
+        end
+      end
+      result
+    end
+  
+    def three_of_a_kind?(cards)
+      return false unless (3..5).include?(cards.length)
+      return true if cards.join(' ') =~ /(.). \1. \1./
+    
+      false
+    end
+  
+    def two_pair?(cards)
+      return false unless (4..5).include?(cards.length)
+      return true if cards.join(' ') =~ /(.). \1. (.). \2./
+    
+      false
+    end
+  
+    def pair?(cards)
+      return false unless (2..5).include?(cards.length)
+      return true if cards.join(' ') =~ /(.). \1./
+
+      false
+    end
+  
+    def high_card?(cards)
+      true
+    end
+  end
+end

data/lib/player.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + "/hand"
+
+module Holdem
+  class Player
+    MAX_ACTIONS = 300
+  
+    attr_reader :hole_cards, :hand, :in_pot, :actions, :in_round, :folded, :delta
+  
+    def initialize
+      @hole_cards = []
+      @actions = []
+      @in_pot = 0.0
+      @in_round = 0.0
+      @delta = 0.0
+      @folded = false
+    end
+  
+    def deal(card)
+      raise "Player already has 2 hole cards" if @hole_cards.length >= 2
+      @hole_cards << card
+    end
+  
+    def find_hand(board)
+      all_cards = (board + @hole_cards).flatten
+      @hand = Hand.new(all_cards)
+    end
+  
+    def pay(amount)
+      @in_pot += amount
+      @in_round += amount
+      @delta -= amount
+    end
+  
+    def award(amount)
+      @delta += amount
+    end
+  
+    # override this for subclass Players
+    def act(game)
+      return :neutral
+    end
+    
+    def record_action(action)
+      @actions << action
+      @actions.delete_at(0) if @actions.length > MAX_ACTIONS
+    end
+  
+    def next_round
+      @in_round = 0.0
+    end
+  
+    def fold
+      @folded = true
+    end
+  end
+end

data/lib/rholdem.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/card"
+require File.dirname(__FILE__) + "/deck"
+require File.dirname(__FILE__) + "/hand"
+require File.dirname(__FILE__) + "/player"
+require File.dirname(__FILE__) + "/game"
+
+module Holdem
+  VERSION = '0.0.1'
+end

data/spec/card_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + "/../lib/card"
+include Holdem
+
+describe Card do
+  before(:each) do
+    @c = Card.new('As')
+  end
+  
+  it "should be creatable from a 2-char string" do
+    @c.should_not be_nil
+  end
+  
+  it "should assign the rank when created" do
+    # RANKS = "23456789TJQKA"
+    @c.rank.should == 12
+  end
+  
+  it "should assign the suit when created" do
+    # SUITS = "cdhs"
+    @c.suit.should == 3
+  end
+  
+  it "should output the abbreviated card name" do
+    @c.to_s.should == 'As'
+  end
+  
+  it "should show error for bad card initializers" do
+    lambda { Card.new('Za') }.should raise_error
+    lambda { Card.new('0') }.should raise_error
+  end
+  
+  it "should evaluate two cards as equal if their ranks and suits match" do
+    c1 = Card.new('3c')
+    c2 = Card.new('3c')
+    
+    c1.should == c2
+    c1.should eql?(c2)
+  end
+  
+  it "should evaluate two cards as equal if their ranks match" do
+    c1 = Card.new('3d')
+    c2 = Card.new('3c')
+    
+    c1.should == c2
+    c1.should eql?(c2)
+  end
+  
+  it "should evaluate two cards as not equal if their ranks don't match" do
+    c1 = Card.new('3h')
+    c2 = Card.new('4h')
+    c1.should_not == c2
+  end
+  
+  it "should evaluate two cards as === if their suits and ranks match" do
+    c1 = Card.new('3d')
+    c2 = Card.new('3d')
+    c1.should === c2
+  end
+  
+  it "should evaluate two cards as not === if their suits don't match" do
+    c1 = Card.new('3d')
+    c2 = Card.new('3h')
+    c1.should_not === c2
+  end
+  
+  it "should evaluate two cards as not === if their ranks don't match" do
+    c1 = Card.new('5d')
+    c2 = Card.new('3d')
+    c1.should_not === c2
+  end
+  
+  it "should return -1 when comparing lower to higher card" do
+    c1 = Card.new('3c')
+    c2 = Card.new('4d')
+    (c1 <=> c2).should == -1
+    (c1 > c2).should == false
+    (c1 < c2).should == true
+  end
+  
+  it "should return 1 when comparing higher to lower card" do
+    c1 = Card.new('8c')
+    c2 = Card.new('4d')
+    (c1 <=> c2).should == 1
+    (c1 > c2).should == true
+    (c1 < c2).should == false
+  end
+  
+  it "should return 0 when cards are equal" do
+    c1 = Card.new('8c')
+    c2 = Card.new('8d')
+    (c1 <=> c2).should == 0
+    (c1 > c2).should == false
+    (c1 < c2).should == false
+  end
+end

data/spec/deck_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + "/../lib/deck"
+include Holdem
+
+describe Deck do
+  before(:each) do
+    @d = Deck.new
+  end
+  
+  it "should have all 52 cards" do
+    @d.cards.length.should == 52
+  end
+  
+  it "should not have repeated cards" do
+    cards = Hash.new
+    @d.cards.each do |c|
+      cards[c].should be_nil
+      cards[c] = 1
+    end
+  end
+  
+  it "should rearrange the cards after a shuffle" do
+    old_sort = @d.cards.dup
+    @d.shuffle
+    old_sort.should_not == @d.cards
+  end
+  
+  it "should be shuffled when created" do
+    ordered_cards = []
+    Card::SUITS.each_byte do |suit|
+      Card::RANKS.each_byte do |rank|
+        ordered_cards << Card.new(rank.chr + suit.chr)
+      end
+    end
+    
+    @d.cards.should_not == ordered_cards
+  end
+  
+  it "should return a card from the deck when dealing" do
+    @d.deal.class.should == Card
+  end
+  
+  it "should remove the card from the deck when dealing" do
+    c = @d.deal
+    @d.cards.each do |card|
+      card.should_not === c
+    end
+  end
+  
+  it "should have 1 less card after dealing" do
+    @d.deal
+    @d.cards.length.should == 51
+  end
+end