bcdice 3.13.0 → 3.15.0

data/lib/bcdice/game_system/KizunaBullet.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "bcdice/game_system/kizuna_bullet/tables"
+
+module BCDice
+  module GameSystem
+    class KizunaBullet < Base
+      # ゲームシステムの識別子
+      ID = 'KizunaBullet'
+
+      # ゲームシステム名
+      NAME = 'キズナバレット'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'きすなはれつと'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~MESSAGETEXT
+        ・ダイスロール
+        nDM…n個の6面ダイスを転がして、一番高い出目を採用します。
+        ・［調査判定］
+        nIN…n個の6面ダイスを転がして、一番高い出目が5以上なら成功します。（［パートナーのヘルプ］使用可）
+        ・［鎮静判定］
+        SEn…2個の6面ダイスを転がして、出目の合計値がn（［ヒビワレ］状態の［キズナ］の個数）より高いと成功します。（［強制鎮静］使用可）
+        ・［解決］ ［アクション］のダメージと［アクシデント］のダメージ軽減
+        nSO…2+n個の6面ダイスを転がして、出目をすべて合計します。（nは減らした【励起値】。省略可能）
+        ・各種表
+        日常表・場所 OP
+        日常表・内容 OC
+        日常表・場所と内容 OPC
+        日常表（仕事）・場所 OWP
+        日常表（仕事）・内容 OWC
+        日常表（仕事）・場所と内容 OWPC
+        日常表（休暇）・場所 OHP
+        日常表（休暇）・内容 OHC
+        日常表（休暇）・場所と内容 OHPC
+        日常表（出張）・場所 OTP
+        日常表（出張）・内容 OTC
+        日常表（出張）・場所と内容 OTPC
+        ターンテーマ表 TT
+        ターンテーマ表・親密 TTI
+        ターンテーマ表・クール TTC
+        ターンテーマ表・主従 TTH
+        遭遇表・場所 EP
+        遭遇表・登場順 EO
+        遭遇表・状況（初対面） EF
+        遭遇表・状況（知り合い） EA
+        遭遇表・決着 EE
+        遭遇表・場所と登場順と状況（初対面）と決着 EFA
+        遭遇表・場所と登場順と状況（知り合い）と決着 EAA
+        交流表・場所 CP
+        交流表・内容 CC
+        交流表・場所と内容 CPC
+        調査表・ベーシック IB
+        調査表・ダイナミック ID
+        調査表・ベーシックとダイナミック IBD
+        ハザード表 HA
+        通常ダイジェスト　キミたちに新しい命令が下った（調査が依頼された）。
+        1:その事件の内容は…… NI1
+        2:捜査に向かった場所は…… NI2
+        3:犯人のキセキ使いは…… NI3
+        4:起きた出来事は…… NI4
+        5:バレットの間では…… NI5
+        6:戦いの結末は…… NI6
+        通常ダイジェスト　キミたちは旅行（出張）である場所を訪れた。
+        1:その場所とは…… NT1
+        2:そこで始まったのは…… NT2
+        3:極限状態のなかで…… NT3
+        4:犯人のキセキ使いは…… NT4
+        5:バレットの間では…… NT5
+        6:戦いの結末は…… NT6
+        ホリデーダイジェスト　キミたちは休日に出かけることにした。
+        1:その場所とは…… HH1
+        2:待ち合わせをしたら…… HH2
+        3:そしてなんと…… HH3
+        4:ふたりが決めたのは…… HH4
+        5:結果的に…… HH5
+        6:バレットは最後に…… HH6
+        ホリデーダイジェスト　キミたちは奇妙な事件に出くわした。
+        1:その場所とは…… HC1
+        2:起きた事件は…… HC2
+        3:犯人のキセキ使いは…… HC3
+        4:犯人を追い詰めるべく…… HC4
+        5:戦いの結果は…… HC5
+        6:バレットは最後に…… HC6
+      MESSAGETEXT
+
+      TABLES = translate_tables(@locale)
+
+      def initialize(command)
+        super(command)
+
+        @sides_implicit_d = 6
+        @round_type = RoundType::CEIL
+        @d66_sort_type = D66SortType::NO_SORT
+      end
+
+      def eval_game_system_specific_command(command)
+        roll_max(command) || roll_investigate(command) || roll_sedative(command) || roll_solve(command) || roll_tables(command, self.class::TABLES)
+      end
+
+      private
+
+      # 最大値
+      def roll_max(command)
+        parser = Command::Parser.new("DM", round_type: @round_type)
+                                .has_prefix_number
+        parsed = parser.parse(command)
+        unless parsed
+          return nil
+        end
+
+        # 最大値計算
+        dice_list = @randomizer.roll_barabara(parsed.prefix_number, 6)
+        max = dice_list.max
+
+        return Result.new.tap do |r|
+          # テキストを整形
+          r.text = "#{command} ＞ [#{dice_list.join(',')}] ＞ #{max}"
+        end
+      end
+
+      # 調査判定
+      def roll_investigate(command)
+        parser = Command::Parser.new("IN", round_type: @round_type)
+                                .has_prefix_number
+        parsed = parser.parse(command)
+        unless parsed
+          return nil
+        end
+
+        texts = []
+        is_success = false
+        is_fumble = false
+
+        # 最大値計算
+        dice_list = @randomizer.roll_barabara(parsed.prefix_number, 6)
+        max = dice_list.max
+
+        if max >= 5
+          # 5以上の出目があった場合
+          # 成功フラグを立てる
+          is_success = true
+          # 成功メッセージを追加
+          texts.push(translate("KizunaBullet.INVESTIGATE.success"))
+        elsif max >= 3
+          # 3以上の出目があった場合
+          # 失敗メッセージを追加
+          texts.push(translate("KizunaBullet.INVESTIGATE.failure"))
+          # ［パートナーのヘルプ］メッセージを追加
+          texts.push(translate("KizunaBullet.INVESTIGATE.partnerHelp"))
+        else
+          # 上記以外
+          # ファンブルフラグを立てる
+          is_fumble = true
+          # 失敗メッセージを追加
+          texts.push(translate("KizunaBullet.INVESTIGATE.failure"))
+          # ファンブルメッセージを追加
+          texts.push(translate("KizunaBullet.INVESTIGATE.fumble"))
+        end
+
+        return Result.new.tap do |r|
+          # テキストを整形
+          r.text = "#{command} ＞ [#{dice_list.join(',')}] ＞ #{texts.join('')}"
+          # 各種成否を格納
+          r.condition = is_success
+          r.fumble = is_fumble
+        end
+      end
+
+      # 鎮静判定
+      def roll_sedative(command)
+        parser = Command::Parser.new("SE", round_type: @round_type)
+                                .has_suffix_number
+        parsed = parser.parse(command)
+        unless parsed
+          return nil
+        end
+
+        text = ''
+        is_success = false
+
+        # 合計値計算
+        sum = @randomizer.roll_sum(2, 6)
+
+        if parsed.suffix_number > 12
+          # 目標値が12より大きい場合
+          # ［晶滅］メッセージを追加
+          text = translate("KizunaBullet.SEDATIVE.burst")
+        elsif parsed.suffix_number < 6
+          # 目標値が6より小さい場合
+          # ［生存］メッセージを追加
+          text = translate("KizunaBullet.SEDATIVE.alive")
+        elsif sum > parsed.suffix_number
+          # 合計値が目標値より大きい場合
+          # 成功フラグを立てる
+          is_success = true
+          # 成功メッセージを追加
+          text = translate("KizunaBullet.SEDATIVE.success")
+        else
+          # 上記以外
+          # ［強制鎮静］に必要な［キズナ］のチェック数の計算
+          # 目標値と出目の差分を計算
+          dif = parsed.suffix_number - sum
+          # チェック一つごとに結果に+2
+          check = (dif / 2) + 1
+          # 失敗メッセージを追加
+          text = translate("KizunaBullet.SEDATIVE.failure", check: check.to_s)
+        end
+
+        return Result.new.tap do |r|
+          # テキストを整形
+          r.text = "#{command} ＞ #{sum} ＞ #{text}"
+          # 各種成否を格納
+          r.condition = is_success
+        end
+      end
+
+      # 解決 ［アクション］のダメージと［アクシデント］のダメージ軽減
+      def roll_solve(command)
+        parser = Command::Parser.new("SO", round_type: @round_type)
+                                .enable_prefix_number
+        parsed = parser.parse(command)
+        unless parsed
+          return nil
+        end
+
+        # 合計値計算
+        sum = @randomizer.roll_sum(parsed.prefix_number.to_i + 2, 6)
+
+        return Result.new.tap do |r|
+          # テキストを整形
+          r.text = "#{command} ＞ #{sum}"
+        end
+      end
+
+      register_prefix('\d+DM', '\d+IN', 'SE\d+', '\d*SO', TABLES.keys)
+    end
+  end
+end

data/lib/bcdice/game_system/KyokoShinshoku.rb

@@ -15,7 +15,7 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = <<~MESSAGETEXT
         ・判定
-        　ダイスを指定数ダイスロールして、最も高い出目を出力します。難易度を指定すると成否を判定します。
+        　ダイスを指定数ダイスロールして、最も高い出目を出力します。難易度を指定すると成否を判定します。オプションでA、Dをつけると、［有利］［不利］の条件で振れます（A=［有利］、D=［不利］）。
         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）
@@ -25,6 +25,16 @@ module BCDice
         y：ダイス数（省略：1）
         z：難易度
 
+        KS(x,y)A>=z（［有利］：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）
+        z：難易度
+
+        KS(x,y)D>=z（［不利］：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）
+        z：難易度
+
         ・観測ロール
         　［現実乖離］の段階に応じたダイスを指定数ダイスロールして、最も高い出目を出力します。
         KR(x)
@@ -62,19 +72,30 @@ module BCDice
       }.freeze
 
       def roll_check(command)
-        m = /^KS(?:\((\d+),([-+\d]+)?\)|(\d+))(?:>=([-+\d]+))?$/.match(command)
+        m = /^KS(?:\(([-+\d]+),([-+\d]+)?\)|(\d+))([AD]?)(?:>=([-+\d]+))?$/.match(command)
         return nil unless m
 
-        dice_size = m[1]&.to_i || m[3].to_i
+        dice_size = m[1] ? Arithmetic.eval(m[1], @round_type) : Arithmetic.eval(m[3], @round_type).to_i
         times = m[2] ? Arithmetic.eval(m[2], @round_type) : 1
-        target = m[4] && Arithmetic.eval(m[4], @round_type)
+        target = m[5] && Arithmetic.eval(m[5], @round_type)
+
+        advantage = m[4]
 
         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)
+        rolls = Array.new(advantage.empty? ? 1 : 2) { roll_check_once(times, dice_size, sides) }
+        values = rolls.map { |v| v[:value] }
+
+        value =
+          if advantage == "A"
+            values.max
+          elsif advantage == "D"
+            values.min
+          else
+            values.first
+          end
 
         result =
           if value == 1
@@ -90,8 +111,8 @@ module BCDice
           end
 
         result.text = [
-          target ? "(KS(#{dice_size},#{times})>=#{target})" : "(KS(#{dice_size},#{times}))",
-          ("#{value}[#{dice_list.join(',')}]" if times > 1),
+          target ? "(KS(#{dice_size},#{times})#{advantage}>=#{target})" : "(KS(#{dice_size},#{times})#{advantage})",
+          format_rolls(rolls),
           value,
           result.text,
         ].compact.join(" ＞ ")
@@ -99,6 +120,28 @@ module BCDice
         return result
       end
 
+      def roll_check_once(times, dice_size, sides)
+        if times < 1
+          dice_list = @randomizer.roll_barabara(2, sides).sort
+          value = dice_list.min.clamp(1, dice_size)
+        else
+          dice_list = @randomizer.roll_barabara(times, sides).sort
+          value = dice_list.max.clamp(1, dice_size)
+        end
+
+        return {dice_list: dice_list, value: value}
+      end
+
+      def format_rolls(rolls)
+        if rolls.length == 1 && rolls.first[:dice_list].length == 1
+          return nil
+        end
+
+        rolls.map do |v|
+          v[:dice_list].length == 1 ? v[:value].to_s : "#{v[:value]}[#{v[:dice_list].join(',')}]"
+        end.join(", ")
+      end
+
       GENJITU_KAIRI_TO_SIDES = [4, 6, 8, 10, 12, 20].freeze
       REALITY_LINE_TO_TIMES = {
         3 => 1,

data/lib/bcdice/game_system/Magius.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Magius < Base
+      # ゲームシステムの識別子
+      ID = 'Magius'
+
+      # ゲームシステム名
+      NAME = 'MAGIUS'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'まきうす'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■能力値判定　MA+x>=t        x:修正値 t:目標値
+        例)MA>=7: ダイスを2個振って、その結果を表示
+
+        ■技能値判定　MS+x>=t        x:修正値 t:目標値
+        例)MS>=7: ダイスを3個振って、そのうち上位2つを採用し、結果を表示
+
+      INFO_MESSAGETEXT
+
+      register_prefix('M[AS]')
+
+      def initialize(command)
+        super(command)
+
+        @sort_barabara_dice = true # バラバラロール（Bコマンド）でソート有
+      end
+
+      def eval_game_system_specific_command(command)
+        resolute_ability_action(command) ||
+          resolute_skill_action(command)
+      end
+
+      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 get_result_of_ability_action(total, _dice_add, target)
+        if total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      def resolute_ability_action(command)
+        m = /MA([+-]\d+)*>=(\d+)/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+        target = m[2].to_i
+
+        dices = @randomizer.roll_barabara(2, 6).sort
+        dice_text = dices.join(",")
+        dice_add = dices.sum
+        total = dice_add + modify
+
+        result = get_result_of_ability_action(total, dice_add, target)
+
+        sequence = [
+          "(#{command})",
+          "[#{dice_text}]#{with_symbol(modify)}",
+          total,
+          result.text,
+        ].compact
+
+        result.text = sequence.join(" ＞ ")
+
+        return result
+      end
+
+      # 技能値値判定
+      # @param [String] command
+      # @return [Result]
+      def get_result_of_skill_action(total, _dice_add, target)
+        if total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      def resolute_skill_action(command)
+        m = /MS([+-]\d+)*>=(\d+)/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+        target = m[2].to_i
+
+        dices = @randomizer.roll_barabara(3, 6).sort
+        dice_text = dices.join(",")
+        dice_add = dices[1].to_i + dices[2].to_i
+        total = dice_add + modify
+
+        result = get_result_of_skill_action(total, dice_add, target)
+
+        sequence = [
+          "(#{command})",
+          "[#{dice_text}]#{with_symbol(modify)}",
+          total,
+          result.text,
+        ].compact
+
+        result.text = sequence.join(" ＞ ")
+
+        return result
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Magius_3rdNewTokyoCity.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/Magius'
+
+module BCDice
+  module GameSystem
+    class Magius_3rdNewTokyoCity < Magius
+      # ゲームシステムの識別子
+      ID = 'Magius_3rdNewTokyoCity'
+
+      # ゲームシステム名
+      NAME = 'MAGIUS:新世紀エヴァンゲリオンRPG 決戦！第3新東京市'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'まきうすしんせいきえうあんけりおんRPGけつせんたい3しんとうきようし'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■能力値判定　MA+x>=t        x:修正値 t:目標値
+        例)MA>=7: ダイスを2個振って、その結果(成功,失敗,絶対成功,絶対失敗)を表示
+
+        ■技能値判定　MS+x>=t        x:修正値 t:目標値
+        例)MS>=7: ダイスを3個振って、そのうち上位2つを採用し、結果(成功,失敗,絶対成功,絶対失敗)を表示
+
+      INFO_MESSAGETEXT
+
+      register_prefix('M[AS]')
+
+      private
+
+      # 能力値判定の結果取得
+      # @param [Integer] total, dice_add, target
+      # @return [Result]
+      def get_result_of_ability_action(total, dice_add, target)
+        if dice_add == 12
+          return Result.critical("絶対成功")
+        elsif dice_add == 2
+          return Result.fumble("絶対失敗")
+        elsif total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      # 技能値判定の結果取得
+      # @param [Integer] total, dice_add, target
+      # @return [Result]
+      def get_result_of_skill_action(total, dice_add, target)
+        if dice_add == 12
+          return Result.critical("絶対成功")
+        elsif dice_add == 2
+          return Result.fumble("絶対失敗")
+        elsif total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/MonotoneMuseum.rb

@@ -25,9 +25,16 @@ module BCDice
         　　クリティカル値、ファンブル値は省略可能です。([]ごと省略できます)
         　　自動成功、自動失敗、成功、失敗を自動表示します。
         ・各種表
+        【改訂版環境】
+        　・感情表　MET
+        　・兆候表（戦闘時）　MBOT／兆候表（非戦闘時）　MNOT
+        　・歪み表　MDT
+        　・世界歪曲表　MWDT
+        　・永劫消失表　MEDT
+        【旧版環境】
         　・感情表　ET／感情表 2.0　ET2
         　・兆候表　OT／兆候表ver2.0　OT2／兆候表ver3.0　OT3
-        　・歪み表　DT／歪み表ver2.0　DT2／歪み表(野外)　DTO／歪み表(海)　DTS／歪み表(館・城)　DTM
+        　・歪み表　DT／歪み表ver2.0　DT2／歪み表（野外）　DTO／歪み表（海）　DTS／歪み表（館・城）　DTM
         　・世界歪曲表　WDT／世界歪曲表2.0　WDT2
         　・永劫消失表　EDT
         ・D66ダイスあり
@@ -146,6 +153,12 @@ module BCDice
             "EDT" => DiceTable::Table.from_i18n("MonotoneMuseum.table.EDT", locale),
             "DTM" => MMTable.from_i18n("MonotoneMuseum.table.DTM", locale),
             "OT3" => DiceTable::Table.from_i18n("MonotoneMuseum.table.OT3", locale),
+            "MET" => DiceTable::D66GridTable.from_i18n("MonotoneMuseum.table.MET", locale),
+            "MBOT" => DiceTable::Table.from_i18n("MonotoneMuseum.table.MBOT", locale),
+            "MNOT" => DiceTable::Table.from_i18n("MonotoneMuseum.table.MNOT", locale),
+            "MDT" => MMTable.from_i18n("MonotoneMuseum.table.MDT", locale),
+            "MWDT" => DiceTable::Table.from_i18n("MonotoneMuseum.table.MWDT", locale),
+            "MEDT" => DiceTable::Table.from_i18n("MonotoneMuseum.table.MEDT", locale),
           }
         end
       end

data/lib/bcdice/game_system/MonotoneMuseum_Korean.rb

@@ -22,11 +22,11 @@ module BCDice
         　　크리티컬, 펌블치는 생략가능합니다. ([]자체를 생략가능)
         　　자동성공, 자동실패, 성공, 실패를 자동표기합니다.
         ・각종표
-        　・감정표　ET／감정표 2.0　ET2
-        　・징조표　OT／징조표ver2.0　OT2／징조표ver3.0　OT3
+        　・감정표　ET／감정표 2.0　ET2／개정판 감정표 MET
+        　・징조표　OT／징조표ver2.0　OT2／징조표ver3.0　OT3 / 개정판 전투 징조표 MBOT / 개정판 비전투 징조표 MNOT
         　・일그러짐표　DT／일그러짐표ver2.0　DT2／일그러짐표(야외)　DTO／일그러짐표(바다)　DTS／일그러짐표(저택・성)　DTM
-        　・세계왜곡표　　WDT／세계왜곡표2.0　WDT2
-        　・영구소실표　EDT
+        　・세계왜곡표　　WDT／세계왜곡표2.0　WDT2／개정판 왜곡표 MDT／개정판 세계왜곡표 MWDT
+        　・영구소실표　EDT／개정판 영구소실표 MEDT
         ・D66다이스 있음
       INFO_MESSAGE_TEXT
 

data/lib/bcdice/game_system/NRR.rb

@@ -97,10 +97,10 @@ module BCDice
       SUCCESSES = [:success, :critical, :miracle].freeze
       CRITICALS = [:critical, :miracle].freeze
 
-      DISADVANTAGE = [:fumble, :fumble, :failure, :failure, :success, :success].freeze
+      DISADVANTAGE = [:fumble, :failure, :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
+      EXTRA = [:fumble, :fumble, :failure, :failure, :success, :success, :critical, :critical, :critical, :critical, :miracle, :miracle].freeze
 
       ICON = {
         fumble: "💀",

data/lib/bcdice/game_system/NSSQ.rb

@@ -54,7 +54,7 @@ module BCDice
         total = largest_two.sum + modifier
         num_1 = dice_list.count(1)
 
-        additional_result =
+        result =
           if largest_two == [6, 6]
             Result.critical(" ＞ 絶対成功！")
           elsif largest_two == [1, 1]
@@ -73,10 +73,11 @@ module BCDice
         sequence = [
           "(#{command})",
           "[#{dice_list.join(',')}]#{Format.modifier(modifier)}",
-          "#{total}[#{largest_two.join(',')}]#{additional_result.text}#{fp_result}",
+          "#{total}[#{largest_two.join(',')}]#{result.text}#{fp_result}",
         ]
 
-        return sequence.join(" ＞ ")
+        result.text = sequence.join(" ＞ ")
+        return result
       end
 
       # ダメージロール
@@ -90,24 +91,29 @@ module BCDice
         resist = m[4].to_i
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
+        normal_damage = damage(dice_list, resist)
 
-        result = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}ダメージ"
+        result = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist}"
 
         critical_target = critical_up ? 1 : 2
 
         if dice_list.count(6) - dice_list.count(1) >= critical_target
-          result += " クリティカルヒット！\n"
-          result += additional_damage_roll(increase_critical_dice, resist)
+          result += critical_damage_roll(increase_critical_dice, resist, normal_damage)
+          result = Result.critical(result)
+        else
+          result += " ＞ #{normal_damage}ダメージ"
+          result = normal_damage > 0 ? Result.success(result) : Result.failure(result)
         end
 
         return result
       end
 
-      def additional_damage_roll(increase_critical_dice, resist)
+      def critical_damage_roll(increase_critical_dice, resist, normal_damage)
         dice_count = increase_critical_dice ? 8 : 4
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
-        "(#{dice_count}DR#{resist}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}ダメージ"
+        critical_damage = damage(dice_list, resist)
+        return " ＞ クリティカルヒット！ ＞ (#{dice_count}DR#{resist}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{normal_damage + critical_damage}ダメージ"
       end
 
       # 回復ロール
@@ -119,8 +125,10 @@ module BCDice
         resist = m[2]&.to_i || 3
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
+        heal_amount = damage(dice_list, resist)
+        result_text = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{heal_amount}回復"
 
-        return "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}回復"
+        return heal_amount > 0 ? Result.success(result_text) : Result.failure(result_text)
       end
 
       def damage(dice_list, resist)