bcdice 3.15.0 → 3.17.0

data/lib/bcdice/game_system/Nechronica_Korean.rb

@@ -17,16 +17,16 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
         ・판정　(nNC+m)
-        　주사위 수n、수정치m으로 판정굴림을 행합니다.
+        　주사위 수n, 수정치m으로 판정굴림을 행합니다.
         　주사위 수가 2개 이상일 때에 파츠파손 수도 표시합니다.
         ・공격판정　(nNA+m)
-        　주사위 수n、수정치m으로 공격판정굴림을 행합니다.
+        　주사위 수n, 수정치m으로 공격판정굴림을 행합니다.
         　명중부위와 주사위 수가 2개 이상일 때에 파츠파손 수도 표시합니다.
 
-        表
-        ・姉妹への未練表 nm
-        ・中立者への未練表 nmn
-        ・敵への未練表 nme
+        표
+        ・자매에 대한 미련표 nm
+        ・중립자에 대한 미련표 nmn
+        ・적에 대한 미련표 nme
       INFO_MESSAGE_TEXT
 
       register_prefix_from_super_class()

data/lib/bcdice/game_system/NegikureNegimaki.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class NegikureNegimaki < Base
+      # ゲームシステムの識別子
+      ID = "NegikureNegimaki"
+
+      # ゲームシステム名
+      NAME = "ネジクレネジマキ"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "ねしくれねしまき"
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ■ 行為判定
+        nNNx#y: n個のD6を振り、x以上の出目の個数を成功レベルとして判定する
+        n: ダイス数（省略時1）
+        x: 難易度（省略時4）
+        y: 要求成功レベル（省略時1、0は1として扱う）
+
+        ■ 戦闘判定（アタック判定）
+        nNAx#y: n個のD6を振り、x以上を成功とする。y以上の成功は直撃ダメージになる
+        n: ダイス数（省略時1）
+        x: 難易度（省略時4）
+        y: クリティカル値（省略時6、0は1として扱う）
+        通常ダメージ = 成功レベル - 直撃ダメージ
+        直撃ダメージ = 成功した出目のうち y 以上の個数
+        ガッツ減少 = 出目 1 の個数
+
+        ■ ストライクの判定
+        nNS: n個のD6を振り、出目 1 の個数だけガッツ減少を算出する
+        n: ダイス数（省略時1）
+        ガッツ減少が 0 なら成功、1 以上なら失敗
+      INFO_MESSAGE_TEXT
+
+      register_prefix('\d*NN\d*(#\d+)?', '\d*NA\d*(#\d+)?', '\d*NS')
+
+      def eval_game_system_specific_command(command)
+        return eval_action_command(command) || eval_attack_command(command) || eval_guts_command(command)
+      end
+
+      private
+
+      def eval_action_command(command)
+        m = /\A(\d+)?NN(\d+)?(?:#(\d+))?\z/i.match(command)
+        return nil unless m
+
+        dice_count = m[1]&.to_i || 1
+        difficulty = m[2]&.to_i || 4
+        required_level = [m[3]&.to_i || 1, 1].max
+
+        return nil if dice_count.zero?
+
+        command_text = "(#{dice_count}NN#{difficulty}##{required_level})"
+
+        dice_list = @randomizer.roll_barabara(dice_count, 6)
+        success_level = dice_list.count { |value| value >= difficulty }
+        detail_text = "[#{dice_list.join(',')}]"
+
+        return build_result(command_text, detail_text, success_level, required_level)
+      end
+
+      def eval_attack_command(command)
+        m = /\A(\d+)?NA(\d+)?(?:#(\d+))?\z/i.match(command)
+        return nil unless m
+
+        dice_count = m[1]&.to_i || 1
+        difficulty = m[2]&.to_i || 4
+        critical_value = [m[3]&.to_i || 6, 1].max
+
+        return nil if dice_count.zero?
+
+        command_text = "(#{dice_count}NA#{difficulty}##{critical_value})"
+
+        dice_list = @randomizer.roll_barabara(dice_count, 6)
+        success_level = dice_list.count { |value| value >= difficulty }
+        direct_damage = dice_list.count { |value| value >= difficulty && value >= critical_value }
+        guts_loss = dice_list.count(1)
+        detail_text = "[#{dice_list.join(',')}]"
+
+        return build_attack_result(command_text, detail_text, success_level, direct_damage, guts_loss)
+      end
+
+      def eval_guts_command(command)
+        m = /\A(\d+)?NS\z/i.match(command)
+        return nil unless m
+
+        dice_count = m[1]&.to_i || 1
+        return nil if dice_count.zero?
+
+        command_text = "(#{dice_count}NS)"
+        dice_list = @randomizer.roll_barabara(dice_count, 6)
+        guts_loss = dice_list.count(1)
+        detail_text = "[#{dice_list.join(',')}]"
+
+        return build_guts_result(command_text, detail_text, guts_loss)
+      end
+
+      def build_result(command_text, detail_text, success_level, required_level)
+        success = success_level >= required_level
+        judge_text = success ? translate('success') : translate('failure')
+        result_level_text = translate('NegikureNegimaki.result_level', success_level: success_level, required_level: required_level)
+        text = "#{command_text} ＞ #{detail_text} ＞ #{result_level_text} ＞ #{judge_text}"
+
+        if success
+          return Result.success(text)
+        end
+
+        return Result.failure(text)
+      end
+
+      def build_attack_result(command_text, detail_text, success_level, direct_damage, guts_loss)
+        normal_damage = [success_level - direct_damage, 0].max
+        success = success_level.positive?
+        damage_text = translate('NegikureNegimaki.damage', normal_damage: normal_damage, direct_damage: direct_damage)
+        damage_text += "/#{translate('NegikureNegimaki.guts_loss', guts_loss: guts_loss)}" if guts_loss.positive?
+        text = "#{command_text} ＞ #{detail_text} ＞ #{translate('NegikureNegimaki.success_level', success_level: success_level)} ＞ #{damage_text}"
+
+        if success
+          return Result.success(text)
+        end
+
+        return Result.failure(text)
+      end
+
+      def build_guts_result(command_text, detail_text, guts_loss)
+        success = guts_loss.zero?
+        text = "#{command_text} ＞ #{detail_text} ＞ #{translate('NegikureNegimaki.guts_loss', guts_loss: guts_loss)}"
+
+        if success
+          return Result.success(text)
+        end
+
+        return Result.failure(text)
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/NegikureNegimaki_Korean.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/NegikureNegimaki'
+
+module BCDice
+  module GameSystem
+    class NegikureNegimaki_Korean < NegikureNegimaki
+      # ゲームシステムの識別子
+      ID = 'NegikureNegimaki:Korean'
+
+      # ゲームシステム名
+      NAME = '네지쿠레 네지마키'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:네지쿠레 네지마키'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ■ 행위 판정
+        nNNx#y: n개의 D6을 굴려, x 이상의 주사위 결과값의 개수를 성공 레벨로 판정.
+        n: 주사위 수（생략 시 1）
+        x: 난이도（생략 시 4）
+        y: 요구 성공 레벨（생략 시 1, 0은 1로 처리）
+
+        ■ 전투 판정（공격 판정）
+        nNAx#y: n개의 D6을 굴려, x 이상을 성공으로 간주. y 이상의 성공은 직격 피해가 된다.
+        n: 주사위 수（생략 시 1）
+        x: 난이도（생략 시 4）
+        y: 크리티컬 값（생략 시 6, 0은 1로 처리）
+        일반 피해 = 성공 레벨 - 직격 피해
+        직격 피해 = 성공한 눈 중 y 이상의 개수
+        거츠 감소 = 주사위 결과값 1의 개수
+
+        ■ 스트라이크 판정
+        nNS: n개의 D6을 굴려, 주사위 결과값 1의 개수만큼 거츠 감소를 산출한다
+        n: 주사위 수（생략 시 1）
+        거츠 감소가 0이면 성공, 1 이상이면 실패
+      INFO_MESSAGE_TEXT
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+        @locale = :ko_kr
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/NeonUnderRealm.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class NeonUnderRealm < Base
+      ID = "NeonUnderRealm"
+      NAME = "光都暗域〈ネオン・アンダーレルム〉"
+      SORT_KEY = "ねおんあんたあれるむ"
+
+      HELP_MESSAGE = <<~TEXT
+        ・判定（D10の出目が「目標値以下」を成功として数える）
+          [M]NU[N][±K][@L][±K']
+
+          M：判定ダイス数（省略不可）。「10+5+3-2」のような加減算を許可
+          N：目標値（1～10）。省略時は 5
+          K, K'：達成値への補正。両方指定された場合はKを採用し、K'は無視される。（省略可）
+          L：気合の閾値（0～5）。省略時は 0（気合は常に0扱い）
+
+          ※Nが1～10の範囲外、またはLが0～5の範囲外の場合はコマンドとして処理しません（出力しません）
+          ※達成値 = max(0, 素の成功数 + K)
+          ※効果値 = ダイス数 - 素の成功数
+          ※素の成功数が0なら判定は失敗（達成値が補正で1以上でも失敗扱い）
+          ※成功は表示しません。素の成功数0または達成値0のときのみ「失敗」を表示します。
+
+        例）
+          4NU
+          4NU7+2
+          10+5+3-2NU5-1@2
+      TEXT
+
+      DEFAULT_THRESHOLD = 5
+      MIN_THRESHOLD = 1
+      MAX_THRESHOLD = 10
+      DEFAULT_KIAI_THRESHOLD = 0
+      MIN_KIAI_THRESHOLD = 0
+      MAX_KIAI_THRESHOLD = 5
+      DEFAULT_MODIFIER = 0
+
+      register_prefix('\d+([+\-]\d+)*NU')
+
+      # [M]NU[N]±[K]@[L]
+      def eval_game_system_specific_command(command)
+        m_expr, n_str, k_str, l_str = parse_command(command)
+        return nil unless m_expr
+
+        dice_count = eval_dice_count(m_expr)
+        return nil unless dice_count && dice_count >= 1
+
+        threshold = n_str&.to_i || DEFAULT_THRESHOLD
+        return nil unless (MIN_THRESHOLD..MAX_THRESHOLD).cover?(threshold)
+
+        modifier = k_str&.to_i || DEFAULT_MODIFIER
+
+        kiai_threshold = l_str&.to_i || DEFAULT_KIAI_THRESHOLD
+        return nil unless (MIN_KIAI_THRESHOLD..MAX_KIAI_THRESHOLD).cover?(kiai_threshold)
+
+        dice_list = @randomizer.roll_barabara(dice_count, 10).sort
+
+        raw_success = dice_list.count { |x| x <= threshold }
+        achieved = raw_success + modifier
+        achieved = 0 if achieved < 0
+
+        effect = dice_count - raw_success
+        kiai = kiai_threshold > 0 ? dice_list.count { |x| x <= kiai_threshold } : 0
+
+        expr_text = build_expr_text(dice_count, threshold,  modifier, kiai_threshold, dice_list)
+
+        result_text_parts = [
+          "達成値：#{achieved}（成功数：#{raw_success}）",
+          "効果値：#{effect}",
+          "気合：#{kiai}",
+        ]
+
+        # 素成功0なら失敗。または達成値0なら失敗。成功表示は不要。失敗表示はこのケースのみ。
+        result_text_parts << "失敗" if raw_success == 0 || achieved == 0
+
+        text = [
+          "(#{command.upcase})",
+          expr_text,
+          result_text_parts.join(" / "),
+        ].join(" ＞ ")
+
+        result = Result.new(text)
+
+        # 成功条件：達成値>=1 かつ 素成功>=1
+        is_success = (achieved >= 1) && (raw_success >= 1)
+        result.success = is_success
+        result.failure = !is_success
+
+        result
+      end
+
+      private
+
+      # returns [m_expr, n_str, k_str, l_str] or [nil,...]
+      def parse_command(command)
+        # M は「加減算のみ」の式を許可（例：10+5+3-2）
+        # N は省略可、K は ±整数、L は @整数、K' は ±整数
+        m = /\A(?<m_expr>\d+(?:[+-]\d+)*)NU(?<n>\d+)?(?<k>[+-]\d+)?(?:@(?<l>\d+))?(?<j>[+-]\d+)?\z/.match(command)
+        return [nil, nil, nil, nil] unless m
+
+        # 修正値が K を優先
+        k = m[:k] || m[:j]
+
+        [m[:m_expr], m[:n], k, m[:l]]
+      end
+
+      def eval_dice_count(source)
+        BCDice::Arithmetic.eval(source, @round_type)
+      rescue StandardError
+        nil
+      end
+
+      def build_expr_text(dice_count, n, k, l, dice_list)
+        # 「MB10」表記に寄せる：xB10<=n±k@l[...]
+        k_text = Format.modifier(k)
+        l_text = l > 0 ? "@#{l}" : ""
+        "#{dice_count}B10<=#{n}#{k_text}#{l_text}[#{dice_list.join(',')}]"
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/NinjaSlayer2.rb

@@ -13,20 +13,62 @@ module BCDice
       SORT_KEY = "にんしやすれいやあTRPG2"
 
       HELP_MESSAGE = <<~TEXT
-        - K{x1},{x2},...,{xn}
-        難易度K([K]ids)の成功判定({x1}B6>=2)を、ダイス{x1}個({x2}～を指定した場合はそれぞれ個々に)で実行します。
-        先頭の文字を変えることで、難易度E([E]asy),N([N]ormal),H([H]ard),U([U]ltra-hard)もしくはUH([U]ltra-[H]ard)でも実行可能です。(以下も同様)
-
-        - K{x1},{x2},...,{xn}[>={y}]
-        K{x1}のロールの結果を使って、[]内で指定された条件を満たすダイスの個数を追加で出力します。
-        判定式は「>=」の他に「>」「<=」「<」「=」「!=」が利用可能です。
-        [=5][=6]のように複数記述することで、それぞれで追加判定が可能です。
-
-        - K{x1},{x2},...,{xn}[S] or K{x1},{x2},...,{xn}[S{y}]
-        - K{x1},{x2},...,{xn}[C] or K{x1},{x2},...,{xn}[C{y}]
-        いずれもK{x1},{x2},...,{xn}[>={y}]のショートカットです。({y}省略時は固定値6で処理します。)
-        出力時のテキストが、Sの場合は「サツバツ！」に、Cの場合は「クリティカル！」になります。
-        こちらも複数記述することで、それぞれで追加判定が可能です。
+        --- 成功判定コマンド ---
+        通常のダイスの「{ダイス個数}B6>={難易度ごとの目標出目}」を実行するための簡易入力コマンドです。
+
+        - K{x}
+        難易度K([K]ids/目標値=2)の成功判定をダイス{x}個で実行します。
+        先頭の文字を変えることで、難易度E([E]asy/目標値=3),N([N]ormal/目標値=4),H([H]ard/目標値=5),U([U]ltra-hard/目標値=6)もしくはUH([U]ltra-[H]ard/目標値=6)でも実行可能です。
+
+        - K{x1},N{x2},...,U{xn}
+        K{x}の複数ロール版。
+        カンマ(,)で区切って複数回入力すると、区切られたセットごとに成功判定を行います。
+        2回目以降は難易度指定を省略可能で、省略した場合はひとつ前の難易度を引き継いで判定を行います。
+        以下のコマンドについても同様の書式で複数ロールしての同時判定が可能です。
+
+        --- 追加判定コマンド ---
+        以下のコマンド群は、成功判定コマンドの後ろに付けて実行してください。
+
+        - [>={y}]
+        - [>{y}]
+        - [<={y}]
+        - [<{y}]
+        - [={y}]
+        - [!={y}]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[]内で指定された条件で追加判定を行います。
+        それぞれ、{y}以上(>=)、{y}より大きい(>)、{y}以下(<=)、{y}未満(<)、{y}のみ(=)、{y}以外(!=)を判定し、
+        ロール結果の中で条件を満たしたダイスの個数を「追加判定」というテキストと共に出力します。
+        [=5][=6]のように複数記述することで、ひとつのロールに対して複数パターンでの追加判定が可能です。
+        ※ 条件は一括でしか指定できないため、ロールごとに異なる条件を指定したい場合はコマンドを分けてください。以下も同様です。。
+
+        - [>={y1}{y2}...{yn}+]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[>={y1}]～[>={yn}]の各条件で追加判定を行います。
+        出目の中に条件を満たしたダイスが**全て**含まれていた場合、「追加判定成功！」というテキストを出力します。
+        例えば[>=665+]とした場合、出目の中に6以上のダイスが2つと5以上のダイスが1つ含まれていれば成功扱いになります。
+
+        - [S{y}]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[>={y}]と同等の追加判定を行います。
+        条件を満たしたダイスの個数を「サツバツ判定」というテキストと共に出力します。
+        ※ {y}は省略可能、省略した場合は固定値6で処理します。
+
+        - [S{y1}{y2}...{yn}+]
+        - [S{y1}{y2}...{yn}/{z1}{z2}...{zn}+]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[>={y1}{y2}...{yn}+]と[>={z1}{z2}...{zn}+]と同等の追加判定を行います。
+        {z1}～{zn}で条件を満たした場合、「ナムアミダブツ！」というテキストを出力します。
+        {z1}～{zn}の条件を満たせず、{y1}～{yn}で条件を満たした場合、「サツバツ！」というテキストを出力します。
+        ※ {z1}～{zn}を省略した場合は、「サツバツ！」の判定のみを行ないます。
+
+        - [C{y}]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[>={y}]と同等の追加判定を行います。
+        条件を満たしたダイスの個数を「クリティカル判定」というテキストと共に出力します。
+        ※ {y}は省略可能、省略した場合は固定値6で処理します。
+
+        - [C{y1}{y2}...{yx}+]
+        成功判定コマンドでカンマ区切りで指定した各ロール結果に対して、[>={y1}{y2}...{yn}+]と同等の追加判定を行います。
+        条件を条件を満たした場合、「クリティカル！」というテキストを出力します。
+
+        --- 定型文コマンド ---
+        以下のコマンド群はそれぞれ単体で使用してください。
 
         - SB or SB@{x}
         {x}(1-6/省略時はd6)に対応したサツバツ([S]atz-[B]atz)・クリティカル表の内容を返します。
@@ -79,27 +121,118 @@ module BCDice
       # @param default [Integer]
       # @return [Integer]
       def s_to_i(string, default)
-        return string.nil? ? default : string.to_i
+        return string.nil? || string.empty? ? default : string.to_i
       end
 
-      # 判定結果の出力テキストと成功数のカウントを返す。
+      # 難易度判定の成功数を返す。
       # @param dice_array [Array<Integer>]
       # @param difficulty [Integer]
       # @param cmp_op [String]
-      # @param title_text [String]
-      # @return [String, Integer]
-      def check_difficulty(dice_array, difficulty, cmp_op, title_text)
-        success_num = 0
+      # @return Integer
+      def check_difficulty(dice_array, difficulty, cmp_op)
         success_dice = []
         dice_array.each do |dice_value|
           if dice_value.send(Normalize.comparison_operator(cmp_op), difficulty)
-            success_num += 1
             success_dice.push(dice_value)
           end
         end
 
-        success_dice_s = success_dice.empty? ? "" : "[#{success_dice.sort.reverse.join(',')}]"
-        return "#{title_text}:#{success_num}#{success_dice_s}", success_num
+        return success_dice
+      end
+
+      # 難易度判定結果を返す。
+      # @param dice_array [Array<Integer>]
+      # @param difficulty [Integer]
+      # @param cmp_op [String]
+      # @return [boolean]
+      def check_difficulty_new(dice_array, difficulty, cmp_op)
+        if difficulty.nil? || dice_array.empty?
+          return false
+        end
+
+        # 難易度とダイスを昇順ソート
+        sorted_dice_array = dice_array.sort()
+        sorted_difficulty = difficulty.chars.sort()
+        debug("sorted_difficulty #{sorted_difficulty}")
+        debug("sorted_dice_array #{sorted_dice_array}")
+
+        # 出目が低い順に難易度を越えているかチェック
+        check_index = 0
+        sorted_dice_array.each do |dice_value|
+          if dice_value.send(Normalize.comparison_operator(cmp_op), sorted_difficulty[check_index].to_i)
+            check_index += 1
+          end
+        end
+
+        # 全難易度を突破していたら成功を返す
+        return check_index >= sorted_difficulty.size
+      end
+
+      # 追加判定の処理
+      # @param roll_result 判定対象とするロール結果の配列
+      # @param ap_commanc 追加判定のコマンド
+      # @return String
+      def proc_appendix(roll_result, ap_command)
+        debug("----- ap_command: #{ap_command}")
+        output_text = ''
+        case ap_command
+        when RE_COUNT_SATZ_BATZ
+          diff_condition = Regexp.last_match[1]
+          if ap_command.end_with?("+")
+            # サツバツ発生チェック
+            sb_condition = diff_condition.sub("\+", "").split("/")[0]
+            nm_condition = diff_condition.sub("\+", "").split("/")[1]
+            debug("sb_condition: #{sb_condition}")
+            debug("nm_condition: #{nm_condition}")
+
+            if check_difficulty_new(roll_result.last_dice_list, nm_condition, ">=")
+              output_text += ", ナムアミダブツ！[#{ap_command}]"
+            elsif check_difficulty_new(roll_result.last_dice_list, sb_condition, ">=")
+              output_text += ", サツバツ！[#{ap_command}]"
+            end
+
+          else
+            # サツバツ数カウント
+            diff_result_array = check_difficulty(roll_result.last_dice_list, s_to_i(diff_condition, 6), ">=")
+            output_text += ", サツバツ判定[#{ap_command}]:#{diff_result_array.size}"
+            unless diff_result_array.empty?
+              output_text += "[#{diff_result_array.sort.reverse.join(',')}]"
+            end
+          end
+        when RE_COUNT_CRITICAL
+          diff_condition = Regexp.last_match[1]
+          if ap_command.end_with?("+")
+            # クリティカル発生チェック
+            if check_difficulty_new(roll_result.last_dice_list, diff_condition.sub("\+", ""), ">=")
+              output_text += ", クリティカル！[#{ap_command}]"
+            end
+          else
+            # クリティカル数カウント
+            diff_result_array = check_difficulty(roll_result.last_dice_list, s_to_i(diff_condition, 6), ">=")
+            output_text += ", クリティカル判定[#{ap_command}]:#{diff_result_array.size}"
+            unless diff_result_array.empty?
+              output_text += "[#{diff_result_array.sort.reverse.join(',')}]"
+            end
+          end
+        when RE_COUNT_JUDGE
+          diff_type = Regexp.last_match[1]
+          diff_condition = Regexp.last_match[2]
+          debug("#{diff_type} / #{diff_condition}")
+          if ap_command.end_with?("+")
+            # 追加判定チェック
+            if check_difficulty_new(roll_result.last_dice_list, diff_condition.sub("\+", ""), diff_type)
+              output_text += ", 追加判定成功！[#{ap_command}]"
+            end
+          else
+            # 追加判定カウント
+            diff_result_array = check_difficulty(roll_result.last_dice_list, s_to_i(diff_condition, 6), diff_type)
+            output_text += ", 追加判定[#{ap_command}]:#{diff_result_array.size}"
+            unless diff_result_array.empty?
+              output_text += "[#{diff_result_array.sort.reverse.join(',')}]"
+            end
+          end
+        end
+        return output_text
       end
 
       # ダイス処理(2版用)
@@ -109,11 +242,16 @@ module BCDice
         output_text = ''
         total_success_num = 0
 
-        difficulty = DIFFICULTY_SYMBOL_TO_INTEGER.fetch(match[1])
-        appendix = match[3]
+        command = match[1]
+        appendix = match[2]
+        difficulty = 0
 
-        match[2].split(",").each do |sub_command|
-          dice_num = sub_command.to_i
+        command.split(",").each do |sub_command|
+          /^(UH|[KENHU])?(\d+)$/i.match(sub_command)
+          unless Regexp.last_match[1].nil?
+            difficulty = DIFFICULTY_SYMBOL_TO_INTEGER.fetch(Regexp.last_match[1])
+          end
+          dice_num = Regexp.last_match[2].to_i
 
           # D6バラバラロール
           roll_command = "#{dice_num}B6>=#{difficulty}"
@@ -127,24 +265,7 @@ module BCDice
             debug("---- appendix: [#{appendix}]")
             ap_command_array = appendix.split("\]\[")
             ap_command_array.each do |ap_command|
-              debug("----- ap_command: #{ap_command}")
-              case ap_command
-              when RE_COUNT_SATZ_BATZ
-                # サツバツ！カウント
-                check_result = check_difficulty(roll_result.last_dice_list, s_to_i(Regexp.last_match[1], 6), ">=", "サツバツ！")
-                output_text += ", #{check_result[0]}"
-                success_num += check_result[1]
-              when RE_COUNT_CRITICAL
-                # クリティカル！カウント
-                check_result = check_difficulty(roll_result.last_dice_list, s_to_i(Regexp.last_match[1], 6), ">=", "クリティカル！")
-                output_text += ", #{check_result[0]}"
-                success_num += check_result[1]
-              when RE_COUNT_JUDGE
-                # 追加判定カウント
-                check_result = check_difficulty(roll_result.last_dice_list, Regexp.last_match[2].to_i, Regexp.last_match[1], "追加判定")
-                output_text += ", #{check_result[0]}"
-                success_num += check_result[1]
-              end
+              output_text += proc_appendix(roll_result, ap_command)
             end
           end
           output_text += " \n"
@@ -266,11 +387,11 @@ module BCDice
         end
       end
 
-      RE_COUNT_SATZ_BATZ = /S([1-6])?/i.freeze
-      RE_COUNT_CRITICAL = /C([1-6])?/i.freeze
-      RE_COUNT_JUDGE = /(=|!=|>=|>|<=|<)([1-6])/.freeze
+      RE_COUNT_SATZ_BATZ = %r{S([1-6]|[1-6]+(?:/[1-6]+)?\+)?$}i.freeze
+      RE_COUNT_CRITICAL = /C([1-6]|[1-6]+\+)?$/i.freeze
+      RE_COUNT_JUDGE = /(=|!=|>=|>|<=|<)([1-6]+\+|[1-6])/.freeze
 
-      RE_JUDGE_DICEROLL = /^(UH|[KENHU])([\d,]+)(?:\[((?:(?:S([1-6])?|C([1-6])?|(=|!=|>=|>|<=|<)([1-6]))(?:\]\[)?)+)\])?$/i.freeze
+      RE_JUDGE_DICEROLL = %r{^((?:(?:UH|[KENHU])?\d+,?)+)(?:\[((?:(?:S([1-6]|[1-6]+(?:/[1-6]+)?\+)?|C([1-6]*\+?)?|(=|!=|>=|>|<=|<)([1-6]+\+?))(?:\]\[)?)+)\])?$}i.freeze
       RE_JUDGE_SATZ_BATZ = /^SB(?:@([1-6]))?$/i.freeze
       RE_JUDGE_WASSHOI = /^WS([1-9]|10|11|12)$/i.freeze
       RE_JUDGE_WASSHOI_ENTRY = /^WSE(?:@([1-6]))?$/i.freeze