bcdice 3.4.0 → 3.5.0

data/lib/bcdice/game_system/SwordWorld2_5.rb

@@ -56,6 +56,12 @@ module BCDice
         ・グレイテストフォーチュンは末尾に gf
         　例）K20gf　K30+24@8GF　K40+24@8$12r5gf
 
+        ・威力表を1d+sfで参照 クリティカル後も継続 sf4
+        　例）k10sf4　k0+5sf4@13　k70+26sf3@9
+
+        ・威力表を1d+tfで参照 クリティカル後は2dで参照 tf3
+        　例）k10tf3　k0+5tf4@13　k70+26tf3@9
+
         ・超越判定用に2d6ロールに 2D6@10 書式でクリティカル値付与が可能に。
         　例）2D6@10　2D6@10+11>=30
 

data/lib/bcdice/game_system/TalesFromTheLoop.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class TalesFromTheLoop < Base
+      # ゲームシステムの識別子
+      ID = "TalesFromTheLoop"
+
+      # ゲームシステム名
+      NAME = "ザ・ループTRPG"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "さるうふTRPG"
+
+      HELP_MESSAGE = <<~TEXT
+        ■ 判定コマンド(nTFLx-x+x or nTFLx+x-x)
+          (必要成功数)TFL(判定ダイス数)+/-(修正ダイス数)
+
+        ※ 必要成功数と修正ダイス数は省略可能
+
+        例1) 必要成功数1、判定ダイスは能力値3
+              1TFL3
+
+        例2）必要成功数不明、あるいはダイスボットの成功判定を使わない、判定ダイスは能力値3+技能1で4、アイテムの修正+1
+              TFL4+1
+
+        例3）必要成功数1、判定ダイスは能力値2+技能1で3、コンディションにチェックが2つ、アイテムの修正+1
+              1TFL3-2+1
+             あるいは以下のようにカッコ書きで内訳を詳細に記述することも可能。
+              1TFL(2+1)-(1+1)+1
+             修正ダイスのプラスとマイナスは逆でもよい。
+              1TFL(2+1)+1-(1+1)
+      TEXT
+
+      register_prefix('(\d+)?(TFL)')
+
+      def eval_game_system_specific_command(command)
+        parser = Command::Parser.new(/\d*TFL\d+/, round_type: round_type)
+        parsed = parser.parse(command)
+        return nil unless parsed
+
+        difficulty, dice_pool = parsed.command.split("TFL", 2).map(&:to_i)
+        dice_pool += parsed.modify_number
+        if dice_pool <= 0
+          dice_pool = 1
+        end
+
+        ability_dice_text, success_dice = make_dice_roll(dice_pool)
+
+        return make_dice_roll_text(difficulty, dice_pool, ability_dice_text, success_dice)
+      end
+
+      private
+
+      def make_dice_roll_text(difficulty, dice_pool, ability_dice_text, success_dice)
+        dice_count_text = "(#{dice_pool}D6) ＞ #{ability_dice_text} 成功数:#{success_dice}"
+        push_dice = (dice_pool - success_dice)
+
+        if push_dice > 0
+          dice_count_text = "#{dice_count_text} 振り直し可能:#{push_dice}"
+          reroll_command = "\n振り直しコマンド: TFL#{push_dice}"
+        end
+
+        if difficulty > 0
+          if success_dice >= difficulty
+            return Result.success("#{dice_count_text} 成功！#{reroll_command}")
+          else
+            return Result.failure("#{dice_count_text} 失敗！#{reroll_command}")
+          end
+        end
+
+        return "#{dice_count_text}#{reroll_command}"
+      end
+
+      def make_dice_roll(dice_pool)
+        dice_list = @randomizer.roll_barabara(dice_pool, 6)
+        success_dice = dice_list.count(6)
+
+        return "[#{dice_list.join(',')}]", success_dice
+      end
+    end
+  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/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