bcdice 3.0.0.pre.alpha.1

data/lib/bcdice/common_command/d66_dice.rb

@@ -0,0 +1,63 @@
+module BCDice
+  module CommonCommand
+    class D66Dice
+      PREFIX_PATTERN = /D66/.freeze
+
+      def initialize(command, randomizer, game_system)
+        @command = command
+        @randomizer = randomizer
+        @game_system = game_system
+
+        @is_secret = false
+      end
+
+      def secret?
+        @is_secret
+      end
+
+      def eval
+        unless @game_system.enabled_d66?
+          return nil
+        end
+
+        m = /^(S)?D66([ANS])?$/i.match(@command)
+        unless m
+          return nil
+        end
+
+        @is_secret = !m[1].nil?
+        @sort_type = sort_type_from_suffix(m[2])
+
+        value = roll()
+
+        return "(D66#{m[2]}) ＞ #{value}"
+      end
+
+      private
+
+      def roll()
+        dice_list = Array.new(2) { @randomizer.roll_once(6) }
+
+        case @sort_type
+        when :asc
+          dice_list.sort!
+        when :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/reroll_dice.rb

@@ -0,0 +1,190 @@
+require "bcdice/normalize"
+require "bcdice/format"
+
+module BCDice
+  module CommonCommand
+    # 個数振り足しダイス
+    #
+    # ダイスを振り、条件を満たした出目の個数だけダイスを振り足す。振り足しがなくなるまでこれを繰り返す。
+    # 成功条件を満たす出目の個数を調べ、成功数を表示する。
+    #
+    # 例
+    #   2R6+1R10[>3]>=5
+    #   2R6+1R10>=5@>3
+    #
+    # 振り足し条件は角カッコかコマンド末尾の @ で指定する。
+    # [>3] の場合、3より大きい出目が出たら振り足す。
+    # [3] のように数値のみ指定されている場合、成功条件の比較演算子を流用する。
+    # 上記の例の時、出目が
+    #   "2R6"  -> [5,6] [5,4] [1,3]
+    #   "1R10" -> [9] [1]
+    # だとすると、 >=5 に該当するダイスは5つなので成功数5となる。
+    #
+    # 成功条件が書かれていない場合、成功数0として扱う。
+    # 振り足し条件が数値のみ指定されている場合、比較演算子は >= が指定されたとして振舞う。
+    class 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
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/upper_dice.rb

@@ -0,0 +1,165 @@
+require "bcdice/arithmetic_evaluator"
+require "bcdice/normalize"
+require "bcdice/format"
+
+module BCDice
+  module CommonCommand
+    # 上方無限ロール
+    #
+    # ダイスを1つ振る、その出目が閾値より大きければダイスを振り足すのを閾値未満の出目が出るまで繰り返す。
+    # これを指定したダイス数だけおこない、それぞれのダイスの合計値を求める。
+    # それらと目標値を比較し、成功した数を表示する。
+    #
+    # フォーマットは以下の通り
+    # 2U4+1U6[4]>=6
+    # 2U4+1U6>=6@4
+    #
+    # 閾値は角カッコで指定するか、コマンドの末尾に @6 のように指定する。
+    # 閾値の指定が重複した場合、角カッコが優先される。
+    # この時、出目が
+    #   "2U4" -> 3[3], 10[4,4,2]
+    #   "1U6" -> 6[4,2]
+    # だとすると、 >=6 に該当するダイスは2つなので成功数2となる。
+    #
+    # 2U4[4]+10>=6 のように修正値を指定できる。修正値は全てのダイスに補正を加え、以下のようになる。
+    #   "2U4" -> 3[3]+10=13, 10[4,4,2]+10=20
+    #
+    # 比較演算子が書かれていない場合、ダイスの最大値と全ダイスの合計値が出力される。
+    # 全ダイスの合計値には補正値が1回だけ適用される
+    # 2U4[4]+10
+    #   "2U4" -> 3[3]+10=13, 10[4,4,2]+10=20
+    #   最大値：20
+    #   合計値：23 = 3[3]+10[4,4,2]+10
+    class UpperDice
+      PREFIX_PATTERN = /\d+U\d+/.freeze
+
+      def initialize(command, bcdice, diceBot)
+        @string = command
+        @bcdice = bcdice
+        @diceBot = diceBot
+
+        @is_secret = false
+      end
+
+      def secret?
+        @is_secret
+      end
+
+      # 上方無限ロールを実行する
+      #
+      # @return [String, nil]
+      def eval
+        unless (m = /^S?(\d+U\d+(?:\+\d+U\d+)*)(?:\[(\d+)\])?([\+\-\d]*)(?:([<>=]+)(\d+))?(?:@(\d+))?/i.match(@string))
+          return nil
+        end
+
+        @is_secret = @string.start_with?("S")
+
+        @command = m[1]
+        @cmp_op = Normalize.comparison_operator(m[4])
+        @target_number = @cmp_op ? m[5].to_i : nil
+        @reroll_threshold = reroll_threshold(m[2] || m[6])
+
+        @modify_number = ArithmeticEvaluator.eval(m[3], round_type: @diceBot.round_type)
+
+        if @reroll_threshold <= 1
+          return "(#{expr()}) ＞ 無限ロールの条件がまちがっています"
+        end
+
+        roll_list = []
+        @command.split("+").each do |u|
+          times, sides = u.split("U", 2).map(&:to_i)
+          roll_list.concat(roll(times, sides))
+        end
+
+        result =
+          if @cmp_op
+            success_count = roll_list.count do |e|
+              x = e[:sum] + @modify_number
+              x.send(@cmp_op, @target_number)
+            end
+            "成功数#{success_count}"
+          else
+            sum_list = roll_list.map { |e| e[:sum] }
+            total = sum_list.inject(0, :+) + @modify_number
+            max = sum_list.map { |i| i + @modify_number }.max
+            "#{max}/#{total}(最大/合計)"
+          end
+
+        sequence = [
+          "(#{expr()})",
+          dice_text(roll_list) + Format.modifier(@modify_number),
+          result
+        ]
+
+        return sequence.join(" ＞ ")
+      end
+
+      private
+
+      # ダイスロールし、ダイスボットのソート設定に応じてソートする
+      #
+      # @param times [Integer] ダイスの個数
+      # @param sides [Integer] ダイスの面数
+      # @return [Array<Hash>]
+      def roll(times, sides)
+        ret = Array.new(times) do
+          list = roll_ones(sides)
+          {sum: list.inject(0, :+), list: list}
+        end
+
+        if @diceBot.sort_barabara_dice?
+          ret = ret.sort_by { |e| e[:sum] }
+        end
+
+        return ret
+      end
+
+      # 一つだけダイスロールする
+      #
+      # @param sides [Integer] ダイスの面数
+      # @return [Array<Integer>]
+      def roll_ones(sides)
+        dice_list = []
+
+        loop do
+          value = @bcdice.roll_once(sides)
+          dice_list.push(value)
+          break if value < @reroll_threshold
+        end
+
+        return dice_list
+      end
+
+      # ダイスロールの結果を文字列に変換する
+      # 振り足しがなければその数値、振り足しがあれば合計と各ダイスの出目を出力する
+      #
+      # @param roll_list [Array<Hash>]
+      # @return [String]
+      def dice_text(roll_list)
+        roll_list.map do |e|
+          if e[:list].size == 1
+            e[:sum]
+          else
+            "#{e[:sum]}[#{e[:list].join(',')}]"
+          end
+        end.join(",")
+      end
+
+      # 振り足しの閾値を得る
+      #
+      # @param target [String]
+      # @return [Integer]
+      def reroll_threshold(target)
+        target&.to_i || @diceBot.upper_dice_reroll_threshold.to_i
+      end
+
+      # パース済みのコマンドを文字列で表示する
+      #
+      # @return [String]
+      def expr
+        "#{@command}[#{@reroll_threshold}]#{Format.modifier(@modify_number)}#{Format.comparison_operator(@cmp_op)}#{@target_number}"
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/version.rb

@@ -0,0 +1,26 @@
+module BCDice
+  module CommonCommand
+    class Version
+      PREFIX_PATTERN = /BCDiceVersion/.freeze
+
+      # @param command [String]
+      # @param _randomizer [Randomizer]
+      # @param _game_system [Base]
+      def initialize(command, _randomizer, _game_system)
+        @command = command
+      end
+
+      # @return [Boolean]
+      def secret?
+        false
+      end
+
+      # @return [String, nil]
+      def eval
+        if @command == "BCDICEVERSION"
+          "BCDice Ver#{BCDice::VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/dice_table.rb

@@ -0,0 +1,8 @@
+require "bcdice/dice_table/roll_result"
+require "bcdice/dice_table/chain_table"
+require "bcdice/dice_table/d66_grid_table"
+require "bcdice/dice_table/d66_range_table"
+require "bcdice/dice_table/d66_table"
+require "bcdice/dice_table/range_table"
+require "bcdice/dice_table/sai_fic_skill_table"
+require "bcdice/dice_table/table"