ofcp_scoring 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: 10da65d396f4b5efaf31275afdf8100f8f2b7a8c
+  data.tar.gz: 5ea2afe03038edb5e9b4cd8408d255659c5c1d93
+!binary "U0hBNTEy":
+  metadata.gz: 9f1e47a0593cf4276ed52dd9f77e848f9f87f45607e3657c4cdcf7167b33673bdc72d7cfd2960b97c41b79ae1a4914b29fa0b56fe8b9e187c89c5721c6b4aab6
+  data.tar.gz: 5ba7cafebbc4e425ac7106b92410ef9d078a87d1be2e9c3f4deda9f1b36dc6efaf898f593aaf13c75951e4492ecae6c3e6b8d54e1fae963b8e3a266837528603

data/.autotest

@@ -0,0 +1,8 @@
+require "autotest/bundler"
+require "autotest/doom"
+
+Autotest.add_hook(:initialize) do |at|
+  at.add_exception %r{^\.git}  # ignore Version Control System
+  at.add_exception %r{^./tmp}
+  at.add_exception %r{^./coverage}
+end

data/.gitignore

@@ -0,0 +1,2 @@
+coverage/
+ofcp.sublime-*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format d

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "2.0.0"
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ofcp_scoring.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    ofcp_scoring (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  ofcp_scoring!
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Clayton Lengel-Zigich
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# Open Face Chinese Poker Scoring
+
+A library for evaluating two open face chinese poker hands.
+
+## Build Status
+[![Build Status](https://travis-ci.org/clayton/ofcp_scoring.png)](https://travis-ci.org/clayton/ofcp_scoring)
+
+## Getting Started
+
+Without Bundler:
+`gem install ofcp_scoring`
+
+With Bundler:
+Add `gem 'ofcp_scoring'` to your Gemfile
+
+## Basic Usage
+
+The basic scoring engine will evaluate two Chinese Poker hands calculating
+royalties and scoop bonuses.
+
+Example:
+
+    engine = OfcpScoring::ScoringEngine.new
+    engine.score(
+      %w(2h 3h 5h 10d 10h 4h 7c 8s Jd Js 6c 7d 9c),
+      %w(Ah 3h 5h 6d 6h 4h 7c 8s Qd Qs 6c 7d 9c)
+    )
+    #=> [1,2]
+
+## Royalty Calculation
+
+With Royalties you receive the following points for Back hands:
+
+* 20 for a Royal
+* 10 for StraightFlush
+* 8 for Quads
+* 6 for a Full House
+* 4 for a OfcpScoring::Flush
+* 2 for a Straight
+
+You receive the following points for Middle hands:
+
+* 20 for StraightFlush
+* 16 for Quads
+* 2 for a Full House
+* 8 for a OfcpScoring::Flush
+* 4 for a Straight
+
+You receive the following points for Front hands (the 3 card hand):
+
+* Pair of Aces: 9 points
+* Pair of Kings: 8 points
+* Pair of Queens: 7 points
+* Pair of Jacks: 6 points
+* Pair of Tens: 5 points
+* Pair of Nines: 4 points
+* Pair of Eights: 3 points
+* Pair of Sevens: 2 points
+* Paid of Sixes: 1 point

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/ofcp_scoring/chinese_poker_hand.rb

@@ -0,0 +1,22 @@
+class OfcpScoring::ChinesePokerHand
+  def initialize(hand)
+    @hand = hand
+  end
+
+  def front
+    @hand[:front]
+  end
+
+  def middle
+    @hand[:middle]
+  end
+
+  def back
+    @hand[:back]
+  end
+
+  def misset?
+    true if front > middle || middle > back || front > back
+  end
+
+end

data/lib/ofcp_scoring/flush.rb

@@ -0,0 +1,11 @@
+require_relative 'ranked_hand'
+class OfcpScoring::Flush < OfcpScoring::RankedHand
+  def <=>(other)
+    return super if super
+    highest_flush_card <=> other.highest_flush_card
+  end
+
+  def highest_flush_card
+    ranks.max
+  end
+end

data/lib/ofcp_scoring/four_of_a_kind.rb

@@ -0,0 +1,10 @@
+class OfcpScoring::FourOfAKind < OfcpScoring::RankedHand
+  def <=>(other)
+    return super if super
+    highest_quad_card <=> other.highest_quad_card
+  end
+
+  def highest_quad_card
+    grouped_ranks.map{|card,matches| card if matches.size == 4}.compact.max
+  end
+end

data/lib/ofcp_scoring/full_house.rb

@@ -0,0 +1,4 @@
+require_relative 'three_of_a_kind'
+class OfcpScoring::FullHouse < OfcpScoring::ThreeOfAKind
+
+end

data/lib/ofcp_scoring/hand_categorizer.rb

@@ -0,0 +1,30 @@
+class OfcpScoring::HandCategorizer
+
+  def initialize(organizer = OfcpScoring::HandOrganizer.new)
+    @organizer = organizer
+  end
+
+  def categorize(hand)
+    return "" if hand.nil?
+
+    organized_hand = @organizer.organize(hand)
+
+    categorization = OfcpScoring::HighCard
+    categorization = OfcpScoring::Pair if organized_hand.two_cards_match?
+    categorization = OfcpScoring::TwoPair if organized_hand.two_different_cards_match?
+    categorization = OfcpScoring::ThreeOfAKind if organized_hand.three_cards_match?
+
+    unless organized_hand.three_card_hand?
+      categorization = OfcpScoring::Straight if organized_hand.ranks_in_order?
+      categorization = OfcpScoring::Flush if organized_hand.all_suits_match?
+      categorization = OfcpScoring::FullHouse if organized_hand.three_cards_match? && organized_hand.two_cards_match?
+      categorization = OfcpScoring::FourOfAKind if organized_hand.four_cards_match?
+      categorization = OfcpScoring::StraightFlush if organized_hand.all_suits_match? && organized_hand.ranks_in_order?
+      categorization = OfcpScoring::RoyalFlush if organized_hand.all_suits_match? && organized_hand.ranks_in_order? && organized_hand.high_card_ace?
+    end
+
+    return categorization.new(organized_hand)
+
+  end
+
+end

data/lib/ofcp_scoring/hand_evaluator.rb

@@ -0,0 +1,50 @@
+class OfcpScoring::HandEvaluator
+  def initialize(hand_factory = OfcpScoring::HandFactory.new, royalties_calculator = OfcpScoring::RoyaltiesCalculator.new)
+    @hand_factory = hand_factory
+    @royalties_calculator = royalties_calculator
+    @hand_one_score = 0
+    @hand_two_score = 0
+    @hand_one_royalties = 0
+    @hand_two_royalties = 0
+
+  end
+  def evaluate(hand_one, hand_two)
+    organized_hand_one = @hand_factory.build(hand_one)
+    organized_hand_two = @hand_factory.build(hand_two)
+
+    score_hands(organized_hand_one, organized_hand_two)
+  end
+
+private
+  def score_hands(organized_hand_one, organized_hand_two)
+    [:front, :middle, :back].each do |sub_hand|
+      if organized_hand_one.send(sub_hand) > organized_hand_two.send(sub_hand)
+        @hand_one_score += 1
+        @hand_one_royalties += @royalties_calculator.calculate_bonus(organized_hand_one.send(sub_hand), sub_hand)
+      end
+      if organized_hand_two.send(sub_hand) > organized_hand_one.send(sub_hand)
+        @hand_two_score += 1
+        @hand_two_royalties += @royalties_calculator.calculate_bonus(organized_hand_two.send(sub_hand), sub_hand)
+      end
+    end
+
+    adjust_for_missets(organized_hand_one, organized_hand_two)
+
+    [(@hand_one_score + @hand_one_royalties), (@hand_two_score + @hand_two_royalties)]
+  end
+
+  def adjust_for_missets(organized_hand_one, organized_hand_two)
+    if organized_hand_one.misset?
+      @hand_one_score = 0
+      @hand_two_score = 3
+    end
+
+    if organized_hand_two.misset?
+      @hand_one_score = 3
+      @hand_two_score = 0
+    end
+
+    @hand_one_score += 3 if @hand_two_score == 0
+    @hand_two_score += 3 if @hand_one_score == 0
+  end
+end

data/lib/ofcp_scoring/hand_factory.rb

@@ -0,0 +1,12 @@
+class OfcpScoring::HandFactory
+  def initialize(categorizer = OfcpScoring::HandCategorizer.new)
+    @categorizer = categorizer
+  end
+  def build(hand)
+    OfcpScoring::ChinesePokerHand.new({
+      :front  => @categorizer.categorize(hand[0..2]),
+      :middle => @categorizer.categorize(hand[3..7]),
+      :back   => @categorizer.categorize(hand[8..12])
+    })
+  end
+end

data/lib/ofcp_scoring/hand_organizer.rb

@@ -0,0 +1,45 @@
+class OfcpScoring::HandOrganizer
+  def organize(hand)
+    return "" if hand.nil?
+    suits_only = Hash.new(0)
+    ranks_only = Hash.new(0)
+    sorted_ranks = []
+    hand.each do |card|
+      ranks_only[card[0..-2]] += 1
+      suits_only[card[1]] += 1
+      case card[0]
+      when "A"
+        sorted_ranks << 1
+      when "K"
+        sorted_ranks << 13
+      when "Q"
+        sorted_ranks << 12
+      when "J"
+        sorted_ranks << 11
+      else
+        sorted_ranks << card[0..-2].to_i
+      end
+    end
+
+    sorted_ranks.sort!
+
+    OfcpScoring::OrganizedHand.new(build_organized_hand(ranks_only, suits_only, sorted_ranks))
+  end
+
+private
+  def build_organized_hand(ranks, suits, sorted)
+    params = {:ranks => sorted}
+
+    params.merge!({:two_cards_match => true}) if ranks.values.include?(2)
+    params.merge!({:two_different_cards_match => true}) if ranks.find_all{|k,v| v == 2}.size > 1
+    params.merge!({:three_cards_match => true}) if ranks.values.include?(3)
+    params.merge!({:four_cards_match => true}) if ranks.values.include?(4)
+    params.merge!({:all_suits_match => true}) if suits.values.include?(5)
+    params.merge!({:ranks_in_order => true}) if (sorted.first..sorted.last).to_a == sorted
+    params.merge!({:ranks_in_order => true}) if (sorted & [1,10,11,12,13]) == sorted
+    params.merge!({:high_card_ace => true}) if sorted.include?(1)
+    params.merge!({:three_card_hand => true}) if sorted.size == 3
+
+    params
+  end
+end

data/lib/ofcp_scoring/high_card.rb

@@ -0,0 +1,6 @@
+class OfcpScoring::HighCard < OfcpScoring::RankedHand
+  def <=>(other)
+    return super if super
+    self.ranks.max <=> other.ranks.max
+  end
+end

data/lib/ofcp_scoring/organized_hand.rb

@@ -0,0 +1,37 @@
+class OfcpScoring::OrganizedHand
+  def initialize(organized_hand)
+    @hand = organized_hand
+  end
+
+  def ranks
+    @hand[:ranks]
+  end
+
+  def two_cards_match?
+    @hand[:two_cards_match]
+  end
+
+  def two_different_cards_match?
+    @hand[:two_different_cards_match]
+  end
+
+  def three_cards_match?
+    @hand[:three_cards_match]
+  end
+
+  def four_cards_match?
+    @hand[:four_cards_match]
+  end
+
+  def all_suits_match?
+    @hand[:all_suits_match]
+  end
+
+  def ranks_in_order?
+    @hand[:ranks_in_order]
+  end
+
+  def three_card_hand?
+    @hand[:three_card_hand]
+  end
+end

data/lib/ofcp_scoring/pair.rb

@@ -0,0 +1,16 @@
+class OfcpScoring::Pair < OfcpScoring::RankedHand
+
+  def <=>(other)
+    return super if super
+    if highest_paired_card == other.highest_paired_card
+      compare_ranks(other)
+    else
+      highest_paired_card <=> other.highest_paired_card
+    end
+  end
+
+  def highest_paired_card
+    grouped_ranks.map{|card,matches| card if matches.size == 2}.compact.first
+  end
+
+end

data/lib/ofcp_scoring/ranked_hand.rb

@@ -0,0 +1,35 @@
+class OfcpScoring::RankedHand
+  include Comparable
+
+  RANKINGS = [
+    "HighCard", "Pair", "TwoPair", "ThreeOfAKind", "Straight", "Flush",
+    "FullHouse", "FourOfAKind", "StraightFlush", "RoyalFlush"
+  ]
+
+  def rank_name
+    self.class.to_s.split("::").last
+  end
+
+  def <=>(other_hand)
+    RANKINGS.index(rank_name) <=> RANKINGS.index(other_hand.rank_name) unless rank_name == other_hand.rank_name
+  end
+
+  def initialize(hand=nil)
+    @hand = hand
+  end
+
+  def ranks
+    ranks = @hand.ranks
+    ranks.map{|r| r == 1 ? 14 : r}.sort
+  end
+
+  def grouped_ranks
+    ranks.group_by{|card| card }
+  end
+
+  def compare_ranks(other)
+    (ranks - (ranks & other.ranks)).max <=> (other.ranks - (ranks & other.ranks)).max
+  end
+
+
+end

data/lib/ofcp_scoring/royal_flush.rb

@@ -0,0 +1,3 @@
+require_relative 'flush'
+class OfcpScoring::RoyalFlush < OfcpScoring::Flush
+end

data/lib/ofcp_scoring/royalties_calculator.rb

@@ -0,0 +1,38 @@
+class OfcpScoring::RoyaltiesCalculator
+  MIDDLE = {
+    "StraightFlush" => 20, "FourOfAKind" => 16, "FullHouse" => 12,
+    "Flush" => 8, "Straight" => 4, "Pair" => 0, "HighCard" => 0
+  }
+
+  BACK = {
+    "RoyalFlush" => 20, "StraightFlush" => 10, "FourOfAKind" => 8,
+    "FullHouse" => 6, "Flush" => 4, "Straight" => 2, "Pair" => 0,
+    "HighCard" => 0
+  }
+
+  def calculate_bonus(hand, position)
+    return calculate_front(hand) if position == :front
+    return calculate_middle(hand) if position == :middle
+    return calculate_back(hand) if position == :back
+  end
+
+private
+  def calculate_back(hand)
+    BACK[hand.rank_name]
+  end
+
+  def calculate_middle(hand)
+    MIDDLE[hand.rank_name]
+  end
+
+  def calculate_front(hand)
+    return 0 unless hand.rank_name == "Pair"
+    bonus_accumulator = 0
+    bonus_start = 5
+    while hand.ranks.max > bonus_start
+      bonus_accumulator += 1
+      bonus_start += 1
+    end
+    bonus_accumulator
+  end
+end

data/lib/ofcp_scoring/scoring_engine.rb

@@ -0,0 +1,9 @@
+class OfcpScoring::ScoringEngine
+  def initialize(evaluator = OfcpScoring::HandEvaluator.new)
+    @evaluator = evaluator
+  end
+  def score(hand_one, hand_two)
+    return [0,0] if hand_one.nil? || hand_two.nil?
+    @evaluator.evaluate(hand_one, hand_two)
+  end
+end

data/lib/ofcp_scoring/straight.rb

@@ -0,0 +1,14 @@
+class OfcpScoring::Straight < OfcpScoring::RankedHand
+
+  def <=>(other)
+    return super if super
+    highest_straight_card <=> other.highest_straight_card
+  end
+
+  def highest_straight_card
+    return ranks.max unless ranks.include?(14)
+    return 1 if ranks.include?(14) && ranks.include?(5)
+    return 14
+  end
+
+end

data/lib/ofcp_scoring/straight_flush.rb

@@ -0,0 +1,2 @@
+class OfcpScoring::StraightFlush < OfcpScoring::Straight
+end

data/lib/ofcp_scoring/three_of_a_kind.rb

@@ -0,0 +1,10 @@
+class OfcpScoring::ThreeOfAKind < OfcpScoring::RankedHand
+  def <=>(other)
+    return super if super
+    highest_trip_card <=> other.highest_trip_card
+  end
+
+  def highest_trip_card
+    grouped_ranks.map{|card,matches| card if matches.size == 3}.compact.max
+  end
+end

data/lib/ofcp_scoring/two_pair.rb

@@ -0,0 +1,22 @@
+class OfcpScoring::TwoPair < OfcpScoring::RankedHand
+  def <=>(other)
+    return super if super
+    if higher_paired_card == other.higher_paired_card
+      if lower_paired_card == other.lower_paired_card
+        compare_ranks(other)
+      else
+        lower_paired_card <=> other.lower_paired_card
+      end
+    else
+      higher_paired_card <=> other.higher_paired_card
+    end
+  end
+
+  def higher_paired_card
+    grouped_ranks.map{|card,matches| card if matches.size == 2}.compact.max
+  end
+
+  def lower_paired_card
+    grouped_ranks.map{|card,matches| card if matches.size == 2}.compact.min
+  end
+end

data/lib/ofcp_scoring/version.rb

@@ -0,0 +1,3 @@
+module OfcpScoring
+  VERSION = "0.0.2"
+end

data/lib/ofcp_scoring.rb

@@ -0,0 +1,9 @@
+require "ofcp_scoring/version"
+require_relative 'ofcp_scoring/ranked_hand'
+Gem.find_files("ofcp_scoring/*.rb").each { |path| require path }
+
+
+
+module OfcpScoring
+  # Your code goes here...
+end

data/ofcp_scoring.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ofcp_scoring/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ofcp_scoring"
+  spec.version       = OfcpScoring::VERSION
+  spec.authors       = ["Clayton Lengel-Zigich"]
+  spec.email         = ["clayton@claytonlz.com"]
+  spec.description   = %q{Open Face Chinese Poker Scoring}
+  spec.summary       = %q{A library to categorize, rank and score open face chinese poker hands with royalties.}
+  spec.homepage      = "http://github.com/clayton/ofcp_scoring"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/acceptance_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe "Open Face Chinese Poker" do
+  it "should determine how many points each poker hand owes the other" do
+    my_hand = %w(2h 3h 5h 10d 10h 4h 7c 8s Jd Js 6c 7d 9c)
+    their_hand = %w(Ah 3h 5h 6d 6h 4h 7c 8s Qd Qs 6c 7d 9c)
+    sut = OfcpScoring::ScoringEngine.new
+    expect(sut.score(my_hand, their_hand)).to eq([1, 2])
+  end
+
+  it "should give me a scoop bonus when I scoop the other player" do
+    my_hand = %w(Ah 4s Qs Js Jd 7d 6c 8h Kc Kd Ad 2c 4d)
+    their_hand = %w(9h 4c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    sut = OfcpScoring::ScoringEngine.new
+    expect(sut.score(my_hand, their_hand)).to eq([6, 0])
+  end
+
+  it "should give the other player a scoop bonus when they scoop me" do
+    my_hand = %w(9h 4c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    their_hand = %w(Ah 4s Qs Js Jd 7d 6c 8h Kc Kd Ad 2c 4d)
+    sut = OfcpScoring::ScoringEngine.new
+    expect(sut.score(my_hand, their_hand)).to eq([0, 6])
+  end
+
+
+  it "should give royalties for extra special hands" do
+    my_hand    = %w(Ah 4s Qs 2h 3h 4h 5h 7h Kh Kd Ks 9c 9s)
+    their_hand = %w(9h 4c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    sut = OfcpScoring::ScoringEngine.new
+    expect(sut.score(my_hand, their_hand)).to eq([20, 0])
+  end
+end