bcdice 3.0.0.pre.alpha.1 → 3.1.0

data/lib/bcdice/common_command/d66_dice.rb

@@ -1,63 +1,81 @@
+# frozen_string_literal: true
+
 module BCDice
   module CommonCommand
     class D66Dice
       PREFIX_PATTERN = /D66/.freeze
 
-      def initialize(command, randomizer, game_system)
-        @command = command
-        @randomizer = randomizer
-        @game_system = game_system
+      class << self
+        # @param command [String]
+        # @param game_system [BCDice::Base]
+        # @param randomizer [Randomizer]
+        # @return [Result, nil]
+        def eval(command, game_system, randomizer)
+          cmd = parse(command, game_system)
+          cmd&.eval(randomizer)
+        end
 
-        @is_secret = false
-      end
+        private
 
-      def secret?
-        @is_secret
-      end
+        def parse(command, game_system)
+          command = command.split(" ", 2).first
+
+          m = /^(S)?D66([ANSD])?$/i.match(command)
+          return nil unless m
 
-      def eval
-        unless @game_system.enabled_d66?
-          return nil
+          new(
+            secret: !m[1].nil?,
+            sort_type: sort_type_from_suffix(m[2]) || game_system.d66_sort_type,
+            suffix: m[2]
+          )
         end
 
-        m = /^(S)?D66([ANS])?$/i.match(@command)
-        unless m
-          return nil
+        def sort_type_from_suffix(suffix)
+          case suffix
+          when "A", "S"
+            D66SortType::ASC
+          when "D"
+            D66SortType::DESC
+          when "N"
+            D66SortType::NO_SORT
+          end
         end
+      end
 
-        @is_secret = !m[1].nil?
-        @sort_type = sort_type_from_suffix(m[2])
+      # @param secret [Boolean]
+      # @param sort_type [Symbol]
+      # @param suffix [String, nil]
+      def initialize(secret:, sort_type:, suffix:)
+        @secret = secret
+        @sort_type = sort_type
+        @suffix = suffix
+      end
 
-        value = roll()
+      # @param randomizer [Randomizer]
+      # @return [Result]
+      def eval(randomizer)
+        value = roll(randomizer)
 
-        return "(D66#{m[2]}) ＞ #{value}"
+        Result.new.tap do |r|
+          r.secret = @secret
+          r.text = "(D66#{@suffix}) ＞ #{value}"
+        end
       end
 
       private
 
-      def roll()
-        dice_list = Array.new(2) { @randomizer.roll_once(6) }
+      def roll(randomizer)
+        dice_list = Array.new(2) { randomizer.roll_once(6) }
 
         case @sort_type
-        when :asc
+        when D66SortType::ASC
           dice_list.sort!
-        when :desc
+        when D66SortType::DESC
           dice_list.sort!.reverse!
         end
 
         return dice_list[0] * 10 + dice_list[1]
       end
-
-      def sort_type_from_suffix(suffix)
-        case suffix
-        when "A", "S"
-          :asc
-        when "N"
-          :no_sort
-        else
-          @game_system.d66_sort_type
-        end
-      end
     end
   end
 end

data/lib/bcdice/common_command/lexer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "bcdice/normalize"
+
+module BCDice
+  module CommonCommand
+    class Lexer
+      SYMBOLS = {
+        "+" => :PLUS,
+        "-" => :MINUS,
+        "*" => :ASTERISK,
+        "/" => :SLASH,
+        "(" => :PARENL,
+        ")" => :PARENR,
+        "[" => :BRACKETL,
+        "]" => :BRACKETR,
+        "?" => :QUESTION,
+        "@" => :AT,
+      }.freeze
+
+      def initialize(source)
+        # sourceが空文字だとString#splitが空になる
+        source = source.split(" ", 2).first || ""
+        @scanner = StringScanner.new(source)
+      end
+
+      def next_token
+        return [false, "$"] if @scanner.eos?
+
+        if (number = @scanner.scan(/\d+/))
+          [:NUMBER, number.to_i]
+        elsif (cmp_op = @scanner.scan(/[<>!=]+/))
+          [:CMP_OP, Normalize.comparison_operator(cmp_op)]
+        else
+          char = @scanner.getch.upcase
+          type = SYMBOLS[char] || char.to_sym
+          [type, char]
+        end
+      end
+
+      def source
+        @scanner.string
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/repeat.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module BCDice
+  module CommonCommand
+    # リピート
+    #
+    # 繰り返し回数を指定して、特定のコマンドを複数回実行する
+    # 例）
+    #   x5 choice[A,B,C,D] #=> `choice[A,B,C,D]`を5回実行する
+    #   rep2 CC<=75        #=> `CC<=75`を2回実行する
+    #   repeat10 2D6+5     #=> `2D6+6`を10回実行する
+    #
+    # このコマンドを入れ子させることは許容しない。繰り返し回数の爆発に繋がるためである。
+    # 以下は実行時にエラーとなる。
+    #   x10 repeat100 100D100
+    class Repeat
+      PREFIX_PATTERN = /(repeat|rep|x)\d+/.freeze
+
+      REPEAT_LIMIT = 100
+
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = parse(command)
+          cmd&.roll(game_system, randomizer)
+        end
+
+        private
+
+        def parse(command)
+          scanner = StringScanner.new(command)
+
+          secret = !scanner.scan(/s/i).nil?
+          keyword = scanner.scan(/repeat|rep|x/i)
+          repeat_times = scanner.scan(/\d+/)&.to_i
+          whitespace = scanner.scan(/\s+/)
+          if keyword.nil? || repeat_times.nil? || whitespace.nil?
+            return nil
+          end
+
+          trailer = scanner.post_match
+          if trailer.nil? || trailer.empty?
+            return nil
+          end
+
+          new(
+            secret: secret,
+            times: repeat_times,
+            trailer: trailer
+          )
+        end
+      end
+
+      def initialize(secret:, times:, trailer:)
+        @secret = secret
+        @times = times
+        @trailer = trailer
+      end
+
+      def roll(game_system, randomizer)
+        err = validate()
+        return err if err
+
+        results = Array.new(@times) do
+          cmd = game_system.class.new(@trailer)
+          cmd.randomizer = randomizer
+          cmd.eval()
+        end
+
+        if results.count(nil) == @times
+          return result_with_text("繰り返し対象のコマンドが実行できませんでした (#{@trailer})")
+        end
+
+        text = results.map.with_index(1) { |r, index| "\##{index}\n#{r.text}" }.join("\n\n")
+        secret = @secret || results.any?(&:secret?)
+
+        Result.new.tap do |r|
+          r.secret = secret
+          r.text = text
+        end
+      end
+
+      private
+
+      def validate
+        if /\A(repeat|rep|x)\d+/.match?(@trailer)
+          result_with_text("Repeatコマンドの重複はできません")
+        elsif @times < 1 || REPEAT_LIMIT < @times
+          result_with_text("繰り返し回数は1以上、#{REPEAT_LIMIT}以下としてください")
+        end
+      end
+
+      def result_with_text(text)
+        Result.new.tap do |r|
+          r.secret = @secret
+          r.text = text
+        end
+      end
+    end
+  end
+end

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