bcdice 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/bcdice/game_system/Cthulhu7th.rb

@@ -45,20 +45,16 @@ module BCDice
         　　強力でない呪文の場合　FCL／強力な呪文の場合　FCM
       INFO_MESSAGE_TEXT
 
-      register_prefix(['CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR.*', 'BMR', 'BMS', 'FCL', 'FCM', 'PH', 'MA'])
+      register_prefix('CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR.*', 'BMR', 'BMS', 'FCL', 'FCM', 'PH', 'MA')
 
-      def initialize(command)
-        super(command)
-
-        @bonus_dice_range = (-2..2)
-      end
+      BONUS_DICE_RANGE = (-2..2).freeze
 
       def eval_game_system_specific_command(command)
         case command
         when /^CC/i
-          return getCheckResult(command)
+          return skill_roll(command)
         when /^CBR/i
-          return getCombineRoll(command)
+          return combine_roll(command)
         when /^FAR/i
           return getFullAutoResult(command)
         when /^BMR/i # 狂気の発作（リアルタイム）
@@ -80,6 +76,52 @@ module BCDice
 
       private
 
+      class ResultLevel
+        LEVEL = [
+          :fumble,
+          :failure,
+          :regular_success,
+          :hard_success,
+          :extreme_success,
+          :critical,
+        ].freeze
+
+        LEVEL_TO_S = {
+          critical: "クリティカル",
+          extreme_success: "イクストリーム成功",
+          hard_success: "ハード成功",
+          regular_success: "レギュラー成功",
+          fumble: "ファンブル",
+          failure: "失敗",
+        }.freeze
+
+        def initialize(level)
+          @level = level
+          @level_index = LEVEL.index(level)
+          raise ArgumentError unless @level_index
+        end
+
+        def success?
+          @level_index >= LEVEL.index(:regular_success)
+        end
+
+        def failure?
+          @level_index <= LEVEL.index(:failure)
+        end
+
+        def critical?
+          @level == :critical
+        end
+
+        def fumble?
+          @level == :fumble
+        end
+
+        def to_s
+          LEVEL_TO_S[@level]
+        end
+      end
+
       def roll_1d8_table(table_name, table)
         total_n = @randomizer.roll_once(8)
         index = total_n - 1
@@ -98,37 +140,44 @@ module BCDice
         return "#{table_name}(#{total_n}) ＞ #{text}"
       end
 
-      def getCheckResult(command)
-        m = /^CC([-+]?\d+)?(<=(\d+))?/i.match(command)
+      def skill_roll(command)
+        m = /^CC([-+]?\d+)?(?:<=(\d+))?$/.match(command)
         unless m
           return nil
         end
 
-        bonus_dice_count = m[1].to_i # ボーナス・ペナルティダイスの個数
-        diff = m[3].to_i
-        without_compare = m[2].nil? || diff <= 0
+        bonus_dice = m[1].to_i
+        difficulty = m[2].to_i
 
-        if bonus_dice_count == 0 && diff <= 0
+        if bonus_dice == 0 && difficulty == 0
           dice = @randomizer.roll_once(100)
           return "1D100 ＞ #{dice}"
         end
 
-        unless @bonus_dice_range.include?(bonus_dice_count)
-          return "エラー。ボーナス・ペナルティダイスの値は#{@bonus_dice_range.min}～#{@bonus_dice_range.max}です。"
+        unless BONUS_DICE_RANGE.include?(bonus_dice)
+          return "エラー。ボーナス・ペナルティダイスの値は#{BONUS_DICE_RANGE.min}～#{BONUS_DICE_RANGE.max}です。"
         end
 
-        total, total_list = roll_with_bonus(bonus_dice_count)
+        total, total_list = roll_with_bonus(bonus_dice)
 
-        if without_compare
-          output = "(1D100) ボーナス・ペナルティダイス[#{bonus_dice_count}]"
-          output += " ＞ #{total_list.join(', ')} ＞ #{total}"
-        else
-          result_text = getCheckResultText(total, diff)
-          output = "(1D100<=#{diff}) ボーナス・ペナルティダイス[#{bonus_dice_count}]"
-          output += " ＞ #{total_list.join(', ')} ＞ #{total} ＞ #{result_text}"
-        end
+        expr = difficulty.zero? ? "1D100" : "1D100<=#{difficulty}"
+        result = result_level(total, difficulty) unless difficulty.zero?
 
-        return output
+        sequence = [
+          "(#{expr}) ボーナス・ペナルティダイス[#{bonus_dice}]",
+          total_list.join(", "),
+          total,
+          result,
+        ].compact
+
+        Result.new.tap do |r|
+          r.text = sequence.join(" ＞ ")
+          if result
+            r.condition = result.success?
+            r.critical = result.critical?
+            r.fumble = result.fumble?
+          end
+        end
       end
 
       # 1D100の一の位用のダイスロール
@@ -163,58 +212,50 @@ module BCDice
         return dice, dice_list
       end
 
-      def getCheckResultText(total, diff, fumbleable = false)
-        if total <= diff
-          return "クリティカル" if total == 1
-          return "イクストリーム成功" if total <= (diff / 5)
-          return "ハード成功" if total <= (diff / 2)
-
-          return "レギュラー成功"
-        end
-
-        fumble_text = "ファンブル"
-
-        return fumble_text if total == 100
-
-        if total >= 96
-          if diff < 50
-            return fumble_text
-          else
-            return fumble_text if fumbleable
-          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
-
-        return "失敗"
       end
 
-      def getCombineRoll(command)
-        return nil unless /CBR\((\d+),(\d+)\)/i =~ command
+      def combine_roll(command)
+        m = /^CBR\((\d+),(\d+)\)$/.match(command)
+        return nil unless m
 
-        diff_1 = Regexp.last_match(1).to_i
-        diff_2 = Regexp.last_match(2).to_i
+        difficulty_1 = m[1].to_i
+        difficulty_2 = m[2].to_i
 
         total = @randomizer.roll_once(100)
 
-        result_1 = getCheckResultText(total, diff_1)
-        result_2 = getCheckResultText(total, diff_2)
-
-        successList = ["クリティカル", "イクストリーム成功", "ハード成功", "レギュラー成功"]
-
-        succesCount = 0
-        succesCount += 1 if successList.include?(result_1)
-        succesCount += 1 if successList.include?(result_2)
-        debug("succesCount", succesCount)
+        result_1 = result_level(total, difficulty_1)
+        result_2 = result_level(total, difficulty_2)
 
         rank =
-          if succesCount >= 2
+          if result_1.success? && result_2.success?
             "成功"
-          elsif succesCount == 1
+          elsif result_1.success? || result_2.success?
             "部分的成功"
           else
             "失敗"
           end
 
-        return "(1d100<=#{diff_1},#{diff_2}) ＞ #{total}[#{result_1},#{result_2}] ＞ #{rank}"
+        Result.new.tap do |r|
+          r.text = "(1d100<=#{difficulty_1},#{difficulty_2}) ＞ #{total}[#{result_1},#{result_2}] ＞ #{rank}"
+          r.success = result_1.success? && result_2.success?
+          r.failure = result_1.failure? && result_2.failure?
+        end
       end
 
       def getFullAutoResult(command)
@@ -261,8 +302,8 @@ module BCDice
           broken_number = broken_number.abs
         end
 
-        unless @bonus_dice_range.include?(bonus_dice_count)
-          return "エラー。ボーナス・ペナルティダイスの値は#{@bonus_dice_range.min}～#{@bonus_dice_range.max}です。"
+        unless BONUS_DICE_RANGE.include?(bonus_dice_count)
+          return "エラー。ボーナス・ペナルティダイスの値は#{BONUS_DICE_RANGE.min}～#{BONUS_DICE_RANGE.max}です。"
         end
 
         output += "ボーナス・ペナルティダイス[#{bonus_dice_count}]"
@@ -286,7 +327,7 @@ module BCDice
           output += getNextDifficultyMessage(more_difficulty)
 
           # ペナルティダイスを減らしながらロール用ループ
-          while dice_num >= @bonus_dice_range.min
+          while dice_num >= BONUS_DICE_RANGE.min
 
             loopCount += 1
             hit_result, total, total_list = getHitResultInfos(dice_num, diff, more_difficulty)
@@ -349,7 +390,7 @@ module BCDice
         total, total_list = roll_with_bonus(dice_num)
 
         fumbleable = getFumbleable(more_difficulty)
-        hit_result = getCheckResultText(total, diff, fumbleable)
+        hit_result = result_level(total, diff, fumbleable).to_s
 
         return hit_result, total, total_list
       end

data/lib/bcdice/game_system/Cthulhu7th_ChineseTraditional.rb

@@ -35,7 +35,7 @@ module BCDice
         ・實時型　Short／總結型　Longer
       INFO_MESSAGE_TEXT
 
-      register_prefix(['CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR\(\d+\)', 'FAR.*'])
+      register_prefix('CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR\(\d+\)', 'FAR.*')
 
       def initialize(command)
         super(command)

data/lib/bcdice/game_system/Cthulhu7th_Korean.rb

@@ -32,7 +32,7 @@ module BCDice
         예）FAR(25,70,98)　FAR(50,80,98,-1)
       INFO_MESSAGE_TEXT
 
-      register_prefix(['CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR\(\d+\)', 'FAR.*'])
+      register_prefix('CC\(\d+\)', 'CC.*', 'CBR\(\d+,\d+\)', 'FAR\(\d+\)', 'FAR.*')
 
       def initialize(command)
         super(command)

data/lib/bcdice/game_system/CthulhuTech.rb

@@ -6,7 +6,7 @@ require 'bcdice/arithmetic_evaluator'
 module BCDice
   module GameSystem
     class CthulhuTech < Base
-      register_prefix(['\d+D10.*'])
+      register_prefix('\d+D10.*')
 
       # ゲームシステムの識別子
       ID = 'CthulhuTech'
@@ -124,27 +124,21 @@ module BCDice
         def calculate_roll_result(sorted_dice_values)
           highest_single_roll = sorted_dice_values.last
 
+          sum_of_highest_set_of_multiples = sorted_dice_values
+                                            .group_by(&:itself)
+                                            .values
+                                            .map(&:sum)
+                                            .max
+
           candidates = [
             highest_single_roll,
-            sum_of_highest_set_of_multiples(sorted_dice_values),
+            sum_of_highest_set_of_multiples,
             sum_of_largest_straight(sorted_dice_values)
           ]
 
           return candidates.max
         end
 
-        # ゾロ目の和の最大値を求める
-        # @param [Array<Integer>] dice_values 出目の配列
-        # @return [Integer]
-        def sum_of_highest_set_of_multiples(dice_values)
-          dice_values.
-            # TODO: Ruby 2.2以降では group_by(&:itself) が使える
-            group_by { |i| i }.
-            # TODO: Ruby 2.4以降では value_group.sum が使える
-            map { |_, value_group| value_group.reduce(0, &:+) }
-                     .max
-        end
-
         # ストレートの和の最大値を求める
         #
         # ストレートとは、昇順で3個以上連続した値のこと。

data/lib/bcdice/game_system/Cthulhu_ChineseTraditional.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "bcdice/game_system/Cthulhu"
+
 module BCDice
   module GameSystem
-    class Cthulhu_ChineseTraditional < Base
+    class Cthulhu_ChineseTraditional < Cthulhu
       # ゲームシステムの識別子
       ID = 'Cthulhu:ChineseTraditional'
 
@@ -44,199 +46,14 @@ module BCDice
         ・CCB(x) c=5、f=96
         同上
 
-        ・瘋狂表
-        ・短期瘋期　Short／長期瘋狂　Longer
-
       INFO_MESSAGE_TEXT
 
-      register_prefix(['CC(B)?\(\d+\)', 'CC(B)?.*', 'RES(B)?.*', 'CBR(B)?\(\d+,\d+\)'])
-
-      def initialize
-        # $isDebug = true
-        super
-        @special_percentage  = 20
-        @critical_percentage = 1
-        @fumble_percentage   = 1
-      end
-
-      def eval_game_system_specific_command(command)
-        case command
-        when /CCB/i
-          # 5%
-          @critical_percentage = 5
-          @fumble_percentage   = 5
-          return getCheckResult(command)
-        when /CC/i
-          # 1%
-          @critical_percentage = 1
-          @fumble_percentage   = 1
-          return getCheckResult(command)
-        when /RESB/i
-          # 5%
-          @critical_percentage = 5
-          @fumble_percentage   = 5
-          return getRegistResult(command)
-        when /CBRB/i
-          # 5%
-          @critical_percentage = 5
-          @fumble_percentage   = 5
-          return getCombineRoll(command)
-        when /RES/i
-          # 1%
-          @critical_percentage = 1
-          @fumble_percentage   = 1
-          return getRegistResult(command)
-        when /CBR/i
-          # 1%
-          @critical_percentage = 1
-          @fumble_percentage   = 1
-          return getCombineRoll(command)
-        end
-
-        return nil
-      end
-
-      def getCheckResult(command)
-        broken_num = 0
-        diff = 0
-
-        if (m = /CC(B)?(\d+)<=(\d+)/i.match(command))
-          # /\(\d+\)/の()はpattern-killerにカイシャクされる
-          broken_num = m[2].to_i
-          diff = m[3].to_i
-        elsif (m = /CC(B)?<=(\d+)/i.match(command))
-          diff = m[2].to_i
-        end
-
-        output = ""
-
-        if diff > 0
-          output = "(1D100<=#{diff})"
-
-          if broken_num > 0
-            output += " 故障率[#{broken_num}]"
-          end
-
-          total_n = @randomizer.roll_once(100)
-
-          output += " ＞ #{total_n}"
-          output += " ＞ #{getCheckResultText(total_n, diff, broken_num)}"
-        else
-          total_n = @randomizer.roll_once(100)
-          output = "(1D100) ＞ #{total_n}"
-        end
-
-        return output
-      end
-
-      def getCheckResultText(total_n, diff, broken_num = 0)
-        result = ""
-        diff_special = 0
-        fumble = false
-
-        if @special_percentage > 0
-          # 需有special的數值設定才能做爆擊/大失敗的判定
-          diff_special = (diff * @special_percentage / 100).floor
-          if diff_special < 1
-            diff_special = 1
-          end
-        end
-
-        if (total_n <= diff) && (total_n < 100)
-          result = "成功"
-
-          if diff_special > 0
-            if total_n <= @critical_percentage
-              if total_n <= diff_special
-                result = "決定性的成功/特殊"
-              else
-                result = "決定性的成功"
-              end
-            else
-              if total_n <= diff_special
-                result = "特殊"
-              end
-            end
-          end
-        else
-          result = "失敗"
-
-          if diff_special > 0
-            if (total_n >= (101 - @fumble_percentage)) && (diff < 100)
-              result = "致命性失敗"
-              fumble = true
-            end
-          end
-        end
-
-        if broken_num > 0
-          if total_n >= broken_num
-            if fumble
-              result += "/故障"
-            else
-              result = "故障"
-            end
-          end
-        end
-
-        return result
-      end
-
-      def getRegistResult(command)
-        m = /RES(B)?([-\d]+)/i.match(command)
-        unless m
-          return "1"
-        end
-
-        value = m[2].to_i
-        target = value * 5 + 50
-
-        if target < 5
-          return "(1d100<=#{target}) ＞ 自動失敗"
-        end
-
-        if target > 95
-          return "(1d100<=#{target}) ＞ 自動成功"
-        end
-
-        # 通常判定
-        total_n = @randomizer.roll_once(100)
-        result = getCheckResultText(total_n, target)
-
-        return "(1d100<=#{target}) ＞ #{total_n} ＞ #{result}"
-      end
-
-      def getCombineRoll(command)
-        m = /CBR(B)?\((\d+),(\d+)\)/i.match(command)
-        unless m
-          return "1"
-        end
-
-        diff_1 = m[2].to_i
-        diff_2 = m[3].to_i
-
-        total = @randomizer.roll_once(100)
-
-        result_1 = getCheckResultText(total, diff_1)
-        result_2 = getCheckResultText(total, diff_2)
-
-        successList = ["決定性成功/特殊", "決定性成功", "特殊", "成功"]
-
-        succesCount = 0
-        succesCount += 1 if successList.include?(result_1)
-        succesCount += 1 if successList.include?(result_2)
-        debug("succesCount", succesCount)
+      register_prefix_from_super_class()
 
-        rank =
-          if succesCount >= 2
-            "成功"
-          elsif succesCount == 1
-            "部分性成功"
-          else
-            "失敗"
-          end
+      def initialize(command)
+        super(command)
 
-        return "(1d100<=#{diff_1},#{diff_2}) ＞ #{total}[#{result_1},#{result_2}] ＞ #{rank}"
+        @locale = :zh_hant
       end
     end
   end