games_dice 0.4.0 → 0.4.2

data/lib/games_dice/bunch.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'games_dice/bunch_helpers'
+
 module GamesDice
   # This class models a number of identical dice, which may be either GamesDice::Die or
   # GamesDice::ComplexDie objects.
@@ -21,6 +23,9 @@ module GamesDice
   #  d.explain_result # => "4, 9, 2, 9, 1. Keep: 9 + 9 = 18"
   #
   class Bunch
+    include KeepHelpers
+    include ExplainHelpers
+
     # The constructor accepts parameters that are suitable for either GamesDice::Die or GamesDice::ComplexDie
     # and decides which of those classes to instantiate.
     # @param [Hash] options
@@ -28,8 +33,10 @@ module GamesDice
     # @option options [Integer] :sides Number of sides on a single die in the bunch, *mandatory*
     # @option options [String] :name Optional name for the bunch
     # @option options [Array<GamesDice::RerollRule,Array>] :rerolls Optional rules that cause the die to roll again
-    # @option options [Array<GamesDice::MapRule,Array>] :maps Optional rules to convert a value into a final result for the die
-    # @option options [#rand] :prng Optional alternative source of randomness to Ruby's built-in #rand, passed to GamesDice::Die's constructor
+    # @option options [Array<GamesDice::MapRule,Array>] :maps Optional rules to convert a value into a final result
+    #   for the die
+    # @option options [#rand] :prng Optional alternative source of randomness to Ruby's built-in #rand, passed to
+    #   GamesDice::Die's constructor
     # @option options [Symbol] :keep_mode Optional, either *:keep_best* or *:keep_worst*
     # @option options [Integer] :keep_number Optional number of dice to keep when :keep_mode is not nil
     # @return [GamesDice::Bunch]
@@ -138,26 +145,15 @@ module GamesDice
     # Simulates rolling the bunch of identical dice
     # @return [Integer] Sum of all rolled dice, or sum of all keepers
     def roll
-      @result = 0
-      @raw_result_details = []
+      generate_raw_results
+      return @result if !@keep_mode || @keep_number.to_i >= @ndice
 
-      @ndice.times do
-        @result += @single_die.roll
-        @raw_result_details << @single_die.result
-      end
-
-      return @result unless @keep_mode
-
-      use_dice = if @keep_mode && @keep_number < @ndice
-                   case @keep_mode
-                   when :keep_best then @raw_result_details.sort[-@keep_number..]
-                   when :keep_worst then @raw_result_details.sort[0..(@keep_number - 1)]
-                   end
-                 else
-                   @raw_result_details
+      use_dice = case @keep_mode
+                 when :keep_best then @raw_result_details.sort[-@keep_number..]
+                 when :keep_worst then @raw_result_details.sort[0..(@keep_number - 1)]
                  end
 
-      @result = use_dice.inject(0) { |so_far, die_result| so_far + die_result }
+      @result = use_dice.sum
     end
 
     # @!attribute [r] explain_result
@@ -166,44 +162,25 @@ module GamesDice
     def explain_result
       return nil unless @result
 
-      explanation = ''
-
       # With #keep_mode, we may need to show unused and used dice separately
       used_dice = result_details
-      unused_dice = []
-
-      # Pick highest numbers and their associated details
-      if @keep_mode && @keep_number < @ndice
-        full_dice = result_details.sort_by(&:total)
-        case @keep_mode
-        when :keep_best
-          used_dice = full_dice[-@keep_number..]
-          unused_dice = full_dice[0..full_dice.length - 1 - @keep_number]
-        when :keep_worst
-          used_dice = full_dice[0..(@keep_number - 1)]
-          unused_dice = full_dice[@keep_number..(full_dice.length - 1)]
-        end
-      end
-
-      # Show unused dice (if any)
-      if @keep_mode || @single_die.maps
-        explanation += result_details.map(&:explain_value).join(', ')
-        if @keep_mode
-          separator = @single_die.maps ? ', ' : ' + '
-          explanation += ". Keep: #{used_dice.map(&:explain_total).join(separator)}"
-        end
-        explanation += ". Successes: #{@result}" if @single_die.maps
-        explanation += " = #{@result}" if @keep_mode && !@single_die.maps && @keep_number > 1
-      else
-        explanation += used_dice.map(&:explain_value).join(' + ')
-        explanation += " = #{@result}" if @ndice > 1
-      end
+      used_dice, = find_used_dice_due_to_keep_mode(result_details) if @keep_mode && @keep_number < @ndice
 
-      explanation
+      build_explanation(used_dice)
     end
 
     private
 
+    def generate_raw_results
+      @result = 0
+      @raw_result_details = []
+
+      @ndice.times do
+        @result += @single_die.roll
+        @raw_result_details << @single_die.result
+      end
+    end
+
     def name_number_sides_from_hash(options)
       @name = options[:name].to_s
       @ndice = Integer(options[:ndice])
@@ -213,21 +190,6 @@ module GamesDice
       raise ArgumentError, ":sides must be 1 or more, but got #{@sides}" unless @sides.positive?
     end
 
-    def keep_mode_from_hash(options)
-      case options[:keep_mode]
-      when nil
-        @keep_mode = nil
-      when :keep_best
-        @keep_mode = :keep_best
-        @keep_number = Integer(options[:keep_number] || 1)
-      when :keep_worst
-        @keep_mode = :keep_worst
-        @keep_number = Integer(options[:keep_number] || 1)
-      else
-        raise ArgumentError, ":keep_mode can be nil, :keep_best or :keep_worst. Got #{options[:keep_mode].inspect}"
-      end
-    end
-
     def complex_die_params_from_hash(options)
       cd_hash = {}
       %i[maps rerolls].each do |k|

data/lib/games_dice/bunch_helpers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module GamesDice
+  class Bunch
+    # @!visibility private
+    # Private extension methods for GamesDice::Bunch keep rules
+    module KeepHelpers
+      private
+
+      def keep_mode_from_hash(options)
+        @keep_mode = options[:keep_mode]
+        case @keep_mode
+        when nil
+          @keep_mode = nil
+        when :keep_best, :keep_worst
+          @keep_number = Integer(options[:keep_number] || 1)
+        else
+          raise ArgumentError, ":keep_mode can be nil, :keep_best or :keep_worst. Got #{options[:keep_mode].inspect}"
+        end
+      end
+
+      def find_used_dice_due_to_keep_mode(used_dice, unused_dice = [])
+        full_dice = result_details.sort_by(&:total)
+        case @keep_mode
+        when :keep_best
+          used_dice = full_dice[-@keep_number..]
+          unused_dice = full_dice[0..(full_dice.length - 1 - @keep_number)]
+        when :keep_worst
+          used_dice = full_dice[0..(@keep_number - 1)]
+          unused_dice = full_dice[@keep_number..]
+        end
+
+        [used_dice, unused_dice]
+      end
+
+      def explain_kept_dice(used_dice)
+        separator = @single_die.maps ? ', ' : ' + '
+        ". Keep: #{used_dice.map(&:explain_total).join(separator)}"
+      end
+    end
+
+    # @!visibility private
+    # Private extension methods for GamesDice::Bunch explaining
+    module ExplainHelpers
+      private
+
+      def build_explanation(used_dice)
+        if @keep_mode || @single_die.maps
+          explanation = explain_with_keep_or_map(used_dice)
+        else
+          explanation = used_dice.map(&:explain_value).join(' + ')
+          explanation += " = #{@result}" if @ndice > 1
+        end
+
+        explanation
+      end
+
+      def explain_with_keep_or_map(used_dice)
+        explanation = result_details.map(&:explain_value).join(', ')
+        explanation += explain_kept_dice(used_dice) if @keep_mode
+        explanation += ". Successes: #{@result}" if @single_die.maps
+        explanation += " = #{@result}" if @keep_mode && !@single_die.maps && @keep_number > 1
+
+        explanation
+      end
+    end
+  end
+end

data/lib/games_dice/complex_die.rb

@@ -24,7 +24,9 @@ module GamesDice
   #  d.explain_result # => "[6+5] 11 Success"
   #
   class ComplexDie
-    include GamesDice::ComplexDieHelpers
+    include RollHelpers
+    include ProbabilityHelpers
+    include MinMaxHelpers
 
     # @!visibility private
     # arbitrary limit to speed up probability calculations. It should
@@ -35,8 +37,10 @@ module GamesDice
     # @param [Integer] sides Number of sides on a single die, passed to GamesDice::Die's constructor
     # @param [Hash] options
     # @option options [Array<GamesDice::RerollRule,Array>] :rerolls The rules that cause the die to roll again
-    # @option options [Array<GamesDice::MapRule,Array>] :maps The rules to convert a value into a final result for the die
-    # @option options [#rand] :prng An alternative source of randomness to Ruby's built-in #rand, passed to GamesDice::Die's constructor
+    # @option options [Array<GamesDice::MapRule,Array>] :maps The rules to convert a value into a final result
+    #    for the die
+    # @option options [#rand] :prng An alternative source of randomness to Ruby's built-in #rand, passed to
+    #    GamesDice::Die's constructor
     # @return [GamesDice::ComplexDie]
     def initialize(sides, options = {})
       @basic_die = GamesDice::Die.new(sides, options[:prng])
@@ -46,6 +50,8 @@ module GamesDice
 
       @total = nil
       @result = nil
+
+      @probabilities_complete = true
     end
 
     # The simple component used by this complex one
@@ -105,27 +111,7 @@ module GamesDice
     # 1e-9 at worst.
     # @return [GamesDice::Probabilities] Probability distribution of die.
     def probabilities
-      return @probabilities if @probabilities
-
-      @probabilities_complete = true
-      if @rerolls && @maps
-        reroll_probs = recursive_probabilities
-        prob_hash = {}
-        reroll_probs.each do |v, p|
-          add_mapped_to_prob_hash(prob_hash, v, p)
-        end
-      elsif @rerolls
-        prob_hash = recursive_probabilities
-      elsif @maps
-        prob_hash = {}
-        @basic_die.probabilities.each do |v, p|
-          add_mapped_to_prob_hash(prob_hash, v, p)
-        end
-      else
-        @probabilities = @basic_die.probabilities
-        return @probabilities
-      end
-      @probabilities = GamesDice::Probabilities.from_h(prob_hash)
+      @probabilities ||= calculate_probabilities
     end
 
     # Simulates rolling the die
@@ -140,63 +126,6 @@ module GamesDice
 
     private
 
-    def add_mapped_to_prob_hash(prob_hash, v, p)
-      m, n = calc_maps(v)
-      prob_hash[m] ||= 0.0
-      prob_hash[m] += p
-    end
-
-    def roll_apply_rerolls
-      return unless @rerolls
-
-      subtracting = false
-      rerolls_remaining = @rerolls.map(&:limit)
-
-      loop do
-        rule_idx = find_matching_reroll_rule(@basic_die.result, @result.rolls.length, rerolls_remaining)
-        break unless rule_idx
-
-        rule = @rerolls[rule_idx]
-        rerolls_remaining[rule_idx] -= 1
-        subtracting = true if rule.type == :reroll_subtract
-        roll_apply_reroll_rule rule, subtracting
-      end
-    end
-
-    def roll_apply_reroll_rule(rule, is_subtracting)
-      # Apply the rule (note reversal for additions, after a subtract)
-      if is_subtracting && rule.type == :reroll_add
-        @result.add_roll(@basic_die.roll, :reroll_subtract)
-      else
-        @result.add_roll(@basic_die.roll, rule.type)
-      end
-    end
-
-    # Find which rule, if any, is being triggered
-    def find_matching_reroll_rule(check_value, num_rolls, rerolls_remaining)
-      @rerolls.zip(rerolls_remaining).find_index do |rule, remaining|
-        next if rule.type == :reroll_subtract && num_rolls > 1
-
-        remaining.positive? && rule.applies?(check_value)
-      end
-    end
-
-    def roll_apply_maps
-      return unless @maps
-
-      m, n = calc_maps(@result.value)
-      @result.apply_map(m, n)
-    end
-
-    def calc_minmax
-      @min_result = probabilities.min
-      @max_result = probabilities.max
-      return if @probabilities_complete
-
-      logical_min, logical_max = logical_minmax
-      @min_result, @max_result = [@min_result, @max_result, logical_min, logical_max].minmax
-    end
-
     def construct_rerolls(rerolls_input)
       check_and_construct rerolls_input, GamesDice::RerollRule, 'rerolls'
     end
@@ -218,70 +147,5 @@ module GamesDice
         end
       end
     end
-
-    def calc_maps(x)
-      y = 0
-      n = ''
-      @maps.find do |rule|
-        maybe_y = rule.map_from(x)
-        if maybe_y
-          y = maybe_y
-          n = rule.mapped_name
-        end
-        maybe_y
-      end
-      [y, n]
-    end
-
-    def minmax_mappings(possible_values)
-      possible_values.map do |x|
-        m, n = calc_maps(x)
-        m
-      end.minmax
-    end
-
-    # This isn't 100% accurate, but does cover most "normal" scenarios, and we're only falling back to it when we have to
-    # The inaccuracy is that min_result..max_result may contain 'holes' which have extreme map values that cannot actually
-    # occur. In practice it is likely a non-issue unless someone went out of their way to invent a dice scheme that broke it.
-    def logical_minmax
-      return @basic_die.minmax unless @rerolls || @maps
-      return minmax_mappings(@basic_die.all_values) unless @rerolls
-
-      min_result, max_result = logical_rerolls_minmax
-      return minmax_mappings((min_result..max_result)) if @maps
-
-      [min_result, max_result]
-    end
-
-    def logical_rerolls_minmax
-      min_result = @basic_die.min
-      max_result = @basic_die.max
-      min_subtract = find_minimum_possible_subtract
-      max_add = find_maximum_possible_adds
-      min_result = [min_subtract - max_add, min_subtract - max_result].min if min_subtract
-      [min_result, max_add + max_result]
-    end
-
-    def find_minimum_possible_subtract
-      min_subtract = nil
-      @rerolls.select { |r| r.type == :reroll_subtract }.each do |rule|
-        min_reroll = @basic_die.all_values.select { |v| rule.applies?(v) }.min
-        next unless min_reroll
-
-        min_subtract = [min_reroll, min_subtract].compact.min
-      end
-      min_subtract
-    end
-
-    def find_maximum_possible_adds
-      total_add = 0
-      @rerolls.select { |r| r.type == :reroll_add }.each do |rule|
-        max_reroll = @basic_die.all_values.select { |v| rule.applies?(v) }.max
-        next unless max_reroll
-
-        total_add += max_reroll * rule.limit
-      end
-      total_add
-    end
   end
 end