bcdice 3.8.0 → 3.10.0

data/lib/bcdice/game_system/KemonoNoMori.rb

@@ -25,7 +25,7 @@ module BCDice
              例2）KC6 → 目標値6の継続判定
         ・罠動作チェック+獲物表(P163): CTR
            罠ごとに1D12を振り、12が出た場合には生き物が罠を動作させ、その影響を受けている。
-        ・各種表
+        ・各種表（基本ルールブック）
           ・大失敗表(P120): FT
           ・能力値ランダム決定表(P121): RST
           ・ランダム所要時間表(P122): RTT
@@ -38,6 +38,16 @@ module BCDice
           ・食材採集表(P157): GFT
           ・水採集表(P157): GWT
           ・白の魔石効果表(P186): WST
+        ・部位ダメージ関連の表（参照先ページはリプレイ&データブック「嚙神ノ宴」のもの）
+          ・人間部位表(P216): HPT
+          ・部位ダメージ段階表(P217): PDT
+          ・四足動物部位表(P225): QPT
+          ・無足動物部位表(P225): APT
+          ・二足動物部位表(P226): TPT
+          ・鳥部位表(P226): BPT
+          ・頭足動物部位表(P227): CPT
+          ・昆虫部位表(P227): IPT
+          ・蜘蛛部位表(P228): SPT
       MESSAGETEXT
 
       def eval_game_system_specific_command(command)
@@ -237,6 +247,128 @@ module BCDice
             '大型動物を召喚する',
           ]
         ),
+        'HPT' => DiceTable::RangeTable.new(
+          '人間部位表',
+          '1D12',
+          [
+            [1..2,  '右腕部'],
+            [3..4,  '左腕部'],
+            [5..6,  '右脚部'],
+            [7..8,  '左脚部'],
+            [9..11, '胴部'],
+            [12,    '頭部'],
+          ]
+        ),
+        'PDT' => DiceTable::RangeTable.new(
+          '部位ダメージ段階表',
+          '1D12',
+          [
+            [1..6,  '軽傷'],
+            [7..10, '重傷'],
+            [11,    '破壊'],
+            [12,    '喪失'],
+          ]
+        ),
+        'QPT' => DiceTable::RangeTable.new(
+          '四足動物部位表',
+          '1D12',
+          [
+            [1..2,    '異形'],
+            [3,       '武器'],
+            [4,       '右前脚部'],
+            [5,       '左前脚部'],
+            [6,       '右後脚部'],
+            [7,       '左後脚部'],
+            [8..10,   '胴部'],
+            [11..12,  '頭部'],
+          ]
+        ),
+        'APT' => DiceTable::RangeTable.new(
+          '無足動物部位表',
+          '1D12',
+          [
+            [1..3,    '異形'],
+            [4..6,    '武器'],
+            [7..10,   '胴部'],
+            [11..12,  '頭部'],
+          ]
+        ),
+        'TPT' => DiceTable::RangeTable.new(
+          '二足動物部位表',
+          '1D12',
+          [
+            [1,     '異形'],
+            [2,     '武器'],
+            [3,     '右腕部'],
+            [4,     '左腕部'],
+            [5..6,  '右脚部'],
+            [7..8,  '左脚部'],
+            [9..11, '胴部'],
+            [12,    '頭部'],
+          ]
+        ),
+        'BPT' => DiceTable::RangeTable.new(
+          '鳥部位表',
+          '1D12',
+          [
+            [1,     '異形'],
+            [2,     '武器'],
+            [3..4,  '右翼(右腕部)'],
+            [5..6,  '左翼(左腕部)'],
+            [7,     '右脚部'],
+            [8,     '左脚部'],
+            [9..11, '胴部'],
+            [12,    '頭部'],
+          ]
+        ),
+        'CPT' => DiceTable::RangeTable.new(
+          '頭足動物部位表',
+          '1D12',
+          [
+            [1,     '異形'],
+            [2,     '武器'],
+            [3,     '右腕部'],
+            [4,     '左腕部'],
+            [5..7,  '右脚部'],
+            [8..10, '左脚部'],
+            [11,    '胴部'],
+            [12,    '頭部'],
+          ]
+        ),
+        'IPT' => DiceTable::RangeTable.new(
+          '昆虫部位表',
+          '1D12',
+          [
+            [1..2,    '異形'],
+            [3,       '武器'],
+            [4,       '右前脚部'],
+            [5,       '左前脚部'],
+            [6,       '右中脚部'],
+            [7,       '左中脚部'],
+            [8,       '右後脚部'],
+            [9,       '左後脚部'],
+            [10..11,  '胴部'],
+            [12,      '頭部'],
+          ]
+        ),
+        'SPT' => DiceTable::RangeTable.new(
+          '蜘蛛部位表',
+          '1D12',
+          [
+            [1,   '異形'],
+            [2,   '武器'],
+            [3,   '右第一脚部'],
+            [4,   '左第一脚部'],
+            [5,   '右第二脚部'],
+            [6,   '左第二脚部'],
+            [7,   '右第三脚部'],
+            [8,   '左第三脚部'],
+            [9,   '右第四脚部'],
+            [10,  '左第四脚部'],
+            [11,  '胴部'],
+            [12,  '頭部'],
+          ]
+        ),
       }.freeze
 
       register_prefix('K[AC]', 'CTR', TABLES.keys)

data/lib/bcdice/game_system/MonotoneMuseum.rb

@@ -59,7 +59,7 @@ module BCDice
       private
 
       def check_roll(command)
-        m = /^(\d+)D6([+\-\d]*)>=(\d+)(\[(\d+)?(,(\d+))?\])?$/i.match(command)
+        m = /^(\d+)D6([+\-\d]*)>=(\?|\d+)(\[(\d+)?(,(\d+))?\])?$/i.match(command)
         unless m
           return nil
         end
@@ -80,6 +80,8 @@ module BCDice
             Result.fumble(translate("MonotoneMuseum.automatic_failure"))
           elsif dice_value >= critical
             Result.critical(translate("MonotoneMuseum.automatic_success"))
+          elsif target == 0
+            Result.success(nil)
           elsif total >= target
             Result.success(translate("success"))
           else
@@ -91,7 +93,7 @@ module BCDice
           "#{dice_value}[#{dice_str}]#{Format.modifier(modify_number)}",
           total.to_s,
           result.text,
-        ]
+        ].compact
 
         result.text = sequence.join(" ＞ ")
 

data/lib/bcdice/game_system/NSSQ.rb

@@ -8,24 +8,26 @@ module BCDice
       SORT_KEY = "えすああるえすしやないせかいしゆのめいきゆうTRPG"
 
       HELP_MESSAGE = <<~MESSAGETEXT
-        ■ 判定 (xSQ±y)
-          xD6の判定。3つ以上振ったとき、出目の高い2つを表示します。クリティカル、ファンブルも計算します。
+        ■ 判定 (xSQ±y>=z)
+          xD6の判定。3つ以上振ったとき、出目の高い2つを表示します。絶対成功、絶対失敗も計算します。
+          2つのサイコロを使用して出目に1があった場合は、FPの獲得も表示します。3つ以上使用した場合は表示しません。
           ±y: yに修正値を入力。±の計算に対応。省略可能。
+          z: 目標値。省略可能。
 
         ■ ダメージロール (xDR(C)(+)y)
-          xD6のダメージロール。クリティカルの自動判定を行います。Cを付けるとクリティカルアップ状態で計算できます。+を付けるとクリティカル時のダイスが8個になります。
+          xD6のダメージロール。クリティカルヒットの自動判定を行います。Cを付けるとクリティカルアップ状態で計算できます。+を付けるとクリティカルヒット時のダイスが8個になります。
           x: xに振るダイス数を入力。
           y: yに耐性を入力。
           例) 5DR3 5DRC4 5DRC+4
 
         ■ 回復ロール (xHRy)
-          xD6の回復ロール。クリティカルが発生しません。
+          xD6の回復ロール。クリティカルヒットが発生しません。
           x: xに振るダイス数を入力。
           y: yに耐性を入力。省略した場合3。
           例) 2HR 10HR2
 
-        ■ 採取ロール (TC±z,SC±z,GC±z)
-          ちょっと(T)、そこそこ(S)、がっつり(G)採取採掘伐採を行う。
+        ■ 採集ロール (TC±z,SC±z,GC±z)
+          少しだけ(T)、そこそこ(S)、ガッツリ(G)採取採掘伐採を行います。
           z: zに追加でロールする回数を入力。省略可能。
           例) TC SC+1 GC-1
       MESSAGETEXT
@@ -40,27 +42,38 @@ module BCDice
 
       # 判定
       def roll_sq(command)
-        m = /(\d+)SQ([+\-\d]+)?/i.match(command)
+        m = /(\d+)SQ([+\-\d]+)?(([>=]+)(\d+))?/i.match(command)
         return nil unless m
 
         dice_count = m[1].to_i
         modifier = ArithmeticEvaluator.eval(m[2])
+        target = m[5].nil? ? nil : m[5].to_i
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
         largest_two = dice_list.sort.reverse.take(2)
         total = largest_two.sum + modifier
+        num_1 = dice_list.count(1)
 
         additional_result =
           if largest_two == [6, 6]
-            " クリティカル！"
+            Result.critical(" ＞ 絶対成功！")
           elsif largest_two == [1, 1]
-            " ファンブル！"
+            Result.fumble(" ＞ 絶対失敗！")
+          elsif target && total >= target
+            Result.success(" ＞ 成功")
+          elsif target && total < target
+            Result.failure(" ＞ 失敗")
+          else
+            Result.new
           end
 
+        # ダイス数が2個の場合は1の出目の数だけ【FP】を獲得できる
+        fp_result = dice_count == 2 && num_1 >= 1 ? " (【FP】#{num_1}獲得)" : ""
+
         sequence = [
           "(#{command})",
           "[#{dice_list.join(',')}]#{Format.modifier(modifier)}",
-          "#{total}[#{largest_two.join(',')}]#{additional_result}",
+          "#{total}[#{largest_two.join(',')}]#{additional_result.text}#{fp_result}",
         ]
 
         return sequence.join(" ＞ ")
@@ -83,7 +96,7 @@ module BCDice
         critical_target = critical_up ? 1 : 2
 
         if dice_list.count(6) - dice_list.count(1) >= critical_target
-          result += " クリティカル！\n"
+          result += " クリティカルヒット！\n"
           result += additional_damage_roll(increase_critical_dice, resist)
         end
 

data/lib/bcdice/game_system/SRS.rb

@@ -16,27 +16,33 @@ module BCDice
 
       HELP_MESSAGE_1 = <<~HELP_MESSAGE
         ・判定
-        　・通常判定：2D6+m>=t[c,f]
+        　・通常判定：2D6+m@c#f>=t または 2D6+m>=t[c,f]
         　　修正値m、目標値t、クリティカル値c、ファンブル値fで判定ロールを行います。
-        　　修正値、クリティカル値、ファンブル値は省略可能です（[]ごと省略可）。
+        　　修正値、クリティカル値、ファンブル値は省略可能です（[]ごと省略可、@c・#fの指定は順不同）。
         　　クリティカル値、ファンブル値の既定値は、それぞれ12、2です。
         　　自動成功、自動失敗、成功、失敗を自動表示します。
 
         　　例) 2d6>=10　　　　　修正値0、目標値10で判定
         　　例) 2d6+2>=10　　　　修正値+2、目標値10で判定
         　　例) 2d6+2>=10[11]　　↑をクリティカル値11で判定
+        　　例) 2d6+2@11>=10 　　↑をクリティカル値11で判定
         　　例) 2d6+2>=10[12,4]　↑をクリティカル値12、ファンブル値4で判定
+        　　例) 2d6+2@12#4>=10 　↑をクリティカル値12、ファンブル値4で判定
+        　　例) 2d6+2>=10[,4]　　↑をクリティカル値12、ファンブル値4で判定（クリティカル値の省略）
+        　　例) 2d6+2#4>=10　　　↑をクリティカル値12、ファンブル値4で判定（クリティカル値の省略）
       HELP_MESSAGE
 
       HELP_MESSAGE_2 = <<~HELP_MESSAGE
-        　・クリティカルおよびファンブルのみの判定：2D6+m[c,f]
+        　・クリティカルおよびファンブルのみの判定：2D6+m@c#f または 2D6+m[c,f]
         　　目標値を指定せず、修正値m、クリティカル値c、ファンブル値fで判定ロールを行います。
-        　　修正値、クリティカル値、ファンブル値は省略可能です（[]は省略不可）。
+        　　修正値、クリティカル値、ファンブル値は省略可能です（[]は省略不可、@c・#fの指定は順不同）。
         　　自動成功、自動失敗を自動表示します。
 
         　　例) 2d6[]　　　　修正値0、クリティカル値12、ファンブル値2で判定
         　　例) 2d6+2[11]　　修正値+2、クリティカル値11、ファンブル値2で判定
+        　　例) 2d6+2@11 　　修正値+2、クリティカル値11、ファンブル値2で判定
         　　例) 2d6+2[12,4]　修正値+2、クリティカル値12、ファンブル値4で判定
+        　　例) 2d6+2@12#4 　修正値+2、クリティカル値12、ファンブル値4で判定
       HELP_MESSAGE
 
       HELP_MESSAGE_3 = <<~HELP_MESSAGE
@@ -50,18 +56,14 @@ module BCDice
 
       # 成功判定のエイリアスコマンド定義用のクラスメソッドを提供するモジュール
       module ClassMethods
+        # 成功判定のエイリアスコマンドの一覧
+        # @return [Array<String>]
+        attr_reader :aliases
+
         # ダイスボットの説明文を返す
         # @return [String]
         attr_reader :help_message
 
-        # 目標値あり成功判定のエイリアスコマンドの正規表現を返す
-        # @return [Regexp, nil]
-        attr_reader :aliases_re_for_srs_roll_with_target_value
-
-        # 目標値なし成功判定のエイリアスコマンドの正規表現を返す
-        # @return [Regexp, nil]
-        attr_reader :aliases_re_for_srs_roll_without_target_value
-
         # 成功判定のエイリアスコマンドを設定する
         # @param [String] aliases エイリアスコマンド（可変長引数）
         # @return [self]
@@ -70,71 +72,48 @@ module BCDice
         # 実行時にそれが2D6に置換されるようになる。
         def set_aliases_for_srs_roll(*aliases)
           aliases_upcase = aliases.map(&:upcase)
-          aliases_part = aliases_upcase
-                         .map { |a| Regexp.escape(a) }
-                         .join('|')
-
-          @aliases_re_for_srs_roll_with_target_value = Regexp.new(
-            '\A' \
-            "(?:#{aliases_part})" \
-            '((?:[-+][-+\d]+)?>=\d+(?:\[\d*(?:,\d+)?\])?)\z'
-          )
-
-          @aliases_re_for_srs_roll_without_target_value = Regexp.new(
-            '\A' \
-            "(?:#{aliases_part})" \
-            '([-+][-+\d]+)?(\[\d*(?:,\d+)?\])?\z'
-          )
-
-          prepare_help_msg_for_aliases_for_srs_roll(aliases_upcase)
-          @help_message = concatenate_help_messages
 
+          @aliases = aliases_upcase.map { |a| Regexp.escape(a) }
+          @help_message = concatenate_help_messages(aliases_upcase)
           return self
         end
 
         # 成功判定のエイリアスコマンドを未設定にする
         # @return [self]
         def clear_aliases_for_srs_roll
-          @aliases_re_for_srs_roll_with_target_value = nil
-          @aliases_re_for_srs_roll_without_target_value = nil
+          @aliases = []
           @help_message = SRS::DEFAULT_HELP_MESSAGE
-
           return self
         end
 
         private
 
-        # 成功判定のエイリアスコマンドの説明文を用意する
+        # ダイスボットの説明文を結合する
         # @param [Array<String>] aliases エイリアスコマンドの配列
-        # @return [self]
+        # @return [String] 結合された説明文
         # @todo 現在は2文字のエイリアスコマンドに幅を合わせてある。
         #   エイリアスコマンドの文字数が変わる場合があれば、位置を調整するコードが
         #   必要。
-        def prepare_help_msg_for_aliases_for_srs_roll(aliases)
-          @help_msg_for_aliases_for_srs_roll_with_target_value =
+        def concatenate_help_messages(aliases)
+          help_msg_for_aliases_for_target_value =
             aliases
-            .map { |a| "　　例) #{a}+2>=10　　　　 2d6+2>=10と同じ（#{a}が2D6のショートカットコマンド）\n" }
+            .map do |a|
+              "　　例) #{a}+2>=10　　　　 2d6+2>=10と同じ（#{a}が2D6のショートカットコマンド）\n"
+            end
             .join()
-
-          @help_msg_for_aliases_for_srs_roll_without_target_value =
+          help_msg_for_aliases_for_without_target_value =
             aliases
             .map do |a|
               "　　例) #{a}　　　　　 2d6[]と同じ（#{a}が2D6のショートカットコマンド）\n" \
-              "　　例) #{a}+2[12,4]　 2d6+2[12,4]と同じ（#{a}が2D6のショートカットコマンド）\n"
+              "　　例) #{a}+2@12#4　　2d6+2@12#4と同じ（#{a}が2D6のショートカットコマンド）\n"
             end
             .join()
 
-          return self
-        end
-
-        # ダイスボットの説明文を結合する
-        # @return [String] 結合された説明文
-        def concatenate_help_messages
-          "#{SRS::HELP_MESSAGE_1}" \
-            "#{@help_msg_for_aliases_for_srs_roll_with_target_value}\n" \
-            "#{SRS::HELP_MESSAGE_2}" \
-            "#{@help_msg_for_aliases_for_srs_roll_without_target_value}\n" \
-            "#{SRS::HELP_MESSAGE_3}"
+          return "#{SRS::HELP_MESSAGE_1}" \
+                 "#{help_msg_for_aliases_for_target_value}\n" \
+                 "#{SRS::HELP_MESSAGE_2}" \
+                 "#{help_msg_for_aliases_for_without_target_value}\n" \
+                 "#{SRS::HELP_MESSAGE_3}"
         end
       end
 
@@ -153,16 +132,10 @@ module BCDice
           DEFAULT_HELP_MESSAGE
         end
 
-        # 目標値あり成功判定のエイリアスコマンドの正規表現を返す
-        # @return [nil]
-        def aliases_re_for_srs_roll_with_target_value
-          nil
-        end
-
-        # 目標値なし成功判定のエイリアスコマンドの正規表現を返す
-        # @return [nil]
-        def aliases_re_for_srs_roll_without_target_value
-          nil
+        # 成功判定のエイリアスコマンドの一覧
+        # @return [Array<String>]
+        def aliases
+          []
         end
       end
 
@@ -187,22 +160,17 @@ module BCDice
         self.class.help_message
       end
 
+      # 成功判定のエイリアスコマンドの一覧
+      # @return [Array<String>]
+      def aliases
+        self.class.aliases
+      end
+
       # 既定のクリティカル値
       DEFAULT_CRITICAL_VALUE = 12
       # 既定のファンブル値
       DEFAULT_FUMBLE_VALUE = 2
 
-      # 目標値あり成功判定の正規表現
-      SRS_ROLL_WITH_TARGET_VALUE_RE =
-        /\A2D6([-+][-+\d]+)?>=(\d+)(?:\[(\d+)?(?:,(\d+))?\])?\z/.freeze
-      # 目標値なし成功判定の正規表現
-      SRS_ROLL_WITHOUT_TARGET_VALUE_RE =
-        /\A2D6([-+][-+\d]+)?\[(\d+)?(?:,(\d+))?\]\z/.freeze
-
-      # 既定の閾値指定表記
-      SRS_ROLL_DEFAULT_THRESHOLDS =
-        "[#{DEFAULT_CRITICAL_VALUE},#{DEFAULT_FUMBLE_VALUE}]"
-
       # 成功判定コマンドのノード
       SRSRollNode = Struct.new(
         :modifier, :critical_value, :fumble_value, :target_value
@@ -221,9 +189,15 @@ module BCDice
       # @param [String] command 入力されたコマンド
       # @return [Result, nil] ダイスロールコマンドの実行結果
       def eval_game_system_specific_command(command)
-        alias_replaced_with_2d6 = replace_alias_for_srs_roll_with_2d6(command)
-
-        if (node = parse(alias_replaced_with_2d6))
+        legacy_c_f_match = /(.+)\[(.*)\]\z/.match(command)
+        node =
+          if legacy_c_f_match
+            parse_legacy(legacy_c_f_match[1], legacy_c_f_match[2])
+          else
+            parse(command)
+          end
+
+        if node
           return execute_srs_roll(node)
         end
 
@@ -232,67 +206,46 @@ module BCDice
 
       private
 
-      # 成功判定のエイリアスコマンドを2D6に置換する
-      # @param [String] input 入力文字列
-      # @return [String]
-      def replace_alias_for_srs_roll_with_2d6(input)
-        case input
-        when self.class.aliases_re_for_srs_roll_with_target_value
-          return "2D6#{Regexp.last_match(1)}"
-        when self.class.aliases_re_for_srs_roll_without_target_value
-          modifier = Regexp.last_match(1)
-          thresholds = Regexp.last_match(2) || SRS_ROLL_DEFAULT_THRESHOLDS
-
-          return "2D6#{modifier}#{thresholds}"
-        else
-          return input
+      def parse(command)
+        prefix_re = Regexp.new(["2D6"].concat(aliases()).join('|'), Regexp::IGNORECASE)
+        parser = Command::Parser.new(prefix_re, round_type: @round_type)
+                                .enable_critical
+                                .enable_fumble
+                                .restrict_cmp_op_to(nil, :>=)
+        cmd = parser.parse(command)
+        unless cmd
+          return nil
         end
-      end
 
-      # 構文解析する
-      # @param [String] command コマンド文字列
-      # @return [SRSRollNode, nil]
-      def parse(command)
-        case command
-        when SRS_ROLL_WITH_TARGET_VALUE_RE
-          return parse_srs_roll_with_target_value(Regexp.last_match)
-        when SRS_ROLL_WITHOUT_TARGET_VALUE_RE
-          return parse_srs_roll_without_target_value(Regexp.last_match)
-        else
+        if command.start_with?(/2D6/i) && cmd.critical.nil? && cmd.fumble.nil? && cmd.target_number.nil?
+          # fallback to default dice
           return nil
         end
-      end
 
-      # 修正値を評価する
-      # @param [String, nil] modifier_str 修正値部分の文字列
-      # @return [Integer] 修正値
-      def eval_modifier(modifier_str)
-        return 0 unless modifier_str
+        cmd.critical ||= DEFAULT_CRITICAL_VALUE
+        cmd.fumble ||= DEFAULT_FUMBLE_VALUE
 
-        return ArithmeticEvaluator.eval(modifier_str, round_type: @round_type)
+        return SRSRollNode.new(cmd.modify_number, cmd.critical, cmd.fumble, cmd.target_number)
       end
 
-      # 目標値あり成功判定の正規表現マッチ情報からノードを作る
-      # @param [MatchData] m 正規表現のマッチ情報
-      # @return [SRSRollNode]
-      def parse_srs_roll_with_target_value(m)
-        modifier = eval_modifier(m[1])
-        target_value = m[2].to_i
-        critical_value = m[3]&.to_i || DEFAULT_CRITICAL_VALUE
-        fumble_value = m[4]&.to_i || DEFAULT_FUMBLE_VALUE
+      def parse_legacy(command, c_f)
+        m = /^(-?\d+)?(?:,(-?\d+))?$/.match(c_f)
+        unless m
+          return nil
+        end
 
-        return SRSRollNode.new(modifier, critical_value, fumble_value, target_value)
-      end
+        critical = m[1]&.to_i || DEFAULT_CRITICAL_VALUE
+        fumble = m[2]&.to_i || DEFAULT_FUMBLE_VALUE
 
-      # 目標値なし成功判定の正規表現マッチ情報からノードを作る
-      # @param [MatchData] m 正規表現のマッチ情報
-      # @return [SRSRollNode]
-      def parse_srs_roll_without_target_value(m)
-        modifier = eval_modifier(m[1])
-        critical_value = m[2]&.to_i || DEFAULT_CRITICAL_VALUE
-        fumble_value = m[3]&.to_i || DEFAULT_FUMBLE_VALUE
+        prefix_re = Regexp.new(["2D6"].concat(aliases()).join('|'), Regexp::IGNORECASE)
+        parser = Command::Parser.new(prefix_re, round_type: @round_type)
+                                .restrict_cmp_op_to(nil, :>=)
+        cmd = parser.parse(command)
+        unless cmd
+          return nil
+        end
 
-        return SRSRollNode.new(modifier, critical_value, fumble_value, nil)
+        return SRSRollNode.new(cmd.modify_number, critical, fumble, cmd.target_number)
       end
 
       # 成功判定を実行する