bcdice 3.1.3 → 3.5.0

data/lib/bcdice/game_system/Utakaze.rb

@@ -18,87 +18,92 @@ module BCDice
           n個のサイコロで行為判定ロール。ゾロ目の最大個数を成功レベルとして表示。nを省略すると2UK扱い。
           例）3UK ：サイコロ3個で行為判定
           例）UK  ：サイコロ2個で行為判定
-          不等号用いた成否判定は現時点では実装してません。
+        ・難易度付き行為判定ロール（nUK>=t）
+          tに難易度を指定した行為判定ロール。
+          成功レベルと難易度tを比べて成否を判定します。
+          例）6UK>=3 ：サイコロ6個で行為判定して、成功レベル3が出れば成功。
         ・クリティカルコール付き行為判定ロール（nUK@c or nUKc）
-        　cに「龍のダイス目」を指定した行為判定ロール。
-          ゾロ目ではなく、cと同じ値の出目数x2が成功レベルとなります。
+          cに「龍のダイス目」を指定した行為判定ロール。
+          ゾロ目ではなく、cと同じ値の出目数x2が成功レベルとなります。難易度の指定も可能です。
           例）3UK@5 ：龍のダイス「月」でクリティカルコール宣言したサイコロ3個の行為判定
       MESSAGETEXT
 
-      register_prefix('\d*UK[@\d]*')
-
-      def initialize(command)
-        super(command)
-        @arrayDragonDiceName = ['', '風', '雨', '雲', '影', '月', '歌']
-        @enabled_upcase_input = false
-      end
+      register_prefix('\d*UK')
 
       def eval_game_system_specific_command(command)
         debug('eval_game_system_specific_command command', command)
 
-        result = ''
+        check_roll(command)
+      end
 
-        case command
-        when /(\d+)?UK(@?(\d))?(>=(\d+))?/i
-          base = (Regexp.last_match(1) || 2).to_i
-          crit = Regexp.last_match(3).to_i
-          diff = Regexp.last_match(5).to_i
-          result = checkRoll(base, crit, diff)
-        end
+      private
 
-        return nil if result.empty?
+      DRAGON_DICE_NAME = {
+        1 => "風",
+        2 => "雨",
+        3 => "雲",
+        4 => "影",
+        5 => "月",
+        6 => "歌"
+      }.freeze
 
-        return "#{command} ＞ #{result}"
-      end
+      def check_roll(command)
+        m = /^(\d+)?UK(@?(\d))?(>=(\d+))?$/i.match(command)
+        return nil unless m
 
-      def checkRoll(base, crit, diff = 0)
-        result = ""
+        base = (m[1] || 2).to_i
+        crit = m[3].to_i
+        diff = m[5].to_i
 
         base = getValue(base)
         crit = getValue(crit)
 
-        return result if base < 1
+        return nil if base < 1
 
         crit = 6 if crit > 6
 
-        result += "(#{base}d6)"
+        dice_list = @randomizer.roll_barabara(base, 6).sort
+        result = get_roll_result(dice_list, crit, diff)
 
-        diceList = @randomizer.roll_barabara(base, 6).sort
-
-        result += " ＞ [#{diceList.join(',')}] ＞ "
-        result += getRollResultString(diceList, crit, diff)
+        sequence = [
+          command,
+          "(#{base}D6)",
+          "[#{dice_list.join(',')}]",
+          result.text
+        ]
+        result.text = sequence.join(" ＞ ")
 
         return result
       end
 
-      def getRollResultString(diceList, crit, diff)
-        success, maxnum, setCount = getSuccessInfo(diceList, crit, diff)
+      def get_roll_result(diceList, crit, diff)
+        success, maxnum, setCount = getSuccessInfo(diceList, crit)
 
-        result = ""
+        sequence = []
 
         if isDragonDice(crit)
-          result += "龍のダイス「#{@arrayDragonDiceName[crit]}」(#{crit})を使用 ＞ "
+          sequence.push("龍のダイス「#{DRAGON_DICE_NAME[crit]}」(#{crit})を使用")
         end
 
-        if  success
-          result += "成功レベル:#{maxnum} (#{setCount}セット)"
-          if diff != 0
-            diffSuccess = (maxnum >= diff)
-            if diffSuccess
-              result += " ＞ 成功"
-            else
-              result += " ＞ 失敗"
-            end
-          end
-
+        if success
+          sequence.push("成功レベル:#{maxnum} (#{setCount}セット)")
         else
-          result += "失敗"
+          sequence.push("失敗")
+          return Result.failure(sequence.join(" ＞ "))
         end
 
-        return result
+        if diff == 0
+          return Result.success(sequence.join(" ＞ ")) # 難易度なしでも成功として扱う
+        elsif maxnum >= diff
+          sequence.push("成功")
+          return Result.success(sequence.join(" ＞ "))
+        else
+          sequence.push("失敗")
+          return Result.failure(sequence.join(" ＞ "))
+        end
       end
 
-      def getSuccessInfo(diceList, crit, _diff)
+      def getSuccessInfo(diceList, crit)
         debug("checkSuccess diceList, crit", diceList, crit)
 
         diceCountHash = getDiceCountHash(diceList, crit)
@@ -109,7 +114,7 @@ module BCDice
         countThreshold = (isDragonDice(crit) ? 1 : 2)
 
         diceCountHash.each do |dice, count|
-          maxnum = count if  count > maxnum
+          maxnum = count if count > maxnum
           successDiceList << dice if count >= countThreshold
         end
 

data/lib/bcdice/game_system/Villaciel.rb

@@ -47,7 +47,7 @@ module BCDice
         ・改良種表　　　　　　IS
       MESSAGETEXT
 
-      register_prefix('\\d+VBS(>=\\d+)?', '\\d+VF', '\\d+VM', '\\d+VG', 'PJ[VA]?', 'PQ[VA]?', 'AC', 'MM([IAD]|V[VA]?)', 'F[LRWGBCS]', 'IP[VA]?', 'EP[VA]?\\d?', 'MP', 'IS')
+      register_prefix('\d+VBS(>=\d+)?', '\d+VF', '\d+VM', '\d+VG', 'PJ[VA]?', 'PQ[VA]?', 'AC', 'MM([IAD]|V[VA]?)', 'F[LRWGBCS]', 'IP[VA]?', 'EP[VA]?', 'MP', 'IS')
 
       def initialize(command)
         super(command)

data/lib/bcdice/game_system/WARPS.rb

@@ -15,17 +15,19 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = "失敗、成功度の自動判定を行います。\n"
 
-      def check_2D6(total, dice_total, _dice_list, cmp_op, target)
+      def result_2d6(total, dice_total, _dice_list, cmp_op, target)
+        return nil unless cmp_op == :<=
+
         if dice_total <= 2
-          " ＞ クリティカル"
+          Result.critical("クリティカル")
         elsif dice_total >= 12
-          " ＞ ファンブル"
-        elsif cmp_op == :<= && target != "?"
-          if total <= target
-            " ＞ #{target - total}成功"
-          else
-            " ＞ 失敗"
-          end
+          Result.fumble("ファンブル")
+        elsif target == "?"
+          Result.nothing
+        elsif total <= target
+          Result.success("#{target - total}成功")
+        else
+          Result.failure("失敗")
         end
       end
     end

data/lib/bcdice/game_system/WaresBlade.rb

@@ -15,18 +15,13 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = "nD10>=m 方式の判定で成否、完全成功、完全失敗を自動判定します。\n"
 
-      def check_nD10(total, _dice_total, dice_list, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :>=
+      def result_nd10(_total, _dice_total, dice_list, cmp_op, _target)
+        return nil unless cmp_op == :>=
 
         if dice_list.count(10) == dice_list.size
-          ' ＞ 完全成功'
+          Result.critical("完全成功")
         elsif dice_list.count(1) == dice_list.size
-          ' ＞ 絶対失敗'
-        elsif total >= target
-          ' ＞ 成功'
-        else
-          ' ＞ 失敗'
+          Result.fumble("絶対失敗")
         end
       end
     end

data/lib/bcdice/game_system/Warhammer.rb

@@ -51,14 +51,23 @@ module BCDice
         return output_msg
       end
 
-      def check_1D100(total, _dice_total, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :<=
+      def result_1d100(total, _dice_total, cmp_op, target)
+        return Result.nothing if target == '?'
+        return nil unless cmp_op == :<=
 
         if total <= target
-          " ＞ 成功(成功度#{(target - total) / 10})"
+          Result.success("成功(成功度#{(target - total) / 10})")
         else
-          " ＞ 失敗(失敗度#{(total - target) / 10})"
+          Result.failure("失敗(失敗度#{(total - target) / 10})")
+        end
+      end
+
+      def result_1d100_text(total, dice_total, cmp_op, target)
+        result = result_1d100(total, dice_total, cmp_op, target)&.text
+        if result.nil?
+          ""
+        else
+          " ＞ #{result}"
         end
       end
 
@@ -322,7 +331,7 @@ module BCDice
         total_n = @randomizer.roll_once(100)
 
         output = "(#{string}) ＞ #{total_n}"
-        output += check_1D100(total_n, total_n, :<=, diff)
+        output += result_1d100_text(total_n, total_n, :<=, diff)
 
         pos_num = (total_n % 10) * 10 + (total_n / 10).to_i
         pos_num = 100 if total_n >= 100

data/lib/bcdice/game_system/Warhammer4.rb

@@ -28,7 +28,7 @@ module BCDice
 
         ■ 命中判定 (WHx)
           "WH(命中値)"の形で指定します。
-          命中判定を行って、命中してクリティカルでなければ部位も表示します。
+          命中判定を行って、クリティカルかファンブルでなければ部位も表示します。
           例）wh60　　wh(43-20)
       INFO_MESSAGE_TEXT
 
@@ -44,9 +44,9 @@ module BCDice
         roll_critical_table(command) || roll_attack(command) || roll_tables(command, TABLES)
       end
 
-      def check_1D100(total, _dice_total, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :<=
+      def result_1d100(total, _dice_total, cmp_op, target)
+        return Result.nothing if target == '?'
+        return nil unless cmp_op == :<=
 
         t10 = total / 10
         d10 = target / 10
@@ -62,18 +62,19 @@ module BCDice
 
         result =
           if total <= 5
-            "自動成功"
+            Result.success("自動成功")
           elsif total >= 96
-            "自動失敗"
+            Result.failure("自動失敗")
           elsif total <= target
-            "成功"
+            Result.success("成功")
           else
-            "失敗"
+            Result.failure("失敗")
           end
 
         sl_text = format("(SL%+d)", sl)
+        result.text += "#{sl_text} ＞ #{result_detail(sl, total, target)}"
 
-        " ＞ #{result}#{sl_text} ＞ #{result_detail(sl, total, target)}"
+        return result
       end
 
       private
@@ -249,7 +250,7 @@ module BCDice
 
         target_number = m[1].to_i
         total = @randomizer.roll_once(100)
-        result = check_1D100(total, total, :<=, target_number).delete_prefix(" ＞ ")
+        result = result_1d100(total, total, :<=, target_number)&.text
 
         sequence = [
           "(#{command})",
@@ -266,6 +267,9 @@ module BCDice
         if (total > target_number) || (total > 95) # 自動失敗時のファンブル処理も
           if ones == tens
             "ファンブル"
+          else
+            # 一の位と十の位を入れ替えて参照する
+            "(#{HIT_PARTS_TABLE.fetch(merge_d100(ones, tens)).content})"
           end
         elsif ones == tens
           "クリティカル"
@@ -317,7 +321,7 @@ module BCDice
             [61..70, '君はひどく躓きバランスを回復するのに手間取る。次の「移動」を失う。'],
             [71..80, '君は武器を取り回しを誤る。次の「アクション」を失う。'],
             [81..90, '君は筋を違えるか、足首をひねってしまう。「筋断裂(軽度)」の負傷を得る。「致命的負傷」としてカウントされる。'],
-            [91..100, '君は射程内のランダムな味方を攻撃してしまう。命中判定の出目の1の位をSLとして用いること。攻撃可能な味方が居ない場合は、自己を攻撃ししまい「朦朧状態」1つを得る。'],
+            [91..100, '君は射程内のランダムな味方を攻撃してしまう。命中判定の出目の1の位をSLとして用いること。攻撃可能な味方が居ない場合は、自己を攻撃してしまい「朦朧状態」1つを得る。'],
           ]
         )
       }.freeze

data/lib/bcdice/game_system/WitchQuest.rb

@@ -22,7 +22,7 @@ module BCDice
         　例）SET1　SET48
       MESSAGETEXT
 
-      register_prefix('WQ\d+', 'SET\d+')
+      register_prefix('WQ', 'SET')
 
       def eval_game_system_specific_command(command)
         case command

data/lib/bcdice/game_system/YankeeYogSothoth.rb

@@ -49,18 +49,13 @@ module BCDice
       end
 
       # ゲーム別成功度判定(2D6)
-      def check_2D6(total, dice_total, _dice_list, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :>=
+      def result_2d6(_total, dice_total, _dice_list, cmp_op, _target)
+        return nil unless cmp_op == :>=
 
         if dice_total <= 2
-          " ＞ ファンブル(判定失敗。ファンブル表（FT）を振ること)"
+          Result.fumble("ファンブル(判定失敗。ファンブル表（FT）を振ること)")
         elsif dice_total >= 12
-          " ＞ スペシャル(判定成功。【テンション】が１段階上昇)"
-        elsif total >= target
-          " ＞ 成功"
-        else
-          " ＞ 失敗"
+          Result.critical("スペシャル(判定成功。【テンション】が１段階上昇)")
         end
       end
 

data/lib/bcdice/game_system/YearZeroEngine.rb

@@ -19,15 +19,17 @@ module BCDice
 
         ・判定コマンド(nMYZx+x+x)
           (難易度)MYZ(能力ダイス数)+(技能ダイス数)+(アイテムダイス数)  # (1と6を数え、プッシュ可能数を表示)
+          (難易度)MYZ(能力ダイス数)-(技能ダイス数)+(アイテムダイス数)  # (1と6を数え、プッシュ可能数を表示、技能のマイナス指定)
 
           ※ 難易度と技能、アイテムダイス数は省略可能
       INFO_MESSAGE_TEXT
 
-      DIFFICULTY_INDEX   = 1 # 難易度のインデックス
-      COMMAND_TYPE_INDEX = 2 # コマンドタイプのインデックス
-      ABILITY_INDEX      = 3 # 能力値ダイスのインデックス
-      SKILL_INDEX        = 5 # 技能値ダイスのインデックス
-      MODIFIED_INDEX     = 7 # 修正ダイスのインデックス
+      DIFFICULTY_INDEX   =  1 # 難易度のインデックス
+      COMMAND_TYPE_INDEX =  2 # コマンドタイプのインデックス
+      ABILITY_INDEX      =  3 # 能力値ダイスのインデックス
+      SKILL_SIGNED_INDEX =  5 # 技能値ダイス符号のインデックス
+      SKILL_INDEX        =  6 # 技能値ダイスのインデックス
+      GEAR_INDEX         =  8 # アイテムダイスのインデックス
 
       register_prefix('(\d+)?(YZE|MYZ)')
 
@@ -42,7 +44,7 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        m = /\A(\d+)?(YZE|MYZ)(\d+)(\+(\d+))?(\+(\d+))?/.match(command)
+        m = /\A(\d+)?(YZE|MYZ)(\d+)((\+|-)(\d+))?(\+(\d+))?/.match(command)
         unless m
           return ''
         end
@@ -70,18 +72,27 @@ module BCDice
           dice_pool = m[SKILL_INDEX].to_i
           skill_dice_text, success_dice, botch_dice = make_dice_roll(dice_pool)
 
-          @total_success_dice += success_dice
+          skill_unsigned = m[SKILL_SIGNED_INDEX]
+          if command_type == 'YZE' && skill_unsigned == '-'
+            # YZEはシンプルに動作するコマンドなのでマイナス技能の処理は対応しない。
+            return "YZEコマンドでは技能ダイスをマイナス指定できません。"
+          elsif command_type == 'MYZ' && skill_unsigned == '-'
+            @total_success_dice -= success_dice # マイナス技能の成功は通常の成功と相殺される
+          else
+            @total_success_dice += success_dice
+          end
+
           @total_botch_dice += botch_dice
-          @skill_botch_dice += botch_dice # 技能ダイスの1はpushで振り直し可能
-          @push_dice += (dice_pool - success_dice) # 技能ダイスのみ1を含む
+          @skill_botch_dice += botch_dice # 技能ダイスの1はpushで振り直し可能（例えマイナス技能でも）
+          @push_dice += (dice_pool - success_dice) # 技能ダイスのみ1を含むので、ここでは1を計算に入れない
 
-          dice_count_text += "+(#{dice_pool}D6)"
-          dice_text += "+#{skill_dice_text}"
+          dice_count_text += "#{skill_unsigned}(#{dice_pool}D6)"
+          dice_text += "#{skill_unsigned}#{skill_dice_text}"
         end
 
-        if m[MODIFIED_INDEX]
-          dice_pool = m[MODIFIED_INDEX].to_i
-          modified_dice_text, success_dice, botch_dice = make_dice_roll(dice_pool)
+        if m[GEAR_INDEX]
+          dice_pool = m[GEAR_INDEX].to_i
+          gear_dice_text, success_dice, botch_dice = make_dice_roll(dice_pool)
 
           @total_success_dice += success_dice
           @total_botch_dice += botch_dice
@@ -89,8 +100,9 @@ module BCDice
           @push_dice += (dice_pool - (success_dice + botch_dice))
 
           dice_count_text += "+(#{dice_pool}D6)"
-          dice_text += "+#{modified_dice_text}"
+          dice_text += "+#{gear_dice_text}"
         end
+
         return make_result_text(command_type, dice_count_text, dice_text)
       end
 
@@ -108,18 +120,27 @@ module BCDice
         result_text = "#{dice_count_text} ＞ #{dice_text} 成功数:#{@total_success_dice}"
         if @difficulty > 0
           if @total_success_dice >= @difficulty
-            result_text = "#{result_text} 難易度=#{@difficulty}:判定成功！"
+            return Result.success("#{result_text} 難易度=#{@difficulty}:判定成功！")
           else
-            result_text = "#{result_text} 難易度=#{@difficulty}:判定失敗！"
+            return Result.failure("#{result_text} 難易度=#{@difficulty}:判定失敗！")
           end
         end
         return result_text
       end
 
       def make_result_with_myz(dice_count_text, dice_text)
-        result_text = make_result_with_yze(dice_count_text, dice_text)
+        result_text = "#{dice_count_text} ＞ #{dice_text} 成功数:#{@total_success_dice}"
+        atter_text = "\n出目1：[能力：#{@base_botch_dice},技能：#{@skill_botch_dice},アイテム：#{@gear_botch_dice}) プッシュ可能=#{@push_dice}ダイス"
+
+        if @difficulty > 0
+          if @total_success_dice >= @difficulty
+            return Result.success("#{result_text} 難易度=#{@difficulty}:判定成功！#{atter_text}")
+          else
+            return Result.failure("#{result_text} 難易度=#{@difficulty}:判定失敗！#{atter_text}")
+          end
+        end
 
-        return "#{result_text}\n出目1：[能力：#{@base_botch_dice},技能：#{@skill_botch_dice},アイテム：#{@gear_botch_dice}) プッシュ可能=#{@push_dice}ダイス"
+        return "#{result_text}#{atter_text}"
       end
 
       def make_dice_roll(dice_pool)

data/lib/bcdice/game_system/Yggdrasill.rb

@@ -88,7 +88,7 @@ module BCDice
 
         add_dice_randomizer = CommonCommand::AddDice::Randomizer.new(@randomizer, self)
         total = node.lhs.eval(self, add_dice_randomizer)
-        rand_values = @randomizer.rand_results.map(&:first)
+        rand_values = add_dice_randomizer.rand_results.map(&:value)
 
         n1 = count_fumble(rand_values, lucky_state)
         n_max = count_critical(rand_values, lucky_state)

data/lib/bcdice/game_system/ZettaiReido.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bcdice/base'
+
 module BCDice
   module GameSystem
     class ZettaiReido < Base
@@ -38,20 +40,23 @@ module BCDice
         mod, modText = getModInfo(modText)
         diff, diffText = getDiffInfo(diffValue)
 
-        output = ""
-        output += "(#{baseAvility}-2DR#{modText}#{diffText})"
-        output += " ＞ #{baseAvility}-#{diceTotal}[#{diceText}]#{modText}"
-
+        baseCommandText = "(#{baseAvility}-2DR#{modText}#{diffText})"
+        diceCommandText = "#{baseAvility}-#{diceTotal}[#{diceText}]#{modText}"
         total = baseAvility - diceTotal + mod
-        output += " ＞ #{total}"
 
-        successText = getSuccessText(diceTotal, total, diff)
-        output += successText
+        result = getResult(diceTotal, total, diff)
 
-        darkPointText = getDarkPointResult(total, diff, darkPoint)
-        output += darkPointText
+        darkPointText = "#{darkPoint}DP" if darkPoint > 0
 
-        return output
+        result.text = [
+          baseCommandText,
+          diceCommandText,
+          total.to_i,
+          result.text,
+          darkPointText,
+        ].compact.join(" ＞ ")
+
+        return result
       end
 
       def roll2DarkDice()
@@ -107,23 +112,13 @@ module BCDice
         return diffValue, diffText
       end
 
-      def getDarkPointResult(_total, _diff, darkPoint)
-        text = ''
-
-        if darkPoint > 0
-          text = " ＞ #{darkPoint}DP"
-        end
-
-        return text
-      end
-
-      def getSuccessText(diceTotal, total, diff)
+      def getResult(diceTotal, total, diff)
         if diceTotal == 0
-          return " ＞ クリティカル"
+          return Result.critical("クリティカル")
         end
 
         if diceTotal == 10
-          return " ＞ ファンブル"
+          return Result.fumble("ファンブル")
         end
 
         if diff.nil?
@@ -132,10 +127,10 @@ module BCDice
 
         successLevel = (total - diff)
         if successLevel >= 0
-          return " ＞ #{successLevel} 成功"
+          return Result.success("#{successLevel} 成功")
         end
 
-        return ' ＞ 失敗'
+        return Result.failure("失敗")
       end
     end
   end

data/lib/bcdice/game_system/beginning_idol/accessories_table.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class << self
+        private
+
+        # @params locale [Symbol]
+        # @return [ChainTable]
+        def translate_accessories_table(locale)
+          items = I18n.t("BeginningIdol.ACT.items", locale: locale)
+          subtables = [
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.head", locale),
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.hat", locale),
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.body", locale),
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.arm", locale),
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.foot", locale),
+            DiceTable::D66Table.from_i18n("BeginningIdol.ACT.subtables.other", locale),
+          ]
+
+          ChainTable.new(
+            I18n.t("BeginningIdol.ACT.name", locale: locale),
+            "1D6",
+            items.zip(subtables)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/beginning_idol/bad_status_table.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class BadStatusTable
+        def initialize(locale)
+          @locale = locale
+        end
+
+        def roll_command(randomizer, command)
+          m = /^BT(\d+)?$/.match(command)
+          unless m
+            return nil
+          end
+
+          roll_counts = m[1]&.to_i || 1
+          return roll(randomizer, roll_counts)
+        end
+
+        # @param randomizer [BCDice::Randomizer]
+        # @param counts [Integer]
+        def roll(randomizer, roll_counts = 1)
+          if roll_counts <= 0
+            return nil
+          end
+
+          name = I18n.t("BeginningIdol.BT.name", locale: @locale)
+          items = I18n.t("BeginningIdol.BT.items", locale: @locale)
+          prefix_format = I18n.t("BeginningIdol.BT.prefix_format", locale: @locale)
+
+          dice_list = randomizer.roll_barabara(roll_counts, 6).sort
+          index_list = dice_list.uniq
+
+          result_prefix = format(prefix_format, count_bad_status: index_list.size) + "\n" if index_list.size > 1
+          result_text = index_list.map { |i| items[i - 1] }.join("\n")
+
+          return "#{name} ＞ [#{dice_list.join(',')}] ＞ #{result_prefix}#{result_text}"
+        end
+      end
+    end
+  end
+end