bcdice 3.2.0 → 3.3.0

data/lib/bcdice/common_command/barabara_dice/node.rb

@@ -43,8 +43,8 @@ module BCDice
             Result.new.tap do |r|
               r.secret = @secret
               r.text = sequence.join(" ＞ ")
-              r.rands = randomizer.rand_results
-              r.detailed_rands = randomizer.detailed_rand_results
+              r.last_dice_list_list = dice_list_list
+              r.last_dice_list = dice_list
               r.success_num = success_num
             end
           end

data/lib/bcdice/common_command/barabara_dice/result.rb

@@ -7,6 +7,10 @@ module BCDice
     module BarabaraDice
       # バラバラロールの結果を表すクラス
       class Result < ::BCDice::Result
+        # @return [Array<Array<Integer>>] 出目のグループの配列
+        attr_accessor :last_dice_list_list
+        # @return [Array<Integer>] すべての出目が格納される配列
+        attr_accessor :last_dice_list
         # @return [Integer] 成功数
         attr_accessor :success_num
 
@@ -14,6 +18,8 @@ module BCDice
         def initialize(text = nil)
           super(text)
 
+          @last_dice_list_list = []
+          @last_dice_list = []
           @success_num = 0
         end
       end

data/lib/bcdice/game_system.rb

@@ -113,6 +113,7 @@ require "bcdice/game_system/LostRecord"
 require "bcdice/game_system/LostRoyal"
 require "bcdice/game_system/MagicaLogia"
 require "bcdice/game_system/MagicaLogia_Korean"
+require "bcdice/game_system/MagicaLogia_SimplifiedChinese"
 require "bcdice/game_system/MeikyuDays"
 require "bcdice/game_system/MeikyuKingdom"
 require "bcdice/game_system/MeikyuKingdomBasic"
@@ -170,8 +171,10 @@ require "bcdice/game_system/ShinobiGami"
 require "bcdice/game_system/ShoujoTenrankai"
 require "bcdice/game_system/Skynauts"
 require "bcdice/game_system/SkynautsBouken"
+require "bcdice/game_system/StarryDolls"
 require "bcdice/game_system/SteamPunkers"
 require "bcdice/game_system/StellarKnights"
+require "bcdice/game_system/StellarKnights_Korean"
 require "bcdice/game_system/SterileLife"
 require "bcdice/game_system/StrangerOfSwordCity"
 require "bcdice/game_system/StratoShout"

data/lib/bcdice/game_system/Amadeus.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "bcdice/arithmetic_evaluator"
+require "bcdice/format"
+require "bcdice/normalize"
+
 module BCDice
   module GameSystem
     class Amadeus < Base
@@ -46,111 +50,124 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        text = amadeusDice(command)
-        return text unless text.nil?
-
-        return roll_tables(command, self.class::TABLES)
+        roll_amadeus(command) ||
+          roll_tables(command, self.class::TABLES)
       end
 
-      def amadeusDice(command)
-        return nil unless /^(R([A-DS])([+\-\d]*))(@(\d))?((>(=)?)([+\-\d]*))?(@(\d))?$/i =~ command
-
-        commandText = Regexp.last_match(1)
-        skillRank = Regexp.last_match(2)
-        modifyText = Regexp.last_match(3)
-        signOfInequality = (Regexp.last_match(7).nil? ? ">=" : Regexp.last_match(7))
-        targetText = (Regexp.last_match(9).nil? ? "4" : Regexp.last_match(9))
-        if nil | Regexp.last_match(5)
-          specialNum = Regexp.last_match(5).to_i
-        elsif nil | Regexp.last_match(11)
-          specialNum = Regexp.last_match(11).to_i
-        else
-          specialNum = 6
+      private
+
+      def roll_amadeus(command)
+        m = /^R([A-DS])([+\-\d]*)(@(\d))?((>=?)([+\-\d]*))?(@(\d))?$/i.match(command)
+        unless m
+          return nil
         end
 
-        diceCount = CHECK_DICE_COUNT[skillRank]
-        modify = ArithmeticEvaluator.eval(modifyText)
-        target = ArithmeticEvaluator.eval(targetText)
-
-        diceList = @randomizer.roll_barabara(diceCount, 6)
-        diceText = diceList.join(",")
-        specialText = (specialNum == 6 ? "" : "@#{specialNum}")
-
-        message = "(#{commandText}#{specialText}#{signOfInequality}#{targetText}) ＞ [#{diceText}]#{modifyText} ＞ "
-        diceList = [diceList.min] if skillRank == "D"
-        is_loop = false
-        diceList.each do |dice|
-          if  is_loop
-            message += " / "
-          elsif diceList.length > 1
-            is_loop = true
+        rank = m[1]
+        modifier = ArithmeticEvaluator.eval(m[2])
+        cmp_op = m[6] ? Normalize.comparison_operator(m[6]) : :>=
+        target = m[7] ? ArithmeticEvaluator.eval(m[7]) : 4
+        special = (m[4] || m[9] || 6).to_i
+
+        dice_count = CHECK_DICE_COUNT[rank]
+
+        dice_list = @randomizer.roll_barabara(dice_count, 6)
+        dice_text = dice_list.join(",")
+        special_text = (special == 6 ? "" : "@#{special}")
+
+        dice_list = [dice_list.min] if rank == "D"
+        available_inga = dice_list.size > 1
+        inga_table = translate("Amadeus.inga_table")
+
+        success = false
+        critical = false
+        fumble = false
+
+        results =
+          dice_list.map do |dice|
+            total = dice + modifier
+            result =
+              if dice == 1
+                fumble = true
+                translate("Amadeus.fumble")
+              elsif dice >= special
+                critical = true
+                success = true
+                translate("Amadeus.special")
+              elsif total.send(cmp_op, target)
+                success = true
+                translate("success")
+              else
+                translate("failure")
+              end
+
+            if available_inga
+              inga = inga_table[dice - 1]
+              "#{total}_#{result}[#{dice}#{inga}]"
+            else
+              "#{total}_#{result}[#{dice}]"
+            end
           end
-          achieve = dice + modify
-          result = check_success(achieve, dice, signOfInequality, target, specialNum)
-          if is_loop
-            inga_table = translate("Amadeus.inga_table")
-            inga = inga_table[dice - 1]
-            message += "#{achieve}_#{result}[#{dice}#{inga}]"
+
+        sequence = [
+          "(R#{rank}#{Format.modifier(modifier)}#{special_text}#{cmp_op}#{target})",
+          "[#{dice_text}]#{Format.modifier(modifier)}",
+          results.join(" / ")
+        ]
+
+        Result.new.tap do |r|
+          r.text = sequence.join(" ＞ ")
+          if success
+            r.success = true
+            r.critical = critical
           else
-            message += "#{achieve}_#{result}[#{dice}]"
+            r.failure = true
+            r.fumble = fumble
           end
         end
-
-        return message
-      end
-
-      def check_success(total_n, dice_n, signOfInequality, diff, special_n)
-        return translate("Amadeus.fumble") if dice_n == 1
-        return translate("Amadeus.special") if dice_n >= special_n
-
-        cmp_op = Normalize.comparison_operator(signOfInequality)
-        target_num = diff.to_i
-
-        if total_n.send(cmp_op, target_num)
-          translate("success")
-        else
-          translate("failure")
-        end
       end
 
       CHECK_DICE_COUNT = {"S" => 4, "A" => 3, "B" => 2, "C" => 1, "D" => 2}.freeze
 
-      def self.translate_tables(locale)
-        {
-          "ECT" => DiceTable::Table.from_i18n("Amadeus.table.ECT", locale),
-          "BST" => DiceTable::Table.from_i18n("Amadeus.table.BST", locale),
-          "RT" => DiceTable::Table.from_i18n("Amadeus.table.RT", locale),
-          "PRT" => DiceTable::Table.from_i18n("Amadeus.table.PRT", locale),
-          "FT" => DiceTable::Table.from_i18n("Amadeus.table.FT", locale),
-          "BT" => DiceTable::D66Table.from_i18n("Amadeus.table.BT", locale),
-          "FWT" => DiceTable::Table.from_i18n("Amadeus.table.FWT", locale),
-          "BRT" => DiceTable::Table.from_i18n("Amadeus.table.BRT", locale),
-          "RIT" => DiceTable::Table.from_i18n("Amadeus.table.RIT", locale),
-          "WT" => DiceTable::Table.from_i18n("Amadeus.table.WT", locale),
-          "NMT" => DiceTable::Table.from_i18n("Amadeus.table.NMT", locale),
-          "TGT" => DiceTable::Table.from_i18n("Amadeus.table.TGT", locale),
-          "CST" => DiceTable::Table.from_i18n("Amadeus.table.CST", locale),
-          "GCVT" => DiceTable::Table.from_i18n("Amadeus.table.GCVT", locale),
-          "YCVT" => DiceTable::Table.from_i18n("Amadeus.table.YCVT", locale),
-          "ECVT" => DiceTable::Table.from_i18n("Amadeus.table.ECVT", locale),
-          "CCVT" => DiceTable::Table.from_i18n("Amadeus.table.CCVT", locale),
-          "NCVT" => DiceTable::Table.from_i18n("Amadeus.table.NCVT", locale),
-          "DGVT" => DiceTable::Table.from_i18n("Amadeus.table.DGVT", locale),
-          "DAVT" => DiceTable::Table.from_i18n("Amadeus.table.DAVT", locale),
-          "PRCT" => DiceTable::Table.from_i18n("Amadeus.table.PRCT", locale),
-          "TCCT" => DiceTable::Table.from_i18n("Amadeus.table.TCCT", locale),
-          "INCT" => DiceTable::Table.from_i18n("Amadeus.table.INCT", locale),
-          "PSCT" => DiceTable::Table.from_i18n("Amadeus.table.PSCT", locale),
-          "LVCT" => DiceTable::Table.from_i18n("Amadeus.table.LVCT", locale),
-          "DACT" => DiceTable::Table.from_i18n("Amadeus.table.DACT", locale),
-          "RGT" => DiceTable::Table.from_i18n("Amadeus.table.RGT", locale),
-          "FBT" => DiceTable::Table.from_i18n("Amadeus.table.FBT", locale),
-          "CHVT" => DiceTable::Table.from_i18n("Amadeus.table.CHVT", locale),
-          "LCVT" => DiceTable::Table.from_i18n("Amadeus.table.LCVT", locale),
-          "KCVT" => DiceTable::Table.from_i18n("Amadeus.table.KCVT", locale),
-          "SAT" => DiceTable::D66Table.from_i18n("Amadeus.table.SAT", locale),
-          "SMT" => DiceTable::D66Table.from_i18n("Amadeus.table.SMT", locale),
-        }
+      class << self
+        private
+
+        def translate_tables(locale)
+          {
+            "ECT" => DiceTable::Table.from_i18n("Amadeus.table.ECT", locale),
+            "BST" => DiceTable::Table.from_i18n("Amadeus.table.BST", locale),
+            "RT" => DiceTable::Table.from_i18n("Amadeus.table.RT", locale),
+            "PRT" => DiceTable::Table.from_i18n("Amadeus.table.PRT", locale),
+            "FT" => DiceTable::Table.from_i18n("Amadeus.table.FT", locale),
+            "BT" => DiceTable::D66Table.from_i18n("Amadeus.table.BT", locale),
+            "FWT" => DiceTable::Table.from_i18n("Amadeus.table.FWT", locale),
+            "BRT" => DiceTable::Table.from_i18n("Amadeus.table.BRT", locale),
+            "RIT" => DiceTable::Table.from_i18n("Amadeus.table.RIT", locale),
+            "WT" => DiceTable::Table.from_i18n("Amadeus.table.WT", locale),
+            "NMT" => DiceTable::Table.from_i18n("Amadeus.table.NMT", locale),
+            "TGT" => DiceTable::Table.from_i18n("Amadeus.table.TGT", locale),
+            "CST" => DiceTable::Table.from_i18n("Amadeus.table.CST", locale),
+            "GCVT" => DiceTable::Table.from_i18n("Amadeus.table.GCVT", locale),
+            "YCVT" => DiceTable::Table.from_i18n("Amadeus.table.YCVT", locale),
+            "ECVT" => DiceTable::Table.from_i18n("Amadeus.table.ECVT", locale),
+            "CCVT" => DiceTable::Table.from_i18n("Amadeus.table.CCVT", locale),
+            "NCVT" => DiceTable::Table.from_i18n("Amadeus.table.NCVT", locale),
+            "DGVT" => DiceTable::Table.from_i18n("Amadeus.table.DGVT", locale),
+            "DAVT" => DiceTable::Table.from_i18n("Amadeus.table.DAVT", locale),
+            "PRCT" => DiceTable::Table.from_i18n("Amadeus.table.PRCT", locale),
+            "TCCT" => DiceTable::Table.from_i18n("Amadeus.table.TCCT", locale),
+            "INCT" => DiceTable::Table.from_i18n("Amadeus.table.INCT", locale),
+            "PSCT" => DiceTable::Table.from_i18n("Amadeus.table.PSCT", locale),
+            "LVCT" => DiceTable::Table.from_i18n("Amadeus.table.LVCT", locale),
+            "DACT" => DiceTable::Table.from_i18n("Amadeus.table.DACT", locale),
+            "RGT" => DiceTable::Table.from_i18n("Amadeus.table.RGT", locale),
+            "FBT" => DiceTable::Table.from_i18n("Amadeus.table.FBT", locale),
+            "CHVT" => DiceTable::Table.from_i18n("Amadeus.table.CHVT", locale),
+            "LCVT" => DiceTable::Table.from_i18n("Amadeus.table.LCVT", locale),
+            "KCVT" => DiceTable::Table.from_i18n("Amadeus.table.KCVT", locale),
+            "SAT" => DiceTable::D66Table.from_i18n("Amadeus.table.SAT", locale),
+            "SMT" => DiceTable::D66Table.from_i18n("Amadeus.table.SMT", locale),
+          }
+        end
       end
 
       TABLES = translate_tables(:ja_jp)

data/lib/bcdice/game_system/AnimaAnimus.rb

@@ -2,7 +2,7 @@
 
 require 'bcdice/dice_table/table'
 require 'bcdice/dice_table/range_table'
-require 'bcdice/arithmetic_evaluator'
+require 'bcdice/arithmetic'
 
 module BCDice
   module GameSystem
@@ -32,17 +32,19 @@ module BCDice
       MESSAGETEXT
 
       def eval_game_system_specific_command(command)
-        case command
-        when /(\d+)AN<=(\d+([+\-]\d+)*)/i
-          return check_action(Regexp.last_match)
-        else
+        m = /(\d+)AN<=(\d+([+\-]\d+)*)/i.match(command)
+        if TABLES.key?(command)
           return roll_tables(command, TABLES)
+        elsif m
+          return check_action(m)
+        else
+          return nil
         end
       end
 
       def check_action(match_data)
-        dice_cnt = ArithmeticEvaluator.eval(match_data[1])
-        target = ArithmeticEvaluator.eval(match_data[2])
+        dice_cnt = Arithmetic.eval(match_data[1], RoundType::FLOOR)
+        target = Arithmetic.eval(match_data[2], RoundType::FLOOR)
         debug("dice_cnt", dice_cnt)
         debug("target", target)
 
@@ -52,7 +54,12 @@ module BCDice
         has_critical = dice_arr.include?(1)
         result = has_critical ? suc_cnt + 2 : suc_cnt
 
-        return "(#{dice_cnt}B10<=#{target}) ＞ #{dice_str} ＞ #{result > 0 ? '成功' : '失敗'}(達成値:#{result})#{has_critical ? ' (クリティカル発生)' : ''}"
+        Result.new.tap do |r|
+          r.text = "(#{dice_cnt}B10<=#{target}) ＞ #{dice_str} ＞ #{result > 0 ? '成功' : '失敗'}(達成値:#{result})#{has_critical ? ' (クリティカル発生)' : ''}"
+          r.critical = has_critical
+          r.success = result > 0
+          r.failure = !r.success?
+        end
       end
 
       TABLES = {

data/lib/bcdice/game_system/BattleTech.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bcdice/format'
+require 'bcdice/command/parser'
 require 'bcdice/dice_table/table'
 require 'bcdice/dice_table/range_table'
 
@@ -26,24 +28,45 @@ module BCDice
         　　正面からダメージ3の攻撃を技能ベース2目標値4で1回判定
         　例）2BT3RL+5>=8
         　　右下半身にダメージ3の攻撃を技能ベース5目標値8で2回判定
-        　ミサイルによるダメージは BT(ダメージ)の変わりに SRM2/4/6, LRM5/10/15/20を指定
+        　ミサイルによるダメージは BT(ダメージ) の代わりに SRM2/4/6, LRM5/10/15/20 を指定
         　例）3SRM6LU+5>=8
         　　左上半身にSRM6連を技能ベース5目標値8で3回判定
+          BT(ダメージ) の代わりに PPC を指定するとダメージ10で判定
+          例）2PPCR+3>=10
+          　右側からPPC（ダメージ10）による攻撃を技能ベース3目標値10で2回判定
         ・CT：致命的命中表
         ・DW：転倒後の向き表
-        ・CDx：メック戦士意識維持表。ダメージ値xで判定　例）CD3
+        ・CDx：メック戦士意識維持ロール。ダメージ値x（1〜6）で判定　例）CD3
       MESSAGETEXT
 
-      register_prefix('\d*SRM', '\d*LRM', '\d*BT', 'PPC', 'CT', 'DW', 'CD')
+      register_prefix('\d*SRM', '\d*LRM', '\d*BT', '\d*PPC', 'CT', 'DW', 'CD')
 
       # 致命的命中が発生しない上限値
       NO_CRITICAL_HIT_LIMIT = 7
 
+      # @return [Command::Parser] PPCコマンドの構文解析器
+      def self.ppc_parser
+        return @ppc_parser if @ppc_parser
+
+        @ppc_parser = Command::Parser.new(/PPC(?:[LCR][LU]?)?/, round_type: RoundType::FLOOR)
+        @ppc_parser.enable_prefix_number
+        @ppc_parser.restrict_cmp_op_to(:>=)
+
+        @ppc_parser
+      end
+
+      # @return [Command::Parser] PPCコマンドの構文解析器
+      def ppc_parser
+        self.class.ppc_parser
+      end
+
       def eval_game_system_specific_command(command)
         result = roll_tables(command, TABLES)
         return result if result
 
-        command = command.gsub("PPC", "BT10")
+        if (ppc_parse_result = ppc_parser.parse(command))
+          return execute_ppc(ppc_parse_result)
+        end
 
         count = 1
         if command =~ /^(\d+)(.+)/
@@ -55,9 +78,9 @@ module BCDice
         debug('executeCommandCatched command', command)
 
         case command
-        when /^CD(\d+)$/
+        when /\ACD([1-6])\z/
           damage = Regexp.last_match(1).to_i
-          return getCheckDieResult(damage)
+          return consciousness_roll(damage)
         when /^((S|L)RM\d+)(.+)/
           tail = Regexp.last_match(3)
           type = Regexp.last_match(1)
@@ -94,7 +117,7 @@ module BCDice
       LRM_LIMIT = 5
 
       def getHitResult(count, damageFunc, tail)
-        m = /([LCR][LU]?)?(\+\d+)?>=(\d+)/.match(tail)
+        m = /\A([LCR][LU]?)?(\+\d+)?>=(\d+)/.match(tail)
         return nil unless m
 
         side = m[1] || 'C'
@@ -105,7 +128,7 @@ module BCDice
 
         partTable = HitPart::TABLES[side]
 
-        resultTexts = []
+        resultLines = []
         damages = {}
         hitCount = 0
 
@@ -117,15 +140,24 @@ module BCDice
             damages, damageText = getDamages(damageFunc, partTable, damages)
             hitResult += damageText
           end
-          resultTexts << hitResult
+          resultLines << hitResult
         end
 
-        resultTexts.push(" ＞ #{hitCount}回命中")
+        # 命中したか？
+        hit = hitCount > 0
 
-        totalResultText = resultTexts.join("\n")
-        totalResultText += " 命中箇所：" + getTotalDamage(damages) if hitCount > 0
+        hitCountText = " ＞ #{hitCount}回命中"
+        hitDetails =
+          if hit
+            "#{hitCountText} 命中箇所：#{getTotalDamage(damages)}"
+          else
+            hitCountText
+          end
+        resultLines.push(hitDetails)
 
-        return totalResultText
+        resultText = resultLines.join("\n")
+
+        return hit ? Result.success(resultText) : Result.failure(resultText)
       end
 
       def getBaseValue(baseString)
@@ -272,26 +304,75 @@ module BCDice
         return result_parts.join(' ＞ '), hit_part.name, criticalText
       end
 
-      def getCheckDieResult(damage)
-        if damage >= 6
-          return "死亡"
+      # メック戦士意識維持ロールを行う
+      #
+      # damageが6の場合は死亡。
+      # damageが5以下の場合は、2d6の結果が意識維持表の値以上かの成功判定。
+      #
+      # @param damage [Integer] メック戦士へのダメージ（1〜6）
+      # @return [Result]
+      # @see 「BattleTech: A Game of Armored Combat」ルールブックp. 44
+      def consciousness_roll(damage)
+        unless (1..6).include?(damage)
+          return nil
+        end
+
+        command = "CD#{damage}"
+
+        if damage == 6
+          return Result.fumble("#{command} ＞ 死亡")
         end
 
-        table = [[1,  3],
-                 [2,  5],
-                 [3,  7],
-                 [4,  10],
-                 [5,  11]]
+        consciousness_table = {
+          1 => 3,
+          2 => 5,
+          3 => 7,
+          4 => 10,
+          5 => 11,
+        }
+
+        target = consciousness_table[damage]
+        expr = "(2D6>=#{target})"
+
+        values = @randomizer.roll_barabara(2, 6)
+        sum = values.sum
+        values_str = values.join(",")
+        sum_and_values = "#{sum}[#{values_str}]"
+
+        success = sum >= target
+        result = success ? "成功" : "失敗"
+
+        parts = [
+          command,
+          expr,
+          sum_and_values,
+          sum,
+          result,
+        ]
+        text = parts.join(" ＞ ")
 
-        target = get_table_by_number(damage, table, nil)
+        return success ? Result.success(text) : Result.failure(text)
+      end
 
-        dice1 = @randomizer.roll_once(6)
-        dice2 = @randomizer.roll_once(6)
-        total = dice1 + dice2
-        result = total >= target ? "成功" : "失敗"
-        text = "#{total}[#{dice1},#{dice2}]>=#{target} ＞ #{result}"
+      # PPCコマンドを実行する
+      # @param parse_result [Command::Parsed] PPCコマンドの構文解析結果
+      # @return [Result, nil]
+      def execute_ppc(parse_result)
+        count = parse_result.prefix_number || 1
+
+        # getHitResult() の引数tailの形に合わせる
+        # TODO: 攻撃を表すクラスに変える
+
+        # "PPC" 以降の部位指定
+        side = parse_result.command[3..-1]
+
+        modifier = Format.modifier(parse_result.modify_number)
+        target = parse_result.target_number
+
+        tail = "#{side}#{modifier}>=#{target}"
 
-        return text
+        # ダメージ10固定で命中判定を行う
+        return getHitResult(count, lambda { 10 }, tail)
       end
 
       # 表の集合