bcdice 3.4.0 → 3.5.0

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/one_way_heroics/random_event_table.rb

@@ -44,7 +44,7 @@ module BCDice
 
         def roll_with_day(day, randomizer)
           value = randomizer.roll_once(6)
-          chosen = choise(value, day)
+          chosen = choice(value, day)
 
           chosen =
             if chosen.respond_to?(:roll_with_day)
@@ -63,7 +63,7 @@ module BCDice
           return result
         end
 
-        def choise(value, day)
+        def choice(value, day)
           raise NotImplementedError
         end
 
@@ -73,7 +73,7 @@ module BCDice
       end
 
       class BranchByElapsedDays < BranchByDay
-        def choise(value, day)
+        def choice(value, day)
           value > day ? @greater : @less_than_equal
         end
 
@@ -87,7 +87,7 @@ module BCDice
       end
 
       class BranchByDayParity < BranchByDay
-        def choise(value, _)
+        def choice(value, _)
           value.odd? ? @greater : @less_than_equal
         end
 

data/lib/bcdice/game_system/sword_world/rating_parsed.rb

@@ -25,6 +25,12 @@ module BCDice
         # @return [Boolean]
         attr_accessor :greatest_fortune
 
+        # @return [Integer, nil]
+        attr_writer :semi_fixed_val
+
+        # @return [Integer, nil]
+        attr_writer :tmp_fixed_val
+
         # @return [Integer]
         attr_accessor :modifier
 
@@ -33,11 +39,14 @@ module BCDice
 
         def initialize
           @critical = nil
+          @min_critical = nil
           @kept_modify = nil
           @first_to = nil
           @first_modify = nil
           @greatest_fortune = false
           @rateup = nil
+          @semi_fixed_val = nil
+          @tmp_fixed_val = nil
         end
 
         # @return [Boolean]
@@ -47,9 +56,22 @@ module BCDice
 
         # @return [Integer]
         def critical
-          crit = @critical || (half ? 13 : 10)
-          crit = 3 if crit < 3
-          return crit
+          return @critical || (half ? 13 : 10)
+        end
+
+        # @return [Integer]
+        def min_critical
+          min_critical = 3
+          unless @semi_fixed_val.nil?
+            if @kept_modify.nil?
+              min_critical = @semi_fixed_val + 2 if min_critical < @semi_fixed_val + 2
+            else
+              min_critical = @semi_fixed_val + @kept_modify + 2 if min_critical < @semi_fixed_val + @kept_modify + 2
+            end
+            min_critical = 3 if @semi_fixed_val == 1
+          end
+          min_critical = 13 if min_critical > 13
+          return min_critical
         end
 
         # @return [Integer]
@@ -67,6 +89,20 @@ module BCDice
           return @rateup || 0
         end
 
+        # @return [Integer]
+        def semi_fixed_val
+          sf = @semi_fixed_val || 0
+          sf = 6 if sf > 6
+          return sf
+        end
+
+        # @return [Integer]
+        def tmp_fixed_val
+          tf = @tmp_fixed_val || 0
+          tf = 6 if tf > 6
+          return tf
+        end
+
         # @return [Integer]
         def kept_modify
           return @kept_modify || 0
@@ -86,6 +122,8 @@ module BCDice
           output += "m[#{first_to}]" if first_to != 0
           output += "r[#{rateup}]" if rateup != 0
           output += "gf" if @greatest_fortune
+          output += "sf[#{semi_fixed_val}]" if semi_fixed_val != 0
+          output += "tf[#{tmp_fixed_val}]" if tmp_fixed_val != 0
           output += "a[#{Format.modifier(kept_modify)}]" if kept_modify != 0
 
           if @modifier != 0
@@ -93,6 +131,11 @@ module BCDice
           end
           return output
         end
+
+        # @return [Boolean]
+        def infinite_roll?
+          return critical < min_critical
+        end
       end
     end
   end