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

data/lib/bcdice/common_command/reroll_dice/parser.y

@@ -0,0 +1,158 @@
+class BCDice::CommonCommand::RerollDice::Parser
+  token NUMBER R U C F S PLUS MINUS ASTERISK SLASH PARENL PARENR BRACKETL BRACKETR LESS GREATER EQUAL NOT AT CMP_OP
+
+  rule
+    expr: secret notations target
+        {
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: val[2][:cmp_op],
+            target_number: val[2][:target],
+            source: @lexer.source
+          )
+        }
+        | secret notations bracket target
+        {
+          target = val[3]
+          threshold = val[2]
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: target[:cmp_op],
+            target_number: target[:target],
+            reroll_cmp_op: threshold[:cmp_op],
+            reroll_threshold: threshold[:threshold],
+            source: @lexer.source
+          )
+        }
+        | secret notations target at
+        {
+          target = val[2]
+          threshold = val[3]
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: target[:cmp_op],
+            target_number: target[:target],
+            reroll_cmp_op: threshold[:cmp_op],
+            reroll_threshold: threshold[:threshold],
+            source: @lexer.source
+          )
+        }
+
+    secret: /* none */
+          { result = false }
+          | S
+          { result = true }
+
+    target: /* none */
+          { result = {} }
+          | CMP_OP add
+          {
+            cmp_op, target = val
+            raise ParseError unless cmp_op
+
+            result = {cmp_op: cmp_op, target: target}
+          }
+
+    bracket: BRACKETL add BRACKETR
+           { result = {threshold: val[1]}  }
+           | BRACKETL CMP_OP add BRACKETR
+           {
+             cmp_op = val[1]
+             threshold = val[2]
+             raise ParseError unless cmp_op
+
+             result = {cmp_op: cmp_op, threshold: threshold}
+           }
+
+    at: AT add
+      { result = {threshold: val[1]} }
+      | AT CMP_OP add
+      {
+        cmp_op = val[1]
+        threshold = val[2]
+        raise ParseError unless cmp_op
+
+        result = {cmp_op: cmp_op, threshold: threshold}
+      }
+
+    notations: notations PLUS dice
+             {
+               notations = val[0]
+               notations.push(val[2])
+               result = notations
+             }
+             | dice
+             { result = [val[0]] }
+
+    dice: term R term
+        {
+          times = val[0]
+          sides = val[2]
+          result = Node::Notation.new(times, sides)
+        }
+
+    add: add PLUS mul
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2]) }
+       | add MINUS mul
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2]) }
+       | mul
+
+    mul: mul ASTERISK unary
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2]) }
+       | mul SLASH unary round_type
+       {
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+       }
+       | unary
+
+    round_type: /* none */
+              { result = Arithmetic::Node::DivideWithGameSystemDefault }
+              | U
+              { result = Arithmetic::Node::DivideWithCeil }
+              | C
+              { result = Arithmetic::Node::DivideWithCeil }
+              | R
+              { result = Arithmetic::Node::DivideWithRound }
+              | F
+              { result = Arithmetic::Node::DivideWithFloor }
+
+    unary: PLUS unary
+         { result = val[1] }
+         | MINUS unary
+         { result = Arithmetic::Node::Negative.new(val[1]) }
+         | term
+
+    term: PARENL add PARENR
+        { result = val[1] }
+        | NUMBER
+        { result = Arithmetic::Node::Number.new(val[0]) }
+end
+
+---- header
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/barabara_dice/node"
+require "bcdice/arithmetic/node"
+
+---- inner
+
+def self.parse(source)
+  new.parse(source)
+end
+
+def parse(source)
+  @lexer = Lexer.new(source)
+  do_parse()
+rescue ParseError
+  nil
+end
+
+private
+
+def next_token
+  @lexer.next_token
+end

data/lib/bcdice/common_command/upper_dice.rb

@@ -1,6 +1,4 @@
-require "bcdice/arithmetic_evaluator"
-require "bcdice/normalize"
-require "bcdice/format"
+require "bcdice/common_command/upper_dice/parser"
 
 module BCDice
   module CommonCommand
@@ -30,135 +28,18 @@ module BCDice
     #   "2U4" -> 3[3]+10=13, 10[4,4,2]+10=20
     #   最大値：20
     #   合計値：23 = 3[3]+10[4,4,2]+10
-    class UpperDice
+    module UpperDice
       PREFIX_PATTERN = /\d+U\d+/.freeze
 
-      def initialize(command, bcdice, diceBot)
-        @string = command
-        @bcdice = bcdice
-        @diceBot = diceBot
-
-        @is_secret = false
-      end
-
-      def secret?
-        @is_secret
-      end
-
-      # 上方無限ロールを実行する
-      #
-      # @return [String, nil]
-      def eval
-        unless (m = /^S?(\d+U\d+(?:\+\d+U\d+)*)(?:\[(\d+)\])?([\+\-\d]*)(?:([<>=]+)(\d+))?(?:@(\d+))?/i.match(@string))
-          return nil
+      class << self
+        # @param command [String]
+        # @param game_system [BCDice::Base]
+        # @param randomizer [BCDice::Randomizer]
+        # @return [UpperDice, nil]
+        def eval(command, game_system, randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system, randomizer)
         end
-
-        @is_secret = @string.start_with?("S")
-
-        @command = m[1]
-        @cmp_op = Normalize.comparison_operator(m[4])
-        @target_number = @cmp_op ? m[5].to_i : nil
-        @reroll_threshold = reroll_threshold(m[2] || m[6])
-
-        @modify_number = ArithmeticEvaluator.eval(m[3], round_type: @diceBot.round_type)
-
-        if @reroll_threshold <= 1
-          return "(#{expr()}) ＞ 無限ロールの条件がまちがっています"
-        end
-
-        roll_list = []
-        @command.split("+").each do |u|
-          times, sides = u.split("U", 2).map(&:to_i)
-          roll_list.concat(roll(times, sides))
-        end
-
-        result =
-          if @cmp_op
-            success_count = roll_list.count do |e|
-              x = e[:sum] + @modify_number
-              x.send(@cmp_op, @target_number)
-            end
-            "成功数#{success_count}"
-          else
-            sum_list = roll_list.map { |e| e[:sum] }
-            total = sum_list.inject(0, :+) + @modify_number
-            max = sum_list.map { |i| i + @modify_number }.max
-            "#{max}/#{total}(最大/合計)"
-          end
-
-        sequence = [
-          "(#{expr()})",
-          dice_text(roll_list) + Format.modifier(@modify_number),
-          result
-        ]
-
-        return sequence.join(" ＞ ")
-      end
-
-      private
-
-      # ダイスロールし、ダイスボットのソート設定に応じてソートする
-      #
-      # @param times [Integer] ダイスの個数
-      # @param sides [Integer] ダイスの面数
-      # @return [Array<Hash>]
-      def roll(times, sides)
-        ret = Array.new(times) do
-          list = roll_ones(sides)
-          {sum: list.inject(0, :+), list: list}
-        end
-
-        if @diceBot.sort_barabara_dice?
-          ret = ret.sort_by { |e| e[:sum] }
-        end
-
-        return ret
-      end
-
-      # 一つだけダイスロールする
-      #
-      # @param sides [Integer] ダイスの面数
-      # @return [Array<Integer>]
-      def roll_ones(sides)
-        dice_list = []
-
-        loop do
-          value = @bcdice.roll_once(sides)
-          dice_list.push(value)
-          break if value < @reroll_threshold
-        end
-
-        return dice_list
-      end
-
-      # ダイスロールの結果を文字列に変換する
-      # 振り足しがなければその数値、振り足しがあれば合計と各ダイスの出目を出力する
-      #
-      # @param roll_list [Array<Hash>]
-      # @return [String]
-      def dice_text(roll_list)
-        roll_list.map do |e|
-          if e[:list].size == 1
-            e[:sum]
-          else
-            "#{e[:sum]}[#{e[:list].join(',')}]"
-          end
-        end.join(",")
-      end
-
-      # 振り足しの閾値を得る
-      #
-      # @param target [String]
-      # @return [Integer]
-      def reroll_threshold(target)
-        target&.to_i || @diceBot.upper_dice_reroll_threshold.to_i
-      end
-
-      # パース済みのコマンドを文字列で表示する
-      #
-      # @return [String]
-      def expr
-        "#{@command}[#{@reroll_threshold}]#{Format.modifier(@modify_number)}#{Format.comparison_operator(@cmp_op)}#{@target_number}"
       end
     end
   end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module BCDice
+  module CommonCommand
+    module UpperDice
+      module Node
+        class Command
+          # @param secret [Boolean]
+          # @param notations [Array<Notation>]
+          # @param modifier [Integer]
+          # @param cmp_op [Symbol, nil]
+          # @param target_number [Integer, nil]
+          # @param reroll_threshold [Integer]
+          def initialize(secret:, notations:, modifier:, cmp_op:, target_number:, reroll_threshold: nil)
+            @secret = secret
+            @notations = notations
+            @modifier = modifier
+            @cmp_op = cmp_op
+            @target_number = target_number
+            @reroll_threshold = reroll_threshold
+          end
+
+          # 上方無限ロールを実行する
+          #
+          # @param randomizer [Randomizer]
+          # @return [Result, nil]
+          def eval(game_system, randomizer)
+            round_type = game_system.round_type
+
+            dice_list = @notations.map { |n| n.to_dice(round_type) }
+            reroll_threshold = @reroll_threshold&.eval(round_type) || game_system.upper_dice_reroll_threshold || 0
+            modifier = @modifier&.eval(round_type) || 0
+            target_number = @target_number&.eval(round_type)
+
+            expr = expr(dice_list, reroll_threshold, modifier, target_number)
+
+            if reroll_threshold <= 1
+              return result_with_text("(#{expr}) ＞ 無限ロールの条件がまちがっています")
+            end
+
+            roll_list = dice_list.map do |n|
+              n.roll(randomizer, reroll_threshold, game_system.sort_barabara_dice?)
+            end.reduce([], :concat)
+
+            result =
+              if @cmp_op
+                result_success_count(roll_list, modifier, target_number)
+              else
+                result_max_sum(roll_list, modifier)
+              end
+
+            sequence = [
+              "(#{expr})",
+              interlim_expr(roll_list, modifier),
+              result
+            ]
+
+            result_with_text(sequence.join(" ＞ "))
+          end
+
+          private
+
+          def result_success_count(roll_list, modifier, target_number)
+            success_count = roll_list.count do |e|
+              x = e[:sum] + modifier
+              x.send(@cmp_op, target_number)
+            end
+
+            "成功数#{success_count}"
+          end
+
+          def result_max_sum(roll_list, modifier)
+            sum_list = roll_list.map { |e| e[:sum] }
+            total = sum_list.sum() + modifier
+            max = sum_list.map { |i| i + modifier }.max
+
+            "#{max}/#{total}(最大/合計)"
+          end
+
+          # ダイスロールの結果を文字列に変換する
+          # 振り足しがなければその数値、振り足しがあれば合計と各ダイスの出目を出力する
+          #
+          # @param roll_list [Array<Hash>]
+          # @param modifier [Integer]
+          # @return [String]
+          def interlim_expr(roll_list, modifier)
+            dice = roll_list.map do |e|
+              if e[:list].size == 1
+                e[:sum]
+              else
+                "#{e[:sum]}[#{e[:list].join(',')}]"
+              end
+            end.join(",")
+
+            dice + Format.modifier(modifier)
+          end
+
+          # パース済みのコマンドを文字列で表示する
+          #
+          # @return [String]
+          def expr(dice_list, reroll_threshold, modifier, target_number)
+            formated_cmp_op = Format.comparison_operator(@cmp_op)
+            formated_modifier = Format.modifier(modifier)
+
+            "#{dice_list.join('+')}[#{reroll_threshold}]#{formated_modifier}#{formated_cmp_op}#{target_number}"
+          end
+
+          def result_with_text(text)
+            Result.new.tap do |r|
+              r.secret = @secret
+              r.text = text
+            end
+          end
+        end
+
+        class Notation
+          # @param roll_times [Object]
+          # @param sides [Object]
+          def initialize(roll_times, sides)
+            @roll_times = roll_times
+            @sides = sides
+          end
+
+          # @param round_type [Symbol]
+          # @return [Dice]
+          def to_dice(round_type)
+            roll_times = @roll_times.eval(round_type)
+            sides = @sides.eval(round_type)
+
+            Dice.new(roll_times, sides)
+          end
+        end
+
+        class Dice
+          # @param roll_times [Integer]
+          # @param sides [Integer]
+          def initialize(roll_times, sides)
+            @roll_times = roll_times
+            @sides = sides
+          end
+
+          # @param randomizer [BCDice::Randomizer]
+          # @param reroll_threshold [Integer]
+          # @param sort [Boolean]
+          # @return [Array<Hash>]
+          def roll(randomizer, reroll_threshold, sort)
+            ret = Array.new(@roll_times) do
+              list = roll_ones(randomizer, reroll_threshold)
+              {sum: list.sum(), list: list}
+            end
+
+            if sort
+              ret = ret.sort_by { |e| e[:sum] }
+            end
+
+            return ret
+          end
+
+          # @return [String]
+          def to_s
+            "#{@roll_times}U#{@sides}"
+          end
+
+          private
+
+          def roll_ones(randomizer, reroll_threshold)
+            dice_list = []
+
+            loop do
+              value = randomizer.roll_once(@sides)
+              dice_list.push(value)
+              break if value < reroll_threshold
+            end
+
+            return dice_list
+          end
+        end
+      end
+    end
+  end
+end