bcdice 3.0.0.pre.rc.2 → 3.1.3

data/lib/bcdice/game_system/BloodMoon.rb

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

data/lib/bcdice/game_system/CardRanker.rb

@@ -18,7 +18,7 @@ module BCDice
         ランダム分野表 RCT
         特定のモンスターカードを選ぶ (CMxy　x：色、y：番号）
         　白：W、青：U、緑：V、金：G、赤：R、黒：B
-        　例）CMW1→白の2：白竜　CMG12→金の12：土精霊
+        　例）CMW2→白の2：白竜　CMG12→金の12：土精霊
         場所表 (ST)
         街中場所表 (CST)
         郊外場所表 (OST)
@@ -202,7 +202,7 @@ module BCDice
           ]
         ),
       }.freeze
-      register_prefix(RTT.prefixes, 'CM.*', TABLES.keys)
+      register_prefix(RTT.prefixes, 'CM', TABLES.keys)
     end
   end
 end

data/lib/bcdice/game_system/ChaosFlare.rb

@@ -39,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)

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,11 @@ 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)

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
@@ -161,7 +180,7 @@ module BCDice
         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()