rora 0.0.6 → 0.4.0

data/lib/rora/model/suit.rb

@@ -5,12 +5,15 @@
 # of cards has four suits: hearts, clubs, spades, and diamonds.
 #
 class Suit
-  attr_reader :id, :key, :value
-
-  def initialize(id, key, value)
+  include Comparable
+  
+  attr_reader :id, :key, :value, :order
+  
+  def initialize(id, key, value, order)
     @id = id
     @key = key
     @value = value
+    @order = order
   end
 
   def self.values
@@ -21,23 +24,35 @@ class Suit
     self.values.each do |suit|
       return suit if suit.key.casecmp(key) == 0
     end
-    raise ArgumentError, "No suit exists for key " + key
+    raise ArgumentError, "No suit exists for key '#{key}'"
   end
 
-  def to_s
-    "Suit: #{@value}s"
+  def <=>(suit)
+    self.order <=> suit.order
+  end
+
+  def eql? suit
+    self == suit
   end
 
   def == suit
-    self.id == suit.id
+    self.key == suit.key
+  end
+
+  def hash
+    return self.key.ord
+  end
+
+  def to_s
+    "#{@value}s"
   end
 
   class << self
     private :new
   end
 
-  HEART = new(43, "H", "Heart")
-  SPADE = new(47, "S", "Spade")
-  CLUB = new(53, "C", "Club")
-  DIAMOND = new(59, "D", "Diamond")
+  HEART = new(2, "H", "Heart", 1)
+  DIAMOND = new(3, "D", "Diamond", 2)
+  SPADE = new(5, "S", "Spade", 3)
+  CLUB = new(7, "C", "Club", 4)
 end

data/lib/rora/model/table.rb

@@ -36,17 +36,14 @@ class Table
   end
 
   def the_small_blind
-    raise RuntimeError, "There are fewer than two players at the table" if players.size < 2
     players.size == 2 ? the_button : the_seat_after(the_button)
   end
 
   def the_big_blind
-    raise RuntimeError, "There are fewer than two players at the table" if players.size < 2
     the_seat_after the_small_blind
   end
 
   def under_the_gun
-    raise RuntimeError, "There are fewer than two players at the table" if players.size < 2
     the_seat_after(the_big_blind)
   end
 

data/lib/rora/repository/card_repository.rb

@@ -0,0 +1,17 @@
+require 'csv'
+require 'singleton'
+
+class CardRepository
+  include Singleton
+  
+  def initialize
+    @card_table = Hash.new
+    CSV.foreach("lib/rora/cards.csv") do |row|
+      @card_table[row[0]] = row[1].to_i
+    end
+  end
+
+  def get(key)
+    @card_table.fetch(key)
+  end
+end

data/lib/rora/repository/hand_repository.rb

@@ -4,16 +4,43 @@ require 'singleton'
 class HandRepository
   include Singleton
 
+  HEART_FLUSH=32
+  DIAMOND_FLUSH=243
+  SPADE_FLUSH=3125
+  CLUB_FLUSH=16807
+  
   def initialize
     @hands = Array.new
-    @table = Hash.new
-    CSV.foreach("lib/rora/hands.csv") do |row|
-      @table[row[1].to_i] = [row[0].to_i, row[3], row[4], row[5].to_f]
+    
+    @five_card_table = Hash.new
+    CSV.foreach("lib/rora/5-card-hands.csv") do |row|
+      @five_card_table[row[1].to_i] = [row[0].to_i, row[3], row[4]]
+    end
+
+    @seven_card_table = Hash.new
+    CSV.foreach("lib/rora/7-card-hands.csv") do |row|
+      @seven_card_table[row[1].to_i] = [row[0].to_i, row[4], row[5]]
+    end
+
+    @flushes_table = Hash.new
+    CSV.foreach("lib/rora/flushes.csv") do |row|
+      @flushes_table[row[0].to_i] = [row[1].to_i, row[2]]
     end
   end
 
-  def find id
-    @table.fetch id
+  def evaluate_5_card_hand(cards)
+    flush = Hand.new(cards).flush?
+    @five_card_table.fetch(cards.inject(1) {|product, card| product * card.rank.id} * (flush ? 67 : 1))
+  end
+
+  def evaluate_7_card_hand(cards)
+    key = generate_suit_key(cards)
+    flush = has_flush?(key)
+    flush ? get_best_hand(cards, key) : @seven_card_table.fetch(cards[0].rank.id * cards[1].rank.id * cards[2].rank.id * cards[3].rank.id * cards[4].rank.id * cards[5].rank.id * cards[6].rank.id)
+  end
+
+  def has_flush?(key)
+    key % HEART_FLUSH == 0 || key % DIAMOND_FLUSH == 0 || key % SPADE_FLUSH == 0 || key % CLUB_FLUSH == 0
   end
 
   # Returns all possible poker hands.
@@ -58,29 +85,28 @@ class HandRepository
   # Starting Hand, Board and Deck
   # This method will return all poker hands that can be made with the given starting
   # hand and cards that remain in the deck.
-  def list arguments=nil
-    return hands if arguments.nil? || arguments[:starting_hand].nil?
+  def list(arguments=nil)
+    return all_hands if arguments.nil? || arguments[:starting_hand].nil?
 
     starting_hand = arguments[:starting_hand]
     deck = arguments[:deck].nil? ? Deck.new : arguments[:deck]
     board = arguments[:board]
-    hands = Array.new
+    spec_hands = Array.new
 
     if !board.nil?
       raise RuntimeError if board.contains_any? starting_hand.cards
       if board.cards.size == 5
-        (board.cards + starting_hand.cards).combination(5).to_a.each { |cards| hands << Hand.new(cards) }
-        return hands
+        (board.cards + starting_hand.cards).combination(5).to_a.each { |cards| spec_hands << Hand.new(cards) }
       else
         deck.remove(starting_hand).remove(board).combination(5 - board.cards.size).to_a.each do |cards|
-          (starting_hand.cards + board.cards + cards).combination(5).to_a.each { |cds| hands << Hand.new(cds) }
+          (starting_hand.cards + board.cards + cards).combination(5).to_a.each { |cds| spec_hands << Hand.new(cds) }
         end
-        return hands
       end
+      return spec_hands
     end
 
-    deck.remove(starting_hand).combination(3).each { |cards| hands << Hand.new(cards + starting_hand.cards) }
-    hands
+    deck.remove(starting_hand).combination(3).each { |cards| spec_hands << Hand.new(cards + starting_hand.cards) }
+    spec_hands
   end
 
   # Returns unique poker hands.
@@ -110,20 +136,34 @@ class HandRepository
   #
   # This method carries the same semantics as the list method, but returns unique hands instead of
   # every possible hand.
-  def list_unique arguments=nil
-    results = list arguments
-    return results if results.nil? || results.size == 0
+  def list_and_group_by_hand_score(arguments=nil)
+    spec_hands = list(arguments)
+    return spec_hands if spec_hands.nil? || spec_hands.size == 0
 
     hash = Hash.new
-    results.each do |result|
-      hash[result.hash_key] = result
+    spec_hands.each do |hand|
+      hash[(hand.cards.inject(1) {|product, card| product * card.rank.id } * (hand.flush? ? 67 : 1))] = hand
     end
     hash.values
   end
 
   private
 
-  def hands
+  def get_best_hand(cards, key)
+    flush = @flushes_table.fetch(key)
+    if(flush[0] != 5)
+      return @seven_card_table.fetch(cards[0].uid * cards[1].uid * cards[2].uid * cards[3].uid * cards[4].uid * cards[5].uid * cards[6].uid)
+    end
+    @five_card_table.fetch(cards.inject(1) {|product, card| product * ((card.suit.key == flush[1]) ? card.rank.id : 1)} * 67)
+  end
+
+  def generate_suit_key(cards)
+    key = 1
+    cards.each {|card| key = key * card.suit.id}
+    key
+  end
+
+  def all_hands
     if @hands.empty?
       Deck.new.combination(5).each {|cards| @hands << Hand.new(cards)}
     end

data/lib/rora/repository/starting_hand_repository.rb

@@ -8,7 +8,8 @@ class StartingHandRepository
     Deck.new.cards.combination(2) do |combination|
       starting_hand = StartingHand.new(combination)
       @all << starting_hand
-      @distinct[starting_hand.key] = starting_hand
+      hash_key = starting_hand.cards.inject(1) {|product, card| product * card.rank.id } * (starting_hand.suited? ? 67 : 1)
+      @distinct[hash_key] = starting_hand
     end
   end
 

data/lib/rora/utils/equity_calculator.rb

@@ -0,0 +1,47 @@
+require 'date'
+
+class EquityCalculator
+  
+  def initialize
+    @hand_repository = HandRepository.instance
+    @best_scores = Hash.new
+  end
+
+  def calculate_equity(starting_hands, board = Board.new)
+    raise ArgumentError, "Must have at least two starting hands for equity comparison" if (starting_hands.nil? || starting_hands.size < 2)
+    raise ArgumentError, "There are duplicate cards" if duplicates?(starting_hands, board)
+
+    equity_map = Hash[starting_hands.map{|starting_hand| [starting_hand, 0]}]
+    game = Deck.new.remove(merge(starting_hands, board)).combination(5 - board.cards.size)
+      
+    game.each do |cards| 
+      showdown(equity_map, starting_hands, board.cards + cards) 
+    end
+
+    total_winning_hands = equity_map.inject(0) {|total, result| total += result[1]}
+    equity_map.inject(Hash.new) { |hash, result| hash[result[0]] = Equity.new(game.size, total_winning_hands, result); hash}
+  end
+
+  private
+
+  def showdown(results, starting_hands, board_cards)
+    @best_scores.clear
+    
+    starting_hands.each do |starting_hand|
+      @best_scores[starting_hand] = @hand_repository.evaluate_7_card_hand((board_cards + starting_hand.cards))[0]
+    end
+    
+    winner = @best_scores.min_by{|key,value| value}
+    results[winner[0]] += 1 if(@best_scores.select {|k,v| v == winner[1]}.size == 1)
+  end
+
+  def duplicates?(starting_hands, board)
+    cards = merge(starting_hands, board)
+    cards.uniq.length != cards.length
+  end
+
+  def merge(starting_hands, board)
+    starting_hands.inject(board.cards) {|cards, starting_hand| cards.concat(starting_hand.cards)}
+  end
+
+end

data/lib/rora/utils/hand_ranking_generator.rb

@@ -0,0 +1,135 @@
+require 'date'
+
+class HandRankingGenerator
+
+  HEART_FLUSH=32
+  DIAMOND_FLUSH=243
+  SPADE_FLUSH=3125
+  CLUB_FLUSH=16807
+  
+  def initialize
+    @total = 133784560
+    @count = 0
+    @scores = {}
+  end
+
+  def generate_flush_map
+    file = File.new("flushes.csv", "w")
+
+    Suit.values().each do |suit_1|
+      Suit.values().each do |suit_2|
+        Suit.values().each do |suit_3|
+          Suit.values().each do |suit_4|
+            Suit.values().each do |suit_5|
+              Suit.values().each do |suit_6|
+                Suit.values().each do |suit_7|
+                  key = suit_1.id * suit_2.id * suit_3.id * suit_4.id * suit_5.id * suit_6.id * suit_7.id
+                  if(!@scores.has_key?(key))
+                    @scores[key] = key
+                    suit = flush_suit(key)
+                    if(!suit.nil?)
+                      count = flush_count([suit_1, suit_2, suit_3, suit_4, suit_5, suit_6, suit_7], suit)
+                      file.write("#{key},#{count},#{suit}\n")
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    file.close
+  end
+
+  def generate_non_flush_hand_rankings
+    file = File.new("7_card_non_flush_hands.csv", "w")
+    cds = Deck.new.cards
+
+    (0..45).each do |index_1|
+      ((index_1 + 1)..46).each do |index_2|
+        ((index_2 + 1)..47).each do |index_3|
+          ((index_3 + 1)..48).each do |index_4|
+            ((index_4 + 1)..49).each do |index_5|
+              ((index_5 + 1)..50).each do |index_6|
+                ((index_6 + 1)..51).each do |index_7|
+                  cards = [cds[index_1], cds[index_2], cds[index_3], cds[index_4], cds[index_5], cds[index_6], cds[index_7]].sort
+                  hand = get_best_hand(cards)
+                  key = get_key(cards, hand)
+                  if(!@scores.has_key?(key) && !hand.flush?)
+                    @scores[key] = hand.score
+                    file.write("#{hand.score},#{key}\n")
+                  end
+                  @count = @count + 1
+                  if(@count % 1000 == 0)
+                    puts "#{DateTime.now.strftime('%Y-%m-%d %H:%M:%S')} :: #{@count} records processed #{sprintf("%05.3f", (Float(@count)/Float(@total)) * 100.0)}% complete, #{@scores.size} records captured"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    file.close
+  end
+
+  def generate_flush_hand_rankings
+    file = File.new("7_card_flush_hands.csv", "w")
+    Suit.values().each do |suit|
+      generate_hand_rankings(suit, 6, 1, file)
+      generate_hand_rankings(suit, 7, 0, file)
+    end
+    file.close
+  end
+
+  private
+
+  def generate_hand_rankings(suit, i, j, file)
+    Deck.new.retain_all(suit).combination(i).each do |suited|
+      Deck.new.remove_all(suit).combination(j).each do |remainder|
+        cards = suited + remainder
+        hand = get_best_hand(cards)
+        key = get_key(cards, hand)
+        if(!@scores.has_key?(key))
+          @scores[key] = hand.score
+          file.write("#{hand.score},#{key}")
+        end
+        @count = @count + 1
+        if(@count % 1000 == 0)
+          puts "#{DateTime.now.strftime('%Y-%m-%d %H:%M:%S')} :: #{@count} records processed, #{@scores.size} records captured"
+        end
+      end
+    end
+  end
+
+  def flush_count(suits, suit)
+    count = 0
+    suits.each do |s|
+      count = count + 1 if s.key == suit
+    end
+    count
+  end
+
+  def flush_suit(key)
+    return "H" if(key % HEART_FLUSH == 0)
+    return "D" if(key % DIAMOND_FLUSH == 0)
+    return "S" if(key % SPADE_FLUSH == 0)
+    return "C" if(key % CLUB_FLUSH == 0)
+  end
+
+  def get_key(cards, hand)
+    cards.inject(1) {|product, card| product * (hand.flush? ? card.uid : card.rank.id) }
+  end
+
+  def ranks(cards)
+    cards.inject('') { |string, card| string << card.rank.key }
+  end
+
+  def get_best_hand(cards)
+    cards.combination(5).to_a.each.collect { |selection| Hand.new(selection) }.sort {|x,y| x.score <=> y.score }[0]
+  end
+
+end

data/test/rora/model/board_test.rb

@@ -7,19 +7,19 @@ class BoardTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a board is created with less than 3 cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "3 to 5 cards are required to create a board, 2 cards provided", ArgumentError do
       Board.new "AS,KS"
     end
   end
 
   test "should raise an error when a board is created with more than 5 cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "3 to 5 cards are required to create a board, 6 cards provided", ArgumentError do
       Board.new "AS,KS,QS,JS,TS,9S"
     end
   end
 
   test "should raise an error when a board is created with duplicate cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "The board contains duplicate cards", ArgumentError do
       Board.new "AS KS JS AS KS"
     end
   end
@@ -30,8 +30,6 @@ class BoardTest < ActiveSupport::TestCase
 
   test "the board should have three cards if the board was initialized with the flop" do
     assert_equal 3, Board.new("AS,KS,QS").cards.size
-    b = Board.new("AS,KS,QS")
-    puts b.flop
   end
 
   test "the board should have four cards if the board was initialized with the flop and turn" do
@@ -43,20 +41,20 @@ class BoardTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a flop is not created with 3 cards" do
-    assert_raise ArgumentError do
-      Board.new.flop "AS,KS"
+    assert_raise_message "3 cards are required on the flop, 2 cards provided", ArgumentError do
+      Board.new.flop= "AS,KS"
     end
   end
 
   test "should raise an error when a flop is set with duplicate cards" do
-    assert_raise ArgumentError do
-      Board.new.flop "AS AS JS"
+    assert_raise_message "The flop contains duplicate cards", ArgumentError do
+      Board.new.flop= "AS AS JS"
     end
   end
 
   test "should raise an error when a flop is set with no cards" do
-    assert_raise ArgumentError do
-      Board.new.flop []
+    assert_raise_message "Cannot deal a flop with empty array of cards", ArgumentError do
+      Board.new.flop= []
     end
   end
 
@@ -68,14 +66,14 @@ class BoardTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a turn card is dealt before the flop has been dealt" do
-    assert_raise RuntimeError do
+    assert_raise_message "The flop must be dealt before the turn card is dealt", RuntimeError do
       board = Board.new
       board.turn = "AS"
     end
   end
 
-  test "should raise an error when the turn card has already been dealt" do
-    assert_raise ArgumentError do
+  test "should raise an error when the turn card has already been dealt on the flop" do
+    assert_raise_message "The board already contains the Ace of Hearts", ArgumentError do
       board = Board.new
       board.flop= "AS,AH,AD"
       board.turn= "AH"
@@ -91,15 +89,15 @@ class BoardTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when the river card is dealt before the turn card has been dealt" do
-    assert_raise RuntimeError do
+    assert_raise_message "The turn card must be dealt before the river card is dealt", RuntimeError do
       board = Board.new
       board.flop = "AS KS QS"
       board.river = "JS"
     end
   end
 
-  test "should raise an error when the river card has already been dealt" do
-    assert_raise ArgumentError do
+  test "should raise an error when the river card was dealt on a previous street" do
+    assert_raise_message "The board already contains the Ace of Spades", ArgumentError do
       board = Board.new
       board.flop = "AS,KS,QS"
       board.turn = "JS"
@@ -121,9 +119,10 @@ class BoardTest < ActiveSupport::TestCase
     assert_equal false, @board.contains?(Card.new("3D"))
   end
 
-  test "should return true if the boad does contain the given card" do
-    assert_equal true, @board.contains?("TS")
-    assert_equal true, @board.contains?(Card.new("AS"))
+  test "should return true if the board contains the given card" do
+    b = Board.new "AS,KS,QS,JS,TS"
+    assert_equal true, b.contains?("TS")
+    assert_equal true, b.contains?(Card.new("AS"))
   end
 
   test "should return false if the board does not contain any of the given cards" do