rora 0.0.5

data/lib/rora/model/board.rb

@@ -0,0 +1,95 @@
+#
+# The logical table area where community cards are dealt.
+#
+# A board can be initialized with flop, turn and river cards.
+#
+# # A board with the flop set
+# board_one = Board.new "AS,KS,QS"
+#
+# # A board with the flop and turn set
+# board_two = Board.new "AS,KS,QS,JS"
+#
+# # A board with the flop, turn and river set.
+# board_three = Board.new "AS,KS,QS,JS,TS"
+#
+# # An empty baord can be created as well.
+# board_four = Board.new
+#
+# Boards may also be populated programmatically using the flop, turn and
+# river methods respectively:
+#
+# board = Board.new
+# board.flop = "AS,KS,QS"
+# board.turn = "JS"
+# board.river = "TS"
+#
+class Board
+  attr_reader :flop, :turn, :river
+
+  def initialize cards=nil
+    return if cards.nil?
+
+    cds = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+    raise ArgumentError, "3 to 5 cards are required to create a board, #{cds.size} cards provided" if cds.size < 3 || cds.size > 5
+    raise ArgumentError, "The board contains duplicate cards" if cds.uniq.length != cds.length
+
+    @flop = cds[0..2]
+    @turn = cds[3] if cds.size >= 4
+    @river = cds[4] if cds.size == 5
+  end
+
+  def flop
+    @flop.dup if !@flop.nil?
+  end
+
+  def flop= cards
+    raise ArgumentError, "Cannot deal a flop with empty array of cards" if cards.nil? || cards.empty?
+
+    cds = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+    raise ArgumentError, "3 cards are required on the flop, #{cds.size} cards provided" if cds.size !=3
+    raise ArgumentError, "The flop contains duplicate cards" if cds.uniq.length != cds.length
+    @flop = cds[0..2]
+  end
+
+  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
+    @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
+    @river = cd
+  end
+
+  def cards
+    cds = Array.new
+    cds += @flop if !@flop.nil?
+    cds.push(@turn) if !@turn.nil?
+    cds.push(@river) if !@river.nil?
+    cds
+  end
+
+  # Determines if the board contains the given card.
+  def contains? argument
+    if argument.kind_of? Card
+      return cards.include?(argument)
+    end
+    cards.include? Card.new(argument)
+  end
+
+  # Determines if the board contains any of the given cards.
+  def contains_any? argument
+    if argument.kind_of? Array
+      argument.each {|card| return true if cards.include? card}
+    end
+    if argument.kind_of? String
+      Card.to_cards(argument).each {|card| return true if cards.include? card}
+    end
+    false
+  end
+
+end

data/lib/rora/model/card.rb

@@ -0,0 +1,74 @@
+#
+# One of 52 of cards that are used to play card games.
+#
+# A card is comprised of one rank and one suit, with 13 ranks and 4 suits there
+# are 52 unique playing cards.  A card can be created in one of two ways:
+#
+# The first method uses the Rank and Suit enumerators
+# card = Card.new(Rank::KING, Suit::HEART)
+#
+# The second method uses rank and suit values.
+# card = Card.new("KH")
+#
+# Rank and suit values are case insensitive, so these work as well
+# card = Card.new("Kh")
+# card = Card.new("kH")
+#
+class Card
+  attr_reader :rank, :suit
+
+  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])
+    end
+  end
+
+  def id
+    @rank.id * @suit.id
+  end
+
+  def key
+    @rank.key + @suit.key
+  end
+
+  def value
+    @rank.value + @suit.value
+  end
+
+  def name
+    "#{@rank.value} of #{@suit.value}s"
+  end
+
+  def eql? card
+    self == card
+  end
+
+  def == card
+    self.id == card.id
+  end
+
+  def hash
+    return self.id
+  end
+
+  def self.to_cards string
+    cards = Array.new
+    if !string.include?(",") && !string.include?(" ")
+      string.scan(/../).each { |chars| cards << Card.new(chars) }
+    else
+      string.split(string.include?(",") ? "," : " ").each { |chars| cards << Card.new(chars) }
+    end
+    cards
+  end
+
+  def to_s
+    "Card: name='#{name}' value='#{@rank.key}#{@suit.key}' id=#{id}"
+  end
+
+end

data/lib/rora/model/deck.rb

@@ -0,0 +1,109 @@
+#
+# A complete set of 52 playing cards.
+#
+# A deck of cards may be used for playing a great variety of card games, with
+# varying elements of skill and chance, some of which are played for money.
+#
+class Deck
+  attr_reader :cards
+
+  def initialize
+    @cards = Array.new
+    Suit.values.each do |suit|
+      Rank.values.each do |rank|
+        @cards << Card.new(rank, suit)
+      end
+    end
+  end
+
+  # Shuffles all cards in the deck.
+  def shuffle
+    @cards.shuffle!
+    self
+  end
+
+  # Returns the number of cards in the deck.
+  def size
+    @cards.size
+  end
+
+  # Deals a single card from the deck.
+  def deal
+    @cards.delete_at 0
+  end
+
+  # Determines if the deck is empty.
+  def empty?
+    @cards.empty?
+  end
+
+  # Returns a shallow copy of the cards in the deck.
+  def cards
+    @cards.dup
+  end
+
+  # Returns the total number of cards with the given rank in the deck.
+  def count_cards_with_rank rank
+    count = 0;
+    @cards.each do |card|
+      count +=1 if card.rank.eql?(rank)
+    end
+    count
+  end
+
+  # Returns the total number of cards with the given suit in the deck.
+  def count_cards_with_suit suit
+    count = 0;
+    @cards.each do |card|
+      count +=1 if card.suit.eql?(suit)
+    end
+    count
+  end
+
+  # Removes cards from the deck.
+  #
+  # This method can remove a Card, an Enumerable (an Array or Hash
+  # of Cards) or a StartingHand from the deck.
+  def remove argument
+    if argument.kind_of? Card
+      @cards.delete argument
+    end
+    if argument.kind_of? Enumerable
+      argument.each { |card| @cards.delete card }
+    end
+    if argument.kind_of? StartingHand
+      argument.cards.each { |card| @cards.delete card }
+    end
+    if argument.kind_of? Board
+      argument.cards.each { |card| @cards.delete card }
+    end
+    if argument.kind_of? String
+      Card.to_cards(argument).each { |card| @cards.delete card }
+    end
+    self
+  end
+
+  # Determines if the deck contains the given card.
+  def contains? argument
+    if argument.kind_of? Card
+      return @cards.include?(argument)
+    end
+    @cards.include? Card.new(argument)
+  end
+
+  # Determines if the deck contains any of the given cards.
+  def contains_any? argument
+    if argument.kind_of? Array
+      argument.each {|card| return true if @cards.include? card}
+    end
+    if argument.kind_of? String
+      Card.to_cards(argument).each {|card| return true if @cards.include? card}
+    end
+    false
+  end
+
+  def combination number
+    cards.combination(number).to_a
+  end
+
+end

data/lib/rora/model/game.rb

@@ -0,0 +1,8 @@
+class Game
+  attr_reader :table, :players, :dealer
+
+  def initialize
+
+  end
+
+end

data/lib/rora/model/hand.rb

@@ -0,0 +1,126 @@
+#
+# A subset of cards held at one time by a player during a game.
+#
+# A hand consists of exactly five cards, and can be created in one of two ways.
+#
+# A hand can be created with an array of cards.
+# hand = Hand.new([c1,c2,c3,c4,c5])
+#
+# A hand can be created with string representation of each card.
+# hand = Hand.new("ACKCJS9H4H")
+#
+class Hand
+  attr_reader :cards, :hand_repository
+
+  def initialize cards
+    @hand_repository = HandRepository.instance
+    @cards = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+
+    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(",")
+  end
+
+  # Returns the hand strength, 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)
+  end
+
+  # Returns the hand type.
+  def type
+    HandType.get resolve_hand_attribute(1)
+  end
+
+  # Returns all cards contained in the hand.
+  def cards
+    @cards.dup
+  end
+
+  # Determines if this hand is a flush.
+  def flush?
+    for i in 0..@cards.size - 2 do
+      return false if @cards[i].suit != @cards[i+1].suit
+    end
+    true
+  end
+
+  # Determines if this hand is a straight flush.
+  def straight_flush?
+    type == HandType::STRAIGHT_FLUSH
+  end
+
+  # Determines if this hand is four of a kind.
+  def four_of_a_kind?
+    type == HandType::FOUR_OF_A_KIND
+  end
+
+  # Determines if this hand is a full house.
+  def full_house?
+    type == HandType::FULL_HOUSE
+  end
+
+  # Determines if this hand is a straight.
+  def straight?
+    type == HandType::STRAIGHT
+  end
+
+  # Determines if this hand is a three of a kind.
+  def three_of_a_kind?
+    type == HandType::THREE_OF_A_KIND
+  end
+
+  # Determines if this hand is two pair.
+  def two_pair?
+    type == HandType::TWO_PAIR
+  end
+
+  # Determines if this hand has one pair.
+  def one_pair?
+    type == HandType::ONE_PAIR
+  end
+
+  # Determines if this hand is a high card.
+  def high_card?
+    type == HandType::HIGH_CARD
+  end
+
+  # Determines if this hand contains the given cards.
+  def contains cards
+    @cards.contains cards
+  end
+
+  private
+
+  def resolve_hand_attribute value
+    @hand_repository.find(hash_key)[value]
+  end
+
+end

data/lib/rora/model/hand_type.rb

@@ -0,0 +1,53 @@
+#
+# The nine different types of 5-card poker hand.
+#
+# A 5-card poker hand will be one of the following hand types:
+#
+# 1. High Card
+# 2. One Pair
+# 3. Two Pair
+# 4. Three of a Kind
+# 5. Straight
+# 6. Flush
+# 7. Full House
+# 8. Four of a Kind
+# 9. Straight Flush
+#
+class HandType
+  attr_reader :key, :value, :order
+
+  def initialize(key, value, order)
+    @key = key
+    @value = value
+    @order = order
+  end
+
+  def self.values
+    [HIGH_CARD, ONE_PAIR, TWO_PAIR, THREE_OF_A_KIND, STRAIGHT, FLUSH, FULL_HOUSE, FOUR_OF_A_KIND, STRAIGHT_FLUSH]
+  end
+
+  def self.get(key)
+    self.values.each do |type|
+      return type if type.key.casecmp(key) == 0
+    end
+    raise ArgumentError, "No hand type exists for key " + key
+  end
+
+  def to_s
+    "HandType: key='#{@key}', value='#{@value}'"
+  end
+
+  class << self
+    private :new
+  end
+
+	HIGH_CARD = new("HC", "High Card", 1)
+  ONE_PAIR = new("1P", "One Pair", 2)
+  TWO_PAIR = new("2P", "Two Pair", 3)
+  THREE_OF_A_KIND = new("3K", "Three of a Kind", 4)
+  STRAIGHT = new("ST", "Straight", 5)
+  FLUSH = new("FL", "Flush", 6)
+  FULL_HOUSE = new("FH", "Full House", 7)
+  FOUR_OF_A_KIND = new("4K", "Four of a Kind", 8)
+  STRAIGHT_FLUSH = new("SF", "Straight Flush", 9)
+end

data/lib/rora/model/player.rb

@@ -0,0 +1,8 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class Player
+  def initialize
+    
+  end
+end

data/lib/rora/model/pot.rb

@@ -0,0 +1,21 @@
+#
+# The sum of money that players wager during a single hand or game.
+#
+class Pot
+
+  attr_reader :total
+
+  def initialize
+    @total = 0
+  end
+
+  def add bet
+    @total += bet
+    self
+  end
+
+  def to_s
+    "Pot: " + sprintf("$%.02f" , @total)
+  end
+
+end

data/lib/rora/model/rank.rb

@@ -0,0 +1,52 @@
+#
+# The thirteen different hierarchical values in a deck of cards.
+#
+# A deck of cards has thirteen ranks: 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen,
+# King, Ace.
+#
+# The ranks have a natural order, with the weakest value (0) assigned to the 2
+# and the strongest value (12) assigned to the ace.
+#
+class Rank
+  attr_reader :id, :key, :value, :order
+
+  def initialize(id, key, value, order)
+    @id = id
+    @key = key
+    @value = value
+    @order = order
+  end
+
+  def self.values
+    [TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE]
+  end
+
+  def self.get(key)
+    self.values.each do |rank|
+      return rank if rank.key.casecmp(key) == 0
+    end
+    raise ArgumentError, "No rank exists for key " + key
+  end
+
+  def to_s
+    "Rank: id=#{@id}, key='#{@key}', 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)
+end

data/lib/rora/model/starting_hand.rb

@@ -0,0 +1,102 @@
+#
+# Two cards, also known as hole cards or pocket cards, which belong solely to
+# one player and remain hidden from the other players.
+#
+class StartingHand
+  attr_reader :id, :key, :cards
+
+  def initialize cards
+    @cards = Array.new, @id = 1, @key = 1
+
+    @cards = cards.kind_of?(Array) ? cards : Card.to_cards(cards)
+    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
+  end
+
+  # Returns all cards contained in the starting hand.
+  def cards
+    @cards.dup
+  end
+
+  # Returns the starting hand value.
+  def value
+    @cards.map { |card| "#{card.key}" }.join(",")
+  end
+
+  # Returns the shorthand notation for the starting hand.
+  #
+  # It is often desirable to have a short hand notation for starting hands,
+  # ignoring card suits and simply describing whether the starting hand is
+  # suited or not. The shorthand notation removes suit characters, and
+  # appends an 'o' (offsuit) or 's' (suited) to the card ranks.
+  #
+  # Starting hand consisting of the Ace of Clubs and Jack of Clubs:
+  # card.value == 'AC,JC'
+  # card.short_value == 'JCs'
+  #
+  # Starting hand consisting of the Ten of Hearts and Eight of Clubs:
+  # card.value == 'TH,8C',
+  # card.short_value == 'T8o'
+  def short_value
+    @cards[0].rank.key + @cards[1].rank.key + (suited? ? "s" : "o")
+  end
+
+  # Determines if the starting hand is a pocket pair.
+  def pocket_pair?
+    cards[0].rank == cards[1].rank
+  end
+
+  # 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
+  end
+
+  # Returns all possible starting hands.
+  #
+  # There are exaclty 1,326 (52c2) starting hands. This method returns
+  # a list containing every possible starting hand.
+  def self.all_starting_hands
+    StartingHandRepository.instance.all_starting_hands
+  end
+
+  # Returns all distinct starting hands.
+  #
+  # While there are 1,324 starting hands, many of these starting hands have
+  # the same value in poker. To elaborate on this a bit, consider the
+  # number of hands a player could have containing a Jack and a Seven:
+  #
+  # J♣ 7♦
+  # J♠ 7♦
+  # J♥ 7♦
+  # J♦ 7♦
+  # J♣ 7♠
+  # J♠ 7♠
+  # J♥ 7♠
+  # J♦ 7♠
+  # J♣ 4♥
+  # J♠ 4♥
+  #
+  # This list goes on a bit further further. You might be surprised to know
+  # that there are 16 starting hand combinations that contain exactly one
+  # Jack and one Seven. Out of this list of 16, only two card values have any
+  # relevance in a poker game - Jack-Seven suited and Jack-Seven unsuited.
+  #
+  # This exercise demonstrates that while there are 1,324 starting hands to
+  # contend with, the number of distinct starting hands is dramatically
+  # lower. This is because card suits don’t tend to affect the score of the
+  # hand.
+  #
+  # Once all 1,324 poker hands are collapsed into distinct values, we end up
+  # with just 169 starting hands!
+  def self.distinct_starting_hands
+    StartingHandRepository.instance.distinct_starting_hands
+  end
+
+end

data/lib/rora/model/suit.rb

@@ -0,0 +1,43 @@
+#
+# The four categories in a deck of cards.
+#
+# Each card bears one of four symbols showing which suit it belongs to. A deck
+# of cards has four suits: hearts, clubs, spades, and diamonds.
+#
+class Suit
+  attr_reader :id, :key, :value
+
+  def initialize(id, key, value)
+    @id = id
+    @key = key
+    @value = value
+  end
+
+  def self.values
+    [HEART, SPADE, CLUB, DIAMOND]
+  end
+
+  def self.get(key)
+    self.values.each do |suit|
+      return suit if suit.key.casecmp(key) == 0
+    end
+    raise ArgumentError, "No suit exists for key " + key
+  end
+
+  def to_s
+    "Suit: id=#{@id}, key='#{@key}', value='#{@value}'"
+  end
+
+  def == suit
+    self.id == suit.id
+  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")
+end