bcdice 3.0.0.pre.alpha.1

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

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "bcdice/arithmetic_evaluator"
+require "bcdice/normalize"
+require "bcdice/common_command/add_dice/node"
+
+module BCDice
+  module CommonCommand
+    class AddDice
+      # 加算ロールの構文解析器のクラス
+      class Parser
+        # 構文解析器を初期化する
+        # @param [String] expr 構文解析対象の文字列
+        def initialize(expr)
+          # 構文解析対象の文字列
+          @expr = expr
+          # 読み込んだトークンのインデックス
+          @idx = 0
+          # 構文解析エラーが発生したかどうか
+          @error = false
+          # 式にダイスロールが含まれるか
+          @contain_dice_roll = false
+
+          @is_secret = false
+        end
+
+        def secret?
+          @is_secret
+        end
+
+        # 構文解析を実行する
+        # @return [Node::Command, nil] 加算ロールコマンド
+        def parse()
+          lhs, cmp_op, rhs = @expr.partition(/[<>=]+/)
+
+          cmp_op = Normalize.comparison_operator(cmp_op)
+          if cmp_op && rhs.empty?
+            @error = true
+            return nil
+          end
+
+          if !rhs.empty? && rhs != "?"
+            ae = ArithmeticEvaluator.new(rhs)
+            rhs = ae.eval()
+
+            @error = ae.error?
+          end
+
+          @tokens = tokenize(lhs)
+          lhs = expr()
+
+          if @idx != @tokens.size || !@contain_dice_roll
+            @error = true
+          end
+
+          return AddDice::Node::Command.new(lhs, cmp_op, rhs)
+        end
+
+        # 構文解析エラーが発生したかどうかを返す
+        # @return [Boolean]
+        def error?
+          @error
+        end
+
+        private
+
+        # 構文解析対象の文字列をトークンの配列に変換する
+        # @return [Array<String>]
+        def tokenize(expr)
+          expr.gsub(%r{[\+\-\*/DURSKHL@()]}) { |e| " #{e} " }.split(" ")
+        end
+
+        # 式
+        def expr
+          @is_secret = consume("S")
+
+          return add()
+        end
+
+        # 加算、減算
+        def add
+          node = mul()
+
+          loop do
+            if consume("+")
+              op, rhs = sub_negative_number(:+, mul())
+              node = AddDice::Node::BinaryOp.new(node, op, rhs)
+            elsif consume("-")
+              op, rhs = sub_negative_number(:-, mul())
+              node = AddDice::Node::BinaryOp.new(node, op, rhs)
+            else
+              break
+            end
+          end
+
+          return node
+        end
+
+        # TODO: 処理の説明を書く
+        def sub_negative_number(op, rhs)
+          if rhs.is_a?(Node::Number) && rhs.literal < 0
+            if op == :+
+              return [:-, rhs.negate]
+            elsif op == :-
+              return [:+, rhs.negate]
+            end
+          end
+
+          [op, rhs]
+        end
+
+        # 乗算、除算
+        def mul
+          node = unary()
+
+          loop do
+            if consume("*")
+              node = AddDice::Node::BinaryOp.new(node, :*, unary())
+            elsif consume("/")
+              rhs = unary()
+              klass = divide_node_class()
+              node = klass.new(node, rhs)
+            else
+              break
+            end
+          end
+
+          return node
+        end
+
+        # 端数処理方法を示す記号を読み込み、対応する除算ノードのクラスを返す
+        # @return [Class] 除算ノードのクラス
+        def divide_node_class
+          if consume("U")
+            # 切り上げ
+            Node::DivideWithRoundingUp
+          elsif consume("R")
+            # 四捨五入
+            Node::DivideWithRoundingOff
+          else
+            # 切り捨て
+            Node::DivideWithRoundingDown
+          end
+        end
+
+        # 単項演算
+        def unary
+          if consume("+")
+            unary()
+          elsif consume("-")
+            node = unary()
+
+            case node
+            when Node::Negate
+              node.body
+            when Node::Number
+              node.negate()
+            else
+              AddDice::Node::Negate.new(node)
+            end
+          else
+            term()
+          end
+        end
+
+        # カッコ、ダイスロール
+        def term
+          if consume("(")
+            node = AddDice::Node::Parenthesis.new(add())
+            expect(")")
+
+            return node
+          else
+            dice_notation()
+          end
+        end
+
+        # ダイスロール、数値
+        def dice_notation
+          num = expect_number()
+          if consume("D")
+            times = num
+            sides = expect_number()
+
+            filter = dice_roll_filter()
+            if filter
+              # ダイスロール後のフィルタリングあり
+              n_filtering = expect_number()
+              @contain_dice_roll = true
+              return Node::DiceRollWithFilter.new(times, sides, n_filtering, filter)
+            end
+
+            # 通常のダイスロール
+            @contain_dice_roll = true
+            return Node::DiceRoll.new(times, sides)
+          end
+
+          return num
+        end
+
+        # ダイスロール：フィルタ処理
+        def dice_roll_filter
+          if consume("K", "H")
+            # 大きな出目から複数個取る
+            Node::DiceRollWithFilter::KEEP_HIGHEST
+          elsif consume("K", "L")
+            # 小さな出目から複数個取る
+            Node::DiceRollWithFilter::KEEP_LOWEST
+          elsif consume("D", "H")
+            # 大きな出目から複数個除く
+            Node::DiceRollWithFilter::DROP_HIGHEST
+          elsif consume("D", "L")
+            # 小さな出目から複数個除く
+            Node::DiceRollWithFilter::DROP_LOWEST
+          end
+        end
+
+        # トークンを消費する
+        #
+        # トークンと期待した文字列が合致していた場合、次のトークンに進む。
+        # 合致していなかった場合は、進まない。
+        #
+        # @param [String] expected 期待する文字列
+        # @return [true] トークンと期待した文字列が合致していた場合
+        # @return [false] トークンと期待した文字列が合致していなかった場合
+        def consume(*expected)
+          target = @tokens.slice(@idx, expected.length)
+          unless target == expected
+            return false
+          end
+
+          @idx += expected.length
+          return true
+        end
+
+        # 指定された文字列のトークンを要求する
+        #
+        # トークンと期待した文字列が合致していなかった場合、エラーとする。
+        # エラーの有無にかかわらず、次のトークンに進む。
+        #
+        # @param [String] str 期待する文字列
+        # @return [void]
+        def expect(str)
+          if @tokens[@idx] != str
+            @error = true
+          end
+
+          @idx += 1
+        end
+
+        # 整数のトークンを要求する
+        #
+        # 整数のトークンならば、対応する整数のノードを返す。
+        # そうでなければエラーとし、整数0のノードを返す。
+        #
+        # エラーの有無にかかわらず、次のトークンに進む。
+        #
+        # @return [Node::Number] 整数のノード
+        def expect_number()
+          unless integer?(@tokens[@idx])
+            @error = true
+            @idx += 1
+            return AddDice::Node::Number.new(0)
+          end
+
+          ret = @tokens[@idx].to_i
+          @idx += 1
+          return AddDice::Node::Number.new(ret)
+        end
+
+        # 文字列が整数かどうかを返す
+        # @param [String] str 対象文字列
+        # @return [Boolean]
+        def integer?(str)
+          # Ruby 1.9 以降では Kernel.#Integer を使うべき
+          # Ruby 1.8 にもあるが、基数を指定できない問題がある
+          !/^\d+$/.match(str).nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module BCDice
+  module CommonCommand
+    class AddDice
+      class Randomizer
+        attr_reader :dicebot, :cmp_op, :dice_list, :sides
+
+        def initialize(bcdice, dicebot, cmp_op)
+          @bcdice = bcdice
+          @dicebot = dicebot
+          @cmp_op = cmp_op
+          @sides = 0
+          @dice_list = []
+        end
+
+        # ダイスを振る
+        # @param [Integer] times ダイス数
+        # @param [Integer] sides 面数
+        # @return [Array<Array<Integer>>] 出目のグループの配列
+        def roll(times, sides)
+          # 振り足し分も含めた出目グループの配列
+          @dice_list = roll_once(times, sides)
+          return [@dice_list]
+        end
+
+        # ダイスを振る（振り足しなしの1回分）
+        # @param [Integer] times ダイス数
+        # @param [Integer] sides 面数
+        # @return [Array<Integer>] 出目の配列
+        def roll_once(times, sides)
+          @sides = sides if @sides < sides
+
+          if sides == 66 && @dicebot.enabled_d66?
+            return Array.new(times) { @bcdice.roll_d66(@dicebot.d66_sort_type) }
+          end
+
+          if sides == 9 && @dicebot.enabled_d9?
+            return Array.new(times) { @bcdice.roll_d9() }
+          end
+
+          dice_list = @bcdice.roll_barabara(times, sides)
+          dice_list.sort! if @dicebot.sort_add_dice?
+
+          return dice_list
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/barabara_dice.rb

@@ -0,0 +1,57 @@
+require "bcdice/format"
+
+module BCDice
+  module CommonCommand
+    class BarabaraDice
+      PREFIX_PATTERN = /\d+B\d+/.freeze
+
+      def initialize(command, randomizer, game_system)
+        @command = command
+        @randomizer = randomizer
+        @game_system = game_system
+
+        @is_secret = false
+      end
+
+      def secret?
+        @is_secret
+      end
+
+      # @return [String, nil]
+      def eval()
+        m = /^(S)?(\d+B\d+(?:\+\d+B\d+)*)(?:([<>=]+)(\d+))?$/i.match(@command)
+        unless m
+          return nil
+        end
+
+        @is_secret = !m[1].nil?
+        lhs = m[2]
+        b_list = lhs.split("+")
+
+        cmp_op = Normalize.comparison_operator(m[3]) || @game_system.default_cmp_op
+        target_number = m[4]&.to_i || @game_system.default_target_number
+
+        dice_list = []
+        b_list.each do |literal|
+          times, sides = literal.split("B", 2).map(&:to_i)
+          list = @randomizer.roll_barabara(times, sides)
+          list.sort! if @game_system.sort_barabara_dice?
+          dice_list.concat(list)
+        end
+
+        count_of_1 = dice_list.count(1)
+        success_num = cmp_op ? dice_list.count { |dice| dice.send(cmp_op, target_number) } : 0
+        success_num_text = "成功数#{success_num}" if cmp_op
+
+        sequence = [
+          "(#{lhs}#{Format.comparison_operator(cmp_op)}#{target_number})",
+          dice_list.join(","),
+          success_num_text,
+          @game_system.grich_text(count_of_1, dice_list.size, success_num)
+        ].compact
+
+        return sequence.join(" ＞ ")
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/calc.rb

@@ -0,0 +1,39 @@
+module BCDice
+  module CommonCommand
+    class Calc
+      PREFIX_PATTERN = /C/.freeze
+
+      # @param command [String]
+      # @param _randomizer [Randomizer]
+      # @param game_system [Base]
+      def initialize(command, _randomizer, game_system)
+        @command = command
+        @game_system = game_system
+
+        @is_secret = false
+      end
+
+      # @return [Boolean]
+      def secret?
+        @is_secret
+      end
+
+      # @return [String, nil]
+      def eval
+        m = %r{^(S)?C([\+\-\*/\d\(\)]+)$}i.match(@command)
+        unless m
+          return nil
+        end
+
+        @is_secret = !m[1].nil?
+        expr = ArithmeticEvaluator.new(m[2], round_type: @game_system.round_type)
+        value = expr.eval()
+        if expr.error?
+          return nil
+        end
+
+        return "計算結果 ＞ #{value}"
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/choice.rb

@@ -0,0 +1,35 @@
+module BCDice
+  module CommonCommand
+    class Choice
+      PREFIX_PATTERN = /choice/.freeze
+
+      def initialize(command, randomizer, game_system)
+        @command = command
+        @randomizer = randomizer
+        @game_system = game_system
+
+        @is_secret = false
+      end
+
+      def secret?
+        @is_secret
+      end
+
+      def eval
+        m = /^(S)?choice\[([^,]+(?:,[^,]+)+)\]$/i.match(@command)
+        unless m
+          return nil
+        end
+
+        @is_secret = !m[1].nil?
+        items = m[2].split(",").map(&:strip)
+
+        index = @randomizer.roll_index(items.size)
+        chosen = items[index]
+
+        expr = "choice[#{items.join(',')}]"
+        return "(#{expr}) ＞ #{chosen}"
+      end
+    end
+  end
+end