rora 0.0.6 → 0.4.0

data/lib/rora/cards.csv

@@ -0,0 +1,52 @@
+AH,2
+KH,3
+QH,5
+JH,7
+TH,11
+9H,13
+8H,17
+7H,19
+6H,23
+5H,29
+4H,31
+3H,37
+2H,41
+AD,43
+KD,47
+QD,53
+JD,59
+TD,61
+9D,67
+8D,71
+7D,73
+6D,79
+5D,83
+4D,89
+3D,97
+2D,101
+AS,103
+KS,107
+QS,109
+JS,113
+TS,127
+9S,131
+8S,137
+7S,139
+6S,149
+5S,151
+4S,157
+3S,163
+2S,167
+AC,173
+KC,179
+QC,181
+JC,191
+TC,193
+9C,197
+8C,199
+7C,211
+6C,223
+5C,227
+4C,229
+3C,233
+2C,239

data/lib/rora/flushes.csv

@@ -0,0 +1,40 @@
+800,5,H
+1120,5,H
+480,5,H
+1568,5,H
+672,5,H
+288,5,H
+320,6,H
+448,6,H
+192,6,H
+128,7,H
+12500,5,S
+28125,5,S
+43750,5,S
+18750,5,S
+153125,5,S
+65625,5,S
+31250,6,S
+109375,6,S
+46875,6,S
+78125,7,S
+151263,5,C
+67228,5,C
+252105,5,C
+168070,5,C
+100842,5,C
+420175,5,C
+235298,6,C
+588245,6,C
+352947,6,C
+823543,7,C
+972,5,D
+2430,5,D
+3402,5,D
+11907,5,D
+6075,5,D
+8505,5,D
+1458,6,D
+3645,6,D
+5103,6,D
+2187,7,D

data/lib/rora/model/board.rb

@@ -54,14 +54,14 @@ class Board
   def turn= card
     cd = card.kind_of?(Card) ? card : Card.new(card)
     raise RuntimeError, "The flop must be dealt before the turn card is dealt" if @flop.nil?
-    raise ArgumentError, "The board already contains the #{cd.name}" if cards.include? cd
+    raise ArgumentError, "The board already contains the #{cd.value}" if cards.include? cd
     @turn = cd
   end
 
   def river= card
     cd = card.kind_of?(Card) ? card : Card.new(card)
     raise RuntimeError, "The turn card must be dealt before the river card is dealt" if @turn.nil?
-    raise ArgumentError, "The board already contains the #{cd.name}" if cards.include? cd
+    raise ArgumentError, "The board already contains the #{cd.value}" if cards.include? cd
     @river = cd
   end
 

data/lib/rora/model/card.rb

@@ -15,29 +15,31 @@
 # card = Card.new("kH")
 #
 class Card
-  attr_reader :rank, :suit
+  include Comparable
 
+  attr_reader :rank, :suit, :key, :uid
+  
   def initialize(*args)
     if(args.size == 2)
       @rank = args[0]
       @suit = args[1]
     end
     if(args.size == 1)
-      raise ArgumentError, "#{args} is an invalid card sequence" if args[0].length != 2
-      @rank = Rank.get(args[0][0])
-      @suit = Suit.get(args[0][1])
+      raise ArgumentError, "#{args[0]} is an invalid card sequence" if args[0].length != 2
+      @rank = Rank.get(args[0][0].chr)
+      @suit = Suit.get(args[0][1].chr)
     end
+    @key =  @rank.key + @suit.key
+    @card_repository = CardRepository.instance
+    @uid = @card_repository.get(@key)
   end
 
-  def id
-    @rank.id * @suit.id
+  def <=>(card)
+    return self.rank <=> card.rank if card.rank != self.rank
+    self.suit <=> card.suit
   end
 
-  def key
-    @rank.key + @suit.key
-  end
-
-  def name
+  def value
     "#{@rank.value} of #{@suit.value}s"
   end
 
@@ -46,11 +48,12 @@ class Card
   end
 
   def == card
-    self.id == card.id
+    return false if !card.kind_of? Card
+    uid == card.uid
   end
 
   def hash
-    return self.id
+     uid
   end
 
   def self.to_cards string
@@ -64,7 +67,7 @@ class Card
   end
 
   def to_s
-    "Card: #{name}"
+    "#{value}"
   end
 
 end

data/lib/rora/model/deck.rb

@@ -14,6 +14,29 @@ class Deck
         @cards << Card.new(rank, suit)
       end
     end
+    @cards.sort!
+  end
+
+  # Retains all cards with the given suit or rank, removing all others.
+  def retain_all argument
+    if argument.kind_of? Suit
+      @cards = @cards.find_all{|card| card.suit.eql?(argument) }
+    end
+    if argument.kind_of? Rank
+      @cards = @cards.find_all{|card| card.rank.eql?(argument) }
+    end
+    self
+  end
+
+  # Removes all cards with the given suit or rank, retaining all others.
+  def remove_all argument
+    if argument.kind_of? Suit
+      @cards = @cards.find_all{|card| !card.suit.eql?(argument) }
+    end
+    if argument.kind_of? Rank
+      @cards = @cards.find_all{|card| !card.rank.eql?(argument) }
+    end
+    self
   end
 
   # Shuffles all cards in the deck.

data/lib/rora/model/equity.rb

@@ -0,0 +1,18 @@
+class Equity
+
+  attr_accessor :starting_hand, :total_hands, :hands_won, :hands_tied, :value
+  
+  def initialize(total_hands_played, total_hands_won, result)
+    @starting_hand = result[0]
+    @total_hands = total_hands_played
+    @hands_won = result[1]
+    @hands_tied = total_hands_played - total_hands_won
+    total_equity = @hands_won + @hands_tied
+    @value = (total_equity == 0 ? 0.00 : total_equity.quo(@total_hands) * 100.00)
+  end
+
+  def to_s
+    "starting hand: #{@starting_hand.key} => hands: #{@total_hands}, won: #{@hands_won}, tied: #{@hands_tied}, equity: #{sprintf("%05.3f", @value)}%"
+  end
+
+end

data/lib/rora/model/hand.rb

@@ -11,43 +11,24 @@
 #
 class Hand
   attr_reader :cards
-
+  
   def initialize cards
     @hand_repository = HandRepository.instance
-    @cards = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+    @cards = (cards.kind_of?(Array) ? cards : Card.to_cards(cards)).sort
     raise ArgumentError, "Exactly 5 cards are required to create a hand, #{cards.size} provided" if @cards.size != 5
     raise ArgumentError, "The hand contains duplicate cards" if @cards.uniq.length != @cards.length
   end
 
-  # Returns the hand id.
-  def id
-    i = 1
-    @cards.each { |card| i = i * card.id }
-    i
-  end
-
-  # Returns the hand hash key.
-  def hash_key
-    j = 1
-    @cards.each { |card| j = j * card.rank.id  }
-    flush? ? (j * 67) : j
-  end
-
-  # Returns the hand value.
-  def value
-    @cards.map { |card| "#{card.key}" }.join(",")
+  # Returns the hand key.
+  def key
+    @cards.map { |card| "#{card.key}" }.join
   end
 
-  # Returns the hand strength, from 1 (strongest) to 7462 (weakest).
+  # Returns the hand score, from 1 (strongest) to 7462 (weakest).
   def score
     resolve_hand_attribute(0)
   end
 
-  # Returns the probability of this hand being dealt.
-  def probability
-    resolve_hand_attribute(3)
-  end
-
   # Returns the hand name.
   def name
     resolve_hand_attribute(2)
@@ -65,7 +46,7 @@ class Hand
 
   # Determines if this hand is a flush.
   def flush?
-    for i in 0..@cards.size - 2 do
+    for i in 0..(@cards.size - 2) do
       return false if @cards[i].suit != @cards[i+1].suit
     end
     true
@@ -116,10 +97,14 @@ class Hand
     @cards.contains cards
   end
 
+  def to_s
+    "#{@cards.inject('') { |string, card| string << card.key }} (#{name})"
+  end
+
   private
 
   def resolve_hand_attribute value
-    @hand_repository.find(hash_key)[value]
+    @hand_repository.evaluate_5_card_hand(cards)[value]
   end
 
 end

data/lib/rora/model/hand_type.rb

@@ -30,7 +30,7 @@ class HandType
     self.values.each do |type|
       return type if type.key.casecmp(key) == 0
     end
-    raise ArgumentError, "No hand type exists for key " + key
+    raise ArgumentError, "No hand type exists for key '#{key}'"
   end
 
   def to_s

data/lib/rora/model/pot.rb

@@ -10,7 +10,7 @@ class Pot
  
   # Adds the specified bet to the pot
   def add bet
-    raise ArgumentError if bet < 0
+    raise ArgumentError, "Can only add positive values" if bet < 0
     @value += bet
     self
   end

data/lib/rora/model/rank.rb

@@ -8,8 +8,10 @@
 # and the strongest value (12) assigned to the ace.
 #
 class Rank
-  attr_reader :id, :key, :value, :order
+  include Comparable
 
+  attr_reader :id, :key, :value, :order
+  
   def initialize(id, key, value, order)
     @id = id
     @key = key
@@ -23,30 +25,46 @@ class Rank
 
   def self.get(key)
     self.values.each do |rank|
-      return rank if rank.key.casecmp(key) == 0
+      return rank if(rank.key.casecmp(key) == 0)
     end
     raise ArgumentError, "No rank exists for key '#{key}'"
   end
 
+  def <=>(rank)
+    self.order <=> rank.order
+  end
+
+  def eql? rank
+    self == rank
+  end
+
+  def == rank
+    self.key == rank.key
+  end
+
+  def hash
+    return self.rank.ord
+  end
+
   def to_s
-    "Rank: #{@value}"
+    "#{@value}"
   end
 
   class << self
     private :new
   end
 
-	TWO = new(2, "2", "Two", 0)
-  THREE = new(3, "3", "Three", 1)
-  FOUR = new(5, "4", "Four", 2)
-  FIVE = new(7, "5", "Five", 3)
-  SIX = new(11, "6", "Six", 4)
-  SEVEN = new(13, "7", "Seven", 5)
-  EIGHT = new(17, "8", "Eight", 6)
-  NINE = new(19, "9", "Nine", 7)
-  TEN = new(23, "T", "Ten", 8)
-  JACK = new(29, "J", "Jack", 9)
-  QUEEN = new(31, "Q", "Queen", 10)
-  KING = new(37, "K", "King", 11)
-  ACE = new(41, "A", "Ace", 12)
+  TWO = new(2, "2", "Two", 13)
+  THREE = new(3, "3", "Three", 12)
+  FOUR = new(5, "4", "Four", 11)
+  FIVE = new(7, "5", "Five", 10)
+  SIX = new(11, "6", "Six", 9)
+  SEVEN = new(13, "7", "Seven", 8)
+  EIGHT = new(17, "8", "Eight", 7)
+  NINE = new(19, "9", "Nine", 6)
+  TEN = new(23, "T", "Ten", 5)
+  JACK = new(29, "J", "Jack", 4)
+  QUEEN = new(31, "Q", "Queen", 3)
+  KING = new(37, "K", "King", 2)
+  ACE = new(41, "A", "Ace", 1)
 end

data/lib/rora/model/starting_hand.rb

@@ -3,18 +3,14 @@
 # one player and remain hidden from the other players.
 #
 class StartingHand
-  attr_reader :id, :key, :cards
-
+  attr_reader :cards, :key, :id
+  
   def initialize cards
-    @cards = Array.new, @id = 1, @key = 1
-
-    @cards = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+    @cards = (cards.kind_of?(Array) ? cards : Card.to_cards(cards)).sort
     raise ArgumentError, "Exactly 2 cards are required to create a starting hand, #{@cards.size} provided" if @cards.size != 2
-    raise ArgumentError, "The hand contains duplicate cards" if @cards.uniq.length != @cards.length
-
-    @cards.each {|card| @id *= card.id}
-    @cards.each {|card| @key *= card.rank.id}
-    @key = suited? ? @key * 67 : @key
+    raise ArgumentError, "The starting hand contains duplicate cards" if @cards.uniq.length != @cards.length
+    @key = @cards.inject('') { |string, card| string << card.key }
+    @id = @cards.inject(1) { |product, card| product * card.uid }
   end
 
   # Returns all cards contained in the starting hand.
@@ -22,11 +18,10 @@ class StartingHand
     @cards.dup
   end
 
-  # Returns the starting hand value.
   def value
-    @cards.map { |card| "#{card.key}" }.join(",")
+    @cards.map { |card| "#{card.value}" }.join(", ")
   end
-
+  
   # Returns the shorthand notation for the starting hand.
   #
   # It is often desirable to have a short hand notation for starting hands,
@@ -52,10 +47,7 @@ class StartingHand
 
   # Determines if the starting hand is suited.
   def suited?
-    for i in 0..@cards.size - 2 do
-      return false if @cards[i].suit != @cards[i+1].suit
-    end
-    true
+    @cards[0].suit == @cards[1].suit
   end
 
   # Returns all possible starting hands.
@@ -99,8 +91,20 @@ class StartingHand
     StartingHandRepository.instance.distinct_starting_hands
   end
 
+  def eql? starting_hand
+    self == starting_hand
+  end
+
+  def == starting_hand
+    self.id == starting_hand.id
+  end
+
+  def hash
+    return self.id
+  end
+
   def to_s
-    "StartingHand => " + @cards[0].to_s + ", " + @cards[1].to_s
+    value
   end
 
 end