bcdice 3.1.3 → 3.5.0

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/AngelGear.rb

@@ -48,17 +48,22 @@ module BCDice
         dice_text = dice.join(",")
         modify_n = 0
         success = 0
-
         if skill_value
           success = dice.count { |val| val <= skill_value }
           modify_n = Arithmetic.eval(modify, RoundType::FLOOR) unless modify.empty?
         end
 
-        output = "(#{command}) ＞ #{success}[#{dice_text}]#{format('%+d', modify_n)} ＞ 成功数: #{success + modify_n}"
+        gospel = '(福音発生)' if success + modify_n >= 100
+
+        output = "(#{command}) ＞ #{success}[#{dice_text}]#{format('%+d', modify_n)} ＞ 成功数: #{success + modify_n}#{gospel}"
+
         if success + modify_n >= 100
-          output += "(福音発生)"
+          Result.critical(output)
+        elsif 0 < success + modify_n
+          Result.success(output)
+        else
+          Result.failure(output)
         end
-        return output
       end
 
       TABLES = {
@@ -117,7 +122,7 @@ module BCDice
         )
       }.freeze
 
-      register_prefix('(\d+)AG(\d+)?(([\+\-]\d+)*)', TABLES.keys)
+      register_prefix('\d+AG', TABLES.keys)
     end
   end
 end

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 = {
@@ -86,7 +93,7 @@ module BCDice
       }.freeze
 
       # ダイスボットで使用するコマンドを配列で列挙する
-      register_prefix('\d+AN<=\d([\+\-]\d+)*', TABLES.keys)
+      register_prefix('\d+AN<=', TABLES.keys)
     end
   end
 end

data/lib/bcdice/game_system/Aoharubaan.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Aoharubaan < Base
+      # ゲームシステムの識別子
+      ID = 'Aoharubaan'
+
+      # ゲームシステム名
+      NAME = 'あおはるばーんっ'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'あおはるはあんつ'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~HELP
+        カレカノ反応表（ KR, KReaction ）
+      HELP
+
+      JUDGE_ROLL_REG = /^(1d6?|d6)(\+\d+)?(>=|=>)(\d+)$/i.freeze
+      register_prefix('(1d6?|d6)(\+\d+)?(>=|=>)(\d+)')
+
+      def eval_game_system_specific_command(command)
+        command = ALIAS[command] || command
+
+        if (m = JUDGE_ROLL_REG.match(command))
+          roll_judge(m[2], m[4])
+        else
+          roll_tables(command, TABLES)
+        end
+      end
+
+      private
+
+      def roll_judge(modifier_expression, border_expression)
+        modifier = modifier_expression ? Arithmetic.eval(modifier_expression, RoundType::FLOOR) : nil
+        border = border_expression.to_i
+
+        command_text = make_command_text(modifier, border)
+
+        dice = @randomizer.roll_once(6)
+        score = dice + modifier.to_i
+
+        is_success = score >= border # 「成功」か？
+        is_right = is_success && score == border # 「ピタリ賞」か？
+        is_excellent = is_success && score >= 7 # 「限界突破」か？
+
+        result_elements = []
+        result_elements << (is_success ? '成功' : '失敗')
+        result_elements << "ピタリ賞" if is_right
+        result_elements << "限界突破" if is_excellent
+
+        message_elements = []
+        message_elements << command_text
+        message_elements << "#{dice}+#{modifier}" if modifier
+        message_elements << score
+        message_elements << result_elements.join(" ＆ ")
+
+        Result.new(message_elements.join(' ＞ ')).tap do |r|
+          r.condition = is_success
+          r.critical = is_right || is_excellent
+        end
+      end
+
+      def make_command_text(modifier, border)
+        command = "1D6"
+        command = "#{command}+#{modifier}" if modifier
+        command = "#{command}>=#{border}"
+        "(#{command})"
+      end
+
+      ALIAS = {
+        "KR" => "KReaction",
+      }.transform_keys(&:upcase).transform_values(&:upcase).freeze
+
+      TABLES = {
+        "KReaction" => DiceTable::RangeTable.new(
+          "カレカノ反応表",
+          "1D6",
+          [
+            [1..2, "何となく素っ気ない気がする。"],
+            [3..4, "いつもと変わらない安心感。"],
+            [5..6, "何故だかすごくデレてきた！　嬉しくて〈テンション〉１回復。"],
+          ]
+        ),
+      }.transform_keys(&:upcase).freeze
+
+      register_prefix(ALIAS.keys, TABLES.keys)
+    end
+  end
+end

data/lib/bcdice/game_system/Arianrhod.rb

@@ -25,25 +25,23 @@ module BCDice
         @d66_sort_type = D66SortType::NO_SORT
       end
 
-      def check_nD6(total, _dice_total, dice_list, cmp_op, target)
+      def result_nd6(total, _dice_total, dice_list, cmp_op, target)
         n_max = dice_list.count(6)
 
         if dice_list.count(1) == dice_list.size
           # 全部１の目ならファンブル
-          " ＞ ファンブル"
+          Result.fumble("ファンブル")
         elsif n_max >= 2
           # ２個以上６の目があったらクリティカル
-          " ＞ クリティカル(+#{n_max}D6)" if n_max >= 2
+          Result.critical("クリティカル(+#{n_max}D6)")
         elsif cmp_op != :>= || target == '?'
-          ''
+          nil
         elsif total >= target
-          " ＞ 成功"
+          Result.success("成功")
         else
-          " ＞ 失敗"
+          Result.failure("失敗")
         end
       end
-
-      alias check_2D6 check_nD6
     end
   end
 end

data/lib/bcdice/game_system/AssaultEngine.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class AssaultEngine < Base
+      # ゲームシステムの識別子
+      ID = 'AssaultEngine'
+
+      # ゲームシステム名
+      NAME = 'アサルトエンジン'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'あさるとえんしん'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~MESSAGETEXT
+        ・判定 AEt (t目標値)
+            例: AE45 （目標値45）
+        ・リロール nAEt (nロール前の値、t目標値)
+            例: 76AE45 (目標値45で、76を振り直す)
+
+        ・スワップ（t目標値） エネミーブックP11
+            例: AES45 （目標値45、スワップ表示あり）
+      MESSAGETEXT
+
+      register_prefix('\d*AE')
+
+      def initialize(command)
+        super(command)
+        @round_type = RoundType::FLOOR # 端数切り捨て
+      end
+
+      def eval_game_system_specific_command(command)
+        cmd = Command::Parser.new(/AES?/, round_type: round_type).enable_prefix_number
+                             .has_suffix_number.parse(command)
+        return nil unless cmd
+
+        target = cmd.suffix_number
+        target = 99 if target >= 100
+
+        if cmd.command.include?("AES") # SWAP初回
+          total = @randomizer.roll_once(100) % 100 # 0-99
+          swap = (total % 10) * 10 + (total / 10)
+          r1 = judge(target, total)
+          r2 = judge(target, swap)
+          text = "(AES#{format00(target)}) ＞ #{r1.text} / スワップ#{r2.text}"
+          check_result(r1, r2, text)
+        elsif cmd.prefix_number.nil? # 初回ロール
+          total = @randomizer.roll_once(100) % 100 # 0-99
+          judge(target, total).tap do |r|
+            r.text = "(AE#{format00(target)}) ＞ #{r.text}"
+          end
+        else # リロール
+          now = cmd.prefix_number
+          die = @randomizer.roll_once(10) % 10 # 0-9
+          new1 = judge(target, (now / 10 * 10) + die)    # 1の位を振り直す
+          new2 = judge(target, now % 10 + die * 10)      # 10の位を振り直す
+
+          text = "(#{format00(now)}AE#{format00(target)}) ＞ #{die} ＞ #{new1.text} / #{new2.text}"
+          check_result(new1, new2, text)
+        end
+      end
+
+      def format00(dice)
+        format("%02d", dice)
+      end
+
+      def check_result(result1, result2, text)
+        if result1.critical? || result2.critical?
+          Result.critical(text)
+        elsif result1.success? || result2.success?
+          Result.success(text)
+        elsif result1.fumble? && result2.fumble?
+          Result.fumble(text)
+        else
+          Result.failure(text)
+        end
+      end
+
+      def judge(target, total)
+        double = (total / 10) == (total % 10)
+        total_text = format00(total)
+        if total <= target
+          double ? Result.critical("(#{total_text})クリティカル") : Result.success("(#{total_text})成功")
+        else
+          double ? Result.fumble("(#{total_text})ファンブル") : Result.failure("(#{total_text})失敗")
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Avandner.rb

@@ -34,7 +34,7 @@ module BCDice
         ・8av4*7+10 → 8d10で目標値4、攻撃力7、クリティカルトリガー10の命中判定。
       MESSAGETEXT
 
-      register_prefix('\d+AV\d+((x|\*)\d+(\+\d+)?)?(c\d+)?')
+      register_prefix('\d+AV')
 
       def initialize(command)
         super(command)