bcdice 3.0.0.pre.alpha.1 → 3.1.0

data/lib/bcdice/game_system/DetatokoSaga_Korean.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "bcdice/game_system/DetatokoSaga"
+
 module BCDice
   module GameSystem
-    class DetatokoSaga_Korean < Base
+    class DetatokoSaga_Korean < DetatokoSaga
       # ゲームシステムの識別子
       ID = 'DetatokoSaga:Korean'
 
@@ -14,9 +16,9 @@ module BCDice
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
-        ・통상판정　xDS or xDSy or xDS>=z or xDSy>=z
-        　(x＝스킬레벨, y＝현재 플래그(생략=0), z＝목표치(생략=８))
-        　예）3DS　2DS5　0DS　3DS>=10　3DS7>=12
+        ・통상판정　xDS or xDSy or xDS>=t or xDSy>=t or xDS+z>=t or xDSy+z>=t
+        　(x＝스킬레벨, y＝현재 플래그(생략=0), z＝수정치(생략=０), t＝목표치(생략=８))
+        　예）3DS　2DS5　0DS　3DS>=10　3DS7>=12 2DS3+1 3DS2+1>=10
         ・판정치　xJD or xJDy or xJDy+z or xJDy-z or xJDy/z
         　(x＝스킬레벨, y＝현재 플래그(생략=0), z＝수정치(생략=０))
         　예）3JD　2JD5　3JD7+1　4JD/3
@@ -26,285 +28,15 @@ module BCDice
         ・기력 배드엔딩표　WBET (WillBadEndTable)
       INFO_MESSAGE_TEXT
 
-      register_prefix([
-        '\d+DS.*', '\d+JD.*',
-        'SST', 'StrengthStigmaTable',
-        'WST', 'WillStigmaTable',
-        'SBET', 'StrengthBadEndTable',
-        'WBET', 'WillBadEndTable'
-      ])
+      register_prefix_from_super_class()
 
       def initialize(command)
         super(command)
 
-        @sort_add_dice = true
-        @enabled_d66 = true
-        @d66_sort_type = D66SortType::ASC
-      end
-
-      def eval_game_system_specific_command(command)
-        debug("eval_game_system_specific_command begin string", command)
-
-        result = checkRoll(command)
-        return result unless result.empty?
-
-        result = checkJudgeValue(command)
-        return result unless result.empty?
-
-        debug("각종표로서 처리")
-        return rollTableCommand(command)
-      end
-
-      # 통상판정　xDS or xDSy or xDS>=z or xDSy>=z
-      def checkRoll(string)
-        debug("checkRoll begin string", string)
-
-        return '' unless /^(\d+)DS(\d+)?((>=)(\d+))?$/i =~ string
-
-        target = 8
-
-        skill = Regexp.last_match(1).to_i
-        flag = Regexp.last_match(2).to_i
-        target = Regexp.last_match(5).to_i unless Regexp.last_match(5).nil?
-
-        result = "판정！　스킬레벨：#{skill}　플래그：#{flag}　목표치：#{target}"
-
-        total, rollText = getRollResult(skill)
-        result += " ＞ #{total}[#{rollText}] ＞ 판정치：#{total}"
-
-        success = getSuccess(total, target)
-        result += " ＞ #{success}"
-
-        result += getCheckFlagResult(total, flag)
-
-        return result
-      end
-
-      def getRollResult(skill)
-        diceCount = skill + 1
-        diceCount = 3 if  skill == 0
-
-        dice = @randomizer.roll_barabara(diceCount, 6)
-        diceText = dice.join(',')
-
-        dice = dice.sort
-        dice = dice.reverse if skill != 0
-
-        total = dice[0] + dice[1]
-
-        return total, diceText
-      end
-
-      def getSuccess(check, target)
-        if check >= target
-          return "목표치 이상！【성공】"
-        end
-
-        return "목표치 미달… 【실패】"
-      end
-
-      def getCheckFlagResult(total, flag)
-        if total > flag
-          return ""
-        end
-
-        willText = getDownWill(flag)
-        result = ", 플래그 이하！ 【기력#{willText}점 감소】"
-        result += " 【판정치 변경 불가】"
-
-        return result
+        @locale = :ko_kr
       end
 
-      def getDownWill(flag)
-        if flag >= 10
-          return "6"
-        end
-
-        dice = @randomizer.roll_once(6)
-        return "1D6->#{dice}"
-      end
-
-      # 스킬판정치　xJD or xJDy or xJDy+z or xJDy-z or xJDy/z
-      def checkJudgeValue(string)
-        debug("checkJudgeValue begin string", string)
-
-        return '' unless %r{^(\d+)JD(\d+)?(([+]|[-]|[/])(\d+))?$}i =~ string
-
-        skill = Regexp.last_match(1).to_i
-        flag = Regexp.last_match(2).to_i
-        operator = Regexp.last_match(4)
-        value = Regexp.last_match(5).to_i
-
-        result = "판정！　스킬레벨：#{skill}　플래그：#{flag}"
-
-        modifyText = getModifyText(operator, value)
-        result += "　수정치：#{modifyText}" unless modifyText.empty?
-
-        total, rollText = getRollResult(skill)
-        result += " ＞ #{total}[#{rollText}]#{modifyText}"
-
-        totalResult = getTotalResultValue(total, value, operator)
-        result += " ＞ #{totalResult}"
-
-        result += getCheckFlagResult(total, flag)
-
-        return result
-      end
-
-      def getModifyText(operator, value)
-        return '' if value == 0
-
-        operatorText =
-          case operator
-          when "+"
-            "＋"
-          when "-"
-            "－"
-          when "/"
-            "÷"
-          else
-            return ""
-          end
-
-        return "#{operatorText}#{value}"
-      end
-
-      def getTotalResultValue(total, value, operator)
-        case operator
-        when "+"
-          return "#{total}+#{value} ＞ 판정치：#{total + value}"
-        when "-"
-          return "#{total}-#{value} ＞ 판정치：#{total - value}"
-        when "/"
-          return getTotalResultValueWhenSlash(total, value)
-        else
-          return "판정치：#{total}"
-        end
-      end
-
-      def getTotalResultValueWhenSlash(total, value)
-        return "0으로는 나누어지지 않습니다" if value == 0
-
-        quotient = ((1.0 * total) / value).ceil
-
-        result = "#{total}÷#{value} ＞ 판정치：#{quotient}"
-        return result
-      end
-
-      ####################
-      # 각종표
-
-      def rollTableCommand(command)
-        command = command.upcase
-
-        debug("eval_game_system_specific_command command", command)
-
-        name = ''
-        text = ''
-        total = 0
-
-        case command.upcase
-        when "SST", "StrengthStigmaTable".upcase
-          name, text, total = choiceStrengthStigmaTable()
-        when "WST", "WillStigmaTable".upcase
-          name, text, total = choiceWillStigmaTable()
-        when "SBET", "StrengthBadEndTable".upcase
-          name, text, total = choiceStrengthBadEndTable()
-        when "WBET", "WillBadEndTable".upcase
-          name, text, total = choiceWillBadEndTable()
-        else
-          return
-        end
-
-        result = "#{name}(#{total}) ＞ #{text}"
-
-        return result
-      end
-
-      # ##표 목록
-
-      def choiceStrengthStigmaTable()
-        name = "체력 낙인표"
-        table = [
-          "당신은 【낙인】을 2개 받는다. 이 표를 다시 2번 굴려 받을 【낙인】을 정한다(그 경우, 다시 이 눈이 나와도 【낙인】은 늘어나지 않는다).",
-          "【상처】 심한 상처를 입었다. 어떻게든 싸울 수는 있지만…….",
-          "【출혈】 피가 흘러넘쳐, 눈이 흐릿하다…….",
-          "【쇠약】 몸이 약해져, 그 마음마저도 시들어버릴 거 같다.",
-          "【고통】 아픔과 괴로움, 한심함. 눈에서 눈물이 새어 나온다.",
-          "【충격】 날려져서, 벽이나 나무에 부딪힌다. 빨리 일어서지 않으면.",
-          "【피로】 당신의 얼굴에 피로의 색이 강해진다……이 싸움이 힘겨워졌다.",
-          "【노호】 성가신 공격에 분노의 함성을 지른다. 분노가 싸움을 어렵게 할까?",
-          "【부상】 상처를 입었다…….",
-          "【경상】 당신의 피부에 상처가 남았다. 이것만이라면 아무렇지도 않다.",
-          "기적적으로 당신은 【낙인】을 받지 않았다.",
-        ]
-
-        text, total = get_table_by_2d6(table)
-        return name, text, total
-      end
-
-      def choiceWillStigmaTable()
-        name = "기력 낙인표"
-
-        table = [
-          "당신은 【낙인】을 2개 받는다. 이 표를 다시 2번 굴려 받을 【낙인】을 정한다(그 경우, 다시 이 눈이 나와도 【낙인】은 늘어나지 않는다).",
-          "【절망】 어떻게 하지 못하는 상황. 희망은 사라지고……무릎을 꿇을 수밖에 없다.",
-          "【통곡】 너무도 부조리함에, 어린아이처럼 울음을 터트릴 수밖에 없다.",
-          "【후회】 이럴 생각은 아니었는데. 하지만 현실은 비정했다.",
-          "【공포】 공포에 사로잡혔다! 적이, 자신의 손이, 무서워서 참을 수 없다!",
-          "【갈등】 정말로 이걸로 괜찮은 걸까? 몇 번이고 자신에게 의문이 일어난다…….",
-          "【증오】 분노와 증오에 사로잡힌 당신은, 본래의 힘을 발휘할 수 있을까?",
-          "【망연】 이것은 현실인가? 몽롱한 정신으로 당신은 생각한다.",
-          "【주저】 망설임을 가졌다. 그것은 싸울 의지를 둔하게 할 것인가?",
-          "【악몽】 이제부터 때때로, 당신은 이 순간을 악몽으로 볼 것이다.",
-          "기적적으로 당신은 【낙인】을 받지 않았다.",
-        ]
-
-        text, total = get_table_by_2d6(table)
-        return name, text, total
-      end
-
-      def choiceStrengthBadEndTable()
-        name = "체력 배드엔딩표"
-
-        table = [
-          "【사망】 당신은 죽었다. 다음 세션에 참가하기 위해서는, 클래스 1개를 『몬스터』나 『암흑』으로 클래스 체인지해야만 한다.",
-          "【목숨 구걸】 당신은 공포를 느껴, 목숨을 구걸했다! 다음 세션 개시 시에, 클래스 1개가 『자코』로 변경된다!",
-          "【망각】 당신은 기억을 잃고, 우두커니 섰다. 다음 세션에 참가하기 위해서는, 클래스 1개를 변경해야만 한다.",
-          "【비극】 당신의 공격은 적이 아니라 아군을 맞췄다! 모든 것이 끝날 때까지 당신은 우두커니 서 있게 된다. 임의의 아군의 【체력】을 1D6점 감소시킨다.",
-          "【폭주】 당신은 이성을 잃고, 충동에 따라 폭주한다! 같은 씬에 있는 전원의 【체력】을 1D6점 감소시킨다.",
-          "【전락】 당신은 단애절벽에서 떨어진다.",
-          "【포로】 당신은 적에게 사로잡혔다.",
-          "【도주】 당신은 겁에 질려, 동료를 버리고 도망쳤다.",
-          "【중상】 당신은 어찌할 수 없는 상처를 입고, 쓰러졌다.",
-          "【기절】 당신은 의식을 잃었다. 그리고 정신이 들면 모든 것이 끝나있었다.",
-          "그래도 아직 일어선다! 당신은 배드엔드를 맞이하지 않았다. 체력의 【낙인】을 1개 지워도 좋다.",
-        ]
-
-        text, total = get_table_by_2d6(table)
-        return name, text, total
-      end
-
-      def choiceWillBadEndTable()
-        name = "기력 배드엔딩표"
-
-        table = [
-          "【자해】 당신은 스스로 죽음을 골랐다. 다음 세션에 참가하기 위해서는 클래스 1개를 『암흑』으로 클래스 체인지해야만 한다.",
-          "【타락】 당신은 마음속의 어둠에 먹혔다. 다음 세션 개시 시에, 클래스 1개가 『암흑』이나 『몬스터』로 변경된다!",
-          "【예속】 당신은 적의 말에 거스를 수 없다. 다음 세션에 당신의 스탠스는 『종속』이 된다.",
-          "【배반】 배반의 충동. 임의의 아군의 【체력】을 1D6점 감소시키고, 그 자리에서 도망친다.",
-          "【폭주】 당신은 이성을 잃고, 충동에 따라 폭주한다! 같은 씬에 있는 전원의 【체력】을 1D6점 감소시킨다.",
-          "【저주】 마음의 어둠이 현재화한 것인가. 적의 원한인가. 저주에 삼켜진 당신은, 그저 고통에 몸부림칠 수밖에 없다.",
-          "【포로】 당신은 적에게 사로잡혀, 그 자리에서 끌려갔다.",
-          "【도주】 당신은 겁에 질려, 동료를 버리고 도망쳤다.",
-          "【방심】 당신은 그저 멍하니 서 있을 수밖에 없다. 정신을 차렸을 때, 모든 것은 끝나있었다.",
-          "【기절】 당신은 의식을 잃었다. 그리고 정신이 들면 모든 것이 끝나있었다.",
-          "그래도 아직 포기하지 않아! 당신은 배드엔드를 맞이하지 않았다. 기력의 【낙인】을 1개 지워도 좋다.",
-        ]
-
-        text, total = get_table_by_2d6(table)
-        return name, text, total
-      end
+      TABLES = translate_tables(:ko_kr)
     end
   end
 end

data/lib/bcdice/game_system/DiceBot.rb

@@ -1,17 +1,35 @@
+# frozen_string_literal: true
+
 module BCDice
   module GameSystem
     class DiceBot < Base
       # ゲームシステムの識別子
-      ID = 'DiceBot'.freeze
+      ID = 'DiceBot'
 
       # ゲームシステム名
-      NAME = 'DiceBot'.freeze
+      NAME = 'DiceBot'
 
       # ゲームシステム名の読みがな
-      SORT_KEY = '*たいすほつと'.freeze
+      SORT_KEY = '*たいすほつと'
 
       # ダイスボットの使い方
-      HELP_MESSAGE = ''.freeze
+      HELP_MESSAGE = <<~HELP
+        3D6+1>=9 ：3d6+1で目標値9以上かの判定
+        1D100<=50 ：D100で50％目標の下方ロールの例
+        3U6[5] ：3d6のダイス目が5以上の場合に振り足しして合計する(上方無限)
+        3B6 ：3d6のダイス目をバラバラのまま出力する（合計しない）
+        10B6>=4 ：10d6を振り4以上のダイス目の個数を数える
+        2R6[>3]>=5 ：2D6のダイス目が3より大きい場合に振り足して、5以上のダイス目の個数を数える
+        (8/2)D(4+6)<=(5*3)：個数・ダイス・達成値には四則演算も使用可能
+        c(10-4*3/2+2)：c(計算式）で計算だけの実行も可能
+        choice[a,b,c]：列挙した要素から一つを選択表示。ランダム攻撃対象決定などに
+        S3d6 ： 各コマンドの先頭に「S」を付けると他人結果の見えないシークレットロール
+        3d6/2 ： ダイス出目を割り算（端数処理はゲームシステム依存）。切り上げは /2C、四捨五入は /2R、切り捨ては /2F
+        D66 ： D66ダイス。順序はゲームに依存。D66N：そのまま、D66A：昇順、D66D：降順
+
+        詳細は下記URLのコマンドガイドを参照
+        https://docs.bcdice.org/
+      HELP
     end
   end
 end

data/lib/bcdice/game_system/DiceOfTheDead.rb

@@ -21,13 +21,12 @@ module BCDice
         （上記二つは最初からシークレットダイスで行われます）
       INFO_MESSAGE_TEXT
 
-      register_prefix(['(ZMB|BIO).*'])
+      register_prefix('ZMB', 'BIO')
 
       def initialize(command)
         super(command)
 
         @sort_add_dice = true
-        @enabled_d66 = true
         @d66_sort_type = D66SortType::ASC
       end
 
@@ -35,14 +34,18 @@ module BCDice
         case command
         when /^BIO(\d+)?$/
           roll_times = (Regexp.last_match(1) || 1).to_i
-          @is_secret = true
 
-          return checkInfection(roll_times)
+          Result.new.tap do |r|
+            r.secret = true
+            r.text = checkInfection(roll_times)
+          end
         when /^ZMB(\+(\d+))?$/
           value = Regexp.last_match(2).to_i
-          @is_secret = true
 
-          return rollZombie(value)
+          Result.new.tap do |r|
+            r.secret = true
+            r.text = rollZombie(value)
+          end
         end
       end
 

data/lib/bcdice/game_system/DoubleCross.rb

@@ -30,10 +30,12 @@ module BCDice
         ・D66ダイスあり
       INFO_MESSAGE_TEXT
 
-      register_prefix(['\d+DX.*', 'ET'])
+      register_prefix('\d+DX', 'ET')
 
       # 成功判定コマンドのノード
       class DX
+        include Translate
+
         # ノードを初期化する
         # @param [Integer] num ダイス数
         # @param [Integer] critical_value クリティカル値
@@ -47,18 +49,20 @@ module BCDice
 
           @modifier_str = Format.modifier(@modifier)
           @expression = node_expression()
+
+          @locale = :ja_jp
         end
 
         # 成功判定を行う
         # @param randomizer [Randomizer]
-        # @return [String] 判定結果
+        # @return [Result] 判定結果
         def execute(randomizer)
           if @critical_value < 2
-            return "(#{@expression}) ＞ クリティカル値が低すぎます。2以上を指定してください。"
+            return Result.new("(#{@expression}) ＞ #{translate('DoubleCross.DX.invalid_critical')}")
           end
 
           if @num < 1
-            return "(#{@expression}) ＞ 自動失敗"
+            return Result.failure("(#{@expression}) ＞ #{translate('DoubleCross.DX.auto_failure')}")
           end
 
           # 出目のグループの配列
@@ -81,7 +85,7 @@ module BCDice
             loop_count += 1
           end
 
-          return result_str(value_groups)
+          return result(value_groups)
         end
 
         private
@@ -94,47 +98,51 @@ module BCDice
           return @target_value ? "#{lhs}>=#{@target_value}" : lhs
         end
 
-        # 判定結果の文字列を返す
+        # 判定結果を返す
         # @param [Array<ValueGroup>] value_groups 出目のグループの配列
-        # @return [String]
-        def result_str(value_groups)
-          fumble = value_groups[0].values.all? { |value| value == 1 }
-          # TODO: Ruby 2.4以降では Array#sum が使える
-          sum = value_groups.map(&:max).reduce(0, &:+)
-          achieved_value = fumble ? 0 : (sum + @modifier)
+        # @return [Result]
+        def result(value_groups)
+          r = Result.new
+
+          r.fumble = value_groups[0].values.all?(1)
+
+          sum = value_groups.map(&:max).sum
+          achieved_value = r.fumble? ? 0 : (sum + @modifier)
+
+          # ファンブルかどうかを含む達成値の表記
+          achieved_value_with_if_fumble =
+            if r.fumble?
+              "#{achieved_value} (#{translate('fumble')})"
+            else
+              achieved_value.to_s
+            end
 
           parts = [
             "(#{@expression})",
             "#{value_groups.join('+')}#{@modifier_str}",
-            achieved_value_with_if_fumble(achieved_value, fumble),
-            compare_result(achieved_value, fumble)
+            achieved_value_with_if_fumble
           ]
 
-          return parts.compact.join(' ＞ ')
-        end
-
-        # ファンブルかどうかを含む達成値の表記を返す
-        # @param [Integer] achieved_value 達成値
-        # @param [Boolean] fumble ファンブルしたか
-        # @return [String]
-        def achieved_value_with_if_fumble(achieved_value, fumble)
-          fumble ? "#{achieved_value} (ファンブル)" : achieved_value.to_s
-        end
-
-        # 達成値と目標値を比較した結果を返す
-        # @param [Integer] achieved_value 達成値
-        # @param [Boolean] fumble ファンブルしたか
-        # @return [String, nil]
-        def compare_result(achieved_value, fumble)
-          return nil unless @target_value
+          if @target_value
+            # 行為判定成功か？
+            #
+            # ファンブル時は自動失敗、達成値が目標値以上ならば行為判定成功
+            # [3rd ルールブック1 pp. 186-187]
+            success = !r.fumble? && (achieved_value >= @target_value)
+
+            if success
+              r.success = true
+            else
+              r.failure = true
+            end
+
+            compare_result_text = translate(success ? 'success' : 'failure')
+            parts.push(compare_result_text)
+          end
 
-          # ファンブル時は自動失敗
-          # [3rd ルールブック1 pp. 186-187]
-          return '失敗' if fumble
+          r.text = parts.join(' ＞ ')
 
-          # 達成値が目標値以上ならば行為判定成功
-          # [3rd ルールブック1 p. 187]
-          return achieved_value >= @target_value ? '成功' : '失敗'
+          return r
         end
       end
 
@@ -173,9 +181,7 @@ module BCDice
         # クリティカルの発生数を返す
         # @return [Integer]
         def num_of_critical_occurrences
-          @values
-            .select { |value| critical?(value) }
-            .length
+          @values.count { |value| critical?(value) }
         end
 
         private
@@ -191,19 +197,6 @@ module BCDice
         end
       end
 
-      def check_nD10(total, _dice_total, dice_list, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :>=
-
-        if dice_list.count(1) == dice_list.size
-          " ＞ ファンブル"
-        elsif total >= target
-          " ＞ 成功"
-        else
-          " ＞ 失敗"
-        end
-      end
-
       # ダイスボット固有コマンドの処理を行う
       # @param [String] command コマンド
       # @return [String] ダイスボット固有コマンドの結果
@@ -222,74 +215,52 @@ module BCDice
 
       private
 
-      # OD Tool式の成功判定コマンドの正規表現
-      #
-      # キャプチャ内容は以下のとおり:
-      #
-      # 1. ダイス数
-      # 2. 修正値
-      # 3. クリティカル値
-      # 4. 達成値
-      DX_OD_TOOL_RE = /\A(\d+)DX([-+]\d+(?:[-+*]\d+)*)?@(\d+)(?:>=(\d+))?\z/io.freeze
-
-      # 疾風怒濤式の成功判定コマンドの正規表現
-      #
-      # キャプチャ内容は以下のとおり:
-      #
-      # 1. ダイス数
-      # 2. クリティカル値
-      # 3. 修正値
-      # 4. 達成値
-      DX_SHIPPU_DOTO_RE = /\A(\d+)DX(\d+)?([-+]\d+(?:[-+*]\d+)*)?(?:>=(\d+))?\z/io.freeze
-
       # 成功判定コマンドの構文解析を行う
       # @param [String] command コマンド文字列
       # @return [DX, nil]
       def parse_dx(command)
-        case command
-        when DX_OD_TOOL_RE
-          return parse_dx_od(Regexp.last_match)
-        when DX_SHIPPU_DOTO_RE
-          return parse_dx_shippu_doto(Regexp.last_match)
-        end
-
-        return nil
+        parse_dx_od(command) || parse_dx_shippu_doto(command)
       end
 
       # OD Tool式の成功判定コマンドの正規表現マッチ情報からノードを作る
-      # @param [MatchData] m 正規表現のマッチ情報
+      # @param command [String]
       # @return [DX]
-      def parse_dx_od(m)
-        num = m[1].to_i
-        modifier = m[2] ? ArithmeticEvaluator.eval(m[2]) : 0
-        critical_value = m[3] ? m[3].to_i : 10
+      def parse_dx_od(command)
+        parser = Command::Parser.new(/\d+DX/, round_type: round_type)
+                                .enable_critical
+                                .restrict_cmp_op_to(nil, :>=)
+        parsed = parser.parse(command)
+        return nil unless parsed
 
-        target_value = m[4]&.to_i
+        num = parsed.command.to_i
+        critical_value = parsed.critical || 10
 
-        return DX.new(num, critical_value, modifier, target_value)
+        self.class::DX.new(num, critical_value, parsed.modify_number, parsed.target_number)
       end
 
       # 疾風怒濤式の成功判定コマンドの正規表現マッチ情報からノードを作る
       # @param [MatchData] m 正規表現のマッチ情報
       # @return [DX]
-      def parse_dx_shippu_doto(m)
-        num = m[1].to_i
-        critical_value = m[2] ? m[2].to_i : 10
-        modifier = m[3] ? ArithmeticEvaluator.eval(m[3]) : 0
+      def parse_dx_shippu_doto(command)
+        parser = Command::Parser.new(/\d+DX\d*/, round_type: round_type)
+                                .restrict_cmp_op_to(nil, :>=)
+        parsed = parser.parse(command)
+        return nil unless parsed
 
-        target_value = m[4]&.to_i
+        num, critical_value = parsed.command.split("DX", 2).map { |x| x&.to_i }
+        critical_value ||= 10
 
-        return DX.new(num, critical_value, modifier, target_value)
+        self.class::DX.new(num, critical_value, parsed.modify_number, parsed.target_number)
       end
 
       # 感情表を振る
       #
       # ポジティブとネガティブの両方を振って、表になっている側に○を付ける。
       #
-      # @return [String]
+      # @return [Result]
       def roll_emotion_table
-        pos_result = POSITIVE_EMOTION_TABLE.roll(@randomizer)
-        neg_result = NEGATIVE_EMOTION_TABLE.roll(@randomizer)
+        pos_result = self.class::POSITIVE_EMOTION_TABLE.roll(@randomizer)
+        neg_result = self.class::NEGATIVE_EMOTION_TABLE.roll(@randomizer)
 
         positive = @randomizer.roll_once(2) == 1
         pos_neg_text =
@@ -299,75 +270,92 @@ module BCDice
             [pos_result.content, "○#{neg_result.content}"]
           end
 
+        name = translate("DoubleCross.ET.name")
         output_parts = [
-          "感情表(#{pos_result.sum}-#{neg_result.sum})",
+          "#{name}(#{pos_result.sum}-#{neg_result.sum})",
           pos_neg_text.join(' - ')
         ]
 
-        return output_parts.join(' ＞ ')
+        return Result.new(output_parts.join(' ＞ '))
+      end
+
+      class << self
+        private
+
+        # @param locale [Symbol]
+        # @return [RangeTable]
+        def positive_emotion_table(locale)
+          DiceTable::RangeTable.new(
+            I18n.translate("DoubleCross.ET.positive.name", locale: locale),
+            "1D100",
+            [
+              # [0, '傾倒(けいとう)'],
+              [1..5,    I18n.translate("DoubleCross.ET.positive.items.1_5", locale: locale)],
+              [6..10,   I18n.translate("DoubleCross.ET.positive.items.6_10", locale: locale)],
+              [11..15,  I18n.translate("DoubleCross.ET.positive.items.11_15", locale: locale)],
+              [16..20,  I18n.translate("DoubleCross.ET.positive.items.16_20", locale: locale)],
+              [21..25,  I18n.translate("DoubleCross.ET.positive.items.21_25", locale: locale)],
+              [26..30,  I18n.translate("DoubleCross.ET.positive.items.26_30", locale: locale)],
+              [31..35,  I18n.translate("DoubleCross.ET.positive.items.31_35", locale: locale)],
+              [36..40,  I18n.translate("DoubleCross.ET.positive.items.36_40", locale: locale)],
+              [41..45,  I18n.translate("DoubleCross.ET.positive.items.41_45", locale: locale)],
+              [46..50,  I18n.translate("DoubleCross.ET.positive.items.46_50", locale: locale)],
+              [51..55,  I18n.translate("DoubleCross.ET.positive.items.51_55", locale: locale)],
+              [56..60,  I18n.translate("DoubleCross.ET.positive.items.56_60", locale: locale)],
+              [61..65,  I18n.translate("DoubleCross.ET.positive.items.61_65", locale: locale)],
+              [66..70,  I18n.translate("DoubleCross.ET.positive.items.66_70", locale: locale)],
+              [71..75,  I18n.translate("DoubleCross.ET.positive.items.71_75", locale: locale)],
+              [76..80,  I18n.translate("DoubleCross.ET.positive.items.76_80", locale: locale)],
+              [81..85,  I18n.translate("DoubleCross.ET.positive.items.81_85", locale: locale)],
+              [86..90,  I18n.translate("DoubleCross.ET.positive.items.86_90", locale: locale)],
+              [91..95,  I18n.translate("DoubleCross.ET.positive.items.91_95", locale: locale)],
+              [96..100, I18n.translate("DoubleCross.ET.positive.items.96_100", locale: locale)],
+              # [101, '懐旧(かいきゅう)'],
+              # [102, '任意(にんい)'],
+            ]
+          )
+        end
+
+        # @param locale [Symbol]
+        # @return [RangeTable]
+        def negative_emotion_table(locale)
+          DiceTable::RangeTable.new(
+            I18n.translate("DoubleCross.ET.negative.name", locale: locale),
+            "1D100",
+            [
+              # [0, '侮蔑(ぶべつ)'],
+              [1..5,    I18n.translate("DoubleCross.ET.negative.items.1_5", locale: locale)],
+              [6..10,   I18n.translate("DoubleCross.ET.negative.items.6_10", locale: locale)],
+              [11..15,  I18n.translate("DoubleCross.ET.negative.items.11_15", locale: locale)],
+              [16..20,  I18n.translate("DoubleCross.ET.negative.items.16_20", locale: locale)],
+              [21..25,  I18n.translate("DoubleCross.ET.negative.items.21_25", locale: locale)],
+              [26..30,  I18n.translate("DoubleCross.ET.negative.items.26_30", locale: locale)],
+              [31..35,  I18n.translate("DoubleCross.ET.negative.items.31_35", locale: locale)],
+              [36..40,  I18n.translate("DoubleCross.ET.negative.items.36_40", locale: locale)],
+              [41..45,  I18n.translate("DoubleCross.ET.negative.items.41_45", locale: locale)],
+              [46..50,  I18n.translate("DoubleCross.ET.negative.items.46_50", locale: locale)],
+              [51..55,  I18n.translate("DoubleCross.ET.negative.items.51_55", locale: locale)],
+              [56..60,  I18n.translate("DoubleCross.ET.negative.items.56_60", locale: locale)],
+              [61..65,  I18n.translate("DoubleCross.ET.negative.items.61_65", locale: locale)],
+              [66..70,  I18n.translate("DoubleCross.ET.negative.items.66_70", locale: locale)],
+              [71..75,  I18n.translate("DoubleCross.ET.negative.items.71_75", locale: locale)],
+              [76..80,  I18n.translate("DoubleCross.ET.negative.items.76_80", locale: locale)],
+              [81..85,  I18n.translate("DoubleCross.ET.negative.items.81_85", locale: locale)],
+              [86..90,  I18n.translate("DoubleCross.ET.negative.items.86_90", locale: locale)],
+              [91..95,  I18n.translate("DoubleCross.ET.negative.items.91_95", locale: locale)],
+              [96..100, I18n.translate("DoubleCross.ET.negative.items.96_100", locale: locale)],
+              # [101, '無関心(むかんしん)'],
+              # [102, '任意(にんい)'],
+            ]
+          ).freeze
+        end
       end
 
       # 感情表（ポジティブ）
-      POSITIVE_EMOTION_TABLE = DiceTable::RangeTable.new(
-        '感情表（ポジティブ）',
-        '1D100',
-        [
-          # [0, '傾倒(けいとう)'],
-          [1..5,    '好奇心(こうきしん)'],
-          [6..10,   '憧憬(どうけい)'],
-          [11..15,  '尊敬(そんけい)'],
-          [16..20,  '連帯感(れんたいかん)'],
-          [21..25,  '慈愛(じあい)'],
-          [26..30,  '感服(かんぷく)'],
-          [31..35,  '純愛(じゅんあい)'],
-          [36..40,  '友情(ゆうじょう)'],
-          [41..45,  '慕情(ぼじょう)'],
-          [46..50,  '同情(どうじょう)'],
-          [51..55,  '遺志(いし)'],
-          [56..60,  '庇護(ひご)'],
-          [61..65,  '幸福感(こうふくかん)'],
-          [66..70,  '信頼(しんらい)'],
-          [71..75,  '執着(しゅうちゃく)'],
-          [76..80,  '親近感(しんきんかん)'],
-          [81..85,  '誠意(せいい)'],
-          [86..90,  '好意(こうい)'],
-          [91..95,  '有為(ゆうい)'],
-          [96..100, '尽力(じんりょく)'],
-          # [101, '懐旧(かいきゅう)'],
-          # [102, '任意(にんい)'],
-        ]
-      ).freeze
+      POSITIVE_EMOTION_TABLE = positive_emotion_table(:ja_jp).freeze
 
       # 感情表（ネガティブ）
-      NEGATIVE_EMOTION_TABLE = DiceTable::RangeTable.new(
-        '感情表（ネガティブ）',
-        '1D100',
-        [
-          # [0, '侮蔑(ぶべつ)'],
-          [1..5,    '食傷(しょくしょう)'],
-          [6..10,   '脅威(きょうい)'],
-          [11..15,  '嫉妬(しっと)'],
-          [16..20,  '悔悟(かいご)'],
-          [21..25,  '恐怖(きょうふ)'],
-          [26..30,  '不安(ふあん)'],
-          [31..35,  '劣等感(れっとうかん)'],
-          [36..40,  '疎外感(そがいかん)'],
-          [41..45,  '恥辱(ちじょく)'],
-          [46..50,  '憐憫(れんびん)'],
-          [51..55,  '偏愛(へんあい)'],
-          [56..60,  '憎悪(ぞうお)'],
-          [61..65,  '隔意(かくい)'],
-          [66..70,  '嫌悪(けんお)'],
-          [71..75,  '猜疑心(さいぎしん)'],
-          [76..80,  '厭気(いやけ)'],
-          [81..85,  '不信感(ふしんかん)'],
-          [86..90,  '不快感(ふかいかん)'],
-          [91..95,  '憤懣(ふんまん)'],
-          [96..100, '敵愾心(てきがいしん)'],
-          # [101, '無関心(むかんしん)'],
-          # [102, '任意(にんい)'],
-        ]
-      ).freeze
+      NEGATIVE_EMOTION_TABLE = negative_emotion_table(:ja_jp).freeze
     end
   end
 end