bcdice 3.0.0.pre.alpha.1

data/lib/bcdice/command_parser.rb

@@ -0,0 +1,242 @@
+require "bcdice/arithmetic_evaluator"
+require "bcdice/normalize"
+require "bcdice/format"
+
+module BCDice
+  # よくある形式のコマンドのパースを補助するクラス
+  #
+  # @example Literal by String
+  #   parser = CommandParser.new("MC")
+  #   parsed = parser.parse("MC+2*3@30<=10/2-3") #=> <CommandParser::Parsed>
+  #
+  #   parsed.command #=> "MC"
+  #   parsed.modify_number #=> 6
+  #   parsed.critical #=> 30
+  #   parsed.cmp_op #=> #>=
+  #   parsed.target_number #=> 2
+  #
+  # @example Literal by Regexp
+  #   parser = CommandParser.new(/^RE\d+$/)
+  #   parsed = parser.parse("RE44+20") #=> <CommandParser::Parsed>
+  #
+  #   parsed.command #=> "RE44"
+  #   parsed.modify_number #=> 20
+  class CommandParser < ArithmeticEvaluator
+    # @param literals [Array<String, Regexp>]
+    def initialize(*literals)
+      @literals = literals
+      @round_type = RoundType::FLOOR
+      @allowed_cmp_op = nil
+
+      @enabled_question_target = false
+    end
+
+    # パース結果
+    class Parsed
+      # @return [String]
+      attr_accessor :command
+
+      # @return [Integer, nil]
+      attr_accessor :critical
+
+      # @return [Integer, nil]
+      attr_accessor :fumble
+
+      # @return [Integer, nil]
+      attr_accessor :dollar
+
+      # @return [Integer]
+      attr_accessor :modify_number
+
+      # @return [Symbol, nil]
+      attr_accessor :cmp_op
+
+      # @return [Integer, nil]
+      attr_accessor :target_number
+
+      # @param value [Boolean]
+      # @return [Boolean]
+      attr_writer :question_target
+
+      def initialize
+        @critical = nil
+        @fumble = nil
+        @dollar = nil
+        @cmp_op = nil
+        @target_number = nil
+        @question_target = false
+      end
+
+      # @return [Boolean]
+      def question_target?
+        @question_target
+      end
+
+      # @param suffix_position [Symbol] クリティカルなどの表示位置
+      # @return [String]
+      def to_s(suffix_position = :after_command)
+        c = @critical ? "@#{@critical}" : nil
+        f = @fumble ? "##{@fumble}" : nil
+        d = @dollar ? "$#{@dollar}" : nil
+        m = Format.modifier(@modify_number)
+        target = @question_target ? "?" : @target_number
+
+        case suffix_position
+        when :after_command
+          [@command, c, f, d, m, @cmp_op, target].join()
+        when :after_modify_number
+          [@command, m, c, f, d, @cmp_op, target].join()
+        when :after_target_number
+          [@command, m, @cmp_op, target, c, f, d].join()
+        end
+      end
+    end
+
+    # 特定の比較演算子のみ許可するようにする。
+    # 比較演算子なしを許可する場合には nil を指定してください。
+    #
+    # @param cmp_op [Array<Symbol, nil>] 許可する比較演算子の一覧
+    # @return [self]
+    def allow_cmp_op(*cmp_op)
+      @allowed_cmp_op = cmp_op
+      self
+    end
+
+    # 目標値 "?" を許容する
+    #
+    # @return [self]
+    def enable_question_target
+      @enabled_question_target = true
+      self
+    end
+
+    # 式をパースする
+    #
+    # @param expr [String]
+    # @param round_type [Symbol]
+    # @return [CommandParser::Parsed, nil]
+    def parse(expr, round_type = RoundType::FLOOR)
+      @tokens = tokenize(expr)
+      @idx = 0
+      @error = false
+      @round_type = round_type
+
+      @parsed = Parsed.new()
+
+      lhs()
+      if @error
+        return nil
+      end
+
+      @parsed.cmp_op = take_cmp_op()
+      rhs() if @parsed.cmp_op
+
+      if @idx < @tokens.size || @error
+        return nil
+      end
+
+      return @parsed
+    end
+
+    private
+
+    # @return [Array<String>]
+    def tokenize(expr)
+      expr.gsub(%r{[\(\)\+\-*/@#\$]|[<>!=]+}) { |e| " #{e} " }.split(" ")
+    end
+
+    def lhs
+      command = take()
+      unless literal?(command)
+        @error = true
+        return
+      end
+
+      command_suffix()
+
+      ret = 0
+      loop do
+        if consume("+")
+          ret += mul()
+        elsif consume("-")
+          ret -= mul()
+        else
+          break
+        end
+      end
+
+      command_suffix()
+
+      @parsed.command = command
+      @parsed.modify_number = ret
+    end
+
+    def command_suffix
+      loop do
+        if consume("@")
+          if @parsed.critical
+            @error = true
+          end
+          @parsed.critical = unary()
+        elsif consume("#")
+          if @parsed.fumble
+            @error = true
+          end
+          @parsed.fumble = unary()
+        elsif consume("$")
+          if @parsed.dollar
+            @error = true
+          end
+          @parsed.dollar = unary()
+        else
+          break
+        end
+      end
+    end
+
+    def rhs
+      if @enabled_question_target && consume("?")
+        @parsed.question_target = true
+        @parsed.target_number = 0
+      else
+        @parsed.question_target = false
+        @parsed.target_number = expr()
+      end
+    end
+
+    def literal?(command)
+      @literals.each do |lit|
+        case lit
+        when String
+          return true if command == lit
+        when Regexp
+          return true if command =~ lit
+        end
+      end
+
+      return false
+    end
+
+    def take
+      ret = @tokens[@idx]
+      @idx += 1
+
+      return ret
+    end
+
+    def take_cmp_op
+      cmp_op = Normalize.comparison_operator(take())
+      @error ||= denied_cmp_op?(cmp_op)
+
+      return cmp_op
+    end
+
+    def denied_cmp_op?(cmp_op)
+      if @allowed_cmp_op.nil?
+        false
+      else
+        !@allowed_cmp_op.include?(cmp_op)
+      end
+    end
+  end
+end

data/lib/bcdice/common_command.rb

@@ -0,0 +1,23 @@
+require "bcdice/common_command/add_dice"
+require "bcdice/common_command/barabara_dice"
+require "bcdice/common_command/calc"
+require "bcdice/common_command/choice"
+require "bcdice/common_command/d66_dice"
+require "bcdice/common_command/reroll_dice"
+require "bcdice/common_command/upper_dice"
+require "bcdice/common_command/version"
+
+module BCDice
+  module CommonCommand
+    COMMANDS = [
+      AddDice,
+      BarabaraDice,
+      Calc,
+      Choice,
+      D66Dice,
+      RerollDice,
+      UpperDice,
+      Version,
+    ].freeze
+  end
+end

data/lib/bcdice/common_command/add_dice.rb

@@ -0,0 +1,54 @@
+require "bcdice/normalize"
+require "bcdice/common_command/add_dice/parser"
+require "bcdice/common_command/add_dice/randomizer"
+
+module BCDice
+  module CommonCommand
+    class AddDice
+      PREFIX_PATTERN = /[\+\-\dD\(\[]+/.freeze
+
+      def initialize(command, randomizer, game_system)
+        @command = command
+        @bcdice = randomizer
+        @diceBot = game_system
+
+        @dice_list = []
+        @is_secret = false
+      end
+
+      def secret?
+        @is_secret
+      end
+
+      def eval()
+        parser = Parser.new(@command)
+
+        command = parser.parse()
+        if parser.error?
+          return nil
+        end
+
+        randomizer = Randomizer.new(@bcdice, @diceBot, command.cmp_op)
+        total = command.lhs.eval(randomizer)
+
+        output =
+          if randomizer.dice_list.size <= 1 && command.lhs.is_a?(Node::DiceRoll)
+            "(#{command}) ＞ #{total}"
+          else
+            "(#{command}) ＞ #{command.lhs.output} ＞ #{total}"
+          end
+
+        dice_list = randomizer.dice_list
+
+        if command.cmp_op
+          dice_total = dice_list.inject(&:+)
+          output += @diceBot.check_result(total, dice_total, dice_list, randomizer.sides, command.cmp_op, command.rhs)
+        end
+
+        @is_secret = parser.secret?
+
+        return output
+      end
+    end
+  end
+end

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

@@ -0,0 +1,488 @@
+# frozen_string_literal: true
+
+module BCDice
+  module CommonCommand
+    class AddDice
+      # 加算ロールの構文解析木のノードを格納するモジュール
+      module Node
+        # 加算ロールコマンドのノード。
+        #
+        # 目標値が設定されていない場合は +lhs+ のみを使用する。
+        # 目標値が設定されている場合は、+lhs+、+cmp_op+、+rhs+ を使用する。
+        class Command
+          # 左辺のノード
+          # @return [Object]
+          attr_reader :lhs
+          # 比較演算子
+          # @return [Symbol]
+          attr_reader :cmp_op
+          # 右辺のノード
+          # @return [Integer, String]
+          attr_reader :rhs
+
+          # ノードを初期化する
+          # @param [Object] lhs 左辺のノード
+          # @param [Symbol] cmp_op 比較演算子
+          # @param [Integer, String] rhs 右辺のノード
+          def initialize(lhs, cmp_op, rhs)
+            @lhs = lhs
+            @cmp_op = cmp_op
+            @rhs = rhs
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            @lhs.to_s + cmp_op_text + @rhs.to_s
+          end
+
+          # ノードのS式を返す
+          # @return [String]
+          def s_exp
+            if @cmp_op
+              "(Command (#{@cmp_op} #{@lhs.s_exp} #{@rhs}))"
+            else
+              "(Command #{@lhs.s_exp})"
+            end
+          end
+
+          private
+
+          # メッセージ中で比較演算子をどのように表示するかを返す
+          # @return [String]
+          def cmp_op_text
+            case @cmp_op
+            when :'!='
+              "<>"
+            when :==
+              "="
+            else
+              @cmp_op.to_s
+            end
+          end
+        end
+
+        # 二項演算子のノード
+        class BinaryOp
+          # ノードを初期化する
+          # @param [Object] lhs 左のオペランドのノード
+          # @param [Symbol] op 演算子
+          # @param [Object] rhs 右のオペランドのノード
+          def initialize(lhs, op, rhs)
+            @lhs = lhs
+            @op = op
+            @rhs = rhs
+          end
+
+          # ノードを評価する
+          #
+          # 左右のオペランドをそれぞれ再帰的に評価した後で、演算を行う。
+          #
+          # @param [Randomizer] randomizer ランダマイザ
+          # @return [Integer] 評価結果
+          def eval(randomizer)
+            lhs = @lhs.eval(randomizer)
+            rhs = @rhs.eval(randomizer)
+
+            return calc(lhs, rhs)
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            "#{@lhs}#{@op}#{@rhs}"
+          end
+
+          # メッセージへの出力を返す
+          # @return [String]
+          def output
+            "#{@lhs.output}#{@op}#{@rhs.output}"
+          end
+
+          # ノードのS式を返す
+          # @return [String]
+          def s_exp
+            "(#{op_for_s_exp} #{@lhs.s_exp} #{@rhs.s_exp})"
+          end
+
+          private
+
+          # 演算を行う
+          # @param [Integer] lhs 左のオペランド
+          # @param [Integer] rhs 右のオペランド
+          # @return [Integer] 演算の結果
+          def calc(lhs, rhs)
+            lhs.send(@op, rhs)
+          end
+
+          # S式で使う演算子の表現を返す
+          # @return [String]
+          def op_for_s_exp
+            @op
+          end
+        end
+
+        # 除算ノードの基底クラス
+        #
+        # 定数 +ROUNDING_METHOD+ で端数処理方法を示す記号
+        # ( +'U'+, +'R'+, +''+ ) を定義すること。
+        # また、除算および端数処理を行う +divide_and_round+ メソッドを実装すること。
+        class DivideBase < BinaryOp
+          # ノードを初期化する
+          # @param [Object] lhs 左のオペランドのノード
+          # @param [Object] rhs 右のオペランドのノード
+          def initialize(lhs, rhs)
+            super(lhs, :/, rhs)
+          end
+
+          # 文字列に変換する
+          #
+          # 通常の結果の末尾に、端数処理方法を示す記号を付加する。
+          #
+          # @return [String]
+          def to_s
+            "#{super}#{rounding_method}"
+          end
+
+          # メッセージへの出力を返す
+          #
+          # 通常の結果の末尾に、端数処理方法を示す記号を付加する。
+          #
+          # @return [String]
+          def output
+            "#{super}#{rounding_method}"
+          end
+
+          private
+
+          # 端数処理方法を示す記号を返す
+          # @return [String]
+          def rounding_method
+            self.class::ROUNDING_METHOD
+          end
+
+          # S式で使う演算子の表現を返す
+          # @return [String]
+          def op_for_s_exp
+            "#{@op}#{rounding_method}"
+          end
+
+          # 演算を行う
+          # @param [Integer] lhs 左のオペランド
+          # @param [Integer] rhs 右のオペランド
+          # @return [Integer] 演算の結果
+          def calc(lhs, rhs)
+            if rhs.zero?
+              return 1
+            end
+
+            return divide_and_round(lhs, rhs)
+          end
+
+          # 除算および端数処理を行う
+          # @param [Integer] _dividend 被除数
+          # @param [Integer] _divisor 除数（0以外）
+          # @return [Integer]
+          def divide_and_round(_dividend, _divisor)
+            raise NotImplementedError
+          end
+        end
+
+        # 除算（切り上げ）のノード
+        class DivideWithRoundingUp < DivideBase
+          # 端数処理方法を示す記号
+          ROUNDING_METHOD = "U"
+
+          private
+
+          # 除算および端数処理を行う
+          # @param [Integer] dividend 被除数
+          # @param [Integer] divisor 除数（0以外）
+          # @return [Integer]
+          def divide_and_round(dividend, divisor)
+            (dividend.to_f / divisor).ceil
+          end
+        end
+
+        # 除算（四捨五入）のノード
+        class DivideWithRoundingOff < DivideBase
+          # 端数処理方法を示す記号
+          ROUNDING_METHOD = "R"
+
+          private
+
+          # 除算および端数処理を行う
+          # @param [Integer] dividend 被除数
+          # @param [Integer] divisor 除数（0以外）
+          # @return [Integer]
+          def divide_and_round(dividend, divisor)
+            (dividend.to_f / divisor).round
+          end
+        end
+
+        # 除算（切り捨て）のノード
+        class DivideWithRoundingDown < DivideBase
+          # 端数処理方法を示す記号
+          ROUNDING_METHOD = ""
+
+          private
+
+          # 除算および端数処理を行う
+          # @param [Integer] dividend 被除数
+          # @param [Integer] divisor 除数（0以外）
+          # @return [Integer]
+          def divide_and_round(dividend, divisor)
+            dividend / divisor
+          end
+        end
+
+        # 符号反転のノード
+        class Negate
+          # 符号反転の対象
+          # @return [Object]
+          attr_reader :body
+
+          # ノードを初期化する
+          # @param [Object] body 符号反転の対象
+          def initialize(body)
+            @body = body
+          end
+
+          # ノードを評価する
+          #
+          # 対象オペランドを再帰的に評価した後、評価結果の符号を反転する。
+          #
+          # @param [Randomizer] randomizer ランダマイザ
+          # @return [Integer] 評価結果
+          def eval(randomizer)
+            -@body.eval(randomizer)
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            "-#{@body}"
+          end
+
+          # メッセージへの出力を返す
+          # @return [String]
+          def output
+            "-#{@body.output}"
+          end
+
+          # ノードのS式を返す
+          # @return [String]
+          def s_exp
+            "(- #{@body.s_exp})"
+          end
+        end
+
+        # ダイスロールのノード
+        class DiceRoll
+          # ノードを初期化する
+          # @param [Number] times ダイスを振る回数のノード
+          # @param [Number] sides ダイスの面数のノード
+          def initialize(times, sides)
+            @times = times.literal
+            @sides = sides.literal
+
+            # ダイスを振った結果の出力
+            @text = nil
+          end
+
+          # ノードを評価する（ダイスを振る）
+          #
+          # 評価結果は出目の合計値になる。
+          # 出目はランダマイザに記録される。
+          #
+          # @param [Randomizer] randomizer ランダマイザ
+          # @return [Integer] 評価結果（出目の合計値）
+          def eval(randomizer)
+            dice_groups = randomizer.roll(@times, @sides)
+
+            # TODO: Ruby 2.4以降では Array#sum が使える
+            total = dice_groups.flatten.reduce(0, &:+)
+
+            dice_str = dice_groups
+                       .map { |dice_list| "[#{dice_list.join(',')}]" }
+                       .join
+            @text = "#{total}#{dice_str}"
+
+            return total
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            "#{@times}D#{@sides}"
+          end
+
+          # メッセージへの出力を返す
+          # @return [String]
+          def output
+            @text
+          end
+
+          # ノードのS式を返す
+          # @return [String]
+          def s_exp
+            "(DiceRoll #{@times} #{@sides})"
+          end
+        end
+
+        # フィルタ処理付きダイスロールのノード。
+        #
+        # ダイスロール後、条件に従って出目を選択し、和を求める。
+        class DiceRollWithFilter
+          # フィルタの構造体
+          #
+          # 各フィルタには、あらかじめソートされた出目の配列が渡される。
+          #
+          # @!attribute abbr
+          #   @return [Symbol] フィルタの略称
+          # @!attribute apply
+          #   @return [Proc] フィルタ処理の内容
+          Filter = Struct.new(:abbr, :apply)
+
+          # 大きな出目から複数個取る
+          KEEP_HIGHEST = Filter.new(
+            :KH,
+            lambda { |sorted_values, n| sorted_values.reverse.take(n) }
+          ).freeze
+
+          # 小さな出目から複数個取る
+          KEEP_LOWEST = Filter.new(
+            :KL,
+            lambda { |sorted_values, n| sorted_values.take(n) }
+          ).freeze
+
+          # 大きな出目から複数個除く
+          DROP_HIGHEST = Filter.new(
+            :DH,
+            lambda { |sorted_values, n| sorted_values.reverse.drop(n) }
+          ).freeze
+
+          # 小さな出目から複数個除く
+          DROP_LOWEST = Filter.new(
+            :DL,
+            lambda { |sorted_values, n| sorted_values.drop(n) }
+          ).freeze
+
+          # ノードを初期化する
+          # @param [Number] times ダイスを振る回数のノード
+          # @param [Number] sides ダイスの面数のノード
+          # @param [Number] n_filtering ダイスを残す/減らす個数のノード
+          # @param [Filter] filter フィルタ
+          def initialize(times, sides, n_filtering, filter)
+            @times = times.literal
+            @sides = sides.literal
+            @n_filtering = n_filtering.literal
+            @filter = filter
+
+            # ダイスを振った結果の出力
+            @text = nil
+          end
+
+          # ノードを評価する（ダイスを振り、出目を選択して和を求める）
+          #
+          # 評価結果は出目の合計値になる。
+          # 出目はランダマイザに記録される。
+          #
+          # @param [Randomizer] randomizer ランダマイザ
+          # @return [Integer] 評価結果（出目の合計値）
+          def eval(randomizer)
+            sorted_values = randomizer.roll_once(@times, @sides).sort
+            total = @filter
+                    .apply[sorted_values, @n_filtering]
+                    .reduce(0, &:+)
+
+            @text = "#{total}[#{sorted_values.join(',')}]"
+
+            return total
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            "#{@times}D#{@sides}#{@filter.abbr}#{@n_filtering}"
+          end
+
+          # メッセージへの出力を返す
+          # @return [String]
+          def output
+            @text
+          end
+
+          # ノードのS式を返す
+          # @return [String]
+          def s_exp
+            "(DiceRollWithFilter #{@times} #{@sides} #{@filter.abbr.inspect} #{@n_filtering})"
+          end
+        end
+
+        # カッコで式をまとめるノード
+        class Parenthesis
+          # @param expr [Object] カッコ内のノード
+          def initialize(expr)
+            @expr = expr
+          end
+
+          # @param randomizer [Randomizer]
+          # @return [integer]
+          def eval(randomizer)
+            @expr.eval(randomizer)
+          end
+
+          # @return [String]
+          def to_s
+            "(#{@expr})"
+          end
+
+          # @return [String]
+          def output
+            "(#{@expr.output})"
+          end
+
+          # @return [String] S式
+          def s_exp
+            "(Parenthesis #{@expr.s_exp})"
+          end
+        end
+
+        # 数値のノード
+        class Number
+          # 値
+          # @return [Integer]
+          attr_reader :literal
+
+          # ノードを初期化する
+          # @param [Integer] literal 値
+          def initialize(literal)
+            @literal = literal
+          end
+
+          # 符号を反転した結果の数値ノードを返す
+          # @return [Number]
+          def negate
+            Number.new(-@literal)
+          end
+
+          # ノードを評価する
+          # @return [Integer] 格納している値
+          def eval(_randomizer)
+            @literal
+          end
+
+          # 文字列に変換する
+          # @return [String]
+          def to_s
+            @literal.to_s
+          end
+
+          alias output to_s
+          alias s_exp to_s
+        end
+      end
+    end
+  end
+end