bcdice 3.0.0 → 3.2.0

data/lib/bcdice/game_system/Chill.rb

@@ -22,24 +22,24 @@ module BCDice
         　例）SR7　　　sr13　　　SR(7+4)　　　Ssr10
       INFO_MESSAGE_TEXT
 
-      register_prefix('SR\d+.*')
+      register_prefix('SR')
 
-      def check_1D100(total, _dice_total, cmp_op, target)
-        return '' if target == '?'
-        return '' if cmp_op != :<=
+      def result_1d100(total, _dice_total, cmp_op, target)
+        return nil if target == '?'
+        return nil if cmp_op != :<=
 
         if total >= 100
-          " ＞ ファンブル"
+          Result.fumble("ファンブル")
         elsif total > target
-          " ＞ 失敗"
+          Result.failure("失敗")
         elsif total >= (target * 0.9)
-          " ＞ Ｌ成功"
+          Result.success("Ｌ成功")
         elsif total >= (target / 2)
-          " ＞ Ｍ成功"
+          Result.success("Ｍ成功")
         elsif total >= (target / 10)
-          " ＞ Ｈ成功"
+          Result.success("Ｈ成功")
         else
-          " ＞ Ｃ成功"
+          Result.critical("Ｃ成功")
         end
       end
 

data/lib/bcdice/game_system/Chill3.rb

@@ -19,9 +19,9 @@ module BCDice
         　　　Chill3 : (1D100<=50) ＞ 55 ＞ Botch
       INFO_MESSAGE_TEXT
 
-      def check_1D100(total, dice_total, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :<=
+      def result_1d100(total, dice_total, cmp_op, target)
+        return nil if target == '?'
+        return nil unless cmp_op == :<=
 
         # ゾロ目ならC-ResultかBotch
         tens = (dice_total / 10) % 10
@@ -30,21 +30,21 @@ module BCDice
         if tens == ones
           if (total > target) || (dice_total == 100) # 00は必ず失敗
             if target > 100 # 目標値が100を超えている場合は、00を振ってもBotchにならない
-              return " ＞ 失敗"
+              return Result.failure("失敗")
             else
-              return " ＞ Botch"
+              return Result.fumble("Botch")
             end
           else
-            return " ＞ Ｃ成功"
+            return Result.critical("Ｃ成功")
           end
         elsif (total <= target) || (dice_total == 1) # 01は必ず成功
           if total <= (target / 2)
-            return " ＞ Ｈ成功"
+            return Result.success("Ｈ成功")
           else
-            return " ＞ Ｌ成功"
+            return Result.success("Ｌ成功")
           end
         else
-          return " ＞ 失敗"
+          return Result.failure("失敗")
         end
       end
     end

data/lib/bcdice/game_system/CodeLayerd.rb

@@ -30,7 +30,7 @@ module BCDice
           デフォルトダイス：10面
       MESSAGETEXT
 
-      register_prefix('[+-]?\d*CL([+-]\d+)?[@\d]*.*')
+      register_prefix('[+-]?\d*CL([+-]\d+)?[@\d]*')
 
       def initialize(command)
         super(command)

data/lib/bcdice/game_system/CrashWorld.rb

@@ -19,7 +19,7 @@ module BCDice
         例・CW8
       INFO_MESSAGE_TEXT
 
-      register_prefix('CW\d+')
+      register_prefix('CW')
 
       def eval_game_system_specific_command(command)
         result = nil

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('CCB?', 'RESB?', 'CBRB?')
 
       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
@@ -14,13 +17,19 @@ module BCDice
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
-        ※コマンドは入力内容の前方一致で検出しています。
         ・判定　CC(x)<=（目標値）
-        　x：ボーナス・ペナルティダイス (2～－2)。省略可。
+        　x：ボーナス・ペナルティダイス。省略可。
         　目標値が無くても1D100は表示される。
         　ファンブル／失敗／　レギュラー成功／ハード成功／
         　イクストリーム成功／クリティカル を自動判定。
-        例）CC<=30　CC(2)<=50 CC(+2)<=50 CC(-1)<=75 CC-1<=50 CC1<=65 CC+1<=65 CC
+        　例）CC<=30　CC(2)<=50 CC(+2)<=50 CC(-1)<=75 CC-1<=50 CC1<=65 CC+1<=65 CC
+
+        ・技能ロールの難易度指定　CC(x)<=(目標値)(難易度)
+        　目標値の後に難易度を指定することで
+        　成功／失敗／クリティカル／ファンブル を自動判定する。
+        　難易度の指定：
+        　　r:レギュラー　h:ハード　e:イクストリーム　c:クリティカル
+        　例）CC<=70r CC1<=60h CC-2<=50e CC2<=99c
 
         ・組み合わせ判定　(CBR(x,y))
         　目標値 x と y で％ロールを行い、成否を判定。
@@ -45,41 +54,36 @@ 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', '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,
           :failure,
+          :success,
           :regular_success,
           :hard_success,
           :extreme_success,
@@ -91,10 +95,43 @@ module BCDice
           extreme_success: "イクストリーム成功",
           hard_success: "ハード成功",
           regular_success: "レギュラー成功",
+          success: "成功",
           fumble: "ファンブル",
           failure: "失敗",
         }.freeze
 
+        def self.with_difficulty_level(total, difficulty)
+          fumble = difficulty < 50 ? 96 : 100
+
+          if total == 1
+            ResultLevel.new(:critical)
+          elsif total <= difficulty
+            ResultLevel.new(:success)
+          elsif total >= fumble
+            ResultLevel.new(:fumble)
+          else
+            ResultLevel.new(:failure)
+          end
+        end
+
+        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)
@@ -102,7 +139,7 @@ module BCDice
         end
 
         def success?
-          @level_index >= LEVEL.index(:regular_success)
+          @level_index >= LEVEL.index(:success)
         end
 
         def failure?
@@ -122,6 +159,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
@@ -141,15 +182,26 @@ module BCDice
       end
 
       def skill_roll(command)
-        m = /^CC([-+]?\d+)?(?:<=(\d+))?$/.match(command)
+        m = /^CC([-+]?\d+)?(?:<=(\d+)([RHEC])?)?$/.match(command)
         unless m
           return nil
         end
 
         bonus_dice = m[1].to_i
-        difficulty = m[2].to_i
+        difficulty = m[2]&.to_i
+        difficulty_level = m[3]
+
+        if difficulty == 0
+          difficulty = nil
+        elsif difficulty_level == "H"
+          difficulty /= 2
+        elsif difficulty_level == "E"
+          difficulty /= 5
+        elsif difficulty_level == "C"
+          difficulty = 0
+        end
 
-        if bonus_dice == 0 && difficulty == 0
+        if bonus_dice == 0 && difficulty.nil?
           dice = @randomizer.roll_once(100)
           return "1D100 ＞ #{dice}"
         end
@@ -160,8 +212,13 @@ module BCDice
 
         total, total_list = roll_with_bonus(bonus_dice)
 
-        expr = difficulty.zero? ? "1D100" : "1D100<=#{difficulty}"
-        result = result_level(total, difficulty) unless difficulty.zero?
+        expr = difficulty.nil? ? "1D100" : "1D100<=#{difficulty}"
+        result =
+          if difficulty_level
+            ResultLevel.with_difficulty_level(total, difficulty)
+          elsif difficulty
+            ResultLevel.from_values(total, difficulty)
+          end
 
         sequence = [
           "(#{expr}) ボーナス・ペナルティダイス[#{bonus_dice}]",
@@ -180,54 +237,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 +250,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 +269,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()