bcdice 3.1.3 → 3.5.0

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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class BeginningIdol < Base
+      class WorkWithChanceTable < DiceTable::D66Table
+        def self.from_i18n(key, locale)
+          table = I18n.t(key, locale: locale)
+          sort_type = D66SortType.const_get(table[:d66_sort_type])
+
+          new(table[:name], sort_type, table[:items], locale)
+        end
+
+        def initialize(name, sort_type, items, locale)
+          super(name, sort_type, items)
+          @regexp = Regexp.new(I18n.t("BeginningIdol.with_chance.regexp", locale: locale))
+          @off = I18n.t("BeginningIdol.with_chance.off_text", locale: locale)
+        end
+
+        def roll_command(randomizer, command)
+          m = /^LO([1-6]{1,2})?$/.match(command)
+          unless m
+            return nil
+          end
+
+          roll(randomizer, m[1]&.to_i)
+        end
+
+        def roll(randomizer, chance = nil)
+          chosen = super(randomizer)
+          unless chance
+            return chosen
+          end
+
+          m = @regexp.match(chosen.body)
+          if m && m[1].to_i >= chance
+            DiceTable::RollResult.new(chosen.table_name, chosen.value, @off)
+          elsif m
+            DiceTable::RollResult.new(chosen.table_name, chosen.value, chosen.body.sub(@regexp, ""))
+          else
+            chosen
+          end
+        end
+      end
+
+      class << self
+        private
+
+        def translate_local_work_table(locale)
+          WorkWithChanceTable.from_i18n("BeginningIdol.local_work", locale)
+        end
+      end
+
+      register_prefix("LO")
+    end
+  end
+end

data/lib/bcdice/game_system/meikyu_kingdom_basic/kingdom_table.rb

@@ -112,7 +112,7 @@ module BCDice
           [3, "あなたの国は、英雄が用いた武具の伝説が残っている。レア武具アイテムの中からランダムに1種を選ぶ。そのレアアイテムのレシピを持っている。【王宮】のある部屋に、そのレア武具アイテムの名前を記入すること。"],
           [4, "あなたの国は、有名な職人たちが揃う工業国家である。コモンアイテムを作成するとき、それらのアイテムを作成するための必要国力が1点高いものとして扱う。"],
           [5, "あなたの国は、質実剛健な兵士たちが揃っている。その国のキャラクターは、《配下》最大値が1人上昇する（最大2人まで上昇する。3回目以降は振り直すこと）。"],
-          [6, "あなたの国は、過去に列強に臣従し、いまでも友好的な関係を築いている。（1D6）を振ること。1ならダイナマイト帝国、2なら千年王朝、3ならメトロ汗国、4ならハグルマ資本主義人民共和国との関係が「友好」になる。5や6なら振り直すこと。また、その列強の列強系施設1軒を獲得する。"],
+          [6, "あなたの国は、過去に列強に臣従し、いまでも友好的な関係を築いている。（1D6）を振ること。1ならダイナマイト帝国、2なら千年王朝、3ならメトロ汗国、4ならハグルマ資本主義神聖共和国との関係が「友好」になる。5や6なら振り直すこと。また、その列強の列強系施設1軒を獲得する。"],
         ]
         return get_table_by_number(num, table)
       end