bcdice 3.0.0.pre.alpha.2 → 3.1.1

data/lib/bcdice/game_system/BloodMoon.rb

@@ -59,10 +59,51 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        return roll_tables(command, TABLES)
+        return roll_tables(command, TABLES) || BloodCrusade::RTT.roll_command(randomizer, command)
       end
 
       TABLES = {
+        "ST" => DiceTable::Table.new(
+          "シーン表",
+          "2D6",
+          [
+            "どこまでも広がる荒野。風が吹き抜けていく。",
+            "血まみれの惨劇の跡。いったい誰がこんなことを？",
+            "都市の地下。かぼそい明かりがコンクリートを照らす。",
+            "豪華な調度が揃えられた室内。くつろぎの空間を演出。",
+            "普通の道端。様々な人が道を行き交う。",
+            "明るく浮かぶ月の下。暴力の気配が満ちていく。",
+            "打ち捨てられた廃墟。荒れ果てた景色に心も荒む。",
+            "生活の様子が色濃く残る部屋の中。誰の部屋だろう？",
+            "にぎやかな飲食店。騒ぐ人々に紛れつつ事態は進行する。",
+            "ざわめく木立。踊る影。",
+            "高い塔の上。都市を一望できる。"
+          ]
+        ),
+        "MIT" => DiceTable::Table.new(
+          "軽度狂気表",
+          "1D6",
+          [
+            "【誇大妄想】（判定に失敗するたびに【テンション】が１増加する。）",
+            "【記憶喪失】（【幸福】の修復判定にマイナス２の修正。）",
+            "【こだわり】（戦闘中の行動を「パス」以外で一つ選択し、その行動をすると【テンション】が６増加する。）",
+            "【お守り中毒】（「幸運のお守り」を装備していない場合、全ての2d6判定にマイナス１の修正。）",
+            "【不死幻想】（自分が受けるダメージが全て１増加する。）",
+            "【血の飢え】（戦闘中、ラウンドごとに他のキャラクターにダメージを与えないと、ラウンド終了時に【テンション】４増加。）"
+          ]
+        ),
+        "SIT" => DiceTable::Table.new(
+          "重度狂気表",
+          "1D6",
+          [
+            "【幸福依存】（【幸福】を一つ選択し、その【幸福】が結果フェイズに失われたとき、死亡する。）",
+            "【見えない友達】（交流判定にマイナス３の修正がつく。）",
+            "【臆病】（自分の行う妨害判定にマイナス２の修正がつく。）",
+            "【陰謀論】（休息判定にマイナス３の修正がつく。）",
+            "【指令受信】（メインフェイズの３サイクル目の自分のシーンでは、可能な範囲でGMが行動を決定する。）",
+            "【猜疑心】（自分が「連携攻撃」を行うとき、関係の【深度】をダメージに加えられない。）"
+          ]
+        ),
         "CHT" => DiceTable::Table.new(
           "自信幸福表",
           "1D6",
@@ -206,7 +247,7 @@ module BCDice
         ),
       }.merge(BloodCrusade::TABLES_WITH_BLOOD_MOON).freeze
 
-      register_prefix(TABLES.keys)
+      register_prefix(BloodCrusade::RTT.prefixes, TABLES.keys)
     end
   end
 end

data/lib/bcdice/game_system/CardRanker.rb

@@ -14,10 +14,11 @@ module BCDice
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
-        ランダムでモンスターカードを選ぶ (RM)
+        ランダムでモンスターカードを選ぶ (RM) (RTTn n：色番号、省略可能)
+        ランダム分野表 RCT
         特定のモンスターカードを選ぶ (CMxy　x：色、y：番号）
         　白：W、青：U、緑：V、金：G、赤：R、黒：B
-        　例）CMW1→白の2：白竜　CMG12→金の12：土精霊
+        　例）CMW2→白の2：白竜　CMG12→金の12：土精霊
         場所表 (ST)
         街中場所表 (CST)
         郊外場所表 (OST)
@@ -43,7 +44,7 @@ module BCDice
         if dice_total <= 2
           return " ＞ ファンブル"
         elsif dice_total >= 12
-          return " ＞ スペシャル ＞ " + getRandumMonster()
+          return " ＞ スペシャル ＞ " + RTT.roll_command(@randomizer, "RM")
         elsif total >= target
           return " ＞ 成功"
         else
@@ -52,72 +53,31 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        command = command.upcase
-
-        case command
-        when /^RM$/i
-          return getRandumMonster
-        when /^CM(\w)(\d+)$/i
-          color = Regexp.last_match(1).upcase
-          index = Regexp.last_match(2).to_i
-          return getMonster(color, index)
-        else
-          return roll_tables(command, TABLES)
-        end
-      end
-
-      def getRandumMonster
-        type = "ランダムモンスター選択"
-        colorTable = getColorTable
-        color, colorIndex = get_table_by_1d6(colorTable)
-
-        monsters = getMonsterTables(colorIndex - 1)
-        monsterName, monsterIndex = get_table_by_2d6(monsters)
-
-        output = "#{type}(#{colorIndex},#{monsterIndex}) ＞ #{color}の#{monsterIndex}：#{monsterName}"
-        return output
+        roll_tables(command, TABLES) || get_monster(command) || RTT.roll_command(randomizer, command)
       end
 
-      def getColorTable
-        ['白', '青', '緑', '金', '赤', '黒']
-      end
-
-      def getMonsterTables(colorIndex)
-        tables = [
-          ['白竜', '僧侶', '格闘家', '斧使い', '剣士', '槍士', '歩兵', '弓兵', '砲兵', '天使', '軍神'],
-          ['水竜', '魚', '魚人', 'イカ', '蟹', '探偵', '海賊', '魔術師', '使い魔', '雲', '水精霊'],
-          ['緑竜', 'ワーム', '鳥人', '鳥', '獣', '獣人', 'エルフ', '妖精', '昆虫', '植物', '森精霊'],
-          ['金竜', '宝石', '岩石', '鋼', '錬金術師', '魔法生物', 'ドワーフ', '機械', '運命', '女神', '土精霊'],
-          ['火竜', '竜人', '恐竜', '戦車', '蛮族', '小鬼', '大鬼', '巨人', '雷', '炎', '火精霊'],
-          ['黒竜', '闇騎士', '怪物', '忍者', '妖怪', '蝙蝠', '吸血鬼', '不死者', '幽霊', '悪魔', '邪神'],
-        ]
-
-        return tables[colorIndex]
-      end
-
-      def getMonster(color, monsterIndex)
-        return nil if monsterIndex < 2
-
-        type = "モンスター選択"
-
-        colorWords = ['W', 'U', 'V', 'G', 'R', 'B']
-        colorIndex = colorWords.index(color)
-        debug("colorIndex")
-
-        return nil if colorIndex.nil?
+      COLOR_TABLE = ['W', 'U', 'V', 'G', 'R', 'B'].freeze
 
-        colorTable = getColorTable
-        color = colorTable[colorIndex]
+      RTT = DiceTable::SaiFicSkillTable.new([
+        ['白', ['白竜', '僧侶', '格闘家', '斧使い', '剣士', '槍士', '歩兵', '弓兵', '砲兵', '天使', '軍神']],
+        ['青', ['水竜', '魚', '魚人', 'イカ', '蟹', '探偵', '海賊', '魔術師', '使い魔', '雲', '水精霊']],
+        ['緑', ['緑竜', 'ワーム', '鳥人', '鳥', '獣', '獣人', 'エルフ', '妖精', '昆虫', '植物', '森精霊']],
+        ['金', ['金竜', '宝石', '岩石', '鋼', '錬金術師', '魔法生物', 'ドワーフ', '機械', '運命', '女神', '土精霊']],
+        ['赤', ['火竜', '竜人', '恐竜', '戦車', '蛮族', '小鬼', '大鬼', '巨人', '雷', '炎', '火精霊']],
+        ['黒', ['黒竜', '闇騎士', '怪物', '忍者', '妖怪', '蝙蝠', '吸血鬼', '不死者', '幽霊', '悪魔', '邪神']],
+      ], rtt: "RM", rtt_format: "ランダムモンスター選択(%<category_dice>d,%<row_dice>d) ＞ %<text>s", s_format: "%<category_name>sの%<row_dice>d：%<skill_name>s")
 
-        monsters = getMonsterTables(colorIndex)
-        debug("monsters", monsters)
-        debug("monsterIndex", monsterIndex)
-        monsterName = monsters[monsterIndex - 2]
+      def get_monster(command)
+        m = command.match(/^CM(\w)(\d+)$/i)
+        return nil unless m
 
-        return nil if monsterName.nil?
+        cat = COLOR_TABLE.index(m[1])
+        row_dice = m[2].to_i
+        return nil unless cat
+        return nil unless row_dice.between?(2, 12)
 
-        output = "#{type} ＞ #{color}の#{monsterIndex}：#{monsterName}"
-        return output
+        skill = RTT.categories[cat].skills[row_dice - 2]
+        return "モンスター選択 ＞ #{skill}"
       end
 
       TABLES = {
@@ -242,7 +202,7 @@ module BCDice
           ]
         ),
       }.freeze
-      register_prefix('RM', 'CM.*', TABLES.keys)
+      register_prefix(RTT.prefixes, 'CM', TABLES.keys)
     end
   end
 end

data/lib/bcdice/game_system/ChaosFlare.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'bcdice/command_parser'
-
 module BCDice
   module GameSystem
     class ChaosFlare < Base
@@ -41,7 +39,7 @@ module BCDice
           - FT7
       INFO_MESSAGE_TEXT
 
-      register_prefix('\d*CF.*', 'FT\d*')
+      register_prefix('\d*CF', 'FT\d*')
 
       # ゲーム別成功度判定(2D6)。以前の処理をそのまま残しています。
       def check_2D6(total, dice_total, _dice_list, cmp_op, target)
@@ -108,7 +106,9 @@ module BCDice
       # @param command [String]
       # @return [String, nil]
       def cf_roll(command)
-        parser = CommandParser.new(/\d*CF/)
+        parser = Command::Parser.new(/\d*CF/, round_type: round_type)
+                                .enable_critical
+                                .enable_fumble
 
         @cmd = parser.parse(command)
         unless @cmd

data/lib/bcdice/game_system/Chill.rb

@@ -22,7 +22,7 @@ module BCDice
         　例）SR7　　　sr13　　　SR(7+4)　　　Ssr10
       INFO_MESSAGE_TEXT
 
-      register_prefix('SR\d+.*')
+      register_prefix('SR\d+')
 
       def check_1D100(total, _dice_total, cmp_op, target)
         return '' if target == '?'

data/lib/bcdice/game_system/CodeLayerd.rb

@@ -26,9 +26,17 @@ module BCDice
           4CL+2@7 または 4CL@7+2  ：サイコロ4個で判定値7のロールを行い達成値を出し、修正値2を足す。
           4CL[2] ：サイコロ4個でクリティカル値2のロールを行う。
           0CL : 1CL[0]と同じ判定
+
+          デフォルトダイス：10面
       MESSAGETEXT
 
-      register_prefix('[+-]?\d*CL([+-]\d+)?[@\d]*.*')
+      register_prefix('[+-]?\d*CL([+-]\d+)?[@\d]*')
+
+      def initialize(command)
+        super(command)
+
+        @sides_implicit_d = 10
+      end
 
       def eval_game_system_specific_command(command)
         debug('eval_game_system_specific_command command', command)
@@ -36,15 +44,15 @@ module BCDice
         result = ''
 
         case command
-        when /([+-]?\d+)?CL([+-]\d+)?(\@(\d))?(\[(\d+)\])?([+-]\d+)?(>=(\d+))?/i
+        when /([+-]?\d+)?CL([+-]\d+)?(@(\d))?(\[(\d+)\])?([+-]\d+)?(>=(\d+))?/i
           m = Regexp.last_match
           base = (m[1] || 1).to_i
           modifier1 = m[2].to_i
           target = (m[4] || 6).to_i
-          criticalTarget = (m[6] || 1).to_i
+          critical_target = (m[6] || 1).to_i
           modifier2 = m[7].to_i
           diff = m[9].to_i
-          result = checkRoll(base, target, criticalTarget, diff, modifier1 + modifier2)
+          result = check_roll(base, target, critical_target, diff, modifier1 + modifier2)
         end
 
         return nil if result.empty?
@@ -52,80 +60,42 @@ module BCDice
         return "#{command} ＞ #{result}"
       end
 
-      def checkRoll(base, target, criticalTarget, diff, modifier)
-        result = ""
-
-        base = getValue(base)
-        target = getValue(target)
-        criticalTarget = getValue(criticalTarget)
-        if base <= 0
-          criticalTarget = 0
+      def check_roll(base, target, critical_target, diff, modifier)
+        if base <= 0 # クリティカルしない1D
+          critical_target = 0
           base = 1
         end
 
         target = 10 if target > 10
+        dice_list = @randomizer.roll_barabara(base, 10).sort
+        success_count = dice_list.count { |x| x <= target }
+        critical_count = dice_list.count { |x| x <= critical_target }
+        success_total = success_count + critical_count + modifier
 
-        result += "(#{base}d10#{Format.modifier(modifier)})"
-
-        diceList = @randomizer.roll_barabara(base, 10).sort
-
-        result += " ＞ [#{diceList.join(',')}]#{Format.modifier(modifier)} ＞ "
-        result += getRollResultString(diceList, target, criticalTarget, diff, modifier)
-
-        return result
-      end
-
-      def getRollResultString(diceList, target, criticalTarget, diff, modifier)
-        successCount, criticalCount = getSuccessInfo(diceList, target, criticalTarget)
-
-        successTotal = successCount + criticalCount + modifier
-        result = ""
+        mod_text = Format.modifier(modifier)
 
+        # (10d10+5)
+        result = "(#{base}d10#{mod_text}) ＞ [#{dice_list.join(',')}]#{mod_text} ＞ "
         result += "判定値[#{target}] " unless target == 6
-        result += "クリティカル値[#{criticalTarget}] " unless criticalTarget == 1
-        result += "達成値[#{successCount}]"
-
-        # 出目がすべて判定値より大きければ固定値に関わらずファンブル
-        if successCount <= 0
-          result += " ＞ ファンブル！"
-          return result
-        end
-
-        result += "+クリティカル[#{criticalCount}]" if criticalCount > 0
-        result += Format.modifier(modifier)
-        result += "=[#{successTotal}]" if criticalCount > 0 || modifier != 0
-
-        successText = getSuccessResultText(successTotal, diff)
-        result += " ＞ #{successText}"
-
-        return result
-      end
-
-      def getSuccessResultText(successTotal, diff)
-        return successTotal.to_s if diff == 0
-        return "成功" if successTotal >= diff
+        result += "クリティカル値[#{critical_target}] " unless critical_target == 1
+        result += "達成値[#{success_count}]"
 
-        return "失敗"
-      end
-
-      def getSuccessInfo(diceList, target, criticalTarget)
-        debug("checkSuccess diceList, target, criticalTarget", diceList, target, criticalTarget)
-
-        successCount  = 0
-        criticalCount = 0
+        return "#{result} ＞ ファンブル！" if success_count <= 0
 
-        diceList.each do |dice|
-          successCount += 1 if dice <= target
-          criticalCount += 1 if dice <= criticalTarget
-        end
-
-        return successCount, criticalCount
-      end
+        result += "+クリティカル[#{critical_count}]" if critical_count > 0
+        result += mod_text
+        result += "=[#{success_total}]" if critical_count > 0 || modifier != 0
 
-      def getValue(number)
-        return 0 if number > 100
+        success_text =
+          if diff == 0
+            success_total.to_s
+          elsif success_total >= diff
+            "成功"
+          else
+            "失敗"
+          end
 
-        return number
+        return "#{result} ＞ #{success_text}"
       end
     end
   end

data/lib/bcdice/game_system/ColossalHunter.rb

@@ -45,7 +45,7 @@ module BCDice
       def getCheckRollDiceCommandResult(command)
         debug("getCheckRollDiceCommandResult command", command)
 
-        return nil unless command =~ /(\d+)?CH([\+\-\d]*)(>=([\+\-\d]*))?$/i
+        return nil unless command =~ /(\d+)?CH([+\-\d]*)(>=([+\-\d]*))?$/i
 
         diceCount = (Regexp.last_match(1) || 3).to_i
         modifyText = (Regexp.last_match(2) || '')
@@ -134,7 +134,7 @@ module BCDice
       def getYear(yearText)
         text = yearText.gsub(/(\d+)D(6+)/) { getD6xResult(Regexp.last_match(1).to_i, Regexp.last_match(2).length) }
 
-        unless text.match?(%r{^[\+\-\*/\d]+$})
+        unless text.match?(%r{^[+\-*/\d]+$})
           return nil
         end
 

data/lib/bcdice/game_system/Cthulhu.rb

@@ -48,7 +48,7 @@ module BCDice
 
       INFO_MESSAGE_TEXT
 
-      register_prefix('CC(B)?\(\d+\)', 'CC(B)?.*', 'RES(B)?.*', 'CBR(B)?\(\d+,\d+\)')
+      register_prefix('CC(B)?\(\d+\)', 'CC(B)?', 'RES(B)?', 'CBR(B)?\(\d+,\d+\)')
 
       def initialize(command)
         super(command)
@@ -97,7 +97,11 @@ module BCDice
       private
 
       def getCheckResult(command)
-        m = %r{CCB?(\d+)?(?:<=([+-/*\d]+))?}i.match(command)
+        m = %r{^CCB?(\d+)?(?:<=([+-/*\d]+))?$}i.match(command)
+        unless m
+          return nil
+        end
+
         broken_num = m[1].to_i
         diff = ArithmeticEvaluator.eval(m[2])
 
@@ -189,7 +193,7 @@ module BCDice
       end
 
       def getRegistResult(command)
-        m = /RES(B)?([-\d]+)/i.match(command)
+        m = /^RES(B)?([-\d]+)$/i.match(command)
         unless m
           return nil
         end
@@ -215,7 +219,7 @@ module BCDice
       end
 
       def getCombineRoll(command)
-        m = /CBR(B)?\((\d+),(\d+)\)/i.match(command)
+        m = /^CBR(B)?\((\d+),(\d+)\)$/i.match(command)
         unless m
           return nil
         end

data/lib/bcdice/game_system/Cthulhu7th.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "bcdice/game_system/cthulhu7th/rollable"
+require "bcdice/game_system/cthulhu7th/full_auto"
+
 module BCDice
   module GameSystem
     class Cthulhu7th < Base
@@ -45,37 +48,31 @@ module BCDice
         　　強力でない呪文の場合　FCL／強力な呪文の場合　FCM
       INFO_MESSAGE_TEXT
 
-      register_prefix('CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR.*', 'BMR', 'BMS', 'FCL', 'FCM', 'PH', 'MA')
-
-      BONUS_DICE_RANGE = (-2..2).freeze
+      register_prefix('CC', 'CBR\(\d+,\d+\)', 'FAR', 'BMR', 'BMS', 'FCL', 'FCM', 'PH', 'MA')
 
       def eval_game_system_specific_command(command)
         case command
         when /^CC/i
-          return skill_roll(command)
+          skill_roll(command)
         when /^CBR/i
-          return combine_roll(command)
+          combine_roll(command)
         when /^FAR/i
-          return getFullAutoResult(command)
+          getFullAutoResult(command)
         when /^BMR/i # 狂気の発作（リアルタイム）
-          return roll_bmr_table()
+          roll_bmr_table()
         when /^BMS/i # 狂気の発作（サマリー）
-          return roll_bms_table()
+          roll_bms_table()
         when /^FCL/i # キャスティング・ロールのプッシュに失敗した場合（小）
-          return roll_1d8_table("キャスティング・ロール失敗(小)表", FAILED_CASTING_L_TABLE)
+          roll_1d8_table("キャスティング・ロール失敗(小)表", FAILED_CASTING_L_TABLE)
         when /^FCM/i # キャスティング・ロールのプッシュに失敗した場合（大）
-          return roll_1d8_table("キャスティング・ロール失敗(大)表", FAILED_CASTING_M_TABLE)
+          roll_1d8_table("キャスティング・ロール失敗(大)表", FAILED_CASTING_M_TABLE)
         when /^PH/i # 恐怖症表
-          return roll_1d100_table("恐怖症表", PHOBIAS_TABLE)
+          roll_1d100_table("恐怖症表", PHOBIAS_TABLE)
         when /^MA/i # マニア表
-          return roll_1d100_table("マニア表", MANIAS_TABLE)
-        else
-          return nil
+          roll_1d100_table("マニア表", MANIAS_TABLE)
         end
       end
 
-      private
-
       class ResultLevel
         LEVEL = [
           :fumble,
@@ -95,6 +92,24 @@ module BCDice
           failure: "失敗",
         }.freeze
 
+        def self.from_values(total, difficulty, fumbleable = false)
+          fumble = difficulty < 50 || fumbleable ? 96 : 100
+
+          if total == 1
+            ResultLevel.new(:critical)
+          elsif total <= (difficulty / 5)
+            ResultLevel.new(:extreme_success)
+          elsif total <= (difficulty / 2)
+            ResultLevel.new(:hard_success)
+          elsif total <= difficulty
+            ResultLevel.new(:regular_success)
+          elsif total >= fumble
+            ResultLevel.new(:fumble)
+          else
+            ResultLevel.new(:failure)
+          end
+        end
+
         def initialize(level)
           @level = level
           @level_index = LEVEL.index(level)
@@ -122,6 +137,10 @@ module BCDice
         end
       end
 
+      private
+
+      include Rollable
+
       def roll_1d8_table(table_name, table)
         total_n = @randomizer.roll_once(8)
         index = total_n - 1
@@ -154,14 +173,14 @@ module BCDice
           return "1D100 ＞ #{dice}"
         end
 
-        unless BONUS_DICE_RANGE.include?(bonus_dice)
-          return "エラー。ボーナス・ペナルティダイスの値は#{BONUS_DICE_RANGE.min}～#{BONUS_DICE_RANGE.max}です。"
+        if bonus_dice.abs > 100
+          return "ボーナス・ペナルティダイスの値は-100以上、100以下としてください"
         end
 
         total, total_list = roll_with_bonus(bonus_dice)
 
         expr = difficulty.zero? ? "1D100" : "1D100<=#{difficulty}"
-        result = result_level(total, difficulty) unless difficulty.zero?
+        result = ResultLevel.from_values(total, difficulty) unless difficulty.zero?
 
         sequence = [
           "(#{expr}) ボーナス・ペナルティダイス[#{bonus_dice}]",
@@ -180,54 +199,8 @@ module BCDice
         end
       end
 
-      # 1D100の一の位用のダイスロール
-      # 0から9までの値を返す
-      #
-      # @return [Integer]
-      def roll_ones_d10
-        dice = @randomizer.roll_once(10)
-        return 0 if dice == 10
-
-        return dice
-      end
-
-      # @param bonus [Integer] ボーナス・ペナルティダイスの数。負の数ならペナルティダイス。
-      # @return [Array<(Integer, Array<Integer>)>]
-      def roll_with_bonus(bonus)
-        tens_list = Array.new(bonus.abs + 1) { @randomizer.roll_tens_d10 }
-        ones = roll_ones_d10()
-
-        dice_list = tens_list.map do |tens|
-          dice = tens + ones
-          dice == 0 ? 100 : dice
-        end
-
-        dice =
-          if bonus >= 0
-            dice_list.min
-          else
-            dice_list.max
-          end
-
-        return dice, dice_list
-      end
-
-      def result_level(total, difficulty, fumbleable = false)
-        fumble = difficulty < 50 || fumbleable ? 96 : 100
-
-        if total == 1
-          ResultLevel.new(:critical)
-        elsif total <= (difficulty / 5)
-          ResultLevel.new(:extreme_success)
-        elsif total <= (difficulty / 2)
-          ResultLevel.new(:hard_success)
-        elsif total <= difficulty
-          ResultLevel.new(:regular_success)
-        elsif total >= fumble
-          ResultLevel.new(:fumble)
-        else
-          ResultLevel.new(:failure)
-        end
+      def getFullAutoResult(command)
+        FullAuto.eval(command, @randomizer)
       end
 
       def combine_roll(command)
@@ -239,8 +212,8 @@ module BCDice
 
         total = @randomizer.roll_once(100)
 
-        result_1 = result_level(total, difficulty_1)
-        result_2 = result_level(total, difficulty_2)
+        result_1 = ResultLevel.from_values(total, difficulty_1)
+        result_2 = ResultLevel.from_values(total, difficulty_2)
 
         rank =
           if result_1.success? && result_2.success?
@@ -258,273 +231,6 @@ module BCDice
         end
       end
 
-      def getFullAutoResult(command)
-        return nil unless /^FAR\((-?\d+),(-?\d+),(-?\d+)(?:,(-?\d+)?)?(?:,(-?\w+)?)?(?:,(-?\d+)?)?\)/i =~ command
-
-        bullet_count = Regexp.last_match(1).to_i
-        diff = Regexp.last_match(2).to_i
-        broken_number = Regexp.last_match(3).to_i
-        bonus_dice_count = (Regexp.last_match(4) || 0).to_i
-        stop_count = (Regexp.last_match(5) || "").to_s.downcase
-        bullet_set_count_cap = (Regexp.last_match(6) || diff / 10).to_i
-
-        output = ""
-
-        # 最大で（8回*（PC技能値最大値/10））＝72発しか撃てないはずなので上限
-        bullet_count_limit = 100
-        if bullet_count > bullet_count_limit
-          output += "弾薬が多すぎます。装填された弾薬を#{bullet_count_limit}発に変更します。\n"
-          bullet_count = bullet_count_limit
-        end
-
-        # ボレーの上限の設定がおかしい場合の注意表示
-        if (bullet_set_count_cap > diff / 10) && (diff > 39) && !Regexp.last_match(6).nil?
-          bullet_set_count_cap = diff / 10
-          output += "ボレーの弾丸の数の上限は\[技能値÷10（切り捨て）\]発なので、それより高い数を指定できません。ボレーの弾丸の数を#{bullet_set_count_cap}発に変更します。\n"
-        elsif (diff <= 39) && (bullet_set_count_cap > 3) && !Regexp.last_match(6).nil?
-          bullet_set_count_cap = 3
-          output += "技能値が39以下ではボレーの弾丸の数の上限および下限は3発です。ボレーの弾丸の数を#{bullet_set_count_cap}発に変更します。\n"
-        end
-
-        # ボレーの下限の設定がおかしい場合の注意表示およびエラー表示
-        return "ボレーの弾丸の数は正の数です。" if (bullet_set_count_cap <= 0) && !Regexp.last_match(6).nil?
-
-        if (bullet_set_count_cap < 3) && !Regexp.last_match(6).nil?
-          bullet_set_count_cap = 3
-          output += "ボレーの弾丸の数の下限は3発です。ボレーの弾丸の数を3発に変更します。\n"
-        end
-
-        return "弾薬は正の数です。" if bullet_count <= 0
-        return "目標値は正の数です。" if diff <= 0
-
-        if broken_number < 0
-          output += "故障ナンバーは正の数です。マイナス記号を外します。\n"
-          broken_number = broken_number.abs
-        end
-
-        unless BONUS_DICE_RANGE.include?(bonus_dice_count)
-          return "エラー。ボーナス・ペナルティダイスの値は#{BONUS_DICE_RANGE.min}～#{BONUS_DICE_RANGE.max}です。"
-        end
-
-        output += "ボーナス・ペナルティダイス[#{bonus_dice_count}]"
-        output += rollFullAuto(bullet_count, diff, broken_number, bonus_dice_count, stop_count, bullet_set_count_cap)
-
-        return output
-      end
-
-      def rollFullAuto(bullet_count, diff, broken_number, dice_num, stop_count, bullet_set_count_cap)
-        output = ""
-        loopCount = 0
-
-        counts = {
-          hit_bullet: 0,
-          impale_bullet: 0,
-          bullet: bullet_count,
-        }
-
-        # 難易度変更用ループ
-        (0..3).each do |more_difficulty|
-          output += getNextDifficultyMessage(more_difficulty)
-
-          # ペナルティダイスを減らしながらロール用ループ
-          while dice_num >= BONUS_DICE_RANGE.min
-
-            loopCount += 1
-            hit_result, total, total_list = getHitResultInfos(dice_num, diff, more_difficulty)
-            output += "\n#{loopCount}回目: ＞ #{total_list.join(', ')} ＞ #{hit_result}"
-
-            if total >= broken_number
-              output += "　ジャム"
-              return getHitResultText(output, counts)
-            end
-
-            hit_type = getHitType(more_difficulty, hit_result)
-            hit_bullet, impale_bullet, lost_bullet = getBulletResults(counts[:bullet], hit_type, diff, bullet_set_count_cap)
-
-            output += "　（#{hit_bullet}発が命中、#{impale_bullet}発が貫通）"
-
-            counts[:hit_bullet] += hit_bullet
-            counts[:impale_bullet] += impale_bullet
-            counts[:bullet] -= lost_bullet
-
-            return getHitResultText(output, counts) if counts[:bullet] <= 0
-
-            dice_num -= 1
-          end
-
-          # 指定された難易度となった場合、連射処理を途中で止める
-          if shouldStopRollFullAuto?(stop_count, more_difficulty)
-            output += "\n【指定の難易度となったので、処理を終了します。】"
-            break
-          end
-
-          dice_num += 1
-        end
-
-        return getHitResultText(output, counts)
-      end
-
-      # 連射処理を止める条件（難易度の閾値）
-      # @return [Hash<String, Integer>]
-      #
-      # 成功の種類の小文字表記 => 難易度の閾値
-      ROLL_FULL_AUTO_DIFFICULTY_THRESHOLD = {
-        # レギュラー
-        'r' => 0,
-        # ハード
-        'h' => 1,
-        # イクストリーム
-        'e' => 2
-      }.freeze
-
-      # 連射処理を止めるべきかどうかを返す
-      # @param [String] stop_count 成功の種類
-      # @param [Integer] difficulty 難易度
-      # @return [Boolean]
-      def shouldStopRollFullAuto?(stop_count, difficulty)
-        difficulty_threshold = ROLL_FULL_AUTO_DIFFICULTY_THRESHOLD[stop_count]
-        return difficulty_threshold && difficulty >= difficulty_threshold
-      end
-
-      def getHitResultInfos(dice_num, diff, more_difficulty)
-        total, total_list = roll_with_bonus(dice_num)
-
-        fumbleable = getFumbleable(more_difficulty)
-        hit_result = result_level(total, diff, fumbleable).to_s
-
-        return hit_result, total, total_list
-      end
-
-      def getHitResultText(output, counts)
-        return "#{output}\n＞ #{counts[:hit_bullet]}発が通常命中、#{counts[:impale_bullet]}発が貫通、残弾#{counts[:bullet]}発"
-      end
-
-      def getHitType(more_difficulty, hit_result)
-        successList, impaleBulletList = getSuccessListImpaleBulletList(more_difficulty)
-
-        return :hit if successList.include?(hit_result)
-        return :impale if impaleBulletList.include?(hit_result)
-
-        return ""
-      end
-
-      def getBulletResults(bullet_count, hit_type, diff, bullet_set_count_cap)
-        bullet_set_count = getSetOfBullet(diff, bullet_set_count_cap)
-        hit_bullet_count_base = getHitBulletCountBase(diff, bullet_set_count)
-        impale_bullet_count_base = (bullet_set_count / 2.to_f)
-
-        lost_bullet_count = 0
-        hit_bullet_count = 0
-        impale_bullet_count = 0
-
-        if !isLastBulletTurn(bullet_count, bullet_set_count)
-
-          case hit_type
-          when :hit
-            hit_bullet_count = hit_bullet_count_base # 通常命中した弾数の計算
-
-          when :impale
-            impale_bullet_count = impale_bullet_count_base.floor # 貫通した弾数の計算
-            hit_bullet_count = impale_bullet_count_base.ceil
-          end
-
-          lost_bullet_count = bullet_set_count
-
-        else
-
-          case hit_type
-          when :hit
-            hit_bullet_count = getLastHitBulletCount(bullet_count)
-
-          when :impale
-            impale_bullet_count = getLastHitBulletCount(bullet_count)
-            hit_bullet_count = bullet_count - impale_bullet_count
-          end
-
-          lost_bullet_count = bullet_count
-        end
-
-        return hit_bullet_count, impale_bullet_count, lost_bullet_count
-      end
-
-      def getSuccessListImpaleBulletList(more_difficulty)
-        successList = []
-        impaleBulletList = []
-
-        case more_difficulty
-        when 0
-          successList = ["ハード成功", "レギュラー成功"]
-          impaleBulletList = ["クリティカル", "イクストリーム成功"]
-        when 1
-          successList = ["ハード成功"]
-          impaleBulletList = ["クリティカル", "イクストリーム成功"]
-        when 2
-          successList = []
-          impaleBulletList = ["クリティカル", "イクストリーム成功"]
-        when 3
-          successList = ["クリティカル"]
-          impaleBulletList = []
-        end
-
-        return successList, impaleBulletList
-      end
-
-      def getNextDifficultyMessage(more_difficulty)
-        case more_difficulty
-        when 1
-          return "\n【難易度がハードに変更】"
-        when 2
-          return "\n【難易度がイクストリームに変更】"
-        when 3
-          return "\n【難易度がクリティカルに変更】"
-        end
-
-        return ""
-      end
-
-      def getSetOfBullet(diff, bullet_set_count_cap)
-        bullet_set_count = diff / 10
-
-        if bullet_set_count_cap < bullet_set_count
-          bullet_set_count = bullet_set_count_cap
-        end
-
-        if (diff >= 1) && (diff < 30)
-          bullet_set_count = 3 # 技能値が29以下での最低値保障処理
-        end
-
-        return bullet_set_count
-      end
-
-      def getHitBulletCountBase(diff, bullet_set_count)
-        hit_bullet_count_base = (bullet_set_count / 2)
-
-        if (diff >= 1) && (diff < 30)
-          hit_bullet_count_base = 1 # 技能値29以下での最低値保障
-        end
-
-        return hit_bullet_count_base
-      end
-
-      def isLastBulletTurn(bullet_count, bullet_set_count)
-        ((bullet_count - bullet_set_count) < 0)
-      end
-
-      def getLastHitBulletCount(bullet_count)
-        # 残弾1での最低値保障処理
-        if bullet_count == 1
-          return 1
-        end
-
-        count = (bullet_count / 2.to_f).floor
-        return count
-      end
-
-      def getFumbleable(more_difficulty)
-        # 成功が49以下の出目のみとなるため、ファンブル値は上昇
-        return (more_difficulty >= 1)
-      end
-
       # 表一式
       # 即時の恐怖症表
       def roll_bmr_table()