bcdice 3.2.0 → 3.3.0

data/lib/bcdice/game_system/LogHorizon.rb

@@ -128,27 +128,30 @@ module BCDice
         dice_total = dice_list.sum()
         total = dice_total + parsed.modify_number
 
+        result = result_text(dice_count, dice_list, total, parsed)
+
         sequence = [
           "(#{parsed})",
           "#{dice_total}[#{dice_list.join(',')}]#{Format.modifier(parsed.modify_number)}",
           total,
-          result_text(dice_count, dice_list, total, parsed),
+          result.text,
         ].compact
 
-        return sequence.join(" ＞ ")
+        result.text = sequence.join(" ＞ ")
+        result
       end
 
       def result_text(dice_count, dice_list, total, parsed)
         if dice_list.count(6) >= 2
-          translate("LogHorizon.LH.critical")
+          Result.critical(translate("LogHorizon.LH.critical"))
         elsif dice_list.count(1) >= dice_count
-          translate("LogHorizon.LH.fumble")
+          Result.fumble(translate("LogHorizon.LH.fumble"))
         elsif parsed.cmp_op.nil?
-          nil
+          Result.new
         elsif total >= parsed.target_number
-          translate('success')
+          Result.success(translate("success"))
         else
-          translate('failure')
+          Result.failure(translate("failure"))
         end
       end
 

data/lib/bcdice/game_system/MagicaLogia_SimplifiedChinese.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "bcdice/game_system/MagicaLogia"
+
+module BCDice
+  module GameSystem
+    class MagicaLogia_SimplifiedChinese < MagicaLogia
+      # ゲームシステムの識別子
+      ID = "MagicaLogia:SimplifiedChinese"
+
+      # ゲームシステム名
+      NAME = "魔导书大战"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "国際化:Simplified Chinese:魔导书大战"
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ・判定
+        可以判定大成功／大失败／成功／失败
+        ・各种表
+        经历表　BGT/初期锚点表　DAT/命运属性表　FAT
+        愿望表　WIT/战利品表　PT
+        时间流逝表　TPT/大判时间流逝表　TPTB
+        事件表　AT
+        大失败表　FT／变调表　WT
+        命运转变表表　FCT
+        　典型性灾厄 TCT／物理性灾厄 PCT／精神性灾厄 MCT／狂气性灾厄 ICT
+        　社会性灾厄 SCT／超自然灾厄 XCT／不可思议的灾厄 WCT／喜剧性灾厄 CCT
+        　魔法使的灾厄 MGCT
+        场景表　ST／大判场景表　STB
+        　极限环境 XEST／内心世界 IWST／魔法都市 MCST
+        　死后世界 WDST／迷宫世界 LWST
+        　魔法书架 MBST／魔法学院 MAST／克雷德塔 TCST
+        　平行世界 PWST／终末世界 PAST／异世界酒吧 GBST
+        　星影 SLST／旧图书馆 OLST
+        世界法则追加表 WLAT/徘徊怪物表 WMT
+        随机领域表　RCT
+        随机特技表　RTT
+        　星领域随机特技表  RTS, RTT1
+        　兽领域随机特技表  RTB, RTT2
+        　力领域随机特技表  RTF, RTT3
+        　歌领域随机特技表  RTP, RTT4
+        　梦领域随机特技表  RTD, RTT5
+        　暗领域随机特技表  RTN, RTT6
+        空白秘密表　BST
+        　宿敌表　MIT/谋略表　MOT/因缘表　MAT
+        　奇人表　MUT/力场表　MFT/同盟表　MLT
+        落花表　FFT
+        那之后表 FLT
+        ・可以使用D66
+      INFO_MESSAGE_TEXT
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+
+        @locale = :zh_hans
+      end
+
+      SKILL_TABLE = translate_skill_table(:zh_hans)
+      TABLES = translate_tables(:zh_hans, SKILL_TABLE)
+    end
+  end
+end

data/lib/bcdice/game_system/MeikyuKingdomBasic.rb

@@ -72,7 +72,8 @@ module BCDice
         'BUS', 'SHS', 'ASS', 'SUS', 'SCS', 'LAS', 'NES', 'COS', 'ENS', 'TOS',
         'ABUS', 'ASHS', 'AASS', 'ASUS', 'ASCS', 'ALAS', 'ANES', 'ACOS', 'AENS', 'ATOS',
         'SE', 'ARN', 'WEN', 'NEN', 'CEN', 'SEN', 'OEN',
-        'DFT'
+        'DFT',
+        'PNT', 'MLT'
       )
 
       def initialize(command)

data/lib/bcdice/game_system/Nechronica.rb

@@ -17,10 +17,10 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
         ・判定　(nNC+m)
-        　ダイス数n、修正値mで判定ロールを行います。
+        　ダイス数n、修正値mで判定ロールを行います(省略=1)
         　ダイス数が2以上の時のパーツ破損数も表示します。
         ・攻撃判定　(nNA+m)
-        　ダイス数n、修正値mで攻撃判定ロールを行います。
+        　ダイス数n、修正値mで攻撃判定ロールを行います(省略=1)
         　命中部位とダイス数が2以上の時のパーツ破損数も表示します。
 
         表
@@ -37,126 +37,92 @@ module BCDice
         @default_target_number = 6 # 目標値が空欄の時の目標値
       end
 
-      private
-
-      def replace_text(string)
-        string = string.gsub(/(\d+)NC(10)?([+\-][+\-\d]+)/i) { "#{Regexp.last_match(1)}R10#{Regexp.last_match(3)}[0]" }
-        string = string.gsub(/(\d+)NC(10)?/i) { "#{Regexp.last_match(1)}R10[0]" }
-        string = string.gsub(/(\d+)NA(10)?([+\-][+\-\d]+)/i) { "#{Regexp.last_match(1)}R10#{Regexp.last_match(3)}[1]" }
-        string = string.gsub(/(\d+)NA(10)?/i) { "#{Regexp.last_match(1)}R10[1]" }
-
-        return string
+      def eval_game_system_specific_command(command)
+        roll_tables(command, self.class::TABLES) || nechronica_check(command)
       end
 
-      public
+      def result_nd10(total, _dice_total, value_list, cmp_op, target)
+        # 後方互換を維持するため、1d10>=nを目標値nの1NCとして処理
+        if value_list.count != 1 || cmp_op != :>= || target.nil? || target == "?"
+          return nil
+        end
 
-      def eval_game_system_specific_command(command)
-        return roll_tables(command, self.class::TABLES) || nechronica_check(command)
+        result_nechronica([total], target)
       end
 
       private
 
-      def result_nd10(total, _dice_total, dice_list, cmp_op, target) # ゲーム別成功度判定(nD10)
-        return Result.nothing if target == '?'
-        return nil unless cmp_op == :>=
-
-        if total >= 11
-          Result.critical(translate("Nechronica.critical"))
-        elsif total >= target
-          Result.success(translate("success"))
-        elsif dice_list.count { |i| i <= 1 } == 0
+      def result_nechronica(value_list, target)
+        if value_list.max >= target
+          if value_list.max >= 11
+            Result.critical(translate("Nechronica.critical"))
+          else
+            Result.success(translate("success"))
+          end
+        elsif value_list.count { |i| i <= 1 } == 0
           Result.failure(translate("failure"))
-        elsif dice_list.size > 1
-          fumble = translate("Nechronica.fumble")
+        elsif value_list.size > 1
           break_all_parts = translate("Nechronica.break_all_parts")
+          fumble = translate("Nechronica.fumble")
           Result.fumble("#{fumble} ＞ #{break_all_parts}")
         else
           Result.fumble(translate("Nechronica.fumble"))
         end
       end
 
-      def result_nd10_text(total, dice_list, target)
-        text = result_nd10(total, 0, dice_list, :>=, target)&.text
+      # Rコマンドの後方互換を維持する
+      def r_backward_compatibility(command)
+        m = command.match(/^(\d)?R10([+\-\d]+)?(\[(\d+)\])?$/)
+        return command unless m
 
-        if text.nil?
-          ""
+        if m[4] == "1"
+          "#{m[1]}NA#{m[2]}"
         else
-          " ＞ #{text}"
+          "#{m[1]}NC#{m[2]}"
         end
       end
 
-      def nechronica_check(string)
-        string = replace_text(string)
-        debug("nechronica_check string", string)
-
-        unless /(^|\s)S?((\d+)[rR]10([+\-\d]+)?(\[(\d+)\])?)(\s|$)/i =~ string
-          return nil
-        end
-
-        string = Regexp.last_match(2)
+      def nechronica_check(command)
+        command = r_backward_compatibility(command)
+        # 歴史的経緯で10を受理する
+        cmd = Command::Parser.new(/N[CA](10)?/, round_type: round_type)
+                             .enable_prefix_number.parse(command)
+        return nil unless cmd
 
-        dice_n = 1
-        dice_n = Regexp.last_match(3).to_i if Regexp.last_match(3)
+        dice_count = [1, cmd.prefix_number.to_i].max
+        modify_number = cmd.modify_number || 0
 
-        battleMode = Regexp.last_match(6).to_i
+        dice = @randomizer.roll_barabara(dice_count, 10).sort
+        dice_mod = dice.map { |i| i + modify_number }
+        total = dice_mod.max
 
-        modText = Regexp.last_match(4)
-        mod = ArithmeticEvaluator.eval(modText)
+        na = get_hit_location(total) if cmd.command.start_with?("NA")
 
-        # 0=判定モード, 1=戦闘モード
-        isBattleMode = (battleMode == 1)
-        debug("nechronica_check string", string)
-        debug("isBattleMode", isBattleMode)
+        result = result_nechronica(dice_mod, 6)
 
-        diff = 6
+        sequence = [
+          "(#{cmd})",
+          "[#{dice.join(',')}]#{Format.modifier(modify_number)}",
+          "#{total}[#{dice_mod.join(',')}]",
+          result.text,
+          na,
+        ].compact
 
-        dice = @randomizer.roll_barabara(dice_n, 10).sort
-        n_max = dice.max
-
-        total_n = n_max + mod
-
-        output = "(#{string}) ＞ [#{dice.join(',')}]"
-        if mod < 0
-          output += mod.to_s
-        elsif mod > 0
-          output += "+#{mod}"
-        end
-
-        dice.map! { |i| i + mod }
-
-        dice_str = dice.join(",")
-        output += "  ＞ #{total_n}[#{dice_str}]"
-
-        output += result_nd10_text(total_n, dice, diff)
-
-        if isBattleMode
-          hit_loc = getHitLocation(total_n)
-          if hit_loc != '1'
-            output += " ＞ #{hit_loc}"
-          end
-        end
-
-        return output
+        result.text = sequence.join(" ＞ ")
+        return result
       end
 
-      def getHitLocation(dice)
-        output = '1'
-
-        debug("getHitLocation dice", dice)
-        return output if dice <= 5
+      def get_hit_location(value)
+        return nil if value <= 5
 
         table = translate("Nechronica.hit_location.table")
-        index = dice - 6
+        text = table[(value - 6).clamp(0, 5)]
 
-        addDamage = ""
-        if dice > 10
-          index = 5
-          addDamage = translate("Nechronica.hit_location.additional_damage", damage: dice - 10)
+        if value > 10
+          text + translate("Nechronica.hit_location.additional_damage", damage: value - 10)
+        else
+          text
         end
-
-        output = table[index] + addDamage
-
-        return output
       end
 
       class << self
@@ -173,7 +139,7 @@ module BCDice
 
       TABLES = translate_tables(:ja_jp)
 
-      register_prefix('\d+NC', '\d+NA', '\d+R10', TABLES.keys)
+      register_prefix('\d?NC', '\d?NA', '\dR10', TABLES.keys)
     end
   end
 end

data/lib/bcdice/game_system/NinjaSlayer.rb

@@ -176,8 +176,7 @@ module BCDice
         command = bRollCommand(at.num, at.difficulty)
         roll_result = BCDice::CommonCommand::BarabaraDice.eval(command, self, @randomizer)
 
-        values = roll_result.rands.map { |v, _| v }
-        num_of_max_values = values.count(6)
+        num_of_max_values = roll_result.last_dice_list.count(6)
 
         parts = [roll_result.text]
 
@@ -195,7 +194,7 @@ module BCDice
         command = bRollCommand(el.num, el.difficulty)
         roll_result = BCDice::CommonCommand::BarabaraDice.eval(command, self, @randomizer)
 
-        values = roll_result.rands.map { |v, _| v }
+        values = roll_result.last_dice_list
         num_of_max_values = values.count(6)
         sum_of_true_values = values.count { |v| v >= el.difficulty }
 

data/lib/bcdice/game_system/SRS.rb

@@ -219,7 +219,7 @@ module BCDice
 
       # 固有のダイスロールコマンドを実行する
       # @param [String] command 入力されたコマンド
-      # @return [String, nil] ダイスロールコマンドの実行結果
+      # @return [Result, nil] ダイスロールコマンドの実行結果
       def eval_game_system_specific_command(command)
         alias_replaced_with_2d6 = replace_alias_for_srs_roll_with_2d6(command)
 
@@ -297,7 +297,7 @@ module BCDice
 
       # 成功判定を実行する
       # @param [SRSRollNode] srs_roll 成功判定ノード
-      # @return [String] 成功判定結果
+      # @return [Result] 成功判定結果
       def execute_srs_roll(srs_roll)
         dice_list = @randomizer.roll_barabara(2, 6)
         dice_list.sort! if @sort_add_dice
@@ -307,35 +307,36 @@ module BCDice
 
         modified_sum = sum + srs_roll.modifier
 
+        result = compare_result(srs_roll, sum, modified_sum)
+
         parts = [
           "(#{srs_roll})",
           "#{sum}[#{dice_str}]#{Format.modifier(srs_roll.modifier)}",
           modified_sum,
-          compare_result(srs_roll, sum, modified_sum)
+          result.text
         ]
 
-        return parts.compact.join(' ＞ ')
+        result.text = parts.compact.join(' ＞ ')
+        result
       end
 
       # ダイスロール結果を目標値、クリティカル値、ファンブル値と比較する
       # @param [SRSRollNode] srs_roll 成功判定ノード
       # @param [Integer] sum 出目の合計
       # @param [Integer] modified_sum 修正後の値
-      # @return [String, nil] 比較結果
+      # @return [Result] 比較結果
       def compare_result(srs_roll, sum, modified_sum)
         if sum >= srs_roll.critical_value
-          return '自動成功'
-        end
-
-        if sum <= srs_roll.fumble_value
-          return '自動失敗'
-        end
-
-        if srs_roll.target_value
-          return modified_sum >= srs_roll.target_value ? '成功' : '失敗'
+          Result.critical("自動成功")
+        elsif sum <= srs_roll.fumble_value
+          Result.fumble("自動失敗")
+        elsif srs_roll.target_value.nil?
+          Result.new
+        elsif modified_sum >= srs_roll.target_value
+          Result.success("成功")
+        else
+          Result.failure("失敗")
         end
-
-        return nil
       end
     end
   end

data/lib/bcdice/game_system/SamsaraBallad.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bcdice/base'
+
 module BCDice
   module GameSystem
     class SamsaraBallad < Base
@@ -59,38 +61,63 @@ module BCDice
           total = 100 if total == 0
         end
 
-        cmp_result = compare(total, cmd)
+        result = compare(total, cmd)
+
+        result_str =
+          if result.failure?
+            "失敗"
+          elsif result.success?
+            "成功"
+          end
+
+        additional_str =
+          if result.fumble?
+            "ファンブル"
+          elsif result.critical?
+            "クリティカル"
+          end
 
         sequence = [
           "(D100#{cmd.cmp_op}#{cmd.target_number})",
           places_text,
           total.to_s,
-          cmp_result,
+          result_str,
+          additional_str,
         ].compact
 
-        return sequence.join(" ＞ ")
+        result.text = sequence.join(" ＞ ")
+
+        return result
       end
 
       private
 
-      # @return [String]
-      # @return [nil]
+      # @return [Result]
       def compare(total, cmd)
         if [:<=, :<].include?(cmd.cmp_op)
           if !total.send(cmd.cmp_op, cmd.target_number)
-            "失敗"
+            Result.failure(nil)
           elsif fumble_?(total, cmd.fumble)
-            "ファンブル"
+            Result.new.tap do |r|
+              r.success = true
+              r.fumble = true
+            end
           elsif critical_?(total, cmd.critical)
-            "クリティカル"
+            Result.critical(nil)
           else
-            "成功"
+            Result.success(nil)
           end
         elsif fumble_?(total, cmd.fumble)
           # ファンブル優先
-          "ファンブル"
+          Result.new.tap do |r|
+            r.fumble = true
+          end
         elsif critical_?(total, cmd.critical)
-          "クリティカル"
+          Result.new.tap do |r|
+            r.critical = true
+          end
+        else
+          Result.new
         end
       end