bcdice 3.16.1 → 3.17.0

data/lib/bcdice/game_system/MetallicGuardian_Korean.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/MetallicGuardian'
+
+module BCDice
+  module GameSystem
+    class MetallicGuardian_Korean < MetallicGuardian
+      # ゲームシステムの識別子
+      ID = 'MetallicGuardian:Korean'
+
+      # ゲームシステム名
+      NAME = '메탈릭 가디언 RPG'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:메탈릭 가디언 RPG'
+
+      set_aliases_for_srs_roll('MG')
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+
+        @locale = :ko_kr
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/MorkBorg.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'bcdice/dice_table/table'
+
+module BCDice
+  module GameSystem
+    class MorkBorg < Base
+      # ゲームシステムの識別子
+      ID = 'MorkBorg'
+
+      # ゲームシステム名
+      NAME = 'MÖRK BORG'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'むるくほりい'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■判定　sDRt        s: 能力値(省略時:0) t:目標値
+
+        例)+3DR12: 能力値+3、DR12で1d20を振って、その結果を表示(クリティカル・ファンブルも表示)
+
+        ■イニシアティヴ　sINS s: 能力値(省略時:0. 個別のイニシアティブを使う場合)
+
+        例)INS: 1d6を振って、イニシアティヴの結果を表示(PC先行を成功として表示)
+
+        ■モラル　sMORt s: 能力値(省略時:0) t:相手クリーチャーのモラル値
+
+        例)MOR8: 2d6を振って、モラル判定の結果を表示(モラル崩壊を成功として表示)
+
+
+        ■各種表
+
+        ・遭遇反応表 Reaction (ERT)
+        ・破損 Broken (BRO)
+
+      INFO_MESSAGETEXT
+
+      def initialize(command)
+        super(command)
+
+        @sort_add_dice = true
+        @d66_sort_type = D66SortType::NO_SORT
+      end
+
+      def eval_game_system_specific_command(command)
+        resolute_action(command) || resolute_initiative(command) || resolute_morale(command) || roll_tables(command, self.class::TABLES)
+      end
+
+      private
+
+      def result_dr(total, dice_total, target)
+        if dice_total <= 1
+          Result.fumble(translate('MorkBorg.fumble'))
+        elsif dice_total >= 20
+          Result.critical(translate('MorkBorg.critical'))
+        elsif total >= target
+          Result.success(translate('MorkBorg.success'))
+        else
+          Result.failure(translate('MorkBorg.failure'))
+        end
+      end
+
+      # DR判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_action(command)
+        m = /^([+-]?\d+)?DR(\d+)$/.match(command)
+        return nil unless m
+
+        num_status = m[1].to_i
+        num_target = m[2].to_i
+
+        total = @randomizer.roll_once(20)
+        total_status = total.to_s + with_symbol(num_status)
+        result = result_dr(total + num_status, total, num_target)
+
+        sequence = [
+          "(#{command})",
+          total_status,
+          total + num_status,
+          result.text,
+        ]
+
+        result.text = sequence.join(" ＞ ")
+        return result
+      end
+
+      def with_symbol(number)
+        if number == 0
+          return "+0"
+        elsif number > 0
+          return "+#{number}"
+        else
+          return number.to_s
+        end
+      end
+
+      # イニシアティヴ判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_initiative(command)
+        m = /^([+-]?\d+)?INS$/.match(command)
+        return nil unless m
+
+        num_status = m[1].to_i
+
+        die = @randomizer.roll_once(6)
+        total = die + num_status
+        result =
+          if total >= 4
+            Result.success(translate('MorkBorg.pcs_go_first'))
+          else
+            Result.failure(translate('MorkBorg.enemies_go_first'))
+          end
+
+        result.text = "(#{command}) ＞ #{die}#{with_symbol(num_status)} ＞ #{total} ＞ #{result.text}"
+        return result
+      end
+
+      # モラル判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_morale(command)
+        m = /^([+-]?\d+)?MOR(\d+)$/.match(command)
+        return nil unless m
+
+        num_status = m[1].to_i
+        num_target = m[2].to_i
+
+        dice_list = @randomizer.roll_barabara(2, 6)
+        dice_total = dice_list.sum()
+        total = dice_total + num_status
+
+        die = ""
+        result =
+          if total <= num_target
+            Result.failure(translate('MorkBorg.maintain'))
+          else
+            die = @randomizer.roll_once(6)
+            if die >= 4
+              Result.success(translate('MorkBorg.surrender'))
+            else
+              Result.success(translate('MorkBorg.flee'))
+            end
+          end
+        result.text = "(#{command}) ＞ #{dice_total}#{with_symbol(num_status)} ＞ #{total} ＞ #{die}#{result.text}"
+
+        return result
+      end
+
+      # 各種表
+
+      class << self
+        private
+
+        def translate_tables(locale)
+          {
+            'ERT' => DiceTable::Table.from_i18n('MorkBorg.ERT', locale),
+            'BRO' => DiceTable::Table.from_i18n('MorkBorg.BRO', locale),
+          }
+        end
+      end
+
+      TABLES = translate_tables(:ja_jp).freeze
+
+      register_prefix('([+-]?\d+)?DR[\d]+', '([+-]?\d+)?INS', '([+-]?\d+)?MOR', TABLES.keys)
+    end
+  end
+end

data/lib/bcdice/game_system/MorkBorg_Korean.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/MorkBorg'
+
+module BCDice
+  module GameSystem
+    class MorkBorg_Korean < MorkBorg
+      # ゲームシステムの識別子
+      ID = 'MorkBorg:Korean'
+
+      # ゲームシステム名
+      NAME = '모크 보그(MÖRK BORG)'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:모크 보그(MÖRK BORG)'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■판정　sDRt        s: 능력치(생략 시:0) t:목표값
+
+        예)+3DR12: 능력치+3, DR12로 1d20을 굴려서 결과 표시(크리티컬·펌블도 표시)
+
+        ■이니셔티브　sINS s: 능력치(생략 시:0. 개별 이니셔티브를 사용하는 경우)
+
+        예)INS: 1d6을 굴려서 이니셔티브 결과 표시(PC 선공을 성공으로 표시)
+
+        ■모럴　sMORt s: 능력치(생략 시:0) t:상대 크리처의 모럴 값
+
+        예)MOR8: 2d6을 굴려서 모럴 판정 결과 표시(모럴 붕괴를 성공으로 표시)
+
+
+        ■각종 표
+
+        ・조우 반응표 Reaction (ERT)
+        ・파손(빈사표) Broken (BRO)
+
+      INFO_MESSAGETEXT
+
+      def initialize(command)
+        super(command)
+        @locale = :ko_kr
+      end
+
+      TABLES = translate_tables(:ko_kr).freeze
+
+      register_prefix_from_super_class()
+    end
+  end
+end

data/lib/bcdice/game_system/NanimonaiMura.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class NanimonaiMura < Base
+      # ゲームシステムの識別子
+      ID = "NanimonaiMura"
+
+      # ゲームシステム名
+      NAME = "なにもない村"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "なにもないむら"
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ・行為判定 xNMy
+        　x個のD10を振り、2つの出目から達成値を作成して判定します。
+        　達成値は成功度が最も高くなる組み合わせを自動選択し、同値なら低い値を優先します。
+        　x: ダイス数（1以上）
+        　y: 判定値（0以上）
+        　例）4NM55 6NM199 2NM35
+      INFO_MESSAGE_TEXT
+
+      register_prefix('\d+NM\d+')
+
+      ResultData = Struct.new(:score, :success, :critical, :result_text, :success_level)
+
+      STAGE_NAMES = ['ノーマル', 'エピック', 'レジェンダリ', 'ミシック'].freeze
+      BASE_SUCCESS_LEVELS = [1, 11, 21, 31].freeze
+
+      def eval_game_system_specific_command(command)
+        roll_action(command)
+      end
+
+      private
+
+      def roll_action(command)
+        m = /\A(\d+)NM(\d+)\z/.match(command)
+        return nil unless m
+
+        dice_count = m[1].to_i
+        target = m[2].to_i
+        return nil if dice_count < 1
+
+        dice_list = @randomizer.roll_barabara(dice_count, 10).map { |value| normalize_d10(value) }
+        result = select_best_result(dice_list, target)
+
+        Result.new.tap do |r|
+          r.text = "#{command} (#{dice_count}D10) ＞ [#{dice_list.join(',')}] ＞ #{result.score} ＞ #{result.result_text} ＞ 成功度#{result.success_level}"
+          r.condition = result.success
+          r.critical = result.critical
+        end
+      end
+
+      def normalize_d10(value)
+        value == 10 ? 0 : value
+      end
+
+      def select_best_result(dice_list, target)
+        candidates =
+          if dice_list.size == 1
+            [build_result(dice_list.first * 10, target)]
+          else
+            [].tap do |results|
+              dice_list.each_index do |i|
+                dice_list.each_index do |j|
+                  next if i == j
+
+                  results << build_result(dice_list[i] * 10 + dice_list[j], target)
+                end
+              end
+            end
+          end
+
+        best_result = candidates.first
+
+        candidates.drop(1).each do |candidate|
+          next if candidate.success_level < best_result.success_level
+          next if candidate.success_level == best_result.success_level && candidate.score > best_result.score
+
+          best_result = candidate
+        end
+
+        best_result
+      end
+
+      def build_result(score, target)
+        if score > target
+          return ResultData.new(score, false, false, "失敗", 0)
+        end
+
+        diff = target - score
+        stage_index = [diff.div(100), STAGE_NAMES.size - 1].min
+        critical_bonus = zoro_bonus(score)
+        critical = !critical_bonus.nil?
+        success_level = BASE_SUCCESS_LEVELS[stage_index] + (critical_bonus || 0)
+        result_text = "#{STAGE_NAMES[stage_index]}#{critical ? '大成功' : '成功'}"
+
+        ResultData.new(score, true, critical, result_text, success_level)
+      end
+
+      def zoro_bonus(score)
+        tens = score.div(10)
+        ones = score % 10
+        return nil unless tens == ones
+
+        ones
+      end
+    end
+  end
+end

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