bcdice 3.13.0 → 3.15.0

data/lib/bcdice/game_system/Agnostos.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Agnostos < Base
+      # ゲームシステムの識別子
+      ID = "Agnostos"
+
+      # ゲームシステム名
+      NAME = "アグノストス"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "あくのすとす"
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~MESSAGETEXT
+        ■ 行為判定
+          CDx>=t
+          x: コンディションレベル（A~E もしくは 5~1)
+          t: 目標値
+          の成否とコンディションの変動量を判定します。
+
+        ■ 心拍のコンディションチェック
+          HCDx
+          x: コンディションレベル（C+, B+, A, B-, C-, もしくは 5~1）
+          酸素の消費量、コンディションの変動量、気絶したかを判定します。
+
+        ■ 必殺技
+          xSPy
+          x: メインコンディション（A~E もしくは 5~1)
+          y: サブコンディション（A~E もしくは 5~1)
+          必殺技のダメージ量を判定します。
+      MESSAGETEXT
+
+      register_prefix('CD', 'HCD', '[A-E1-5]SP[A-E1-5]')
+
+      def eval_game_system_specific_command(command)
+        condition_roll(command) || heart_condition_roll(command) || special_roll(command)
+      end
+
+      private
+
+      # コンディションチェック
+      def condition_roll(command)
+        parser = Command::Parser.new(/CD[A-E1-5]/, round_type: @round_type).disable_modifier.restrict_cmp_op_to(:>=)
+        parsed = parser.parse(command)
+        unless parsed
+          return nil
+        end
+
+        condition_level = to_condition_level(parsed.command[-1])
+        sides = to_sides(condition_level)
+        value = @randomizer.roll_once(sides)
+
+        Result.new.tap do |r|
+          r.critical = critical?(sides, value)
+          r.fumble = fumble?(sides, value)
+          r.condition = value >= parsed.target_number
+
+          r.text = [
+            "(CD#{condition_level}>=#{parsed.target_number})",
+            "(1D#{sides}>=#{parsed.target_number})",
+            value.to_s(),
+            r.success? ? "成功" : "失敗",
+            condition_change(sides, value),
+          ].join(" ＞ ")
+        end
+      end
+
+      def to_condition_level(char)
+        case char
+        when "5"
+          "A"
+        when "4"
+          "B"
+        when "3"
+          "C"
+        when "2"
+          "D"
+        when "1"
+          "E"
+        else
+          char
+        end
+      end
+
+      def to_sides(condition)
+        case condition
+        when "A"
+          12
+        when "B"
+          10
+        when "C"
+          8
+        when "D"
+          6
+        else # "E"
+          4
+        end
+      end
+
+      def condition_change(sides, value)
+        if critical?(sides, value)
+          "コンディション：2段階上昇（クリティカル）"
+        elsif fumble?(sides, value)
+          "コンディション：2段階下降（ファンブル）"
+        elsif sides != 12 && sides - value <= 1
+          "コンディション：1段階上昇"
+        elsif sides == 12 && value <= 6
+          "コンディション：1段階下降"
+        elsif sides == 10 && value <= 3
+          "コンディション：1段階下降"
+        elsif sides == 8 && value <= 2
+          "コンディション：1段階下降"
+        else
+          "コンディション：変動なし"
+        end
+      end
+
+      def critical?(sides, value)
+        sides != 12 && sides == value
+      end
+
+      def fumble?(sides, value)
+        sides != 4 && value == 1
+      end
+
+      # 心拍のコンディションチェック
+      def heart_condition_roll(command)
+        m = /^HCD([A1-5]|[BC][+-])$/.match(command)
+        unless m
+          return nil
+        end
+
+        suffix = m[1]
+        condition_level = to_heart_condition_level(suffix)
+        sides = to_heart_sides(condition_level)
+        value = @randomizer.roll_once(sides)
+
+        Result.new.tap do |r|
+          r.critical = critical?(sides, value)
+          r.fumble = fumble?(sides, value)
+
+          r.text = [
+            "(HCD#{condition_level})",
+            "(1D#{sides})",
+            value.to_s(),
+            heart_condition_change(sides, value),
+          ].join(" ＞ ")
+        end
+      end
+
+      def to_heart_condition_level(char)
+        case char
+        when "5"
+          "C+"
+        when "4"
+          "B+"
+        when "3"
+          "A"
+        when "2"
+          "B-"
+        when "1"
+          "C-"
+        else
+          char
+        end
+      end
+
+      def to_heart_sides(condition)
+        case condition
+        when "C+"
+          12
+        when "B+"
+          10
+        when "A"
+          8
+        when "B-"
+          6
+        else # "C-"
+          4
+        end
+      end
+
+      def fainted?(sides, value)
+        case sides
+        when 12
+          value >= 7
+        when 10
+          value >= 10
+        when 8
+          false
+        when 6
+          value <= 1
+        else # 4
+          value <= 2
+        end
+      end
+
+      def heart_condition_change(sides, value)
+        if fainted?(sides, value)
+          "気絶"
+        else
+          condition_change(sides, value)
+        end
+      end
+
+      # 必殺技
+      def special_roll(command)
+        m = /^([A-E1-5])SP([A-E1-5])$/.match(command)
+        unless m
+          return nil
+        end
+
+        times_conditon_level = to_condition_level(m[1])
+        sides_conditon_level = to_condition_level(m[2])
+
+        times = to_times(times_conditon_level)
+        sides = to_sides(sides_conditon_level)
+
+        dice_list = @randomizer.roll_barabara(times, sides)
+        value = dice_list.sum()
+
+        return [
+          "(#{times_conditon_level}SP#{sides_conditon_level})",
+          "(#{times}D#{sides})",
+          "#{value}[#{dice_list.join(',')}]",
+          value.to_s(),
+        ].join(" ＞ ")
+      end
+
+      def to_times(condition)
+        case condition
+        when "A"
+          5
+        when "B"
+          4
+        when "C"
+          3
+        when "D"
+          2
+        else # "E"
+          1
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Aionia.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Aionia < Base
+      # ゲームシステムの識別子
+      ID = "Aionia"
+
+      # ゲームシステム名
+      NAME = "慈悲なきアイオニア"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "しひなきあいおにあ"
+
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        - 技能判定（クリティカル・ファンブルなし）
+        AB{n}>={dif} n=10面ダイスの数、dif=難易度
+        - 技能判定（クリティカル・ファンブルあり）
+        ABT{n}>={dif} n=10面ダイスの数、dif=難易度
+
+        例:AB2>=5        （一般技能を活用して難易度5の技能判定。 クリファンなし。）
+        例:ABT3>=15      （専門技能を活用して難易度15の技能判定。クリファンあり。）
+        例:AB1+2>=8      （一般技能を活用せず難易度8の技能判定。 ボーナスとして+2点の補正あり。  クリファンなし。）
+        例:ABT3-3>=10    （専門技能を活用して難易度10の技能判定。ペナルティとして-3点の補正あり。クリファンあり。）
+        例:ABT2>=4/8/12  （一般技能を活用して難易度4/8/12の段階的な技能判定。クリファンあり。）
+      INFO_MESSAGE_TEXT
+
+      register_prefix('ABT?\d+([\+\-]\d+)?>=\d+(\/\d+)*')
+
+      def eval_game_system_specific_command(command)
+        return roll_skills(command)
+      end
+
+      def roll_skills(command)
+        m = %r{AB(T?)(\d+)([+-]\d+)?>=((\d+)((/\d+)*))}.match(command)
+        return nil unless m
+
+        # 値の取得
+        use_cf = m[1] != ''
+        times = m[2].to_i
+        bonus = m[3].to_i
+        targets = m[4].split('/').map(&:to_i)
+        target = targets[0]
+        min_target = targets.min
+        max_target = targets.max
+
+        # ダイスロール
+        dice_list = @randomizer.roll_barabara(times, 10)
+        dice_total = dice_list.sum
+        total = dice_total + bonus
+
+        # Result用変数宣言
+        is_success = false
+        has_critical = false
+        has_fumble = false
+
+        # 結果判定
+        # 難易度が一つの場合
+        if targets.count == 1
+          if total >= target
+            is_success = true
+            if total >= target + 20 && use_cf
+              result = 'クリティカル'
+              has_critical = true
+            elsif target <= times
+              result = '自動成功'
+            else
+              result = '成功'
+            end
+          else
+            is_success = false
+            if dice_list.count(1) == times && use_cf
+              result = 'ファンブル'
+              has_fumble = true
+            elsif target > 10 * times
+              result = '自動失敗'
+            else
+              result = '失敗'
+            end
+          end
+        # 段階的な難易度判定の場合
+        else
+          if total >= min_target
+            is_success = true
+            if total >= max_target + 20 && use_cf
+              result = 'クリティカル'
+              has_critical = true
+            elsif max_target <= times
+              result = '自動成功'
+            elsif total >= max_target
+              result = '全成功'
+            else
+              times_suc = targets.count { |x| x <= total }
+              result = "#{times_suc}段階成功"
+            end
+          else
+            is_success = false
+            if dice_list.count(1) == times && use_cf
+              result = 'ファンブル'
+              has_fumble = true
+            elsif min_target > 10 * times
+              result = '自動失敗'
+            else
+              result = '失敗'
+            end
+          end
+        end
+
+        # ボーナスがある場合の処理
+        bonus_text = ''
+        bonus_result = ''
+        if bonus != 0
+          if bonus > 0
+            bonus_text = "+"
+          end
+          bonus_text += bonus.to_s
+          bonus_result = "#{total} ＞ "
+        end
+
+        # Resultクラスに結果を入れる
+        Result.new.tap do |r|
+          r.text = "(#{command}) ＞ #{dice_total}[#{dice_list.join(',')}]#{bonus_text} ＞ #{bonus_result}#{result}"
+          r.critical = has_critical
+          r.fumble = has_fumble
+          r.success = is_success
+          r.failure = !is_success
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/AniMalus.rb

@@ -14,23 +14,23 @@ module BCDice
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGETEXT
-        ■ステータスのダイス判定　nAM<=t,x        n:能力値 t:成功値 x:必要成功数
-        例)3AM<=2,1: ダイスを3個振って、成功値2,必要成功数1で判定。その結果(成功数,成功・失敗)を表示
+        ■ステータスのダイス判定　n[+-b]AM<=t,x        n:能力値 b:修正値(省略可能) t:成功値 x:必要成功数
+        例)3AM<=2,1: ダイスを3個振って、成功値2,必要成功数1で判定。その結果(成功数,成功・失敗,クリティカル,ファンブル)を表示
 
-        ■探索技能のダイス判定　AI<=t,x        t:探索技能レベル x:必要成功数
-        例)AI<=3,1: ダイスを3個振って、探索技能レベル3,必要成功数1で判定。その結果(成功数,成功・失敗)を表示
+        ■探索技能のダイス判定　[+-b]AI<=t,x        t:探索技能レベル b:修正値(省略可能) x:必要成功数
+        例)AI<=3,1: ダイスを3個振って、探索技能レベル3,必要成功数1で判定。その結果(成功数,成功・失敗,クリティカル,ファンブル)を表示
 
-        ■攻撃判定　AA<=t        t:戦闘技能レベル
+        ■攻撃判定　[+-b]AA<=t       t:戦闘技能レベル b:修正値(省略可能)
         例)AA<=3: ダイスを3個振って、戦闘技能レベル3で判定。その結果(成功・失敗,ダメージ,クリティカル,ファンブル)を表示
 
-        ■防御判定　AG=t        t:攻撃技能レベル
-        例)AG=2: ダイスを3個振って、攻撃技能レベル2で判定。その結果(成功・失敗,ダメージ,クリティカル,ファンブル)を表示
+        ■防御判定　[+-b]AG=t        t:攻撃技能レベル b:修正値(省略可能)
+        例)AG=2: ダイスを3個振って、攻撃技能レベル2で判定。その結果(成功・失敗,ダメージ軽減,クリティカル,ファンブル)を表示
 
-        ■回避判定　AD=t        t:攻撃技能レベル
+        ■回避判定　[+-b]AD=t        t:攻撃技能レベル b:修正値(省略可能)
         例)AD=3: ダイスを1個振って、攻撃技能レベル3で判定。その結果(成功・失敗)を表示
       INFO_MESSAGETEXT
 
-      register_prefix('\d*A[MIAGD]')
+      register_prefix('[-+\d]*A[MIAGD]')
 
       def initialize(command)
         super(command)
@@ -48,27 +48,53 @@ module BCDice
 
       private
 
+      def with_symbol(number)
+        if number == 0
+          return ""
+        elsif number > 0
+          return "+#{number}"
+        else
+          return number.to_s
+        end
+      end
+
       # ステータスの判定
       # @param [String] command
       # @return [Result]
       def resolute_action(command)
-        m = /^(\d+)AM<=(\d+),(\d)$/.match(command)
+        m = /^(\d+)([-+]\d+)?AM<=(\d+),(\d)$/.match(command)
         return nil unless m
 
         num_dice = m[1].to_i
-        num_target = m[2].to_i
-        num_success = m[3].to_i
+        num_bonus = m[2].to_i
+        num_target = m[3].to_i
+        num_success = m[4].to_i
 
-        dice = @randomizer.roll_barabara(num_dice, 6).sort
+        dice = @randomizer.roll_barabara(num_dice + num_bonus, 6).sort
         dice_text = dice.join(",")
         success_num = dice.count { |val| val <= num_target }
-        output = "(#{num_dice}AM<=#{num_target},#{num_success}) ＞ #{dice_text} ＞ 成功数#{success_num}"
-        if success_num >= num_success
-          output += " ＞ 成功"
-          return Result.success(output)
-        else
-          output += " ＞ 失敗"
-          return Result.failure(output)
+        is_critical = dice.include?(1) && dice.include?(2) && dice.include?(3)
+        is_fumble = dice.include?(4) && dice.include?(5) && dice.include?(6)
+
+        return Result.new.tap do |result|
+          result.critical = is_critical
+          result.fumble = is_fumble
+          result.condition = (success_num >= num_success)
+
+          sequence = [
+            "(#{num_dice}#{with_symbol(num_bonus)}AM<=#{num_target},#{num_success})",
+            dice_text,
+            "成功数#{success_num}",
+            if result.success?
+              "成功"
+            else
+              "失敗"
+            end
+          ].compact
+          sequence.push("クリティカル") if result.critical?
+          sequence.push("ファンブル") if result.fumble?
+
+          result.text = sequence.join(" ＞ ")
         end
       end
 
@@ -76,22 +102,38 @@ module BCDice
       # @param [String] command
       # @return [Result]
       def resolute_investigation(command)
-        m = /^AI<=(\d+),(\d)$/.match(command)
+        m = /^([-+]\d+)?AI<=(\d+),(\d)$/.match(command)
         return nil unless m
 
-        num_target = m[1].to_i
-        num_success = m[2].to_i
+        num_bonus = m[1].to_i
+        num_target = m[2].to_i
+        num_success = m[3].to_i
 
-        dice = @randomizer.roll_barabara(3, 6).sort
+        dice = @randomizer.roll_barabara(3 + num_bonus, 6).sort
         dice_text = dice.join(",")
         success_num = dice.count { |val| val <= num_target }
-        output = "(AI<=#{num_target},#{num_success}) ＞ #{dice_text} ＞ 成功数#{success_num}"
-        if success_num >= num_success
-          output += " ＞ 成功"
-          return Result.success(output)
-        else
-          output += " ＞ 失敗"
-          return Result.failure(output)
+        is_critical = dice.include?(1) && dice.include?(2) && dice.include?(3)
+        is_fumble = dice.include?(4) && dice.include?(5) && dice.include?(6)
+
+        return Result.new.tap do |result|
+          result.critical = is_critical
+          result.fumble = is_fumble
+          result.condition = (success_num >= num_success)
+
+          sequence = [
+            "(#{with_symbol(num_bonus)}AI<=#{num_target},#{num_success})",
+            dice_text,
+            "成功数#{success_num}",
+            if result.success?
+              "成功"
+            else
+              "失敗"
+            end
+          ].compact
+          sequence.push("クリティカル") if result.critical?
+          sequence.push("ファンブル") if result.fumble?
+
+          result.text = sequence.join(" ＞ ")
         end
       end
 
@@ -99,25 +141,25 @@ module BCDice
       # @param [String] command
       # @return [Result]
       def resolute_attacking(command)
-        m = /^AA<=(\d+)$/.match(command)
+        m = /^([-+]\d+)?AA<=(\d+)$/.match(command)
         return nil unless m
 
-        num_target = m[1].to_i
+        num_bonus = m[1].to_i
+        num_target = m[2].to_i
 
-        dice = @randomizer.roll_barabara(3, 6).sort
+        dice = @randomizer.roll_barabara(3 + num_bonus, 6).sort
         dice_text = dice.join(",")
         success_num = dice.count { |val| val <= num_target }
-        is_critical = dice[0] == 1 && dice[1] == 2 && dice[2] == 3
-        is_fumble = dice[0] == 4 && dice[1] == 5 && dice[2] == 6
+        is_critical = dice.include?(1) && dice.include?(2) && dice.include?(3)
+        is_fumble = dice.include?(4) && dice.include?(5) && dice.include?(6)
+
         damage1 = dice.max
         damage2 = dice.max
-        if dice[0] == dice[1] && dice[1] == dice[2] && dice[2] <= num_target
-          damage2 += 6
-          damage1 = damage2
-        elsif dice[0] == dice[1] && dice[1] <= num_target
-          damage2 += 3
-        elsif dice[1] == dice[2] && dice[2] <= num_target
-          damage2 += 3
+        (1..num_target).each do |idx|
+          if dice.count(idx) > 1
+            now_damage = damage1 + 3 * (dice.count(idx) - 1)
+            damage2 = now_damage if damage2 < now_damage
+          end
         end
 
         return Result.new.tap do |result|
@@ -126,7 +168,7 @@ module BCDice
           result.condition = (success_num > 0)
 
           sequence = [
-            "(AA<=#{num_target})",
+            "(#{with_symbol(num_bonus)}AA<=#{num_target})",
             dice_text,
             "成功数#{success_num}",
             if result.success?
@@ -136,11 +178,7 @@ module BCDice
             end
           ].compact
           if result.success?
-            if damage1 == damage2
-              sequence.push("ダメージ(#{damage1})")
-            else
-              sequence.push("ダメージ(#{damage1}か#{damage2})")
-            end
+            sequence.push("最大ダメージ(#{damage2})")
           end
           sequence.push("クリティカル") if result.critical?
           sequence.push("ファンブル") if result.fumble?
@@ -153,16 +191,17 @@ module BCDice
       # @param [String] command
       # @return [Result]
       def resolute_guarding(command)
-        m = /^AG=(\d+)$/.match(command)
+        m = /^([-+]\d+)?AG=(\d+)$/.match(command)
         return nil unless m
 
-        num_target = m[1].to_i
+        num_bonus = m[1].to_i
+        num_target = m[2].to_i
 
-        dice = @randomizer.roll_barabara(3, 6).sort
+        dice = @randomizer.roll_barabara(3 + num_bonus, 6).sort
         dice_text = dice.join(",")
         success_num = dice.count(num_target)
-        is_critical = dice[0] == 1 && dice[1] == 2 && dice[2] == 3
-        is_fumble = dice[0] == 4 && dice[1] == 5 && dice[2] == 6
+        is_critical = dice.include?(1) && dice.include?(2) && dice.include?(3)
+        is_fumble = dice.include?(4) && dice.include?(5) && dice.include?(6)
 
         return Result.new.tap do |result|
           result.critical = is_critical
@@ -170,7 +209,7 @@ module BCDice
           result.condition = (success_num > 0)
 
           sequence = [
-            "(AG=#{num_target})",
+            "(#{with_symbol(num_bonus)}AG=#{num_target})",
             dice_text,
             "成功数#{success_num}",
             if result.success?
@@ -190,12 +229,13 @@ module BCDice
       # @param [String] command
       # @return [Result]
       def resolute_dodging(command)
-        m = /^AD=(\d+)$/.match(command)
+        m = /^([-+]\d+)?AD=(\d+)$/.match(command)
         return nil unless m
 
-        num_target = m[1].to_i
+        num_bonus = m[1].to_i
+        num_target = m[2].to_i
 
-        dice = @randomizer.roll_barabara(1, 6)
+        dice = @randomizer.roll_barabara(1 + num_bonus, 6)
         dice_text = dice.join(",")
         success_num = dice.count(num_target)
 
@@ -203,7 +243,7 @@ module BCDice
           result.condition = (success_num > 0)
 
           sequence = [
-            "(AD=#{num_target})",
+            "(#{with_symbol(num_bonus)}AD=#{num_target})",
             dice_text,
             "成功数#{success_num}",
             if result.success?

data/lib/bcdice/game_system/Arianrhod_Korean.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "bcdice/game_system/Arianrhod"
+
+module BCDice
+  module GameSystem
+    class Arianrhod_Korean < Arianrhod
+      # ゲームシステムの識別子
+      ID = 'Arianrhod:Korean'
+
+      # ゲームシステム名
+      NAME = '아리안로드RPG'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:아리안로드RPG'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ・크리티컬, 펌블의 자동판정을 행합니다.(크리티컬 시의 추가 대미지도 표시됩니다)
+        ・D66 다이스 있음
+      INFO_MESSAGE_TEXT
+
+      def initialize(command)
+        super(command)
+
+        @locale = :ko_kr
+      end
+
+      register_prefix_from_super_class()
+    end
+  end
+end