bcdice 3.0.0 → 3.2.0

data/lib/bcdice/game_system/SterileLife.rb

@@ -37,8 +37,7 @@ module BCDice
         　・超未来の宇宙船内　INT
       MESSAGETEXT
 
-      register_prefix('(\d+)*DA.*\[(\d+),(\d+)(,(\d+))?\]', 'VPFT', 'VNFT', 'VNRT', 'AAFT', 'AST', 'RNST', 'RET', 'TRST', 'TRAT', 'TRMT', 'TROT', 'TET', 'ENT', 'CUT', 'NAT', 'INT') # '(\d+)*DA.*\[.*\]'
-
+      register_prefix('\d*DA', 'VPFT', 'VNFT', 'VNRT', 'AAFT', 'AST', 'RNST', 'RET', 'TRST', 'TRAT', 'TRMT', 'TROT', 'TET', 'ENT', 'CUT', 'NAT', 'INT')
       def eval_game_system_specific_command(command) # ダイスロールコマンド
         # 通常判定部分をgetJudgeResultコマンドに切り分け
         output = getJudgeResult(command)
@@ -104,7 +103,7 @@ module BCDice
 
       def getJudgeResult(command)
         case command
-        when /(\d+)*DA([\d+*\-]*\d)?\[(\d+),(\d+)(,(\d+))?\]/i
+        when /(\d+)?DA([\d+*\-]*\d)?\[(\d+),(\d+)(,(\d+))?\]/i
           number = (Regexp.last_match(1) || 1).to_i
           correction = (Regexp.last_match(2) || 0).to_i
           single = (Regexp.last_match(3) || 4).to_i

data/lib/bcdice/game_system/StrangerOfSwordCity.rb

@@ -10,7 +10,7 @@ module BCDice
       NAME = '剣の街の異邦人TRPG'
 
       # ゲームシステム名の読みがな
-      SORT_KEY = 'けんのまちのいほうしんTRPG'
+      SORT_KEY = 'つるきのまちのいほうしんTRPG'
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
@@ -21,7 +21,7 @@ module BCDice
         ・D66ダイスあり
       INFO_MESSAGE_TEXT
 
-      register_prefix('\d+SR.*')
+      register_prefix('\d+SR')
 
       def initialize(command)
         super(command)

data/lib/bcdice/game_system/StratoShout.rb

@@ -32,22 +32,14 @@ module BCDice
         @d66_sort_type = D66SortType::ASC
       end
 
-      def check_2D6(total, dice_total, _dice_list, cmp_op, target)
-        return '' if target == '?'
-        return '' unless cmp_op == :>=
-
-        result =
-          if dice_total <= 2
-            translate("StratoShout.fumble")
-          elsif dice_total >= 12
-            translate("StratoShout.critical")
-          elsif total >= target
-            translate("success")
-          else
-            translate("failure")
-          end
-
-        return " ＞ #{result}"
+      def result_2d6(_total, dice_total, _dice_list, cmp_op, _target)
+        return nil unless cmp_op == :>=
+
+        if dice_total <= 2
+          Result.fumble(translate("StratoShout.fumble"))
+        elsif dice_total >= 12
+          Result.critical(translate("StratoShout.critical"))
+        end
       end
 
       def eval_game_system_specific_command(command)

data/lib/bcdice/game_system/Strave.rb

@@ -33,7 +33,7 @@ module BCDice
       MESSAGETEXT
 
       register_prefix(
-        'MP\d+', '\d+ST\d+(x|\*)\d+',
+        'MP', '\d+ST',
         'AFF', 'IDT', 'AFV', 'IDV'
       )
 

data/lib/bcdice/game_system/SwordWorld.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "bcdice/base"
+require "bcdice/game_system/sword_world/rating_parser"
+
 module BCDice
   module GameSystem
     class SwordWorld < Base
@@ -7,7 +10,7 @@ module BCDice
       ID = 'SwordWorld'
 
       # ゲームシステム名
-      NAME = 'ソードワールドRPG'
+      NAME = 'ソード・ワールドRPG'
 
       # ゲームシステム名の読みがな
       SORT_KEY = 'そおとわあると'
@@ -15,35 +18,13 @@ module BCDice
       # ダイスボットの使い方
       HELP_MESSAGE = "・SW　レーティング表　(Kx[c]+m$f) (x:キー, c:クリティカル値, m:ボーナス, f:出目修正)\n"
 
-      register_prefix('H?K\d+.*')
+      register_prefix('H?K')
 
       def initialize(command)
         super(command)
         @rating_table = 0
       end
 
-      # change_textで使うレーティング表コマンドの正規表現
-      #
-      # SW 2.5のダイスボットでも必要なため、共通化のために定数として定義する
-      RATING_TABLE_RE_FOR_CHANGE_TEXT = /\AS?H?K\d+/i.freeze
-
-      # コマンド実行前にメッセージを置換する
-      # @param [String] string 受信したメッセージ
-      # @return [String]
-      def replace_text(string)
-        return string unless RATING_TABLE_RE_FOR_CHANGE_TEXT.match?(string)
-
-        string
-          .gsub(/\[(\d+)\]/) { "c[#{Regexp.last_match(1)}]" }
-          .gsub(/@(\d+)/) { "c[#{Regexp.last_match(1)}]" }
-          .gsub(/\$([-+]?\d+)/) { "m[#{Regexp.last_match(1)}]" }
-          .gsub(/r([-+]?\d+)/i) { "r[#{Regexp.last_match(1)}]" }
-      end
-
-      def getRatingCommandStrings
-        "cmCM"
-      end
-
       def result_2d6(total, dice_total, _dice_list, cmp_op, target)
         if dice_total >= 12
           Result.critical("自動的成功")
@@ -64,60 +45,32 @@ module BCDice
 
       private
 
+      def rating_parser
+        return RatingParser.new
+      end
+
       ####################        SWレーティング表       ########################
       def rating(string) # レーティング表
-        string = replace_text(string)
         debug("rating string", string)
+        command = rating_parser.parse(string)
 
-        commands = getRatingCommandStrings
-
-        m = /^S?(H?K[\d+\-]+([#{commands}]\[([\d+\-]+)\])*([\d+\-]*)([CMR]\[([\d+\-]+)\]|GF|H)*)/i.match(string)
-        unless m
+        unless command
           debug("not matched")
           return '1'
         end
 
-        string = m[1]
-        half = string.include?("H")
-
-        rateUp, string = getRateUpFromString(string)
-        crit, string = getCriticalFromString(string, half)
-        firstDiceChanteTo, firstDiceChangeModify, string = getDiceChangesFromString(string)
-
-        key, addValue = getKeyAndAddValueFromString(string)
-
-        return '1' unless key =~ /(\d+)/
-
-        key = Regexp.last_match(1).to_i
-
         # 2.0対応
         rate_sw2_0 = getSW2_0_RatingTable
 
         keyMax = rate_sw2_0.length - 1
         debug("keyMax", keyMax)
-        if key > keyMax
+        if command.rate > keyMax
           return "キーナンバーは#{keyMax}までです"
         end
 
         newRates = getNewRates(rate_sw2_0)
 
-        output = "KeyNo.#{key}"
-
-        output += "c[#{crit}]" if crit < 13
-        output += "m[#{firstDiceChangeModify}]" if firstDiceChangeModify != 0
-        output += "m[#{firstDiceChanteTo}]" if  firstDiceChanteTo != 0
-        output += "r[#{rateUp}]" if rateUp != 0
-
-        output, values = getAdditionalString(string, output)
-
-        debug('output', output)
-
-        if addValue != 0
-          output += "+#{addValue}" if addValue > 0
-          output += addValue.to_s if addValue < 0
-        end
-
-        output += " ＞ "
+        output = "#{command} ＞ "
 
         diceResultTotals = []
         diceResults = []
@@ -126,17 +79,19 @@ module BCDice
         diceOnlyTotal = 0
         totalValue = 0
         round = 0
+        first_to = command.first_to
+        first_modify = command.first_modify
 
         loop do
-          dice_raw, diceText = rollDice(values)
+          dice_raw, diceText = rollDice(command)
           dice = dice_raw
 
-          if  firstDiceChanteTo != 0
-            dice = dice_raw = firstDiceChanteTo
-            firstDiceChanteTo = 0
-          elsif  firstDiceChangeModify != 0
-            dice += firstDiceChangeModify.to_i
-            firstDiceChangeModify = 0
+          if first_to != 0
+            dice = dice_raw = first_to
+            first_to = 0
+          elsif first_modify != 0
+            dice += first_modify
+            first_modify = 0
           end
 
           # 出目がピンゾロの時にはそこで終了
@@ -149,12 +104,12 @@ module BCDice
             break
           end
 
-          dice += getAdditionalDiceValue(dice, values)
+          dice += command.kept_modify if (command.kept_modify != 0) && (dice != 2)
 
           dice = 2 if dice < 2
           dice = 12 if dice > 12
 
-          currentKey = [key + round * rateUp, keyMax].min
+          currentKey = [command.rate + round * command.rateup, keyMax].min
           debug("currentKey", currentKey)
           rateValue = newRates[dice][currentKey]
           debug("rateValue", rateValue)
@@ -168,77 +123,20 @@ module BCDice
 
           round += 1
 
-          break unless dice >= crit
+          break unless dice >= command.critical
         end
 
-        output += getResultText(totalValue, addValue, diceResults, diceResultTotals,
-                                rateResults, diceOnlyTotal, round, half)
-
-        return output
-      end
-
-      def getAdditionalString(_string, output)
-        values = {}
-        return output, values
-      end
-
-      def getAdditionalDiceValue(_dice, _values)
-        0
-      end
-
-      def getCriticalFromString(string, half)
-        crit = half ? 13 : 10
+        result_text, critical, fumble = getResultText(
+          totalValue, command, diceResults, diceResultTotals,
+          rateResults, diceOnlyTotal, round
+        )
+        output += result_text
 
-        regexp = /c\[(\d+)\]/i
-
-        if regexp =~ string
-          crit = Regexp.last_match(1).to_i
-          crit = 3 if crit < 3 # エラートラップ(クリティカル値が3未満なら3とする)
-          string = string.gsub(regexp, '')
+        return Result.new.tap do |r|
+          r.text = output
+          r.critical = critical
+          r.fumble = fumble
         end
-
-        return crit, string
-      end
-
-      def getDiceChangesFromString(string)
-        firstDiceChanteTo = 0
-        firstDiceChangeModify = 0
-
-        regexp = /m\[([\d+\-]+)\]/i
-
-        if  regexp =~ string
-          firstDiceChangeModify = Regexp.last_match(1)
-
-          unless /[+\-]/ =~ firstDiceChangeModify
-            firstDiceChanteTo = firstDiceChangeModify.to_i
-            firstDiceChangeModify = 0
-          end
-
-          string = string.gsub(regexp, '')
-        end
-
-        return firstDiceChanteTo, firstDiceChangeModify, string
-      end
-
-      def getRateUpFromString(string)
-        rateUp = 0
-        return rateUp, string
-      end
-
-      def getKeyAndAddValueFromString(string)
-        key = nil
-        addValue = 0
-
-        if /K(\d+)([\d+\-]*)/i =~ string # ボーナスの抽出
-          key = Regexp.last_match(1)
-          if Regexp.last_match(2)
-            addValue = ArithmeticEvaluator.eval(Regexp.last_match(2))
-          end
-        else
-          key = string
-        end
-
-        return key, addValue
       end
 
       def getSW2_0_RatingTable
@@ -397,7 +295,7 @@ module BCDice
         return newRates
       end
 
-      def rollDice(_values)
+      def rollDice(_command)
         dice_list = @randomizer.roll_barabara(2, 6)
         total = dice_list.sum()
         dice_str = dice_list.join(",")
@@ -405,15 +303,15 @@ module BCDice
       end
 
       # @param rating_total [Integer]
-      # @param modifier [Integer]
+      # @param command [SwordWorld::RatingParsed]
       # @param diceResults [Array<String>]
       # @param diceResultTotals [Array<String>]
       # @param rateResults  [Array<String>]
       # @param dice_total [Integer]
       # @param round [Integer]
-      # @param half [Boolean]
-      def getResultText(rating_total, modifier, diceResults, diceResultTotals,
-                        rateResults, dice_total, round, half)
+      # @return [Array(String, Boolean, Boolean)] output, critical, fumble
+      def getResultText(rating_total, command, diceResults, diceResultTotals,
+                        rateResults, dice_total, round)
         sequence = []
 
         sequence.push("2D:[#{diceResults.join(' ')}]=#{diceResultTotals.join(',')}")
@@ -421,18 +319,25 @@ module BCDice
         if dice_total <= 2
           sequence.push(rateResults.join(','))
           sequence.push("自動的失敗")
-          return sequence.join(" ＞ ")
+          return sequence.join(" ＞ "), false, true
         end
 
         # rate回数が1回で、修正値がない時には途中式と最終結果が一致するので、途中式を省略する
-        if rateResults.size > 1 || modifier != 0
-          text = rateResults.join(',') + Format.modifier(modifier)
-          if half
+        if rateResults.size > 1 || command.modifier != 0
+          text = rateResults.join(',') + Format.modifier(command.modifier)
+          if command.half
             text = "(#{text})/2"
+            if command.modifier_after_half != 0
+              text += Format.modifier(command.modifier_after_half)
+            end
+          end
+          sequence.push(text)
+        elsif command.half
+          text = "#{rateResults.first}/2"
+          if command.modifier_after_half != 0
+            text += Format.modifier(command.modifier_after_half)
           end
           sequence.push(text)
-        elsif half
-          sequence.push("#{rateResults.first}/2")
         end
 
         if round > 1
@@ -440,50 +345,18 @@ module BCDice
           sequence.push(round_text)
         end
 
-        total = rating_total + modifier
-        if half
+        total = rating_total + command.modifier
+        if command.half
           total = (total / 2.0).ceil
+          if command.modifier_after_half != 0
+            total += command.modifier_after_half
+          end
         end
 
         total_text = total.to_s
         sequence.push(total_text)
 
-        return sequence.join(" ＞ ")
-      end
-
-      def setRatingTable(tnick)
-        mode_str = ""
-        pre_mode = @rating_table
-
-        if /(\d+)/ =~ tnick
-          @rating_table = Regexp.last_match(1).to_i
-          if @rating_table > 1
-            mode_str = "2.0-mode"
-            @rating_table = 2
-          elsif @rating_table > 0
-            mode_str = "new-mode"
-            @rating_table = 1
-          else
-            mode_str = "old-mode"
-            @rating_table = 0
-          end
-        else
-          case tnick
-          when /old/i
-            @rating_table = 0
-            mode_str = "old-mode"
-          when /new/i
-            @rating_table = 1
-            mode_str = "new-mode"
-          when /2\.0/i
-            @rating_table = 2
-            mode_str = "2.0-mode"
-          end
-        end
-
-        return '1' if @rating_table == pre_mode
-
-        return "RatingTableを#{mode_str}に変更しました"
+        return sequence.join(" ＞ "), round > 1, false
       end
     end
   end

data/lib/bcdice/game_system/SwordWorld2_0.rb

@@ -3,6 +3,7 @@
 require 'bcdice/arithmetic_evaluator'
 
 require 'bcdice/game_system/SwordWorld'
+require 'bcdice/game_system/sword_world/transcendent_test'
 
 module BCDice
   module GameSystem
@@ -11,7 +12,7 @@ module BCDice
       ID = 'SwordWorld2.0'
 
       # ゲームシステム名
-      NAME = 'ソードワールド2.0'
+      NAME = 'ソード・ワールド2.0'
 
       # ゲームシステム名の読みがな
       SORT_KEY = 'そおとわあると2.0'
@@ -34,10 +35,12 @@ module BCDice
         　またタイプの軽減化のために末尾に「@クリティカル値」でも処理するようにしました。
         　例）K20[10]　　　K10+5[9]　　　k30[10]　　　k10[9]+10　　　k10-5@9
 
-        ・レーティング表の半減 (HKx)
+        ・レーティング表の半減 (HKx, KxH+N)
         　レーティング表の先頭または末尾に"H"をつけると、レーティング表を振って最終結果を半減させます。
+        　末尾につけた場合、直後に修正ををつけることで、半減後の加減算を行うことができます。
+        　この際、複数の項による修正にはカッコで囲うことが必要です（カッコがないとパースに失敗します）
         　クリティカル値を指定しない場合、クリティカルなしと扱われます。
-        　例）HK20　　K20h　　HK10-5@9　　K10-5@9H　　K20gfH
+        　例）HK20　　K20h　　HK10-5@9　　K10-5@9H　　K20gfH　　K20+8H+2　　K20+8H(1+1)
 
         ・ダイス目の修正（運命変転やクリティカルレイ用）
         　末尾に「$修正値」でダイス目に修正がかかります。
@@ -65,115 +68,13 @@ module BCDice
         　絡み効果表を出すことができます。
       INFO_MESSAGE_TEXT
 
-      register_prefix('H?K\d+.*', 'Gr(\d+)?', '2D6?@\d+.*', 'FT', 'TT')
-
-      # 超越判定のノード
-      class TranscendentTest
-        # @param [Integer] critical_value クリティカル値
-        # @param [Integer] modifier 修正値
-        # @param [String, nil] cmp_op 比較演算子（> または >=）
-        # @param [Integer, nil] target 目標値
-        def initialize(critical_value, modifier, cmp_op, target)
-          @critical_value = critical_value
-          @modifier = modifier
-          @cmp_op = cmp_op
-          @target = target
-
-          @modifier_str = Format.modifier(@modifier)
-          @expression = node_expression()
-        end
-
-        # 超越判定を行う
-        # @param randomizer [Randomizer]
-        # @return [String]
-        def execute(randomizer)
-          if @critical_value < 3
-            return "(#{@expression}) ＞ クリティカル値が小さすぎます。3以上を指定してください。"
-          end
-
-          first_value_group = randomizer.roll_barabara(2, 6)
-          value_groups = [first_value_group]
-
-          fumble = first_value_group == [1, 1]
-          critical = first_value_group == [6, 6]
-
-          if !fumble && !critical
-            while sum_of_dice(value_groups.last) >= @critical_value
-              value_groups.push(randomizer.roll_barabara(2, 6))
-            end
-          end
-
-          sum = sum_of_dice(value_groups)
-          total_sum = sum + @modifier
-
-          parts = [
-            "(#{@expression})",
-            "#{dice_str(value_groups, sum)}#{@modifier_str}",
-            total_sum,
-            @target && result_str(total_sum, value_groups.length, fumble, critical)
-          ].compact
-
-          return parts.join(' ＞ ')
-        end
-
-        private
-
-        # 数式表記を返す
-        # @return [String]
-        def node_expression
-          lhs = "2D6@#{@critical_value}#{@modifier_str}"
-
-          return @target ? "#{lhs}#{@cmp_op}#{@target}" : lhs
-        end
-
-        # 出目の合計を返す
-        # @param [(Integer, Integer), Array<(Integer, Integer)>] value_groups
-        #   出目のグループまたはその配列
-        # @return [Integer]
-        def sum_of_dice(value_groups)
-          value_groups.flatten.sum
-        end
-
-        # ダイス部分の文字列を返す
-        # @param [Array<(Integer, Integer)>] value_groups 出目のグループの配列
-        # @param [Integer] sum 出目の合計
-        # @return [String]
-        def dice_str(value_groups, sum)
-          value_groups_str =
-            value_groups
-            .map { |values| "[#{values.join(',')}]" }
-            .join
-
-          return "#{sum}#{value_groups_str}"
-        end
-
-        # 判定結果の文字列を返す
-        # @param [Integer] total_sum 合計値
-        # @param [Integer] n_value_groups 出目のグループの数
-        # @param [Boolean] fumble ファンブルかどうか
-        # @param [Boolean] critical クリティカルかどうか
-        # @return [String]
-        def result_str(total_sum, n_value_groups, fumble, critical)
-          return '自動的失敗' if fumble
-          return '自動的成功' if critical
-
-          if total_sum.send(@cmp_op, @target)
-            # 振り足しが行われ、合計値が41以上ならば「超成功」
-            n_value_groups >= 2 && total_sum >= 41 ? '超成功' : '成功'
-          else
-            '失敗'
-          end
-        end
-      end
+      register_prefix('H?K', 'Gr', '2D6?@\d+', 'FT', 'TT')
 
       def initialize(command)
         super(command)
         @rating_table = 2
       end
 
-      # 超越判定のパターン
-      TRANSCENDENT_TEST_RE = /\A2D6?@(\d+)([-+\d]+)?(?:(>=?)(\d+))?/.freeze
-
       def eval_game_system_specific_command(command)
         case command
         when /^Gr(\d+)?/i
@@ -182,15 +83,17 @@ module BCDice
           else
             growth
           end
-        when TRANSCENDENT_TEST_RE
-          m = Regexp.last_match
-
-          critical_value = m[1].to_i
-          modifier = m[2] ? ArithmeticEvaluator.eval(m[2]) : 0
-          cmp_op = m[3]
-          target = m[3] && m[4].to_i
+        when /^2D6?@\d+/i
+          transcendent_parser = Command::Parser.new(/2D6?/i, round_type: BCDice::RoundType::CEIL)
+                                               .enable_critical
+                                               .restrict_cmp_op_to(nil, :>=, :>)
+          cmd = transcendent_parser.parse(command)
+
+          unless cmd
+            return nil
+          end
 
-          node = TranscendentTest.new(critical_value, modifier, cmp_op, target)
+          node = TranscendentTest.new(cmd.critical, cmd.modify_number, cmd.cmp_op, cmd.target_number)
           node.execute(@randomizer)
         when 'FT'
           get_fumble_table
@@ -201,32 +104,13 @@ module BCDice
         end
       end
 
-      def getRateUpFromString(string)
-        rateUp = 0
-
-        regexp = /r\[(\d+)\]/i
-        if (m = regexp.match(string))
-          rateUp = m[1].to_i
-          string = string.gsub(regexp, '')
-        end
-
-        return rateUp, string
-      end
-
-      def getAdditionalString(string, output)
-        output, values = super(string, output)
-
-        isGratestFortune, = getGratestFortuneFromString(string)
-
-        values['isGratestFortune'] = isGratestFortune
-        output += "gf" if isGratestFortune
-
-        return output, values
+      def rating_parser
+        return RatingParser.new(version: :v2_0)
       end
 
-      def rollDice(values)
-        unless values['isGratestFortune']
-          return super(values)
+      def rollDice(command)
+        unless command.greatest_fortune
+          return super(command)
         end
 
         dice = @randomizer.roll_once(6)
@@ -234,18 +118,6 @@ module BCDice
         return dice * 2, "#{dice},#{dice}"
       end
 
-      def getGratestFortuneFromString(string)
-        isGratestFortune = false
-
-        regexp = /gf/i
-        if regexp.match?(string)
-          isGratestFortune = true
-          string = string.gsub(regexp, '')
-        end
-
-        return isGratestFortune, string
-      end
-
       def growth(count = 1)
         ((1..count).map { growth_step }).join " | "
       end