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

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

@@ -0,0 +1,153 @@
+class BCDice::CommonCommand::AddDice::Parser
+token NUMBER CMP_OP S D K H L U R PLUS MINUS ASTERISK SLASH PARENL PARENR QUESTION
+
+rule
+  command: secret add
+         {
+           secret, lhs = val
+           raise ParseError unless lhs.include_dice?
+
+           result = Node::Command.new(secret, lhs)
+         }
+         | secret add CMP_OP target
+         {
+           secret, lhs, cmp_op, rhs = val
+           raise ParseError if !lhs.include_dice? || rhs.include_dice? || cmp_op.nil?
+
+           result = Node::Command.new(secret, lhs, cmp_op, rhs)
+         }
+
+  secret: /* none */
+        { result = false }
+        | S
+        { result = true }
+
+  target: add
+        | QUESTION
+        { result = Node::UndecidedTarget.instance }
+
+  add: add PLUS mul
+     {
+      lhs = val[0]
+      op, rhs = expand_negate(:+, val[2])
+      result = Node::BinaryOp.new(lhs, op, rhs)
+     }
+     | add MINUS mul
+     {
+      lhs = val[0]
+      op, rhs = expand_negate(:-, val[2])
+      result = Node::BinaryOp.new(lhs, op, rhs)
+     }
+     | mul
+
+  mul: mul ASTERISK unary
+     {
+      lhs = val[0]
+      rhs = val[2]
+      result = Node::BinaryOp.new(lhs, :*, rhs)
+     }
+     | mul SLASH unary round_type
+     {
+       lhs = val[0]
+       rhs = val[2]
+       divied_class = val[3]
+       result = divied_class.new(lhs, rhs)
+     }
+     | unary
+
+  round_type: /* none */
+            { result = Node::DivideWithRoundingDown }
+            | U
+            { result = Node::DivideWithRoundingUp }
+            | R
+            { result = Node::DivideWithRoundingOff }
+
+  unary: PLUS unary
+       { result = val[1] }
+       | MINUS unary
+       {
+         body = val[1]
+         result = body.is_a?(Node::Negate) ? body.body : Node::Negate.new(body)
+       }
+       | dice
+
+  dice: term D term
+      {
+        times = val[0]
+        sides = val[2]
+        raise ParseError if times.include_dice? || sides.include_dice?
+
+        result = Node::DiceRoll.new(times, sides)
+      }
+      | term D
+      {
+        times = val[0]
+        sides = Node::Number.new(6)
+        raise ParseError if times.include_dice?
+
+        result = Node::DiceRoll.new(times, sides)
+      }
+      | term D term filter_type term
+      {
+        times = val[0]
+        sides = val[2]
+        filter = val[3]
+        n_filtering = val[4]
+        raise ParseError if times.include_dice? || sides.include_dice? || n_filtering.include_dice?
+
+        result = Node::DiceRollWithFilter.new(times, sides, n_filtering, filter)
+      }
+      | term
+
+  filter_type: K H
+             { result = Node::DiceRollWithFilter::KEEP_HIGHEST }
+             | K L
+             { result = Node::DiceRollWithFilter::KEEP_LOWEST }
+             | D H
+             { result = Node::DiceRollWithFilter::DROP_HIGHEST }
+             | D L
+             { result = Node::DiceRollWithFilter::DROP_LOWEST }
+
+  term: PARENL add PARENR
+      { result = Node::Parenthesis.new(val[1]) }
+      | NUMBER
+      { result = Node::Number.new(val[0]) }
+end
+
+---- header
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/add_dice/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
+
+# 加減算の右辺が負数である場合に加減算を逆転させる
+def expand_negate(op, rhs)
+  if rhs.is_a?(Node::Negate)
+    if op == :+
+      return [:-, rhs.body]
+    elsif op == :-
+      return [:+, rhs.body]
+    end
+  end
+
+  [op, rhs]
+end
+

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

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

data/lib/bcdice/common_command/barabara_dice.rb

@@ -1,56 +1,15 @@
-require "bcdice/format"
+require "bcdice/common_command/barabara_dice/parser"
 
 module BCDice
   module CommonCommand
-    class BarabaraDice
+    module 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)
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system, randomizer)
         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

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

@@ -0,0 +1,84 @@
+require "bcdice/format"
+
+module BCDice
+  module CommonCommand
+    module BarabaraDice
+      module Node
+        class Command
+          def initialize(secret:, notations:, cmp_op:, target_number:)
+            @secret = secret
+            @notations = notations
+            @cmp_op = cmp_op
+            @target_number = target_number
+          end
+
+          # @return [String, nil]
+          def eval(game_system, randomizer)
+            round_type = game_system.round_type
+            notations = @notations.map { |n| n.to_dice(round_type) }
+            cmp_op = @cmp_op || game_system.default_cmp_op
+            target_number = @target_number&.eval(round_type) || game_system.default_target_number
+
+            dice_list_list = notations.map { |d| d.roll(randomizer) }
+            dice_list_list.map!(&:sort) if game_system.sort_barabara_dice?
+
+            dice_list = dice_list_list.flatten
+
+            count_of_1 = dice_list.count(1)
+            success_num = cmp_op ? dice_list.count { |d| d.send(cmp_op, target_number) } : 0
+            success_num_text = "成功数#{success_num}" if cmp_op
+
+            sequence = [
+              "(#{notations.join('+')}#{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
+
+            Result.new.tap do |r|
+              r.secret = @secret
+              r.text = sequence.join(" ＞ ")
+            end
+          end
+        end
+
+        class Notation
+          # @param times [#eval]
+          # @param sides [#eval]
+          def initialize(times, sides)
+            @times = times
+            @sides = sides
+          end
+
+          # @param round_type [Symbol]
+          def to_dice(round_type)
+            times = @times.eval(round_type)
+            sides = @sides.eval(round_type)
+
+            Dice.new(times, sides)
+          end
+        end
+
+        class Dice
+          # @param times [Integer]
+          # @param sides [Integer]
+          def initialize(times, sides)
+            @times = times
+            @sides = sides
+          end
+
+          # @param randomizer [BCDice::Randomizer]
+          # @return [Array<Integer>]
+          def roll(randomizer)
+            randomizer.roll_barabara(@times, @sides)
+          end
+
+          # @return [String]
+          def to_s
+            "#{@times}B#{@sides}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,336 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/reroll_dice/node"
+require "bcdice/arithmetic/node"
+
+module BCDice
+  module CommonCommand
+    module BarabaraDice
+      class Parser < Racc::Parser
+
+
+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
+##### State transition tables begin ###
+
+racc_action_table = [
+    13,     9,     3,     9,    24,    25,     9,     9,     9,    26,
+    18,    19,     8,    12,     8,    18,    19,     8,     8,     8,
+     9,     4,     9,    38,    36,    37,    39,    18,    19,    18,
+    19,     8,     9,     8,     9,    27,    28,    24,    25,    18,
+    19,    18,    19,     8,     9,     8,     9,    27,    28,    27,
+    28,    18,    19,    18,    19,     8,    10,     8,    14 ]
+
+racc_action_check = [
+     5,     2,     0,     8,    15,    15,    13,    14,    12,    15,
+     8,     8,     2,     5,     8,    12,    12,    13,    14,    12,
+    18,     1,    19,    34,    34,    34,    34,    18,    18,    19,
+    19,    18,    24,    19,    25,    16,    16,    21,    21,    24,
+    24,    25,    25,    24,    27,    25,    28,    31,    31,    32,
+    32,    27,    27,    28,    28,    27,     4,    28,     7 ]
+
+racc_action_pointer = [
+    -6,    21,    -1,   nil,    56,    -9,   nil,    55,     1,   nil,
+   nil,   nil,     6,     4,     5,    -5,    24,   nil,    18,    20,
+   nil,    28,   nil,   nil,    30,    32,   nil,    42,    44,   nil,
+   nil,    36,    38,   nil,    19,   nil,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -2,   -25,   -25,    -3,   -25,    -4,    -7,   -25,   -25,   -24,
+    40,    -1,   -25,   -25,   -25,   -25,   -11,   -14,   -25,   -25,
+   -22,    -5,    -6,    -8,   -25,   -25,   -23,   -25,   -25,   -20,
+   -21,    -9,   -10,   -12,   -15,   -13,   -16,   -17,   -18,   -19 ]
+
+racc_goto_table = [
+     7,     1,     6,    15,     2,    29,    30,    21,    31,    32,
+     5,     7,    23,    22,    33,    34,    11,    35 ]
+
+racc_goto_check = [
+     7,     1,     6,     5,     2,     9,     9,     5,     8,     8,
+     3,     7,     7,     6,     9,     9,     4,    10 ]
+
+racc_goto_pointer = [
+   nil,     1,     4,     8,    11,    -5,     0,    -2,   -16,   -13,
+   -17 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    20,    16,    17,
+   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 24, :_reduce_1,
+  0, 25, :_reduce_2,
+  1, 25, :_reduce_3,
+  0, 27, :_reduce_4,
+  2, 27, :_reduce_5,
+  3, 26, :_reduce_6,
+  1, 26, :_reduce_7,
+  3, 29, :_reduce_8,
+  3, 28, :_reduce_9,
+  3, 28, :_reduce_10,
+  1, 28, :_reduce_none,
+  3, 31, :_reduce_12,
+  4, 31, :_reduce_13,
+  1, 31, :_reduce_none,
+  0, 33, :_reduce_15,
+  1, 33, :_reduce_16,
+  1, 33, :_reduce_17,
+  1, 33, :_reduce_18,
+  1, 33, :_reduce_19,
+  2, 32, :_reduce_20,
+  2, 32, :_reduce_21,
+  1, 32, :_reduce_none,
+  3, 30, :_reduce_23,
+  1, 30, :_reduce_24 ]
+
+racc_reduce_n = 25
+
+racc_shift_n = 40
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :B => 3,
+  :R => 4,
+  :U => 5,
+  :C => 6,
+  :F => 7,
+  :S => 8,
+  :PLUS => 9,
+  :MINUS => 10,
+  :ASTERISK => 11,
+  :SLASH => 12,
+  :PARENL => 13,
+  :PARENR => 14,
+  :BRACKETL => 15,
+  :BRACKETR => 16,
+  :LESS => 17,
+  :GREATER => 18,
+  :EQUAL => 19,
+  :NOT => 20,
+  :AT => 21,
+  :CMP_OP => 22 }
+
+racc_nt_base = 23
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "NUMBER",
+  "B",
+  "R",
+  "U",
+  "C",
+  "F",
+  "S",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "BRACKETL",
+  "BRACKETR",
+  "LESS",
+  "GREATER",
+  "EQUAL",
+  "NOT",
+  "AT",
+  "CMP_OP",
+  "$start",
+  "expr",
+  "secret",
+  "notations",
+  "target",
+  "add",
+  "dice",
+  "term",
+  "mul",
+  "unary",
+  "round_type" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: val[2][:cmp_op],
+            target_number: val[2][:target]
+          )
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = false
+    result
+end
+
+def _reduce_3(val, _values, result)
+ result = true
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = {}
+    result
+end
+
+def _reduce_5(val, _values, result)
+            cmp_op, target = val
+            raise ParseError unless cmp_op
+
+            result = {cmp_op: cmp_op, target: target}
+
+    result
+end
+
+def _reduce_6(val, _values, result)
+               notations = val[0]
+               notations.push(val[2])
+               result = notations
+
+    result
+end
+
+def _reduce_7(val, _values, result)
+ result = [val[0]]
+    result
+end
+
+def _reduce_8(val, _values, result)
+          times = val[0]
+          sides = val[2]
+          result = Node::Notation.new(times, sides)
+
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+# reduce 11 omitted
+
+def _reduce_12(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
+    result
+end
+
+def _reduce_13(val, _values, result)
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+
+    result
+end
+
+# reduce 14 omitted
+
+def _reduce_15(val, _values, result)
+ result = Arithmetic::Node::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_17(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_18(val, _values, result)
+ result = Arithmetic::Node::DivideWithRound
+    result
+end
+
+def _reduce_19(val, _values, result)
+ result = Arithmetic::Node::DivideWithFloor
+    result
+end
+
+def _reduce_20(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_21(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+# reduce 22 omitted
+
+def _reduce_23(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_24(val, _values, result)
+ result = Arithmetic::Node::Number.new(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+      end   # class Parser
+    end   # module BarabaraDice
+  end   # module CommonCommand
+end   # module BCDice