pokerstats 2.0.1

data/lib/pokerstats/hand_statistics_api.rb

@@ -0,0 +1,64 @@
+module Pokerstats
+  module HandStatisticsAPI
+    def initialize handstatistics
+      @hand_statistics = handstatistics
+    end
+
+    def self.exposed_methods
+      self.public_instance_methods - StatisticsHolder.public_instance_methods
+    end
+
+    def report screen_name
+      automatic_report screen_name
+    end
+
+    def register_player screen_name, street
+    end
+
+    def street_transition street
+    end
+
+    def street_transition_for_player street, player
+    end
+
+    def apply_action action, street
+    end
+  
+    def automatic_report screen_name
+      result = {}
+      self.class.report_specification.each do |each|
+        result[each[0]] = send(each[2], screen_name)
+      end
+      result
+    end
+    
+    private
+  
+    module ClassMethods
+      def report_specification
+        [
+          # [key,   sql_type,   function]
+        ]
+      end
+  
+      def rails_migration_segment_for_player_data
+        prefix = "\n" + " " * 10
+        result = "#{prefix}# FROM #{self.to_s}"
+        report_specification.each do |each|
+          result += "#{prefix}t.#{each[1]}\t#{each[0].inspect}"
+        end
+        result += "\n"
+      end
+    
+      def rails_generator_command_line_for_player_data
+        report_specification.inject("") do |string, each|
+          string + "#{each[0]}:#{each[1]} " 
+        end
+      end
+    end
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/pokerstats/player_statistics.rb

@@ -0,0 +1,58 @@
+module Pokerstats
+  class PlayerStatistics
+
+    def initialize
+      @aggregate_statistics = {}
+    end
+
+    def reports
+      @aggregate_statistics
+    end
+  
+    def aggregate_numeric_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
+      @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
+    end
+  
+    def aggregate_boolean_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
+      @aggregate_statistics[each_player][aggregate_stat] += 1 if reports[each_player][hand_stat]
+    end
+  
+    def aggregate_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
+      if /^is_/ =~ hand_stat.to_s
+        @aggregate_statistics[each_player][aggregate_stat] += 1 if reports[each_player][hand_stat]
+      else
+        @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
+      end
+    end
+  
+    def record hand_statistics
+      reports = hand_statistics.reports
+      reports.keys.each do |each_player|
+        @aggregate_statistics[each_player] ||= {}
+      
+        @aggregate_statistics[each_player][:t_hands] ||= 0
+         @aggregate_statistics[each_player][:t_hands] += 1
+         @aggregate_statistics[each_player][:t_vpip] ||= 0
+         @aggregate_statistics[each_player][:t_vpip] += 1 unless reports[each_player][:paid].zero?
+         aggregate_numeric_statistic each_player, reports, :t_posted, :posted
+        aggregate_numeric_statistic each_player, reports, :t_paid, :paid
+        aggregate_numeric_statistic each_player, reports, :t_won, :won
+        aggregate_numeric_statistic each_player, reports, :t_preflop_passive, :preflop_passive
+        aggregate_numeric_statistic each_player, reports, :t_preflop_aggressive, :preflop_aggressive
+        aggregate_numeric_statistic each_player, reports, :t_postflop_passive, :postflop_passive
+        aggregate_numeric_statistic each_player, reports, :t_postflop_aggressive, :postflop_aggressive
+        aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity, :is_blind_attack_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity_taken, :is_blind_attack_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity, :is_blind_defense_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity_taken, :is_blind_defense_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity, :is_pfr_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity_taken, :is_pfr_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity, :is_cbet_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity_taken, :is_cbet_opportunity_taken
+      end
+    end
+  end
+end

data/lib/pokerstats/plugins/aggression_statistics.rb

@@ -0,0 +1,57 @@
+module Pokerstats
+  class AggressionStatistics < HandStatistics::Plugin
+
+    def self.report_specification
+      [
+        # [key,                               sql_type,   function]
+        [:preflop_passive,      'integer',  :preflop_passive],
+        [:postflop_passive,     'integer',  :postflop_passive],
+        [:preflop_aggressive,   'integer',  :preflop_aggressive],
+        [:postflop_aggressive,  'integer',  :postflop_aggressive]
+      ]
+    end
+
+    def initialize handstatistics
+      super handstatistics
+      @preflop_passive = {}
+      @preflop_aggressive = {}
+      @postflop_passive = {}
+      @postflop_aggressive = {}
+    end
+    
+    def preflop_passive(screen_name)
+      @preflop_passive[screen_name]
+    end
+  
+    def postflop_passive(screen_name)
+      @postflop_passive[screen_name]
+    end
+  
+    def preflop_aggressive(screen_name)
+      @preflop_aggressive[screen_name]
+    end
+  
+    def postflop_aggressive(screen_name)
+      @postflop_aggressive[screen_name]
+    end
+
+    def register_player screen_name, street
+      @preflop_passive[screen_name] = 0
+      @preflop_aggressive[screen_name] = 0
+      @postflop_passive[screen_name] = 0
+      @postflop_aggressive[screen_name] = 0
+    end
+
+    def apply_action action, street
+      aggression = action[:aggression]
+      player = action[:screen_name]
+      if [:prelude, :preflop].member?(street)
+        @preflop_aggressive[player] +=1 if aggression == :aggressive
+        @preflop_passive[player] += 1 if aggression == :passive
+      else
+        @postflop_aggressive[player] +=1 if aggression == :aggressive
+        @postflop_passive[player] +=1 if aggression == :passive
+      end
+    end
+  end
+end

data/lib/pokerstats/plugins/blind_attack_statistics.rb

@@ -0,0 +1,78 @@
+module Pokerstats
+  class BlindAttackStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super(handstatistics)
+      @blind_attack_state = :no_action_taken
+      @blind_attack_opportunity = {}
+      @blind_attack_opportunity_taken ={}
+      @blind_defense_opportunity = {}
+      @blind_defense_opportunity_taken = {}
+    end
+  
+    def blind_attack_opportunity?(screen_name)
+      @blind_attack_opportunity[screen_name]
+    end
+  
+    def blind_attack_opportunity_taken?(screen_name)
+      @blind_attack_opportunity_taken[screen_name]
+    end
+  
+    def blind_defense_opportunity?(screen_name)
+      @blind_defense_opportunity[screen_name]
+    end
+  
+    def blind_defense_opportunity_taken?(screen_name)
+      @blind_defense_opportunity_taken[screen_name]
+    end
+  
+    def self.report_specification
+      [
+        # [key,                               sql_type,   function]
+        [:is_blind_attack_opportunity,        'integer',  :blind_attack_opportunity?],
+        [:is_blind_attack_opportunity_taken,  'integer',  :blind_attack_opportunity_taken?],
+        [:is_blind_defense_opportunity,       'integer',  :blind_defense_opportunity?],
+        [:is_blind_defense_opportunity_taken, 'integer',  :blind_defense_opportunity_taken?]
+      ]
+    end
+  
+    # def report(screen_name)
+    #   {
+    #     :is_blind_attack_opportunity => blind_attack_opportunity?(screen_name),
+    #     :is_blind_attack_opportunity_taken => blind_attack_opportunity_taken?(screen_name),
+    #     :is_blind_defense_opportunity => blind_defense_opportunity?(screen_name),
+    #     :is_blind_defense_opportunity_taken => blind_defense_opportunity_taken?(screen_name)
+    #   }
+    # end
+      
+    def apply_action action, street
+      player = action[:screen_name]
+      aggression = action[:aggression]
+
+      return if aggression == :neutral || street != :preflop
+
+      @blind_defense_opportunity[player] ||= @hand_statistics.blind?(player) && @blind_attack_state == :attacker_raised_first_in
+      @blind_defense_opportunity_taken[player] ||= @blind_defense_opportunity[player] && aggression != :fold
+      case @blind_attack_state
+      when :no_action_taken
+        @blind_attack_opportunity[player] ||= @hand_statistics.attacker?(player)
+        @blind_attack_opportunity_taken[player] ||= @hand_statistics.attacker?(player) && aggression == :aggressive
+        @blind_attack_state = case aggression
+        when :aggressive
+          @hand_statistics.attacker?(player) ? :attacker_raised_first_in : :responsive_action_taken
+        when :passive
+          :responsive_action_taken
+        else
+          :no_action_taken
+        end
+      when :attacker_raised_first_in
+        @blind_attack_opportunity[player] ||= false
+        @blind_attack_opportunity_taken[player] ||= false
+        @blind_attack_state = :responsive_action_taken unless [:check, :fold].member?(aggression)
+      when :responsive_action_taken
+        @blind_attack_opportunity[player] ||= false
+        @blind_attack_opportunity_taken[player] ||= false      
+      else raise "invalid state: #{@blind_attack_state}"
+      end
+    end
+  end
+end

data/lib/pokerstats/plugins/cash_statistics.rb

@@ -0,0 +1,95 @@
+module Pokerstats
+  class CashStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super handstatistics
+      @posted = {}
+      @paid = {}
+      @paid_this_round = {}
+      @won = {}
+      @cards = {}
+      @stats = {:posted => @posted, :paid => @paid, :won => @won, :cards => @cards}
+    end
+  
+    def posted(player)
+      @posted[player]
+    end
+  
+    def paid(player)
+      @paid[player]
+    end
+  
+    def paid_this_round(player)
+      @paid_this_round[player]    
+    end
+  
+    def won(player)
+      @won[player]
+    end
+  
+    def cards(player)
+      @cards[player]
+    end
+  
+    def self.report_specification
+      [
+        # [key,   sql_type,   function]
+        [:posted, 'decimal',  :posted],
+        [:paid,   'decimal',  :paid],
+        [:won,    'decimal',  :won],
+        [:cards,  'string',   :cards]
+      ]
+    end
+  
+    # def report(screen_name)
+    #   {
+    #     :posted => posted(screen_name),
+    #     :paid => paid(screen_name),
+    #     :won => won(screen_name),
+    #     :cards => cards(screen_name)
+    #   }
+    # end
+  
+    def stats(player=nil)
+      return @stats unless player
+      # @stats.inject({}){|last, pair| last.merge(pair[0] => pair[1][player])}
+    end
+  
+    def register_player(screen_name, street)
+      @posted[screen_name] = 0
+      @paid[screen_name] = 0
+      @won[screen_name] = 0
+    end
+  
+    def street_transition_for_player street, player
+      @paid_this_round[player] = 0 unless street == :preflop
+    end
+  
+    def apply_action action, street
+      player = action[:screen_name]
+      description = action[:description]
+      result = action[:result]
+      amount = action[:amount]
+      data = action[:data]
+      case result
+      when :post
+        @posted[player] += amount
+        @paid_this_round[player] += amount unless description == "antes"
+      when :pay
+        @paid[player] ||= 0
+        @paid[player] += amount
+        @paid_this_round[player] += amount
+      when :pay_to
+        net_amount_paid = amount - @paid_this_round[player]
+        action[:net_amount_paid] = net_amount_paid
+        @paid[player] += net_amount_paid
+        @paid_this_round[player] += net_amount_paid
+      when :win
+        @won[player] += amount
+      when :neutral
+      when :cards
+        @cards[player] = data
+      else raise "invalid action result: #{result.inspect}"
+      end
+    end
+  end
+end

data/lib/pokerstats/plugins/continuation_bet_statistics.rb

@@ -0,0 +1,68 @@
+module Pokerstats
+  class ContinuationBetStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super(handstatistics)
+      @last_preflop_raiser = nil
+      @number_preflop_raises = 0
+      @first_aggressor = {}
+      @first_aggression_opportunity = {}
+      @first_aggression_opportunity_taken = {}
+    end
+  
+    def cbet_opportunity?(screen_name, street = :flop)
+      # puts "cbet_opportunity?(#{screen_name}, #{street})"
+      # puts @first_aggression_opportunity.inspect
+      @number_preflop_raises==1 && @last_preflop_raiser==screen_name && @first_aggression_opportunity[street] && @first_aggression_opportunity[street][screen_name]
+    end
+  
+    def cbet_opportunity_taken?(screen_name, street = :flop)
+      cbet_opportunity?(screen_name) && @first_aggression_opportunity_taken[street][screen_name]
+    end
+  
+    def self.report_specification
+      [
+        # [key,                     sql_type,   function]
+        [:is_cbet_opportunity,       'integer',  :cbet_opportunity?],
+        [:is_cbet_opportunity_taken, 'integer',  :cbet_opportunity_taken?]
+      ]
+    end
+  
+    # 
+    # def report(screen_name)
+    #   {
+    #     :is_cbet_opportunity => cbet_opportunity?(screen_name),
+    #     :is_cbet_opportunity_taken => cbet_opportunity_taken?(screen_name)
+    #   }
+    # end
+  
+    def street_transition street
+      @first_aggressor[street] = nil
+      @first_aggression_opportunity[street] = {}
+      @first_aggression_opportunity_taken[street] = {}
+      super(street)
+    end
+  
+    def street_transition_for_player street, player
+      @first_aggression_opportunity[street][player] = nil
+      @first_aggression_opportunity_taken[street][player] = false
+    end
+  
+    def apply_action action, street
+      player = action[:screen_name]
+      aggression = action[:aggression]
+      result = action[:result]
+      if street == :preflop and result == :pay_to
+        @number_preflop_raises += 1
+        @last_preflop_raiser = player
+      end
+      if aggression != :neutral && @first_aggressor[street].nil? && @first_aggression_opportunity[street][player].nil?
+        @first_aggression_opportunity[street][player] = true
+        if aggression == :aggressive
+          @first_aggressor[street] = player
+          @first_aggression_opportunity_taken[street][player] = true
+          @hand_statistics.players.each {|player| @first_aggression_opportunity[street][player] ||= false}
+        end
+      end
+    end
+  end
+end

data/lib/pokerstats/plugins/preflop_raise_statistics.rb

@@ -0,0 +1,50 @@
+module Pokerstats
+  class PreflopRaiseStatistics < HandStatistics::Plugin
+
+    def initialize handstatistics
+      super handstatistics
+      @pfr_opportunity = {}
+      @pfr_opportunity_taken = {}
+      @pfr_size_in_bb = {}
+    end
+  
+    def pfr_opportunity?(screen_name)
+      @pfr_opportunity[screen_name]
+    end
+  
+    def pfr_opportunity_taken?(screen_name)
+      @pfr_opportunity[screen_name] && @pfr_opportunity_taken[screen_name]
+    end
+  
+    def self.report_specification
+      [
+        # [key,                     sql_type,   function]
+        [:is_pfr_opportunity,       'integer',  :pfr_opportunity?],
+        [:is_pfr_opportunity_taken, 'integer',  :pfr_opportunity_taken?]
+      ]
+    end
+    
+    # def report screen_name
+    #   {
+    #     :is_pfr_opportunity => pfr_opportunity?(screen_name),
+    #     :is_pfr_opportunity_taken => pfr_opportunity_taken?(screen_name)
+    #   }
+    # end
+  
+    def apply_action action, street
+      # puts "pfr: apply_action #{street}, #{action.inspect}"
+      result = action[:result]
+      player = action[:screen_name]
+      if street == :preflop and [:pay, :pay_to, :neutral].member?(result) and @pfr_opportunity[player].nil?
+        case result
+        when :pay, :neutral
+          @pfr_opportunity[player] = true
+          @pfr_opportunity_taken[player] = false
+        when :pay_to
+          @hand_statistics.players.each {|each_player| @pfr_opportunity[each_player] ||= (each_player == player)}
+          @pfr_opportunity_taken[player] = true
+        end
+      end
+    end
+  end
+end