bcdice 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/bcdice/common_command/reroll_dice.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "bcdice/normalize"
 require "bcdice/format"
+require "bcdice/common_command/reroll_dice/parser"
 
 module BCDice
   module CommonCommand
@@ -22,167 +25,14 @@ module BCDice
     #
     # 成功条件が書かれていない場合、成功数0として扱う。
     # 振り足し条件が数値のみ指定されている場合、比較演算子は >= が指定されたとして振舞う。
-    class RerollDice
+    module RerollDice
       PREFIX_PATTERN = /\d+R\d+/.freeze
       REROLL_LIMIT = 10000
 
-      def initialize(command, bcdice, diceBot)
-        @command = command
-        @bcdice = bcdice
-        @diceBot = diceBot
-
-        @is_secret = false
-      end
-
-      def secret?
-        @is_secret
-      end
-
-      def eval()
-        unless parse(@command)
-          return nil
-        end
-
-        unless @reroll_threshold
-          return msg_invalid_reroll_number(@command)
-        end
-
-        dice_queue = @notation.split("+").map do |xRn|
-          x, n = xRn.split("R").map(&:to_i)
-          [x, n, 0]
-        end
-
-        unless dice_queue.all? { |d| valid_reroll_rule?(d[1], @reroll_cmp_op, @reroll_threshold) }
-          return msg_invalid_reroll_number(@command)
-        end
-
-        success_count = 0
-        dice_str_list = []
-        one_count = 0
-        loop_count = 0
-
-        dice_total_count = 0
-
-        while !dice_queue.empty? && loop_count < REROLL_LIMIT
-          # xRn
-          x, n, depth = dice_queue.shift
-          loop_count += 1
-          dice_total_count += x
-
-          dice_list = @bcdice.roll_barabara(x, n)
-          dice_list.sort! if @diceBot.sort_barabara_dice?
-          success_count += dice_list.count() { |val| val.send(@cmp_op, @target_number) } if @cmp_op
-          reroll_count = dice_list.count() { |val| val.send(@reroll_cmp_op, @reroll_threshold) }
-
-          dice_str_list.push(dice_list.join(","))
-
-          if depth.zero?
-            one_count += dice_list.count(1)
-          end
-
-          if reroll_count > 0
-            dice_queue.push([reroll_count, n, depth + 1])
-          end
-        end
-
-        sequence = [
-          expr(),
-          dice_str_list.join(" + "),
-          "成功数#{success_count}",
-          @diceBot.grich_text(one_count, dice_total_count, success_count),
-        ].compact
-
-        return sequence.join(" ＞ ")
-      end
-
-      private
-
-      # @param command [String]
-      # @return [Boolean]
-      def parse(command)
-        m = /^S?(\d+R\d+(?:\+\d+R\d+)*)(?:\[([<>=]+)?(\d+)\])?(?:([<>=]+)(\d+))?(?:@([<>=]+)?(\d+))?$/.match(command)
-        unless m
-          return false
-        end
-
-        @is_secret = command.start_with?("S")
-        @notation = m[1]
-        @cmp_op = Normalize.comparison_operator(m[4]) || @diceBot.default_cmp_op
-        @target_number = m[5]&.to_i || @diceBot.default_target_number
-
-        @reroll_cmp_op = decide_reroll_cmp_op(m)
-        @reroll_threshold = decide_reroll_threshold(m[3] || m[7], @target_number)
-
-        return true
-      end
-
-      # @param m [MatchData]
-      # @return [Symbol]
-      def decide_reroll_cmp_op(m)
-        bracket_op = m[2]
-        bracket_number = m[3]
-        at_op = m[6]
-        at_number = m[7]
-        cmp_op = m[4]
-
-        op =
-          if bracket_op && bracket_number
-            bracket_op
-          elsif at_op && at_number
-            at_op
-          else
-            cmp_op
-          end
-
-        Normalize.comparison_operator(op) || :>=
-      end
-
-      # @param captured_threshold [String, nil]
-      # @param target_number [Integer, nil]
-      # @return [Integer]
-      # @return [nil]
-      def decide_reroll_threshold(captured_threshold, target_number)
-        if captured_threshold
-          captured_threshold.to_i
-        elsif @diceBot.reroll_dice_reroll_threshold
-          @diceBot.reroll_dice_reroll_threshold
-        else
-          target_number
-        end
-      end
-
-      # @return [String]
-      def expr()
-        reroll_cmp_op_text = @cmp_op != @reroll_cmp_op ? Format.comparison_operator(@reroll_cmp_op) : nil
-        cmp_op_text = Format.comparison_operator(@cmp_op)
-
-        "(#{@notation}[#{reroll_cmp_op_text}#{@reroll_threshold}]#{cmp_op_text}#{@target_number})"
-      end
-
-      # @param command [String]
-      # @return [String]
-      def msg_invalid_reroll_number(command)
-        "#{command} ＞ 条件が間違っています。2R6>=5 あるいは 2R6[5] のように振り足し目標値を指定してください。"
-      end
-
-      # @param sides [Integer]
-      # @param cmp_op [Symbol]
-      # @param reroll_threshold [Integer]
-      # @return [Boolean]
-      def valid_reroll_rule?(sides, cmp_op, reroll_threshold) # 振り足しロールの条件確認
-        case cmp_op
-        when :<=
-          reroll_threshold < sides
-        when :<
-          reroll_threshold <= sides
-        when :>=
-          reroll_threshold > 1
-        when :>
-          reroll_threshold >= 1
-        when :'!='
-          (1..sides).include?(reroll_threshold)
-        else
-          true
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system, randomizer)
         end
       end
     end

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

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module BCDice
+  module CommonCommand
+    module RerollDice
+      module Node
+        class Command
+          def initialize(secret:, notations:, source:, cmp_op: nil, target_number: nil, reroll_cmp_op: nil, reroll_threshold: nil)
+            @secret = secret
+            @notations = notations
+            @cmp_op = cmp_op
+            @target_number_node = target_number
+            @reroll_cmp_op = reroll_cmp_op
+            @reroll_threshold_node = reroll_threshold
+            @source = source
+          end
+
+          def eval(game_system, randomizer)
+            round_type = game_system.round_type
+            cmp_op = @cmp_op || game_system.default_cmp_op
+            reroll_cmp_op = @reroll_cmp_op || cmp_op || :>=
+
+            target_number =
+              @target_number_node&.eval(round_type) ||
+              game_system.default_target_number
+
+            reroll_threshold =
+              @reroll_threshold_node&.eval(round_type) ||
+              game_system.reroll_dice_reroll_threshold ||
+              target_number
+
+            reroll_condition = RerollCondition.new(reroll_cmp_op, reroll_threshold)
+
+            dice_queue = @notations.map { |node| node.to_dice(round_type) }
+            unless dice_queue.all? { |d| reroll_condition.valid?(d.sides) }
+              return result_with_text("#{@source} ＞ 条件が間違っています。2R6>=5 あるいは 2R6[5] のように振り足し目標値を指定してください。")
+            end
+
+            dice_list_list = roll(
+              dice_queue,
+              randomizer,
+              reroll_condition,
+              game_system.sort_barabara_dice?
+            )
+
+            dice_list = dice_list_list.flatten
+
+            # 振り足し分は出目1の個数をカウントしない
+            one_count = dice_list_list
+                        .take(@notations.size)
+                        .flatten
+                        .count(1)
+
+            success_count =
+              if cmp_op
+                dice_list.count { |val| val.send(cmp_op, target_number) }
+              else
+                0
+              end
+
+            sequence = [
+              expr(round_type, reroll_condition, cmp_op, target_number),
+              dice_list_list.map { |list| list.join(",") }.join(" + "),
+              "成功数#{success_count}",
+              game_system.grich_text(one_count, dice_list.size, success_count),
+            ].compact
+
+            result_with_text(sequence.join(" ＞ "))
+          end
+
+          private
+
+          # ダイスロールを行う
+          # @param dice_queue [Array<Dice>] ダイスキュー
+          # @param randomizer [Randomizer] 乱数生成器
+          # @param reroll_condition [RerollCondition] 振り足し条件
+          # @param sort [Boolean] 出目を並び替えるか
+          # @return [Array<Array<Integer>>]
+          def roll(dice_queue, randomizer, reroll_condition, sort)
+            dice_list_list = []
+            loop_count = 0
+
+            while !dice_queue.empty? && loop_count < REROLL_LIMIT
+              dice = dice_queue.shift
+              loop_count += 1
+
+              dice_list = dice.roll(randomizer)
+              dice_list.sort! if sort
+              dice_list_list.push(dice_list)
+
+              reroll_count = dice_list.count { |val| reroll_condition.reroll?(val) }
+              if reroll_count > 0
+                dice_queue.push(Dice.new(reroll_count, dice.sides))
+              end
+            end
+
+            return dice_list_list
+          end
+
+          def expr(round_type, reroll_condition, cmp_op, target_number)
+            notation = @notations.map { |n| n.to_dice(round_type) }.join("+")
+
+            reroll_cmp_op_text =
+              if reroll_condition.cmp_op == cmp_op
+                ""
+              else
+                Format.comparison_operator(reroll_condition.cmp_op)
+              end
+
+            cmp_op_text = Format.comparison_operator(cmp_op)
+
+            "(#{notation}[#{reroll_cmp_op_text}#{reroll_condition.threshold}]#{cmp_op_text}#{target_number})"
+          end
+
+          def result_with_text(text)
+            Result.new.tap do |r|
+              r.secret = @secret
+              r.text = text
+            end
+          end
+        end
+
+        # 振り足し条件を表すクラス。
+        class RerollCondition
+          # @return [Symbol] 比較演算子
+          attr_reader :cmp_op
+          # @return [Integer] 振り足しの閾値
+          attr_reader :threshold
+
+          # @param cmp_op [Symbol] 比較演算子
+          # @param threshold [Integer] 振り足しの閾値
+          def initialize(cmp_op, threshold)
+            @cmp_op = cmp_op
+            @threshold = threshold
+          end
+
+          # @param sides [Integer] ダイスの面数
+          # @return [Boolean] 振り足し条件が妥当か
+          def valid?(sides)
+            return false unless @threshold
+
+            case @cmp_op
+            when :<=
+              @threshold < sides
+            when :<
+              @threshold <= sides
+            when :>=
+              @threshold > 1
+            when :>
+              @threshold >= 1
+            when :'!='
+              (1..sides).include?(@threshold)
+            else # :==
+              true
+            end
+          end
+
+          # @param value [Integer] 出目
+          # @return [Boolean] 振り足しを行うべきか
+          def reroll?(value)
+            value.send(@cmp_op, @threshold)
+          end
+        end
+
+        class Notation
+          def initialize(times, sides)
+            @times = times
+            @sides = sides
+          end
+
+          def to_dice(round_type)
+            times = @times.eval(round_type)
+            sides = @sides.eval(round_type)
+
+            Dice.new(times, sides)
+          end
+        end
+
+        class Dice
+          attr_reader :times, :sides
+
+          def initialize(times, sides)
+            @times = times
+            @sides = sides
+          end
+
+          def roll(randomizer)
+            randomizer.roll_barabara(times, sides)
+          end
+
+          def to_s
+            "#{times}R#{sides}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/reroll_dice/parser.rb

@@ -0,0 +1,421 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/barabara_dice/node"
+require "bcdice/arithmetic/node"
+
+module BCDice
+  module CommonCommand
+    module RerollDice
+      class Parser < Racc::Parser
+
+
+def self.parse(source)
+  new.parse(source)
+end
+
+def parse(source)
+  @lexer = Lexer.new(source)
+  do_parse()
+rescue ParseError
+  nil
+end
+
+private
+
+def next_token
+  @lexer.next_token
+end
+##### State transition tables begin ###
+
+racc_action_table = [
+     9,     3,     9,     9,     9,    15,    20,    21,    20,    21,
+     8,    14,     8,     8,     8,     9,     9,     4,    13,    28,
+    10,    39,    20,    21,     9,     8,     8,    31,    32,     9,
+    20,    21,    33,    16,     8,    20,    21,     9,    24,     8,
+    34,    35,     9,    20,    21,    31,    32,     8,    20,    21,
+     9,    13,     8,    31,    32,     9,    20,    21,    34,    35,
+     8,    20,    21,     9,   nil,     8,    34,    35,     9,    20,
+    21,    31,    32,     8,    20,    21,     9,   nil,     8,   nil,
+    31,    32,    20,    21,    31,    32,     8,    40,   nil,   nil,
+   nil,    47,    51,    49,    50,    52 ]
+
+racc_action_check = [
+    14,     0,    24,     2,    15,     5,    14,    14,    24,    24,
+    14,     5,    24,     2,    15,    16,     8,     1,     5,    14,
+     4,    24,     8,     8,    13,    16,     8,    17,    17,    20,
+    13,    13,    17,     7,    13,    20,    20,    21,    11,    20,
+    18,    18,    28,    21,    21,    26,    26,    21,    28,    28,
+    31,    12,    28,    38,    38,    32,    31,    31,    42,    42,
+    31,    32,    32,    34,   nil,    32,    43,    43,    35,    34,
+    34,    46,    46,    34,    35,    35,    39,   nil,    35,   nil,
+    27,    27,    39,    39,    41,    41,    39,    27,   nil,   nil,
+   nil,    41,    45,    45,    45,    45 ]
+
+racc_action_pointer = [
+    -6,    17,     1,   nil,    20,    -3,   nil,    30,    14,   nil,
+   nil,    18,    30,    22,    -2,     2,    13,    19,    30,   nil,
+    27,    35,   nil,   nil,     0,   nil,    37,    72,    40,   nil,
+   nil,    48,    53,   nil,    61,    66,   nil,   nil,    45,    74,
+   nil,    76,    48,    56,   nil,    89,    63,   nil,   nil,   nil,
+   nil,   nil,   nil ]
+
+racc_action_default = [
+    -4,   -31,   -31,    -5,   -31,    -6,   -13,   -31,   -31,   -30,
+    53,    -1,    -6,   -31,   -31,   -31,   -31,   -31,   -17,   -20,
+   -31,   -31,   -28,    -3,   -31,    -2,    -7,   -31,   -31,   -12,
+   -14,   -31,   -31,   -29,   -31,   -31,   -26,   -27,   -10,   -31,
+    -8,   -31,   -15,   -16,   -18,   -21,   -11,    -9,   -19,   -22,
+   -23,   -24,   -25 ]
+
+racc_goto_table = [
+    17,     7,    11,    36,    37,    26,    27,     1,     6,    25,
+    42,    43,     2,     5,     7,    30,    38,    44,    45,    12,
+    41,    29,    23,    48,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    46 ]
+
+racc_goto_check = [
+     7,     9,     4,    11,    11,     7,     7,     1,     8,     4,
+    10,    10,     2,     3,     9,     9,     7,    11,    11,     5,
+     7,     8,     6,    12,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,     7 ]
+
+racc_goto_pointer = [
+   nil,     7,    12,    11,    -3,    14,    11,    -8,     6,    -1,
+   -21,   -17,   -22 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    22,
+    18,    19,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 23, :_reduce_1,
+  4, 23, :_reduce_2,
+  4, 23, :_reduce_3,
+  0, 24, :_reduce_4,
+  1, 24, :_reduce_5,
+  0, 26, :_reduce_6,
+  2, 26, :_reduce_7,
+  3, 27, :_reduce_8,
+  4, 27, :_reduce_9,
+  2, 28, :_reduce_10,
+  3, 28, :_reduce_11,
+  3, 25, :_reduce_12,
+  1, 25, :_reduce_13,
+  3, 30, :_reduce_14,
+  3, 29, :_reduce_15,
+  3, 29, :_reduce_16,
+  1, 29, :_reduce_none,
+  3, 32, :_reduce_18,
+  4, 32, :_reduce_19,
+  1, 32, :_reduce_none,
+  0, 34, :_reduce_21,
+  1, 34, :_reduce_22,
+  1, 34, :_reduce_23,
+  1, 34, :_reduce_24,
+  1, 34, :_reduce_25,
+  2, 33, :_reduce_26,
+  2, 33, :_reduce_27,
+  1, 33, :_reduce_none,
+  3, 31, :_reduce_29,
+  1, 31, :_reduce_30 ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 53
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :R => 3,
+  :U => 4,
+  :C => 5,
+  :F => 6,
+  :S => 7,
+  :PLUS => 8,
+  :MINUS => 9,
+  :ASTERISK => 10,
+  :SLASH => 11,
+  :PARENL => 12,
+  :PARENR => 13,
+  :BRACKETL => 14,
+  :BRACKETR => 15,
+  :LESS => 16,
+  :GREATER => 17,
+  :EQUAL => 18,
+  :NOT => 19,
+  :AT => 20,
+  :CMP_OP => 21 }
+
+racc_nt_base = 22
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "NUMBER",
+  "R",
+  "U",
+  "C",
+  "F",
+  "S",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "BRACKETL",
+  "BRACKETR",
+  "LESS",
+  "GREATER",
+  "EQUAL",
+  "NOT",
+  "AT",
+  "CMP_OP",
+  "$start",
+  "expr",
+  "secret",
+  "notations",
+  "target",
+  "bracket",
+  "at",
+  "add",
+  "dice",
+  "term",
+  "mul",
+  "unary",
+  "round_type" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: val[2][:cmp_op],
+            target_number: val[2][:target],
+            source: @lexer.source
+          )
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+          target = val[3]
+          threshold = val[2]
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: target[:cmp_op],
+            target_number: target[:target],
+            reroll_cmp_op: threshold[:cmp_op],
+            reroll_threshold: threshold[:threshold],
+            source: @lexer.source
+          )
+
+    result
+end
+
+def _reduce_3(val, _values, result)
+          target = val[2]
+          threshold = val[3]
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: target[:cmp_op],
+            target_number: target[:target],
+            reroll_cmp_op: threshold[:cmp_op],
+            reroll_threshold: threshold[:threshold],
+            source: @lexer.source
+          )
+
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = false
+    result
+end
+
+def _reduce_5(val, _values, result)
+ result = true
+    result
+end
+
+def _reduce_6(val, _values, result)
+ result = {}
+    result
+end
+
+def _reduce_7(val, _values, result)
+            cmp_op, target = val
+            raise ParseError unless cmp_op
+
+            result = {cmp_op: cmp_op, target: target}
+
+    result
+end
+
+def _reduce_8(val, _values, result)
+ result = {threshold: val[1]}
+    result
+end
+
+def _reduce_9(val, _values, result)
+             cmp_op = val[1]
+             threshold = val[2]
+             raise ParseError unless cmp_op
+
+             result = {cmp_op: cmp_op, threshold: threshold}
+
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = {threshold: val[1]}
+    result
+end
+
+def _reduce_11(val, _values, result)
+        cmp_op = val[1]
+        threshold = val[2]
+        raise ParseError unless cmp_op
+
+        result = {cmp_op: cmp_op, threshold: threshold}
+
+    result
+end
+
+def _reduce_12(val, _values, result)
+               notations = val[0]
+               notations.push(val[2])
+               result = notations
+
+    result
+end
+
+def _reduce_13(val, _values, result)
+ result = [val[0]]
+    result
+end
+
+def _reduce_14(val, _values, result)
+          times = val[0]
+          sides = val[2]
+          result = Node::Notation.new(times, sides)
+
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+# reduce 17 omitted
+
+def _reduce_18(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
+    result
+end
+
+def _reduce_19(val, _values, result)
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+
+    result
+end
+
+# reduce 20 omitted
+
+def _reduce_21(val, _values, result)
+ result = Arithmetic::Node::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_22(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_23(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_24(val, _values, result)
+ result = Arithmetic::Node::DivideWithRound
+    result
+end
+
+def _reduce_25(val, _values, result)
+ result = Arithmetic::Node::DivideWithFloor
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+# reduce 28 omitted
+
+def _reduce_29(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_30(val, _values, result)
+ result = Arithmetic::Node::Number.new(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+      end   # class Parser
+    end   # module RerollDice
+  end   # module CommonCommand
+end   # module BCDice