bcdice 3.11.0 → 3.13.0

data/lib/bcdice/game_system/KamitsubakiCityUnderConstructionNarrative.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class KamitsubakiCityUnderConstructionNarrative < Base
+      # ゲームシステムの識別子
+      ID = 'KamitsubakiCityUnderConstructionNarrative'
+
+      # ゲームシステム名
+      NAME = '神椿市建設中。NARRATIVE'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'かみつはきしけんせつちゆうならていふ'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ・可組（KA）
+        　KA6 行動判定
+        　KA8 技能ロール
+        　KA10 特技ロール
+        　KA12 Aロール
+
+        ・裏組（RI）
+        　RI6 行動判定
+        　RI8 技能ロール
+        　RI10 特技ロール
+        　RI12 Aロール
+
+        ・羽組（HA）
+        　HA6 行動判定
+        　HA8 技能ロール
+        　HA10 特技ロール
+        　HA12 Aロール
+
+        ・星組（SE）
+        　SE6 行動判定
+        　SE8 技能ロール
+        　SE10 特技ロール
+        　SE12 Aロール
+
+        ・狐組（CO）
+        　CO6 行動判定
+        　CO8 技能ロール
+        　CO10 特技ロール
+        　CO12 Aロール
+
+        ・GM用
+        　GM6 （成否判定なし）
+        　GM8 技能ロール
+        　GM10 特技ロール
+        　Q12 Qロール
+
+        ・存在証明 EXI<=x
+        　存在証明の判定を行う
+        　x: 存在値
+      INFO_MESSAGE_TEXT
+
+      def eval_game_system_specific_command(command)
+        roll_kumi(command) || roll_existence(command)
+      end
+
+      private
+
+      def roll_kumi(command)
+        table = TABLES[command]
+        unless table
+          return nil
+        end
+
+        return table.roll(@randomizer)
+      end
+
+      class KumiDice
+        def initialize(items)
+          @items = items.freeze
+        end
+
+        CRITICAL = "M"
+        FUMBLE = "Q"
+
+        def roll(randomizer)
+          dice = randomizer.roll_once(@items.length)
+          chosen = @items[dice - 1]
+
+          fumble = chosen == FUMBLE
+          critical = chosen == CRITICAL
+
+          result_tail =
+            if fumble
+              "ファンブル"
+            elsif critical
+              "マジック"
+            elsif !chosen.empty?
+              "成功"
+            else
+              "失敗"
+            end
+
+          Result.new.tap do |r|
+            r.critical = critical
+            r.fumble = fumble
+            r.condition = !chosen.empty? && !r.fumble?
+            r.text = [
+              "(D#{@items.length})",
+              dice,
+              chosen.empty? ? nil : chosen,
+              result_tail
+            ].compact.join(" ＞ ")
+          end
+        end
+      end
+
+      class KumiD6
+        def initialize(success_symbol)
+          @success_symbol = success_symbol
+        end
+
+        TABLE = ["裏", "羽", "星", "狐", "可", "Q"].freeze
+
+        def roll(randomizer)
+          dice = randomizer.roll_once(6)
+          chosen = TABLE[dice - 1]
+
+          Result.new.tap do |r|
+            unless @success_symbol.nil?
+              r.fumble = chosen == "Q"
+              r.condition = chosen == @success_symbol
+            end
+
+            result_tail =
+              if r.fumble?
+                "ファンブル"
+              elsif r.success?
+                "成功"
+              elsif r.failure?
+                "失敗"
+              end
+
+            r.text = [
+              "(D6)",
+              dice,
+              chosen,
+              result_tail
+            ].compact.join(" ＞ ")
+          end
+        end
+      end
+
+      class QDice
+        def initialize(items)
+          @items = items.freeze
+        end
+
+        CRITICAL = "M"
+
+        def roll(randomizer)
+          dice = randomizer.roll_once(@items.length)
+          chosen = @items[dice - 1]
+
+          critical = chosen == CRITICAL
+
+          result_tail =
+            if critical
+              "マジック"
+            elsif !chosen.empty?
+              "成功"
+            else
+              "失敗"
+            end
+
+          Result.new.tap do |r|
+            r.critical = critical
+            r.condition = !chosen.empty?
+            r.text = [
+              "(D#{@items.length})",
+              dice.to_s,
+              chosen.empty? ? nil : chosen,
+              result_tail,
+            ].compact.join(" ＞ ")
+          end
+        end
+      end
+
+      def roll_existence(command)
+        m = /^EXI<=(\d+)$/.match(command)
+        unless m
+          return nil
+        end
+
+        target = m[1].to_i
+        dice = @randomizer.roll_once(20)
+        Result.new.tap do |r|
+          r.critical = dice == 1
+          r.fumble = dice == 20
+          r.condition = (dice <= target && !r.fumble?) || r.critical?
+
+          result_tail =
+            if r.critical?
+              "M ＞ マジック"
+            elsif r.fumble?
+              "Q ＞ ファンブル"
+            elsif r.success?
+              "成功"
+            else
+              "失敗"
+            end
+
+          r.text = [
+            "(D20<=#{target})",
+            dice,
+            result_tail
+          ].join(" ＞ ")
+        end
+      end
+
+      TABLES = {
+        "KA6" => KumiD6.new("可"),
+        "KA8" => KumiDice.new(["Q", "", "", "", "可", "可", "可", "M"]),
+        "KA10" => KumiDice.new(["Q", "", "", "可", "可", "可", "可", "可", "M", "M"]),
+        "KA12" => KumiDice.new(["Q", "", "", "可", "可", "可", "可", "可", "可", "可", "M", "M"]),
+
+        "RI6" => KumiD6.new("裏"),
+        "RI8" => KumiDice.new(["Q", "", "", "", "裏", "裏", "裏", "M"]),
+        "RI10" => KumiDice.new(["Q", "", "", "裏", "裏", "裏", "裏", "裏", "M", "M"]),
+        "RI12" => KumiDice.new(["M", "M", "裏", "裏", "裏", "裏", "裏", "裏", "裏", "", "", "Q"]),
+
+        "HA6" => KumiD6.new("羽"),
+        "HA8" => KumiDice.new(["Q", "", "", "", "羽", "羽", "羽", "M"]),
+        "HA10" => KumiDice.new(["Q", "", "", "羽", "羽", "羽", "羽", "羽", "M", "M"]),
+        "HA12" => KumiDice.new(["Q", "Q", "羽", "羽", "羽", "", "", "", "M", "M", "M", "M"]),
+
+        "SE6" => KumiD6.new("星"),
+        "SE8" => KumiDice.new(["Q", "", "", "", "星", "星", "星", "M"]),
+        "SE10" => KumiDice.new(["Q", "", "", "星", "星", "星", "星", "星", "M", "M"]),
+        "SE12" => KumiDice.new(["星", "", "星", "星", "M", "Q", "M", "星", "星", "星", "", "星"]),
+
+        "CO6" => KumiD6.new("狐"),
+        "CO8" => KumiDice.new(["Q", "", "", "", "狐", "狐", "狐", "M"]),
+        "CO10" => KumiDice.new(["Q", "", "", "狐", "狐", "狐", "狐", "狐", "M", "M"]),
+        "CO12" => KumiDice.new(["Q", "", "", "狐狐狐", "狐狐", "狐", "狐狐狐", "狐狐", "狐", "狐", "M", "M"]),
+
+        "GM6" => KumiD6.new(nil),
+        "GM8" => KumiDice.new(["Q", "", "", "", "W", "W", "W", "M"]),
+        "GM10" => KumiDice.new(["Q", "", "", "W", "W", "W", "W", "W", "M", "M"]),
+        "Q12" => QDice.new(["", "", "", "Q", "Q", "Q", "Q", "Q", "Q", "Q", "M", "M"])
+      }.freeze
+
+      register_prefix("EXI", TABLES.keys)
+    end
+  end
+end

data/lib/bcdice/game_system/KillDeathBusiness.rb

@@ -101,7 +101,7 @@ module BCDice
           target = 5
         end
 
-        if  fumble < 2
+        if fumble < 2
           fumble = 2
         elsif fumble > 11
           result += "【#{command}】 ＞ #{translate('KillDeathBusiness.JD.warning.over_fumble')}\n"

data/lib/bcdice/game_system/KyokoShinshoku.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class KyokoShinshoku < Base
+      # ゲームシステムの識別子
+      ID = "KyokoShinshoku"
+
+      # ゲームシステム名
+      NAME = "虚構侵蝕TRPG"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "きよこうしんしよくTRPG"
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~MESSAGETEXT
+        ・判定
+        　ダイスを指定数ダイスロールして、最も高い出目を出力します。難易度を指定すると成否を判定します。
+        KS(x,y)
+        x：ダイスサイズ。1=D4（能力値1、2以上の出目が出ていたとしても最大1）／2=D4（能力値2、3以上の出目が出ていたとしても最大2）／3=D4（能力値3、出目4が出ていたとしても最大3）／4=D4／6=D6／8=D8／10=D10／12=D12／20=D20
+        y：ダイス数（省略：1）
+
+        KS(x,y)>=z
+        x：ダイスサイズ。1=D4（能力値1、2以上の出目が出ていたとしても最大1）／2=D4（能力値2、3以上の出目が出ていたとしても最大2）／3=D4（能力値3、出目4が出ていたとしても最大3）／4=D4／6=D6／8=D8／10=D10／12=D12／20=D20
+        y：ダイス数（省略：1）
+        z：難易度
+
+        ・観測ロール
+        　［現実乖離］の段階に応じたダイスを指定数ダイスロールして、最も高い出目を出力します。
+        KR(x)
+        x=［現実乖離］の段階（1=D4／2=D6／3=D8／4=D10／5=D12／6=D20）
+
+        KR(x,y)　観測ロール（リアリティラインあり）
+        x=［現実乖離］の段階（1=D4／2=D6／3=D8／4=D10／5=D12／6=D20）
+        y=［リアリティライン］のレベル（3=1個／2=2個／1=3個）
+
+        ・虚構の収束の侵蝕度減少ロール
+        　［現実乖離］の段階に応じたダイスを指定数ダイスロールして、その合計を出力します。
+        KRS(x,y)
+        x=［現実乖離］の段階（1=D4／2=D6／3=D8／4=D10／5=D12／6=D20）
+        y=ダイスの個数
+      MESSAGETEXT
+
+      register_prefix('KS', 'KR', 'KRS')
+
+      def eval_game_system_specific_command(command)
+        roll_check(command) || roll_kansoku(command) || roll_shusoku(command)
+      end
+
+      private
+
+      DICE_SIZE_TO_SIDES = {
+        1 => 4,
+        2 => 4,
+        3 => 4,
+        4 => 4,
+        6 => 6,
+        8 => 8,
+        10 => 10,
+        12 => 12,
+        20 => 20,
+      }.freeze
+
+      def roll_check(command)
+        m = /^KS(?:\((\d+),([-+\d]+)?\)|(\d+))(?:>=([-+\d]+))?$/.match(command)
+        return nil unless m
+
+        dice_size = m[1]&.to_i || m[3].to_i
+        times = m[2] ? Arithmetic.eval(m[2], @round_type) : 1
+        target = m[4] && Arithmetic.eval(m[4], @round_type)
+
+        sides = DICE_SIZE_TO_SIDES[dice_size]
+
+        return nil if sides.nil? || times.nil?
+
+        dice_list = @randomizer.roll_barabara(times, sides).sort
+        value = dice_list.max.clamp(1, dice_size)
+
+        result =
+          if value == 1
+            Result.fumble("ファンブル")
+          elsif target && value < target
+            Result.failure("失敗")
+          elsif target && value == sides
+            Result.critical("クリティカル")
+          elsif target && value >= target
+            Result.success("成功")
+          else
+            Result.new()
+          end
+
+        result.text = [
+          target ? "(KS(#{dice_size},#{times})>=#{target})" : "(KS(#{dice_size},#{times}))",
+          ("#{value}[#{dice_list.join(',')}]" if times > 1),
+          value,
+          result.text,
+        ].compact.join(" ＞ ")
+
+        return result
+      end
+
+      GENJITU_KAIRI_TO_SIDES = [4, 6, 8, 10, 12, 20].freeze
+      REALITY_LINE_TO_TIMES = {
+        3 => 1,
+        2 => 2,
+        1 => 3,
+      }.freeze
+
+      def roll_kansoku(command)
+        m = /^KR(?:(\d+)|\((\d),(\d)\))$/.match(command)
+        return nil unless m
+
+        dice_size = m[1]&.to_i || m[2].to_i
+        reality_line = m[3]&.to_i
+
+        if reality_line && (reality_line > 3 || reality_line < 1)
+          return nil
+        end
+
+        sides = GENJITU_KAIRI_TO_SIDES[dice_size - 1]
+        times = REALITY_LINE_TO_TIMES[reality_line] || 1
+
+        return nil unless sides
+
+        dice_list = @randomizer.roll_barabara(times, sides).sort
+        value = dice_list.max
+
+        cmd = reality_line ? "KR(#{dice_size},#{reality_line})" : "KR(#{dice_size})"
+
+        if times == 1
+          "(#{cmd}) ＞ #{value}"
+        else
+          "(#{cmd}) ＞ #{value}[#{dice_list.join(',')}] ＞ #{value}"
+        end
+      end
+
+      def roll_shusoku(command)
+        m = /^KRS(?:\((\d),([-+\d]+)\))$/.match(command)
+        return nil unless m
+
+        dice_size = m[1].to_i
+        times = m[2] && Arithmetic.eval(m[2], @round_type)
+
+        sides = GENJITU_KAIRI_TO_SIDES[dice_size - 1]
+        return nil if sides.nil? || times.nil?
+
+        dice_list = @randomizer.roll_barabara(times, sides)
+        value = dice_list.sum
+
+        if times == 1
+          "(KRS(#{dice_size},#{times})) ＞ #{value}"
+        else
+          "(KRS(#{dice_size},#{times})) ＞ #{value}[#{dice_list.join(',')}] ＞ #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Liminal.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Liminal < Base
+      # ゲームシステムの識別子
+      ID = 'Liminal'
+
+      # ゲームシステム名
+      NAME = 'リミナル'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'りみなる'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■技能判定　LMx+b>=t+m   x:技能レベル b:ボーナス t:難易度 m:敵の技能レベル(対抗判定)
+
+        例)LM2>=8:  技能レベル2,難易度8で技能判定し、その結果を表示。(クリティカル成功も表示)
+           LM3+2>=9:技能レベル3,ボーナス+2,難易度9で技能判定し、その結果を表示。( 〃 )
+           LM0>=8:  技能なし,難易度8で技能判定する。(難易度+2は自動的に足されます)
+
+        ■イニシアティヴ判定　LIx+b>=t+m   x:認識力レベル b:ボーナス t:難易度 m:敵の認識力レベル
+        例)LI2>=8+2:  認識力レベル2,難易度8,敵認識力レベル2で技能判定し、その結果を表示。
+           LI0>=8+2:  認識力なし,難易度8,敵認識力レベル2で技能判定する。(難易度加算なし)
+      INFO_MESSAGETEXT
+
+      register_prefix("LI", "LM")
+
+      def eval_game_system_specific_command(command)
+        resolute_action(command) || resolute_initiative(command)
+      end
+
+      private
+
+      # 技能判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_action(command)
+        parser = Command::Parser.new("LM", round_type: @round_type)
+                                .has_suffix_number
+                                .restrict_cmp_op_to(:>=)
+        parsed = parser.parse(command)
+        return nil unless parsed
+
+        skill_level = parsed.suffix_number
+        bonus = parsed.modify_number
+        difficulty = parsed.target_number
+
+        dice = @randomizer.roll_barabara(2, 6)
+        dice_total = dice.sum
+        total = dice_total + skill_level + bonus
+        difficulty += 2 if skill_level == 0
+
+        return Result.new.tap do |result|
+          result.condition = (total >= difficulty)
+          result.critical = (total >= difficulty + 5)
+          if dice_total == 2
+            result.fumble = true
+            result.critical = false
+            result.condition = false
+          end
+
+          sequence = [
+            "(LM#{skill_level}#{with_symbol(bonus)}>=#{difficulty})",
+            "#{dice_total}[#{dice.join(',')}]#{with_symbol(skill_level + bonus)}",
+            total.to_s,
+            if result.fumble?
+              "1ゾロ"
+            elsif result.critical?
+              "クリティカル"
+            else
+              result.success? ? "成功" : "失敗"
+            end
+          ].compact
+
+          result.text = sequence.join(" ＞ ")
+        end
+      end
+
+      def with_symbol(number)
+        if number == 0
+          return "+0"
+        elsif number > 0
+          return "+#{number}"
+        else
+          return number.to_s
+        end
+      end
+
+      # イニシアティヴ判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_initiative(command)
+        parser = Command::Parser.new("LI", round_type: @round_type)
+                                .has_suffix_number
+                                .restrict_cmp_op_to(:>=)
+        parsed = parser.parse(command)
+        return nil unless parsed
+
+        skill_level = parsed.suffix_number
+        bonus = parsed.modify_number
+        difficulty = parsed.target_number
+
+        dice = @randomizer.roll_barabara(2, 6)
+        dice_total = dice.sum
+        total = dice_total + skill_level + bonus
+
+        return Result.new.tap do |result|
+          result.condition = (total >= difficulty)
+          result.critical = (total >= difficulty + 5)
+          if dice_total == 2
+            result.fumble = true
+            result.critical = false
+            result.condition = false
+          end
+
+          sequence = [
+            "(LI#{skill_level}#{with_symbol(bonus)}>=#{difficulty})",
+            "#{dice_total}[#{dice.join(',')}]#{with_symbol(skill_level + bonus)}",
+            total.to_s,
+            if result.fumble?
+              "1ゾロ"
+            elsif result.critical?
+              "クリティカル"
+            else
+              result.success? ? "成功" : "失敗"
+            end
+          ].compact
+
+          result.text = sequence.join(" ＞ ")
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/MetalHead.rb

@@ -151,7 +151,7 @@ module BCDice
           'D' => [{'LW' => 2}, {'MW' => 26}, {'HW' => 46}, {'MO' => 76}, {'K' => 96}],
           'E' => [{'LW' => 2}, {'MW' => 26}, {'HW' => 39}, {'MO' => 54}, {'K' => 76}],
           'F' => [{'LW' => 2}, {'MW' => 16}, {'HW' => 39}, {'MO' => 54}, {'K' => 66}],
-          'G' => [{'LW' => 2}, {'MW' =>  6}, {'HW' => 16}, {'MO' => 26}, {'K' => 39}],
+          'G' => [{'LW' => 2}, {'MW' => 6}, {'HW' => 16}, {'MO' => 26}, {'K' => 39}],
           'M' => [{'0'  => 2}, {'1' => 22}, {'2' => 42}, {'3' => 62}, {'4' => 82}, {'5' => 92}, {'6' => 102}, {'8' => 112}],
         }
 

data/lib/bcdice/game_system/MetalHeadExtream.rb

@@ -68,7 +68,7 @@ module BCDice
             type = m[1]
             target = m[2].to_i
             modify = get_value(1, m[3])
-            paramText = (m[5] || '')
+            paramText = m[5] || ''
             isMuse = !m[8].nil? # パンドラ《ミューズ》
 
             accidentValue = 96

data/lib/bcdice/game_system/NRR.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class NRR < Base
+      # ゲームシステムの識別子
+      ID = 'NRR'
+
+      # ゲームシステム名
+      NAME = 'nRR'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'えぬああるあある'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ▪️判定
+        ・ノーマルダイス　NR8
+        ・有利ダイス　NR10
+        ・不利ダイス　NR6
+        ・Exダイス　NR12
+
+        ダイスの個数を指定しての判定ができます。
+        例：有利ダイス2個で判定　2NR10
+
+        ▪️判定結果とシンボル
+        ⭕：成功
+        ❌：失敗
+        ✨：クリティカル（大成功）
+        💀：ファンブル（大失敗）
+        🌈：ミラクル（奇跡）
+      INFO_MESSAGETEXT
+
+      register_prefix('\d*NR(6|8|10|12)')
+
+      def initialize(command)
+        super(command)
+
+        @sort_barabara_dice = true # バラバラロール（Bコマンド）でソート有
+      end
+
+      def eval_game_system_specific_command(command)
+        roll_nr(command)
+      end
+
+      private
+
+      def roll_nr(command)
+        m = /^(\d+)?NR(6|8|10|12)$/.match(command)
+        return nil unless m
+
+        times = m[1]&.to_i || 1
+        table = case m[2]
+                when "6"
+                  DISADVANTAGE
+                when "8"
+                  NORMAL
+                when "10"
+                  ADVANTAGE
+                else
+                  EXTRA
+                end
+
+        values = @randomizer.roll_barabara(times, table.size)
+        result = Result.new
+        text =
+          if times == 1
+            level = table[values[0] - 1]
+            result.condition = SUCCESSES.include?(level)
+            result.fumble = level == :fumble
+            result.critical = CRITICALS.include?(level)
+
+            "#{ICON[level]} #{RESULT_LABEL[level]}"
+          else
+            levels = values.map { |v| table[v - 1] }
+            values_count = levels
+                           .group_by(&:itself)
+                           .transform_values(&:length)
+
+            values_count_strs = LEVELS.map do |l|
+              count = values_count.fetch(l, 0)
+              next nil if count == 0
+
+              "#{ICON[l]} #{count}"
+            end
+
+            values_count_strs.compact.join(", ")
+          end
+
+        times_str = times == 1 ? nil : times
+        result.text = "(#{times_str}NR#{m[2]}) ＞ #{values.join(',')} ＞ #{text}"
+
+        result
+      end
+
+      LEVELS = [:fumble, :failure, :success, :critical, :miracle].freeze
+      SUCCESSES = [:success, :critical, :miracle].freeze
+      CRITICALS = [:critical, :miracle].freeze
+
+      DISADVANTAGE = [:fumble, :fumble, :failure, :failure, :success, :success].freeze
+      NORMAL = [:fumble, :failure, :failure, :failure, :success, :success, :success, :critical].freeze
+      ADVANTAGE = [:fumble, :failure, :failure, :success, :success, :success, :success, :success, :critical, :critical].freeze
+      EXTRA = [:fumble, :fumble, :fumble, :failure, :success, :success, :critical, :critical, :critical, :critical, :miracle, :miracle].freeze
+
+      ICON = {
+        fumble: "💀",
+        failure: "❌",
+        success: "⭕️",
+        critical: "✨",
+        miracle: "🌈",
+      }.freeze
+
+      RESULT_LABEL = {
+        fumble: "ファンブル（大失敗）",
+        failure: "失敗",
+        success: "成功",
+        critical: "クリティカル（大成功）",
+        miracle: "ミラクル（奇跡）",
+      }.freeze
+    end
+  end
+end