pokerstats 2.0.13 → 2.0.14

data/VERSION

@@ -1 +1 @@
-2.0.13
+2.0.14

data/lib/pokerstats/hand_classification.rb

@@ -1,6 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/hand_constants")
-module Pokerstats
-  
+module Pokerstats  
   def class_index_from_hand_string(hand_string)
       return class_index_from_hand_string!(hand_string)
   rescue ArgumentError
@@ -8,10 +7,16 @@ module Pokerstats
   end
   
   def class_index_from_hand_string!(hand_string)
-    class_index_from_class_string(class_string_from_hand_string(hand_string))
+    class_index_from_class_string!(class_string_from_hand_string!(hand_string))
   end
   
   def class_string_from_hand_string(hand_string)
+      class_string_from_hand_string!(hand_string)
+  rescue
+      nil
+  end
+  
+  def class_string_from_hand_string!(hand_string)
     raise ArgumentError, "hand_string '#{hand_string}' must be a String" unless hand_string.kind_of?(String)
     hand_string = hand_string.gsub(/ /,'')
     hand_string = hand_string.upcase
@@ -37,6 +42,12 @@ module Pokerstats
   end
   
   def class_index_from_class_string(class_string)
+      class_index_from_class_string!(class_string)
+  rescue
+      nil
+  end
+  
+  def class_index_from_class_string!(class_string)
     raise ArgumentError, "class_string #{class_string.inspect} must be a String" unless class_string.kind_of?(String)
     class_string.upcase!
     first = Pokerstats::HandConstants::CARDS.index(class_string[0..0])
@@ -52,8 +63,15 @@ module Pokerstats
     end
   end
   
-  def class_string_from_class_index(classIndex)
-    row, col = row_from_class_index(classIndex), col_from_class_index(classIndex)
+  def class_string_from_class_index(class_index)
+      class_string_from_class_index!(class_index)
+  rescue ArgumentError
+      nil
+  end
+  
+  def class_string_from_class_index!(class_index)
+    raise ArgumentError, "class_index must be an integer" unless class_index.kind_of? Integer
+    row, col = row_from_class_index(class_index), col_from_class_index(class_index)
     case row <=> col
     when 1
       Pokerstats::HandConstants::CARDS[col..col] + Pokerstats::HandConstants::CARDS[row..row] + "o"

data/lib/pokerstats/hand_constants.rb

@@ -1,18 +1,24 @@
 module Pokerstats
   module HandConstants
     HAND_REPORT_SPECIFICATION = [
-      # [key,   sql_type,   function]
       [:session_filename, 'string'],
       [:starting_at, 'datetime'],
       [:name, 'string'], 
+      [:table_name, 'string'], 
       [:description, 'string'], 
+      [:ante, 'decimal'],
       [:sb, 'decimal'], 
       [:bb, 'decimal'], 
       [:board, 'string'], 
       [:total_pot, 'decimal'], 
       [:rake, 'decimal'],
       [:played_at, 'datetime'], 
-      [:tournament, 'string']
+      [:tournament, 'string'],
+      [:max_players, 'integer'],
+      [:number_players, 'integer'],
+      [:game_type, 'string'],
+      [:limit_type, 'string'],
+      [:stakes_type, 'decimal']
     ]
     HAND_INFORMATION_KEYS = HAND_REPORT_SPECIFICATION.map{|each| each.first}
     HAND_RECORD_INCOMPLETE_MESSAGE = "hand record is incomplete"

data/lib/pokerstats/hand_statistics.rb

@@ -12,11 +12,12 @@ module Pokerstats
     plugin_include_module HandStatisticsAPI
     def initialize
       install_plugins self
-      @hand_information = {}
+      @hand_information = {:number_players => 0, :ante => "0.0".to_d}
       @player_hashes = []
       @button_player_index = nil
       @cached_player_position = nil
       @street_state = nil
+      @last_street_state = nil
       street_transition(:prelude)
     end
 
@@ -30,6 +31,10 @@ module Pokerstats
         hash.merge!(key => @hand_information[key])
       end
     end
+    
+    def hand_information(field)
+        @hand_information[field]
+    end
 
     def update_hand update
       street_transition(update[:street]) unless update[:street] == @street_state
@@ -65,7 +70,8 @@ module Pokerstats
       raise Pokerstats::HandHistoryParseError, "#{PLAYER_RECORDS_DUPLICATE_PLAYER_NAME}: #{screen_name.inspect}" if players.member?(screen_name)
       @cached_player_position = nil
       @player_hashes << player
-      plugins.each{|each| each.register_player(screen_name, @street_state)}  #why the second parameter?
+      @hand_information[:number_players]+=1
+      plugins.each{|each| each.register_player(screen_name, @street_state, player)}  #why the second parameter?
       street_transition_for_player(@street_state, screen_name)
     end
   
@@ -76,8 +82,13 @@ module Pokerstats
     def street
       @street_state
     end
+    
+    def last_street
+        @last_street_state
+    end
   
     def street_transition street
+      @last_street_state = @street_state
       @street_state = street
       plugins.each{|each| each.street_transition(street)}
       players.each {|player| street_transition_for_player(street, player)}
@@ -116,6 +127,17 @@ module Pokerstats
     def position screen_name
       (@cached_player_position && @cached_player_position[screen_name]) || calculate_player_position(screen_name)
     end
+    
+    # player screen_name_first goes before player screen_name_second
+    def betting_order?(screen_name_first, screen_name_second)
+        if button?(screen_name_first)
+            false
+        elsif button?(screen_name_second)
+            true
+        else
+            position(screen_name_first) < position(screen_name_second)
+        end
+    end
   
     def button?(screen_name)
       position(screen_name) && position(screen_name).zero?
@@ -146,8 +168,7 @@ module Pokerstats
     def attacker?(screen_name)
       (number_players > 2) && (button?(screen_name) || cutoff?(screen_name))
     end
-  
-  
+
     ##
     # Action Information
     ##

data/lib/pokerstats/hand_statistics_api.rb

@@ -12,7 +12,7 @@ module Pokerstats
       automatic_report screen_name
     end
 
-    def register_player screen_name, street
+    def register_player screen_name, street, player_hash
     end
 
     def street_transition street

data/lib/pokerstats/plugins/aggression_statistics.rb

@@ -35,7 +35,7 @@ module Pokerstats
       @postflop_aggressive[screen_name]
     end
 
-    def register_player screen_name, street
+    def register_player screen_name, street, player
       @preflop_passive[screen_name] = 0
       @preflop_aggressive[screen_name] = 0
       @postflop_passive[screen_name] = 0

data/lib/pokerstats/plugins/cash_statistics.rb

@@ -2,14 +2,25 @@ module Pokerstats
   class CashStatistics < HandStatistics::Plugin
     def initialize handstatistics
       super handstatistics
+      @seat = {}
       @posted = {}
       @paid = {}
       @paid_this_round = {}
       @won = {}
       @cards = {}
+      @starting_stack = {}
       @stats = {:posted => @posted, :paid => @paid, :won => @won, :cards => @cards}
     end
 
+
+    def position(player)
+        @hand_statistics.position player
+    end
+    
+    def seat(player)
+        @seat[player]
+    end
+
     def profit(player)
         return nil unless won(player) && posted(player) && paid(player)
         won(player) - posted(player) - paid(player)
@@ -34,7 +45,7 @@ module Pokerstats
     def divided_by_bb(value)
         bb = @hand_statistics.report_hand_information[:bb]
         return nil if bb.nil? || bb.zero?
-        value / bb
+        value / (2 * bb)
     end
   
     def profit_in_bb(player)
@@ -54,7 +65,45 @@ module Pokerstats
     end
   
     def cards(player)
-      @cards[player]
+        @cards[player]
+    end
+    
+    def starting_stack(player)
+        @starting_stack[player]
+    end
+    
+    def starting_stack_in_bb(player)
+        divided_by_bb(starting_stack(player))
+    end
+    
+    def starting_pot
+        sb = @hand_statistics.report_hand_information[:sb]
+        bb = @hand_statistics.report_hand_information[:bb]
+        ante = @hand_statistics.report_hand_information[:ante]
+        number_players = @hand_statistics.report_hand_information[:number_players]
+        sb && bb && ante && number_players &&
+        (sb + bb + ante * number_players)
+    end
+    
+    def starting_stack_as_M(player)
+        starting_stack(player) && starting_pot && (starting_pot > 0) && 
+        ("1.0".to_d * starting_stack(player) / starting_pot)
+    end
+    
+    def starting_stack_as_M_class(player)
+        starting_stack_as_M(player) &&
+        case starting_stack_as_M(player)
+        when 0 .. 2.99
+            "darkred"
+        when 2.99 .. 5.99
+            "red"
+        when 5.99 .. 9.99
+            "orange"
+        when 9.99 .. 19.99
+            "yellow"
+        else
+            "green"
+        end
     end
     
     def card_category_index(player)
@@ -62,29 +111,38 @@ module Pokerstats
     end
   
     def self.report_specification
-      [
-        # [key,   sql_type,   function]
-        [:posted,               'decimal',  :posted],
-        [:paid,                 'decimal',  :paid],
-        [:won,                  'decimal',  :won],
-        [:profit,               'decimal',  :profit],
-        [:posted_in_bb,         'string',   :posted_in_bb],
-        [:paid_in_bb,           'string',   :paid_in_bb],
-        [:won_in_bb,            'string',   :won_in_bb],
-        [:profit_in_bb,         'string',   :profit_in_bb],
-        [:cards,                'string',   :cards],
-        [:card_category_index,  'integer',  :card_category_index]
-      ]
+        [
+            # [key,                 sql_type,   function]
+            [:seat,                 'integer',  :seat],
+            [:position,             'integer',  :position],
+            [:posted,               'decimal',  :posted],
+            [:paid,                 'decimal',  :paid],
+            [:won,                  'decimal',  :won],
+            [:profit,               'decimal',  :profit],
+            [:posted_in_bb,         'decimal',  :posted_in_bb],
+            [:paid_in_bb,           'decimal',  :paid_in_bb],
+            [:won_in_bb,            'decimal',  :won_in_bb],
+            [:profit_in_bb,         'decimal',  :profit_in_bb],
+            [:cards,                'string',   :cards],
+            [:card_category_index,  'integer',  :card_category_index],
+            [:starting_stack,       'decimal',  :starting_stack],
+            [:starting_stack_in_bb, 'decimal',  :starting_stack_in_bb],
+            [:starting_stack_as_M, 'decimal',  :starting_stack_as_M],
+            [:starting_stack_as_M_class, 'decimal',  :starting_stack_as_M_class]
+        ]
     end
   
     def stats(player=nil)
       return @stats unless player
     end
   
-    def register_player(screen_name, street)
+    def register_player(screen_name, street, player_hash)
+      # puts "register_player(#{screen_name.inspect}, #{street.inspect}, #{player_hash.inspect})"
       @posted[screen_name] = 0
       @paid[screen_name] = 0
       @won[screen_name] = 0
+      @starting_stack[screen_name] = player_hash[:starting_stack]
+      @seat[screen_name] = player_hash[:seat]
     end
   
     def street_transition_for_player street, player

data/lib/pokerstats/plugins/street_bet_statistics.rb

@@ -0,0 +1,219 @@
+module Pokerstats
+    class StreetBetStatistics < HandStatistics::Plugin
+        def self.report_specification
+            [
+                [:preflop_2bet,         "boolean",  :preflop_2bet],
+                [:preflop_3bet,         "boolean",  :preflop_3bet],
+                [:preflop_4bet,         "boolean",  :preflop_4bet],
+                [:flop_1bet,            "boolean",  :flop_1bet],
+                [:flop_2bet,            "boolean",  :flop_2bet],
+                [:flop_3bet,            "boolean",  :flop_3bet],
+                [:flop_4bet,            "boolean",  :flop_4bet],
+                [:turn_1bet,            "boolean",  :turn_1bet],
+                [:turn_2bet,            "boolean",  :turn_2bet],
+                [:turn_3bet,            "boolean",  :turn_3bet],
+                [:turn_4bet,            "boolean",  :turn_4bet],
+                [:river_1bet,           "boolean",  :river_1bet],
+                [:river_2bet,           "boolean",  :river_2bet],
+                [:river_3bet,           "boolean",  :river_3bet],
+                [:river_4bet,           "boolean",  :river_4bet],
+
+                [:fold_to_preflop_1bet, "boolean",  :fold_to_preflop_1bet],
+                [:fold_to_preflop_2bet, "boolean",  :fold_to_preflop_2bet],
+                [:fold_to_preflop_3bet, "boolean",  :fold_to_preflop_3bet],
+                [:fold_to_preflop_4bet, "boolean",  :fold_to_preflop_4bet],
+                [:fold_to_flop_1bet,    "boolean",  :fold_to_flop_1bet],
+                [:fold_to_flop_2bet,    "boolean",  :fold_to_flop_2bet],
+                [:fold_to_flop_3bet,    "boolean",  :fold_to_flop_3bet],
+                [:fold_to_flop_4bet,    "boolean",  :fold_to_flop_4bet],
+                [:fold_to_turn_1bet,    "boolean",  :fold_to_turn_1bet],
+                [:fold_to_turn_2bet,    "boolean",  :fold_to_turn_2bet],
+                [:fold_to_turn_3bet,    "boolean",  :fold_to_turn_3bet],
+                [:fold_to_turn_4bet,    "boolean",  :fold_to_turn_4bet],
+                [:fold_to_river_1bet,   "boolean",  :fold_to_river_1bet],
+                [:fold_to_river_2bet,   "boolean",  :fold_to_river_2bet],
+                [:fold_to_river_3bet,   "boolean",  :fold_to_river_3bet],
+                [:fold_to_river_4bet,   "boolean",  :fold_to_river_4bet],
+
+                [:call_preflop_1bet,    "boolean",  :call_preflop_1bet],
+                [:call_preflop_2bet,    "boolean",  :call_preflop_2bet],
+                [:call_preflop_3bet,    "boolean",  :call_preflop_3bet],
+                [:call_preflop_4bet,    "boolean",  :call_preflop_4bet],
+                [:call_flop_1bet,       "boolean",  :call_flop_1bet],
+                [:call_flop_2bet,       "boolean",  :call_flop_2bet],
+                [:call_flop_3bet,       "boolean",  :call_flop_3bet],
+                [:call_flop_4bet,       "boolean",  :call_flop_4bet],
+                [:call_turn_1bet,       "boolean",  :call_turn_1bet],
+                [:call_turn_2bet,       "boolean",  :call_turn_2bet],
+                [:call_turn_3bet,       "boolean",  :call_turn_3bet],
+                [:call_turn_4bet,       "boolean",  :call_turn_4bet],
+                [:call_river_1bet,      "boolean",  :call_river_1bet],
+                [:call_river_2bet,      "boolean",  :call_river_2bet],
+                [:call_river_3bet,      "boolean",  :call_river_3bet],
+                [:call_river_4bet,      "boolean",  :call_river_4bet],
+                
+                [:last_aggr_preflop,	'boolean',	:last_aggr_preflop],
+                [:last_aggr_flop,	    'boolean',	:last_aggr_flop],
+                [:last_aggr_turn,	    'boolean',	:last_aggr_turn],
+                [:last_aggr_river,	    'boolean',	:last_aggr_river],
+
+                [:cbet_flop,	        'boolean',	:cbet_flop],
+                [:cbet_turn,	        'boolean',	:cbet_turn],
+                [:cbet_river,	        'boolean',	:cbet_river],
+                [:fold_to_cbet_flop,	'boolean',	:fold_to_cbet_flop],
+                [:fold_to_cbet_turn,	'boolean',	:fold_to_cbet_turn],
+                [:fold_to_cbet_river,	'boolean',	:fold_to_cbet_river],
+
+                [:dbet_flop,	        'boolean',	:dbet_flop],
+                [:dbet_turn,	        'boolean',	:dbet_turn],
+                [:dbet_river,	        'boolean',	:dbet_river],
+                [:fold_to_dbet_flop,	'boolean',	:fold_to_dbet_flop],
+                [:fold_to_dbet_turn,	'boolean',	:fold_to_dbet_turn],
+                [:fold_to_dbet_river,	'boolean',	:fold_to_dbet_river]
+            ]
+        end
+        
+        attr_accessor :street_bets, :fold_to_street_bets, :last_aggr_player
+        
+        #
+        # These functions return one of three, not two values, and hence do not end with a "?".
+        # A nil value indicates that the player had no opportunity to make the described bet.
+        # For example:
+        #   cbet_flop(player)
+        #       nil   -- player did not have an opportunity to make a cbet on the flop
+        #       true  -- player made a cbet on the flop
+        #       false -- player had an opportunity to make a cbet on the flop, but did not
+        #
+        #   fold_to_flop_2bet(player)
+        #       nil   -- player did not have an opportunity to fold to a 2bet on the flop
+        #       true  -- player folded to a 2bet on the flop
+        #       false -- player had an opportunity to fold to a 2bet on the flop, but did not
+        #
+        # Some care must be taken in the code and testing to assure the consistency of the nil/false dichotomy
+        #
+        # They are defined dynamically due to their number and similarities
+        #
+        
+        for street in [:preflop, :flop, :turn, :river]
+
+            #
+            # last agresssion functions
+            #   true only if player made the last aggressive move on the street
+            #   nil otherwise
+            #   never false
+            #
+            class_eval <<-LAST_AGGR_FUNCTIONS
+            def last_aggr_#{street} player
+                @last_aggr_player[:#{street}] && (player==@last_aggr_player[:#{street}] ? true : nil)
+            end
+            LAST_AGGR_FUNCTIONS
+
+            #
+            # make_, call_, and fold_to_ functions, by bet and street street
+            #
+            for bet in 1..4
+                class_eval <<-STREET_AND_BET_FUNCTIONS
+                def #{street}_#{bet}bet(player)
+                    @street_bets[#{street.inspect}] && @street_bets[#{street.inspect}][#{bet}][player]
+                end
+                def call_#{street}_#{bet}bet(player)
+                    @call_street_bets[#{street.inspect}] && @call_street_bets[#{street.inspect}][#{bet}][player]
+                end
+                def fold_to_#{street}_#{bet}bet(player)
+                    @fold_to_street_bets[#{street.inspect}] && @fold_to_street_bets[#{street.inspect}][#{bet}][player]
+                end
+                STREET_AND_BET_FUNCTIONS
+            end
+        end
+        
+        for street in [:flop, :turn, :river]
+            last_street = case street
+            when :flop then :preflop
+            when :turn then :flop
+            when :river then :turn
+            end
+            
+            #
+            # make, call_ and fold_to_ cbet and dbet functions, by street
+            #
+            # cbets (continuation bets) are first-in bets after making last agression on the previous street
+            #
+            # dbets (donk bets) are first-in bets, made after calling another player's aggression out of position on the previous street
+            #
+
+            class_eval <<-FTR_FUNCTIONS
+            def cbet_#{street}(player)
+                last_aggr_#{last_street}(player) && #{street}_1bet(player)
+            end
+            def fold_to_cbet_#{street}(player)
+                @first_aggr_player[:#{street}] && cbet_#{street}(@first_aggr_player[:#{street}]) && fold_to_#{street}_1bet(player)
+                # fold_to_#{street}_1bet(player) && @last_aggr_player[:#{last_street}] && cbet_#{street}(@last_aggr_player[:#{last_street}])
+            end
+            def call_cbet_#{street}(player)
+                @first_aggr_player[:#{street}] && cbet_#{street}(@first_aggr_player[:#{street}]) && call_#{street}_1bet(player)
+            end
+            def dbet_#{street}(player)
+                return nil unless @last_aggr_player[:#{last_street}] && @hand_statistics.betting_order?(player, @last_aggr_player[:#{last_street}])
+                #{street}_1bet(player)
+            end
+            def fold_to_dbet_#{street}(player)
+                return nil unless @first_aggr_player[:#{street}] && dbet_#{street}(@first_aggr_player[:#{street}])
+                fold_to_#{street}_1bet(player)
+            end
+            def call_dbet_#{street}(player)
+                return nil unless @first_aggr_player[:#{street}] && dbet_#{street}(@first_aggr_player[:#{street}])
+                call_#{street}_1bet(player)
+            end
+            FTR_FUNCTIONS
+        end
+
+        def initialize handstatistics
+            @street_bets = {}
+            @call_street_bets = {}
+            @fold_to_street_bets = {}
+            @first_aggr_player = {}
+            @last_aggr_player = {}
+            [:preflop, :flop, :turn, :river].each do|each|
+                @street_bets[each] = [{}, {}, {}, {}, {}] 
+                @call_street_bets[each] = [{}, {}, {}, {}, {}]
+                @fold_to_street_bets[each] = [{}, {}, {}, {}, {}]
+            end
+            super handstatistics
+        end
+
+        def register_player screen_name, street, player
+        end
+
+        def street_transition street
+            case street
+            when :preflop
+                @last_bet = 1
+            when :flop, :turn, :river
+                @last_bet = 0
+            else
+                @last_bet = nil
+            end
+        end
+
+        def street_transition_for_player street, player
+        end
+
+        def apply_action action, street
+            unless @last_bet.nil?
+                # puts "apply_action(#{action[:aggression]}, #{street}) with @last_bet == #{@last_bet}"
+                if @last_bet.between?(0,4)
+                    @fold_to_street_bets[street][@last_bet][action[:screen_name]] = action[:description] == "folds"
+                    @call_street_bets[street][@last_bet][action[:screen_name]] = action[:description] == "calls"
+                end
+                if @last_bet.between?(0,3)
+                    @street_bets[street][@last_bet+1][action[:screen_name]] = action[:aggression] == :aggressive
+                end
+                if action[:aggression] == :aggressive
+                    @last_bet+=1
+                    @first_aggr_player[street] ||= action[:screen_name]
+                    @last_aggr_player[street] = action[:screen_name]
+                end
+            end
+        end
+    end
+end