bcdice 3.3.0 → 3.6.0

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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class ChainD66Table
+        # @param [String] name 表の名前
+        # @param [Array<Array<String, #roll>>] items 表の項目の配列
+        def initialize(name, items)
+          @name = name
+          @items = items.freeze
+        end
+
+        # 表を振る
+        # @param randomizer [#roll_sum] ランダマイザ
+        # @return [String] 結果
+        def roll(randomizer)
+          dice = randomizer.roll_barabara(2, 6).sort
+
+          value = dice[0] * 10 + dice[1]
+          chosen = @items[value]
+          body = chosen.map { |item| item.respond_to?(:roll) ? item.roll(randomizer) : item }.join("\n")
+
+          return "#{@name}(#{value}) ＞ #{body}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class ChainTable
+        # @param [String] name 表の名前
+        # @param [String] type 項目を選ぶときのダイスロールの方法 '1D6'など
+        # @param [Array<Array<String, #roll>>] items 表の項目の配列
+        def initialize(name, type, items)
+          @name = name
+          @items = items.freeze
+
+          m = /^(\d+)D(\d+)$/i.match(type)
+          unless m
+            raise ArgumentError, "Unexpected table type: #{type}"
+          end
+
+          @times = m[1].to_i
+          @sides = m[2].to_i
+        end
+
+        # 表を振る
+        # @param randomizer [#roll_sum] ランダマイザ
+        # @return [String] 結果
+        def roll(randomizer)
+          value = randomizer.roll_sum(@times, @sides)
+          index = value - @times
+          chosen = @items[index]
+          body = chosen.map { |item| item.respond_to?(:roll) ? item.roll(randomizer) : item }.join("\n")
+
+          return "#{@name}(#{value}) ＞ #{body}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class CostumeTable
+        def self.from_i18n(key, locale)
+          table = I18n.t(key, locale: locale)
+          new(table[:name], table[:items])
+        end
+
+        # @param name [String]
+        # @param items [Hash{Integer => String}]
+        def initialize(name, items)
+          @name = name
+          @items = items
+        end
+
+        # @param randomizer [Randomizer]
+        # @return [String]
+        def roll(randomizer)
+          value = randomizer.roll_d66(D66SortType::ASC)
+          "#{@name}(#{value}) ＞ #{@items[value]}"
+        end
+
+        # @return [DiceTable::D66Table]
+        def brand_only()
+          DiceTable::D66Table.new(
+            @name,
+            D66SortType::ASC,
+            @items.transform_values { |e| e.split("\n").first }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class D6TwiceTable
+        # @param key [String]
+        # @param locale [Symbol]
+        # @return [D6TwiceTable]
+        def self.from_i18n(key, locale)
+          table = I18n.t(key, locale: locale)
+          new(table[:name], table[:items1], table[:items2])
+        end
+
+        # @param name [String]
+        # @param items1 [Array<String>]
+        # @param items2 [Array<String>]
+        def initialize(name, items1, items2)
+          @name = name
+          @items1 = items1
+          @items2 = items2
+        end
+
+        # @param [Randomizer]
+        # @return [String]
+        def roll(randomizer)
+          value1, value2 = randomizer.roll_barabara(2, 6)
+          chosen1 = @items1[value1 - 1]
+          chosen2 = @items2[value2 - 1]
+
+          "#{@name}[#{value1},#{value2}] ＞ #{chosen1}#{chosen2}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class ItemTable
+        def initialize(locale)
+          @locale = locale
+        end
+
+        def roll_command(randomizer, command)
+          m = /^IT(\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
+
+          table = I18n.t("BeginningIdol.item_table", locale: @locale)
+
+          dice_list = randomizer.roll_barabara(roll_counts, 6).sort
+          grouped = dice_list.group_by(&:itself)
+
+          item_list = grouped.map do |dice, list|
+            item = table[:items][dice - 1]
+            if grouped.size != 1
+              item = format(table[:emph], item: item)
+            end
+
+            if dice_list.size == grouped.size
+              item
+            else
+              format(table[:counting], item: item, count: list.size)
+            end
+          end
+
+          return "#{table[:name]} ＞ [#{dice_list.join(',')}] ＞ #{item_list.join(table[:sep])}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class MySkillNameTable
+        # @param locale [Symbol]
+        # @return [MySkillNameTable]
+        def initialize(locale)
+          @locale = locale
+
+          article = DiceTable::Table.from_i18n("BeginningIdol.MS.subtables.article", locale)
+          describe = DiceTable::D66Table.from_i18n("BeginningIdol.MS.subtables.describe", locale)
+          scene = DiceTable::D66Table.from_i18n("BeginningIdol.MS.subtables.scene", locale)
+          material = DiceTable::D66Table.from_i18n("BeginningIdol.MS.subtables.material", locale)
+          action = DiceTable::D66Table.from_i18n("BeginningIdol.MS.subtables.action", locale)
+          @chains = [
+            [describe, scene, material],
+            [describe, scene, action],
+            [describe, material, action],
+            [scene, material, action],
+            [describe, scene, article],
+            [material, action, article],
+          ].freeze
+        end
+
+        # @param randomizer [BCDice::Randomizer]
+        # @return [String]
+        def roll(randomizer)
+          index = randomizer.roll_once(6)
+          chosens = @chains[index - 1].map { |t| t.roll(randomizer) }
+
+          dice = chosens.map { |chosen| chosen.table_name + chosen.value.to_s }
+
+          name = I18n.t("BeginningIdol.MS.name", locale: @locale)
+          skill_name_format = I18n.t("BeginningIdol.MS.formats", locale: @locale)[index - 1]
+          skill_name = format(skill_name_format, *chosens.map(&:body))
+
+          "#{name} ＞ [#{index},#{dice.join(',')}] ＞ #{skill_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class RandomEventTable
+        # @param locale [Symbol]
+        # @return [MySkillNameTable]
+        def initialize(locale)
+          @locale = locale
+        end
+
+        # @param randomizer [BCDice::Randomizer]
+        # @return [String]
+        def roll(randomizer)
+          first_index = randomizer.roll_once(6)
+          d66_index = randomizer.roll_d66(D66SortType::NO_SORT)
+
+          i18n_key = first_index.even? ? "BeginningIdol.RE.on_event" : "BeginningIdol.RE.off_event"
+          table = I18n.t(i18n_key, locale: @locale)
+          name = I18n.t("BeginningIdol.RE.name", locale: @locale)
+          result_format = I18n.t("BeginningIdol.RE.format", locale: @locale)
+
+          chosen = table[:items][d66_index]
+
+          return "#{name} ＞ (1D6) ＞ #{first_index}\n#{table[:name]} ＞ [#{d66_index}] ＞ #{format(result_format, event: chosen[0], page: chosen[1])}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class SkillTable < DiceTable::SaiFicSkillTable
+        def roll(randomizer)
+          roll_command(randomizer, "RTT")
+        end
+      end
+
+      class SkillGetTable < DiceTable::Table
+        def self.from_i18n(key, skill_table, locale)
+          table = I18n.t(key, locale: locale)
+          new(table[:name], table[:type], table[:items], skill_table, locale)
+        end
+
+        def initialize(name, type, items, skill_table, locale)
+          super(name, type, items)
+          @skill_table = skill_table
+
+          skill_get_table = I18n.t("BeginningIdol.skill_get_table", locale: locale)
+          @reroll_reg = Regexp.new(skill_get_table[:reroll_reg])
+          @reroll = skill_get_table[:reroll]
+          @secondary_name = skill_get_table[:secondary_name]
+        end
+
+        def roll(randomizer)
+          chosen = super(randomizer)
+
+          m = @reroll_reg.match(chosen.body)
+          unless m
+            return chosen
+          end
+
+          reroll_category = m.captures
+          body = chosen.body + "\n"
+          loop do
+            skill = @skill_table.roll_skill(randomizer)
+            body += "#{@secondary_name} ＞ [#{skill.category_dice},#{skill.row_dice}] ＞ #{skill}"
+            unless reroll_category.include?(skill.category_name)
+              break
+            end
+
+            body += " ＞ #{@reroll}\n"
+          end
+
+          DiceTable::RollResult.new(chosen.table_name, chosen.value, body)
+        end
+      end
+
+      class SkillHometown
+        def initialize(skill_table)
+          @skill_name = skill_table
+        end
+
+        def roll(randomizer)
+          @skill_name.roll_command(randomizer, "AT6")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "bcdice/game_system/beginning_idol/chain_table"
+require "bcdice/game_system/beginning_idol/chain_d66_table"
+require "bcdice/game_system/beginning_idol/bad_status_table"
+require "bcdice/game_system/beginning_idol/random_event_table"
+require "bcdice/game_system/beginning_idol/my_skill_name_table"
+require "bcdice/game_system/beginning_idol/d6_twice_table"
+require "bcdice/game_system/beginning_idol/item_table"
+require "bcdice/game_system/beginning_idol/costume_table"
+require "bcdice/game_system/beginning_idol/accessories_table"
+require "bcdice/game_system/beginning_idol/with_abnormality"
+require "bcdice/game_system/beginning_idol/work_table"
+require "bcdice/game_system/beginning_idol/skill_table"
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class << self
+        private
+
+        def translate_skill_table(locale)
+          SkillTable.from_i18n(
+            "BeginningIdol.skill_table",
+            locale,
+            rtt: "AT",
+            rttn: ["AT1", "AT2", "AT3", "AT4", "AT5", "AT6"]
+          )
+        end
+
+        def translate_tables(locale)
+          costume_challenge_girls = CostumeTable.from_i18n("BeginningIdol.tables.DT", locale)
+          costume_road_to_prince = CostumeTable.from_i18n("BeginningIdol.tables.RC", locale)
+          costume_fortune_stars = CostumeTable.from_i18n("BeginningIdol.tables.FC", locale)
+
+          bland = ChainTable.new(
+            I18n.t("BeginningIdol.ACB.name", locale: locale),
+            "1D6",
+            [
+              [I18n.t("BeginningIdol.ACB.items.challenge_girls", locale: locale), costume_challenge_girls.brand_only()],
+              [I18n.t("BeginningIdol.ACB.items.challenge_girls", locale: locale), costume_challenge_girls.brand_only()],
+              [I18n.t("BeginningIdol.ACB.items.road_to_prince", locale: locale), costume_road_to_prince.brand_only()],
+              [I18n.t("BeginningIdol.ACB.items.road_to_prince", locale: locale), costume_road_to_prince.brand_only()],
+              [I18n.t("BeginningIdol.ACB.items.fortune_stars", locale: locale), costume_fortune_stars.brand_only()],
+              [I18n.t("BeginningIdol.ACB.items.fortune_stars", locale: locale), costume_fortune_stars.brand_only()],
+            ]
+          )
+
+          bad_status_table = BadStatusTable.new(locale)
+
+          skill_table = translate_skill_table(locale)
+
+          rare_skill_table = DiceTable::Table.from_i18n("BeginningIdol.rare_skill_table", locale)
+
+          item_table = ItemTable.new(locale)
+
+          tn = ChainTable.new(
+            I18n.t("BeginningIdol.TN.name", locale: locale),
+            "1D6",
+            I18n.t("BeginningIdol.TN.items", locale: locale).dup.tap { |items| items[3].push(skill_table) }
+          )
+
+          cg = ChainTable.new(
+            I18n.t("BeginningIdol.CG.name", locale: locale),
+            "1D6",
+            I18n.t("BeginningIdol.CG.items", locale: locale).map.with_index do |item, index|
+              if [3, 4].include?(index)
+                [item, item_table]
+              else
+                [item]
+              end
+            end
+          )
+
+          gg = ChainD66Table.new(
+            I18n.t("BeginningIdol.GG.name", locale: locale),
+            I18n.t("BeginningIdol.GG.items", locale: locale).to_h do |index, value|
+              chain =
+                if [23, 24, 25].include?(index)
+                  [value, rare_skill_table]
+                elsif index == 56
+                  [value, item_table]
+                else
+                  [value]
+                end
+
+              [index, chain]
+            end
+          )
+
+          ha = ChainD66Table.new(
+            I18n.t("BeginningIdol.HA.name", locale: locale),
+            I18n.t("BeginningIdol.HA.items", locale: locale).dup.tap { |items| items[22].push(SkillHometown.new(skill_table)) }
+          )
+
+          {
+            "DT" => costume_challenge_girls,
+            "RC" => costume_road_to_prince,
+            "FC" => costume_fortune_stars,
+            "ACB" => bland,
+            "TN" => tn,
+            "CG" => cg,
+            "GG" => gg,
+            "HA" => ha,
+            "CBT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.CBT", locale),
+            "RCB" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.RCB", locale),
+            "HBT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.HBT", locale),
+            "RHB" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.RHB", locale),
+            "RU" => DiceTable::Table.from_i18n("BeginningIdol.tables.RU", locale),
+            "SIP" => DiceTable::Table.from_i18n("BeginningIdol.tables.SIP", locale),
+            "BU" => DiceTable::Table.from_i18n("BeginningIdol.tables.BU", locale),
+            "HW" => DiceTable::Table.from_i18n("BeginningIdol.tables.HW", locale),
+            "FL" => DiceTable::Table.from_i18n("BeginningIdol.tables.FL", locale),
+            "MSE" => DiceTable::Table.from_i18n("BeginningIdol.tables.MSE", locale),
+            "ST" => DiceTable::Table.from_i18n("BeginningIdol.tables.ST", locale),
+            "FST" => DiceTable::Table.from_i18n("BeginningIdol.tables.FST", locale),
+            "BWT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.BWT", locale),
+            "LWT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.LWT", locale),
+            "TWT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.TWT", locale),
+            "CWT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.CWT", locale),
+            "SU" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.SU", locale),
+            "WI" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.WI", locale),
+            "NA" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.NA", locale),
+            "GA" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.GA", locale),
+            "BA" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.BA", locale),
+            "WT" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.WT", locale),
+            "VA" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.VA", locale),
+            "MU" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.MU", locale),
+            "DR" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.DR", locale),
+            "VI" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.VI", locale),
+            "SP" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.SP", locale),
+            "CHR" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.CHR", locale),
+            "PAR" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.PAR", locale),
+            "SW" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.SW", locale),
+            "AN" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.AN", locale),
+            "MOV" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.MOV", locale),
+            "FA" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.FA", locale),
+            "BVT" => DiceTable::Table.from_i18n("BeginningIdol.tables.BVT", locale),
+            "LVT" => DiceTable::Table.from_i18n("BeginningIdol.tables.LVT", locale),
+            "TVT" => DiceTable::Table.from_i18n("BeginningIdol.tables.TVT", locale),
+            "CVT" => DiceTable::Table.from_i18n("BeginningIdol.tables.CVT", locale),
+            "BST" => DiceTable::Table.from_i18n("BeginningIdol.tables.BST", locale),
+            "LST" => DiceTable::Table.from_i18n("BeginningIdol.tables.LST", locale),
+            "TST" => DiceTable::Table.from_i18n("BeginningIdol.tables.TST", locale),
+            "CST" => DiceTable::Table.from_i18n("BeginningIdol.tables.CST", locale),
+            "BPT" => DiceTable::Table.from_i18n("BeginningIdol.tables.BPT", locale),
+            "LPT" => DiceTable::Table.from_i18n("BeginningIdol.tables.LPT", locale),
+            "TPT" => DiceTable::Table.from_i18n("BeginningIdol.tables.TPT", locale),
+            "CPT" => DiceTable::Table.from_i18n("BeginningIdol.tables.CPT", locale),
+            "BIT" => DiceTable::Table.from_i18n("BeginningIdol.tables.BIT", locale),
+            "LIT" => DiceTable::Table.from_i18n("BeginningIdol.tables.LIT", locale),
+            "TIT" => DiceTable::Table.from_i18n("BeginningIdol.tables.TIT", locale),
+            "CIT" => DiceTable::Table.from_i18n("BeginningIdol.tables.CIT", locale),
+            "CHO" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.CHO", locale),
+            "SCH" => DiceTable::Table.from_i18n("BeginningIdol.tables.SCH", locale),
+            "WCH" => DiceTable::Table.from_i18n("BeginningIdol.tables.WCH", locale),
+            "NCH" => DiceTable::Table.from_i18n("BeginningIdol.tables.NCH", locale),
+            "GCH" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.GCH", locale),
+            "PCH" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.PCH", locale),
+            "LUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.LUR", locale),
+            "SUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.SUR", locale),
+            "WUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.WUR", locale),
+            "NUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.NUR", locale),
+            "GUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.GUR", locale),
+            "BUR" => D6TwiceTable.from_i18n("BeginningIdol.tables.BUR", locale),
+            "ACE" => DiceTable::D66Table.from_i18n("BeginningIdol.tables.ACE", locale),
+            "ACT" => translate_accessories_table(locale),
+            "MS" => MySkillNameTable.new(locale),
+            "RE" => RandomEventTable.new(locale),
+            "SH" => D66WithAbnormality.from_i18n("BeginningIdol.tables.SH", bad_status_table, locale),
+            "MO" => D66WithAbnormality.from_i18n("BeginningIdol.tables.MO", bad_status_table, locale),
+            "SEA" => D66WithAbnormality.from_i18n("BeginningIdol.tables.SEA", bad_status_table, locale),
+            "SPA" => D66WithAbnormality.from_i18n("BeginningIdol.tables.SPA", bad_status_table, locale),
+            "LN" => TableWithAbnormality.from_i18n("BeginningIdol.tables.LN", bad_status_table, locale),
+            "SGT" => SkillGetTable.from_i18n("BeginningIdol.tables.SGT", skill_table, locale),
+            "RS" => SkillGetTable.from_i18n("BeginningIdol.tables.RS", skill_table, locale),
+          }
+        end
+      end
+
+      TABLES = translate_tables(:ja_jp)
+
+      BAD_STATUS_TABLE = BadStatusTable.new(:ja_jp)
+
+      LOCAL_WORK_TABLE = translate_local_work_table(:ja_jp)
+      ITEM_TABLE = ItemTable.new(:ja_jp)
+
+      SKILL_TABLE = translate_skill_table(:ja_jp)
+
+      register_prefix(TABLES.keys)
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      module WithAbnormality
+        def replace_abnormality(chosen, randomizer)
+          reg = Regexp.new(I18n.t("BeginningIdol.abnormality.regexp", locale: @locale))
+          m = reg.match(chosen.body)
+          unless m
+            return chosen
+          end
+
+          abno_count = kanji_to_i(m[1])
+          unless abno_count
+            return chosen
+          end
+
+          text = @bad_status_table.roll(randomizer, abno_count)
+          new_body = chosen.body.sub(reg, text)
+
+          return DiceTable::RollResult.new(chosen.table_name, chosen.value, new_body)
+        end
+
+        def kanji_to_i(kanji)
+          list = I18n.t("BeginningIdol.abnormality.num_map", locale: @locale)
+          list.find_index(kanji)&.succ
+        end
+      end
+
+      class D66WithAbnormality < DiceTable::D66Table
+        include WithAbnormality
+
+        def self.from_i18n(key, bad_status_table, locale)
+          table = I18n.t(key, locale: locale)
+          sort_type = D66SortType.const_get(table[:d66_sort_type])
+
+          new(table[:name], sort_type, table[:items], bad_status_table, locale)
+        end
+
+        def initialize(name, sort_type, items, bad_status_table, locale)
+          super(name, sort_type, items)
+          @bad_status_table = bad_status_table
+          @locale = locale
+        end
+
+        def roll(randomizer)
+          chosen = super(randomizer)
+          replace_abnormality(chosen, randomizer)
+        end
+      end
+
+      class TableWithAbnormality < DiceTable::Table
+        include WithAbnormality
+
+        def self.from_i18n(key, bad_status_table, locale)
+          table = I18n.t(key, locale: locale)
+          new(table[:name], table[:type], table[:items], bad_status_table, locale)
+        end
+
+        def initialize(name, type, items, bad_status_table, locale)
+          super(name, type, items)
+          @bad_status_table = bad_status_table
+          @locale = locale
+        end
+
+        def roll(randomizer)
+          chosen = super(randomizer)
+          replace_abnormality(chosen, randomizer)
+        end
+      end
+    end
+  end
+end