bcdice 3.0.0.pre.alpha.1 → 3.1.0

data/lib/bcdice/common_command.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "bcdice/common_command/add_dice"
 require "bcdice/common_command/barabara_dice"
 require "bcdice/common_command/calc"
 require "bcdice/common_command/choice"
 require "bcdice/common_command/d66_dice"
+require "bcdice/common_command/repeat"
 require "bcdice/common_command/reroll_dice"
 require "bcdice/common_command/upper_dice"
 require "bcdice/common_command/version"
@@ -15,6 +18,7 @@ module BCDice
       Calc,
       Choice,
       D66Dice,
+      Repeat,
       RerollDice,
       UpperDice,
       Version,

data/lib/bcdice/common_command/add_dice.rb

@@ -1,53 +1,19 @@
+# frozen_string_literal: true
+
 require "bcdice/normalize"
 require "bcdice/common_command/add_dice/parser"
 require "bcdice/common_command/add_dice/randomizer"
 
 module BCDice
   module CommonCommand
-    class AddDice
-      PREFIX_PATTERN = /[\+\-\dD\(\[]+/.freeze
-
-      def initialize(command, randomizer, game_system)
-        @command = command
-        @bcdice = randomizer
-        @diceBot = game_system
-
-        @dice_list = []
-        @is_secret = false
-      end
-
-      def secret?
-        @is_secret
-      end
-
-      def eval()
-        parser = Parser.new(@command)
+    module AddDice
+      PREFIX_PATTERN = /[+\-\dD(\[]+/.freeze
 
-        command = parser.parse()
-        if parser.error?
-          return nil
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system, randomizer)
         end
-
-        randomizer = Randomizer.new(@bcdice, @diceBot, command.cmp_op)
-        total = command.lhs.eval(randomizer)
-
-        output =
-          if randomizer.dice_list.size <= 1 && command.lhs.is_a?(Node::DiceRoll)
-            "(#{command}) ＞ #{total}"
-          else
-            "(#{command}) ＞ #{command.lhs.output} ＞ #{total}"
-          end
-
-        dice_list = randomizer.dice_list
-
-        if command.cmp_op
-          dice_total = dice_list.inject(&:+)
-          output += @diceBot.check_result(total, dice_total, dice_list, randomizer.sides, command.cmp_op, command.rhs)
-        end
-
-        @is_secret = parser.secret?
-
-        return output
       end
     end
   end

data/lib/bcdice/common_command/add_dice/node.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module BCDice
   module CommonCommand
-    class AddDice
+    module AddDice
       # 加算ロールの構文解析木のノードを格納するモジュール
       module Node
         # 加算ロールコマンドのノード。
@@ -24,28 +26,59 @@ module BCDice
           # @param [Object] lhs 左辺のノード
           # @param [Symbol] cmp_op 比較演算子
           # @param [Integer, String] rhs 右辺のノード
-          def initialize(lhs, cmp_op, rhs)
+          def initialize(secret, lhs, cmp_op = nil, rhs = nil)
+            @secret = secret
             @lhs = lhs
             @cmp_op = cmp_op
             @rhs = rhs
           end
 
           # 文字列に変換する
+          # @param game_system [BCDice::Base]
           # @return [String]
-          def to_s
-            @lhs.to_s + cmp_op_text + @rhs.to_s
+          def expr(game_system)
+            @lhs.expr(game_system) + cmp_op_text + @rhs&.eval(game_system, nil).to_s
           end
 
           # ノードのS式を返す
           # @return [String]
           def s_exp
             if @cmp_op
-              "(Command (#{@cmp_op} #{@lhs.s_exp} #{@rhs}))"
+              "(Command (#{@cmp_op} #{@lhs.s_exp} #{@rhs.s_exp}))"
             else
               "(Command #{@lhs.s_exp})"
             end
           end
 
+          def eval(game_system, randomizer)
+            randomizer = Randomizer.new(randomizer, game_system)
+            total = @lhs.eval(game_system, randomizer)
+
+            interrim_expr =
+              unless randomizer.rand_results.size <= 1 && @lhs.is_a?(Node::DiceRoll)
+                @lhs.output
+              end
+
+            result =
+              if @cmp_op
+                rhs = @rhs.eval(game_system, nil)
+                game_system.check_result(total, randomizer.rand_results, @cmp_op, rhs)
+              end
+            result ||= Result.new
+
+            sequence = [
+              "(#{expr(game_system)})",
+              interrim_expr,
+              total,
+              result&.text
+            ].compact
+
+            result.tap do |r|
+              r.secret = @secret
+              r.text = sequence.join(" ＞ ")
+            end
+          end
+
           private
 
           # メッセージ中で比較演算子をどのように表示するかを返す
@@ -62,6 +95,28 @@ module BCDice
           end
         end
 
+        class UndecidedTarget
+          include Singleton
+
+          def eval(_game_system, _randomizer)
+            "?"
+          end
+
+          def include_dice?
+            false
+          end
+
+          def expr(_game_system)
+            "?"
+          end
+
+          def output
+            "?"
+          end
+
+          alias s_exp output
+        end
+
         # 二項演算子のノード
         class BinaryOp
           # ノードを初期化する
@@ -78,19 +133,28 @@ module BCDice
           #
           # 左右のオペランドをそれぞれ再帰的に評価した後で、演算を行う。
           #
-          # @param [Randomizer] randomizer ランダマイザ
+          # @param game_system [BCDice::Base]
+          # @param randomizer [Randomizer] ランダマイザ
           # @return [Integer] 評価結果
-          def eval(randomizer)
-            lhs = @lhs.eval(randomizer)
-            rhs = @rhs.eval(randomizer)
+          def eval(game_system, randomizer)
+            lhs = @lhs.eval(game_system, randomizer)
+            rhs = @rhs.eval(game_system, randomizer)
 
-            return calc(lhs, rhs)
+            return calc(lhs, rhs, game_system.round_type)
+          end
+
+          # @return [Boolean]
+          def include_dice?
+            @lhs.include_dice? || @rhs.include_dice?
           end
 
           # 文字列に変換する
           # @return [String]
-          def to_s
-            "#{@lhs}#{@op}#{@rhs}"
+          def expr(game_system)
+            lhs = @lhs.expr(game_system)
+            rhs = @rhs.expr(game_system)
+
+            "#{lhs}#{@op}#{rhs}"
           end
 
           # メッセージへの出力を返す
@@ -108,10 +172,11 @@ module BCDice
           private
 
           # 演算を行う
-          # @param [Integer] lhs 左のオペランド
-          # @param [Integer] rhs 右のオペランド
+          # @param lhs [Integer] lhs 左のオペランド
+          # @param rhs [Integer] 右のオペランド
+          # @param _round_type [Symbol] ゲームシステムの端数処理設定
           # @return [Integer] 演算の結果
-          def calc(lhs, rhs)
+          def calc(lhs, rhs, _round_type)
             lhs.send(@op, rhs)
           end
 
@@ -140,8 +205,8 @@ module BCDice
           # 通常の結果の末尾に、端数処理方法を示す記号を付加する。
           #
           # @return [String]
-          def to_s
-            "#{super}#{rounding_method}"
+          def expr(game_system)
+            "#{super(game_system)}#{rounding_method}"
           end
 
           # メッセージへの出力を返す
@@ -168,26 +233,51 @@ module BCDice
           end
 
           # 演算を行う
-          # @param [Integer] lhs 左のオペランド
-          # @param [Integer] rhs 右のオペランド
+          # @param lhs [Integer] 左のオペランド
+          # @param rhs [Integer] 右のオペランド
+          # @param round_type [Symbol] ゲームシステムの端数処理設定
           # @return [Integer] 演算の結果
-          def calc(lhs, rhs)
+          def calc(lhs, rhs, round_type)
             if rhs.zero?
               return 1
             end
 
-            return divide_and_round(lhs, rhs)
+            return divide_and_round(lhs, rhs, round_type)
           end
 
           # 除算および端数処理を行う
-          # @param [Integer] _dividend 被除数
-          # @param [Integer] _divisor 除数（0以外）
+          # @param dividend [Integer] 被除数
+          # @param divisor [Integer] 除数（0以外）
+          # @param round_type [Symbol] ゲームシステムの端数処理設定
           # @return [Integer]
-          def divide_and_round(_dividend, _divisor)
+          def divide_and_round(dividend, divisor, round_type)
             raise NotImplementedError
           end
         end
 
+        # 除算（端数処理はゲームシステム依存）のノード
+        class DivideWithGameSystemDefault < DivideBase
+          ROUNDING_METHOD = ""
+
+          private
+
+          # 除算および端数処理を行う
+          # @param dividend [Integer] 被除数
+          # @param divisor [Integer] 除数（0以外）
+          # @param round_type [Symbol] ゲームシステムの端数処理設定
+          # @return [Integer]
+          def divide_and_round(dividend, divisor, round_type)
+            case round_type
+            when RoundType::CEIL
+              (dividend.to_f / divisor).ceil
+            when RoundType::ROUND
+              (dividend.to_f / divisor).round
+            else # RoundType::FLOOR
+              dividend / divisor
+            end
+          end
+        end
+
         # 除算（切り上げ）のノード
         class DivideWithRoundingUp < DivideBase
           # 端数処理方法を示す記号
@@ -196,10 +286,9 @@ module BCDice
           private
 
           # 除算および端数処理を行う
-          # @param [Integer] dividend 被除数
-          # @param [Integer] divisor 除数（0以外）
+          # @param (see DivideWithGameSystemDefault#divide_and_round)
           # @return [Integer]
-          def divide_and_round(dividend, divisor)
+          def divide_and_round(dividend, divisor, _round_type)
             (dividend.to_f / divisor).ceil
           end
         end
@@ -212,10 +301,9 @@ module BCDice
           private
 
           # 除算および端数処理を行う
-          # @param [Integer] dividend 被除数
-          # @param [Integer] divisor 除数（0以外）
+          # @param (see DivideWithGameSystemDefault#divide_and_round)
           # @return [Integer]
-          def divide_and_round(dividend, divisor)
+          def divide_and_round(dividend, divisor, _round_type)
             (dividend.to_f / divisor).round
           end
         end
@@ -223,15 +311,14 @@ module BCDice
         # 除算（切り捨て）のノード
         class DivideWithRoundingDown < DivideBase
           # 端数処理方法を示す記号
-          ROUNDING_METHOD = ""
+          ROUNDING_METHOD = "F"
 
           private
 
           # 除算および端数処理を行う
-          # @param [Integer] dividend 被除数
-          # @param [Integer] divisor 除数（0以外）
+          # @param (see DivideWithGameSystemDefault#divide_and_round)
           # @return [Integer]
-          def divide_and_round(dividend, divisor)
+          def divide_and_round(dividend, divisor, _round_type)
             dividend / divisor
           end
         end
@@ -254,14 +341,19 @@ module BCDice
           #
           # @param [Randomizer] randomizer ランダマイザ
           # @return [Integer] 評価結果
-          def eval(randomizer)
-            -@body.eval(randomizer)
+          def eval(game_system, randomizer)
+            -@body.eval(game_system, randomizer)
+          end
+
+          # @return [Boolean]
+          def include_dice?
+            @body.include_dice?
           end
 
           # 文字列に変換する
           # @return [String]
-          def to_s
-            "-#{@body}"
+          def expr(game_system)
+            "-#{@body.expr(game_system)}"
           end
 
           # メッセージへの出力を返す
@@ -283,8 +375,8 @@ module BCDice
           # @param [Number] times ダイスを振る回数のノード
           # @param [Number] sides ダイスの面数のノード
           def initialize(times, sides)
-            @times = times.literal
-            @sides = sides.literal
+            @times = times
+            @sides = sides
 
             # ダイスを振った結果の出力
             @text = nil
@@ -297,24 +389,30 @@ module BCDice
           #
           # @param [Randomizer] randomizer ランダマイザ
           # @return [Integer] 評価結果（出目の合計値）
-          def eval(randomizer)
-            dice_groups = randomizer.roll(@times, @sides)
+          def eval(game_system, randomizer)
+            times = @times.eval(game_system, nil)
+            sides = eval_sides(game_system)
 
-            # TODO: Ruby 2.4以降では Array#sum が使える
-            total = dice_groups.flatten.reduce(0, &:+)
+            dice_list = randomizer.roll(times, sides)
 
-            dice_str = dice_groups
-                       .map { |dice_list| "[#{dice_list.join(',')}]" }
-                       .join
-            @text = "#{total}#{dice_str}"
+            total = dice_list.sum()
+            @text = "#{total}[#{dice_list.join(',')}]"
 
             return total
           end
 
+          # @return [Boolean]
+          def include_dice?
+            true
+          end
+
           # 文字列に変換する
           # @return [String]
-          def to_s
-            "#{@times}D#{@sides}"
+          def expr(game_system)
+            times = @times.eval(game_system, nil)
+            sides = eval_sides(game_system)
+
+            "#{times}D#{sides}"
           end
 
           # メッセージへの出力を返す
@@ -326,7 +424,32 @@ module BCDice
           # ノードのS式を返す
           # @return [String]
           def s_exp
-            "(DiceRoll #{@times} #{@sides})"
+            "(DiceRoll #{@times.s_exp} #{@sides.s_exp})"
+          end
+
+          private
+
+          def eval_sides(game_system)
+            @sides.eval(game_system, nil)
+          end
+        end
+
+        class ImplicitSidesDiceRoll < DiceRoll
+          # @param [Number] times ダイスを振る回数のノード
+          def initialize(times)
+            @times = times
+            @text = nil
+          end
+
+          # @return [String]
+          def s_exp
+            "(ImplicitSidesDiceRoll #{@times.s_exp})"
+          end
+
+          private
+
+          def eval_sides(game_system)
+            game_system.sides_implicit_d
           end
         end
 
@@ -369,14 +492,14 @@ module BCDice
           ).freeze
 
           # ノードを初期化する
-          # @param [Number] times ダイスを振る回数のノード
-          # @param [Number] sides ダイスの面数のノード
-          # @param [Number] n_filtering ダイスを残す/減らす個数のノード
+          # @param [Object] times ダイスを振る回数のノード
+          # @param [Object] sides ダイスの面数のノード
+          # @param [Object] n_filtering ダイスを残す/減らす個数のノード
           # @param [Filter] filter フィルタ
           def initialize(times, sides, n_filtering, filter)
-            @times = times.literal
-            @sides = sides.literal
-            @n_filtering = n_filtering.literal
+            @times = times
+            @sides = sides
+            @n_filtering = n_filtering
             @filter = filter
 
             # ダイスを振った結果の出力
@@ -390,21 +513,34 @@ module BCDice
           #
           # @param [Randomizer] randomizer ランダマイザ
           # @return [Integer] 評価結果（出目の合計値）
-          def eval(randomizer)
-            sorted_values = randomizer.roll_once(@times, @sides).sort
+          def eval(game_system, randomizer)
+            times = @times.eval(game_system, nil)
+            sides = @sides.eval(game_system, nil)
+            n_filtering = @n_filtering.eval(game_system, nil)
+
+            sorted_values = randomizer.roll(times, sides).sort
             total = @filter
-                    .apply[sorted_values, @n_filtering]
-                    .reduce(0, &:+)
+                    .apply[sorted_values, n_filtering]
+                    .sum()
 
             @text = "#{total}[#{sorted_values.join(',')}]"
 
             return total
           end
 
+          # @return [Boolean]
+          def include_dice?
+            true
+          end
+
           # 文字列に変換する
           # @return [String]
-          def to_s
-            "#{@times}D#{@sides}#{@filter.abbr}#{@n_filtering}"
+          def expr(game_system)
+            times = @times.eval(game_system, nil)
+            sides = @sides.eval(game_system, nil)
+            n_filtering = @n_filtering.eval(game_system, nil)
+
+            "#{times}D#{sides}#{@filter.abbr}#{n_filtering}"
           end
 
           # メッセージへの出力を返す
@@ -416,7 +552,7 @@ module BCDice
           # ノードのS式を返す
           # @return [String]
           def s_exp
-            "(DiceRollWithFilter #{@times} #{@sides} #{@filter.abbr.inspect} #{@n_filtering})"
+            "(DiceRollWithFilter #{@times.s_exp} #{@sides.s_exp} #{@filter.abbr.inspect} #{@n_filtering.s_exp})"
           end
         end
 
@@ -429,13 +565,18 @@ module BCDice
 
           # @param randomizer [Randomizer]
           # @return [integer]
-          def eval(randomizer)
-            @expr.eval(randomizer)
+          def eval(game_system, randomizer)
+            @expr.eval(game_system, randomizer)
+          end
+
+          # @return [Boolean]
+          def include_dice?
+            @expr.include_dice?
           end
 
           # @return [String]
-          def to_s
-            "(#{@expr})"
+          def expr(game_system)
+            "(#{@expr.expr(game_system)})"
           end
 
           # @return [String]
@@ -469,18 +610,26 @@ module BCDice
 
           # ノードを評価する
           # @return [Integer] 格納している値
-          def eval(_randomizer)
+          def eval(_game_system, _randomizer)
             @literal
           end
 
+          # @return [Boolean]
+          def include_dice?
+            false
+          end
+
           # 文字列に変換する
           # @return [String]
-          def to_s
+          def expr(_game_system)
+            @literal.to_s
+          end
+
+          def output
             @literal.to_s
           end
 
-          alias output to_s
-          alias s_exp to_s
+          alias s_exp output
         end
       end
     end