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

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

@@ -0,0 +1,79 @@
+class BCDice::CommonCommand::Calc::Parser
+  token NUMBER R U C F S PLUS MINUS ASTERISK SLASH PARENL PARENR
+
+  rule
+    expr: secret C add
+        {
+          result = Node::Command.new(
+            secret: val[0],
+            expr: val[2]
+          )
+        }
+
+    secret: /* none */
+          { result = false }
+          | S
+          { result = true }
+
+    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/calc/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/choice.rb

@@ -1,34 +1,152 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 module BCDice
   module CommonCommand
+    # チョイスコマンド
+    #
+    # 列挙された項目の中から一つを選んで出力する。
+    #
+    # フォーマットは以下の通り
+    # choice[A,B,C,D]
+    # choice(A,B,C,D)
+    # choice A B C D
+    # choice(新クトゥルフ神話TRPG, ソード・ワールド2.5, Dungeons & Dragons)
+    #
+    # "choice"の次の文字によって区切り文字が変化する
+    #   "[" -> "," で区切る
+    #   "(" -> "," で区切る
+    #   " " -> /\s+/ にマッチする文字列で区切る
+    #
+    # 各項目の前後に空白文字があった場合は除去される
+    #   choice[A, B,  C , D   ] は choice[A,B,C,D] と等価
+    #
+    # 項目が空文字列である場合、その項目は無視する
+    #   choice[A,,C] は choice[A,C] と等価
+    #
+    # フォーマットを選ぶことで、項目の文字列に()や,を含めることができる
+    #   choice A,B X,Y -> "A,B" と "X,Y" から選ぶ
+    #   choice(A[], B[], C[]) -> "A[]", "B[]", "C[]" から選ぶ
+    #   choice[A(), B(), C()] -> "A()", "B()", "C()" から選ぶ
     class Choice
       PREFIX_PATTERN = /choice/.freeze
 
-      def initialize(command, randomizer, game_system)
-        @command = command
-        @randomizer = randomizer
-        @game_system = game_system
-
-        @is_secret = false
+      module BlockDelimiter
+        BRACKET = :bracket # "["
+        PAREN = :paren # "("
+        SPACE = :space # /\s/
       end
 
-      def secret?
-        @is_secret
-      end
+      DELIMITER = {
+        bracket: /,/,
+        paren: /,/,
+        space: /\s+/,
+      }.freeze
+
+      TERMINATION = {
+        bracket: /\]/,
+        paren: /\)/,
+        space: /$/,
+      }.freeze
+
+      SUFFIX = {
+        bracket: "]",
+        paren: ")",
+        space: "",
+      }.freeze
 
-      def eval
-        m = /^(S)?choice\[([^,]+(?:,[^,]+)+)\]$/i.match(@command)
-        unless m
-          return nil
+      class << self
+        # @param command [String]
+        # @param _game_system [BCDice::Base]
+        # @param randomizer [Randomizer]
+        # @return [Result, nil]
+        def eval(command, _game_system, randomizer)
+          cmd = parse(command)
+          cmd&.roll(randomizer)
         end
 
-        @is_secret = !m[1].nil?
-        items = m[2].split(",").map(&:strip)
+        private
+
+        def parse(command)
+          scanner = StringScanner.new(command)
+          scanner.skip(/\s+/)
+
+          secret = !scanner.scan(/S/i).nil?
+          unless scanner.scan(/choice/i)
+            return nil
+          end
+
+          type =
+            case scanner.scan(/\(|\[|\s+/)
+            when "["
+              BlockDelimiter::BRACKET
+            when "("
+              BlockDelimiter::PAREN
+            when String
+              BlockDelimiter::SPACE
+            else
+              return nil
+            end
+
+          delimiter = DELIMITER[type]
+          termination = TERMINATION[type]
+
+          items = []
+          while (item = scanner.scan_until(delimiter))
+            items.push(item.delete_suffix(","))
+          end
+
+          last_item = scanner.scan_until(termination)
+          unless last_item
+            return nil
+          end
 
-        index = @randomizer.roll_index(items.size)
-        chosen = items[index]
+          items.push(last_item.delete_suffix(SUFFIX[type]))
 
-        expr = "choice[#{items.join(',')}]"
-        return "(#{expr}) ＞ #{chosen}"
+          items = items.map(&:strip).reject(&:empty?)
+          if items.empty?
+            return nil
+          end
+
+          new(
+            secret: secret,
+            block_delimiter: type,
+            items: items
+          )
+        end
+      end
+
+      # @param secret [Boolean]
+      # @param block_delimiter [BlockDelimiter::BRACKET, BlockDelimiter::PAREN, BlockDelimiter::SPACE]
+      # @param items [Array<String>]
+      def initialize(secret:, block_delimiter:, items:)
+        @secret = secret
+        @block_delimiter = block_delimiter
+        @items = items
+      end
+
+      # @param randomizer [Randomizer]
+      # @return [Result]
+      def roll(randomizer)
+        index = randomizer.roll_index(@items.size)
+        chosen = @items[index]
+
+        Result.new.tap do |r|
+          r.secret = @secret
+          r.text = "(#{expr()}) ＞ #{chosen}"
+        end
+      end
+
+      def expr
+        case @block_delimiter
+        when BlockDelimiter::SPACE
+          "choice #{@items.join(' ')}"
+        when BlockDelimiter::BRACKET
+          "choice[#{@items.join(',')}]"
+        when BlockDelimiter::PAREN
+          "choice(#{@items.join(',')})"
+        end
       end
     end
   end

data/lib/bcdice/common_command/d66_dice.rb

@@ -3,61 +3,75 @@ module BCDice
     class D66Dice
       PREFIX_PATTERN = /D66/.freeze
 
-      def initialize(command, randomizer, game_system)
-        @command = command
-        @randomizer = randomizer
-        @game_system = game_system
+      class << self
+        # @param command [String]
+        # @param game_system [BCDice::Base]
+        # @param randomizer [Randomizer]
+        # @return [Result, nil]
+        def eval(command, game_system, randomizer)
+          cmd = parse(command, game_system)
+          cmd&.eval(randomizer)
+        end
 
-        @is_secret = false
-      end
+        private
 
-      def secret?
-        @is_secret
-      end
+        def parse(command, game_system)
+          command = command.split(" ", 2).first
 
-      def eval
-        unless @game_system.enabled_d66?
-          return nil
+          m = /^(S)?D66([ANS])?$/i.match(command)
+          return nil unless m
+
+          new(
+            secret: !m[1].nil?,
+            sort_type: sort_type_from_suffix(m[2]) || game_system.d66_sort_type,
+            suffix: m[2]
+          )
         end
 
-        m = /^(S)?D66([ANS])?$/i.match(@command)
-        unless m
-          return nil
+        def sort_type_from_suffix(suffix)
+          case suffix
+          when "A", "S"
+            D66SortType::ASC
+          when "N"
+            D66SortType::NO_SORT
+          end
         end
+      end
 
-        @is_secret = !m[1].nil?
-        @sort_type = sort_type_from_suffix(m[2])
+      # @param secret [Boolean]
+      # @param sort_type [Symbol]
+      # @param suffix [String, nil]
+      def initialize(secret:, sort_type:, suffix:)
+        @secret = secret
+        @sort_type = sort_type
+        @suffix = suffix
+      end
 
-        value = roll()
+      # @param randomizer [Randomizer]
+      # @return [Result]
+      def eval(randomizer)
+        value = roll(randomizer)
 
-        return "(D66#{m[2]}) ＞ #{value}"
+        Result.new.tap do |r|
+          r.secret = @secret
+          r.text = "(D66#{@suffix}) ＞ #{value}"
+        end
       end
 
       private
 
-      def roll()
-        dice_list = Array.new(2) { @randomizer.roll_once(6) }
+      def roll(randomizer)
+        dice_list = Array.new(2) { randomizer.roll_once(6) }
 
         case @sort_type
-        when :asc
+        when D66SortType::ASC
           dice_list.sort!
-        when :desc
+        when D66SortType::DESC
           dice_list.sort!.reverse!
         end
 
         return dice_list[0] * 10 + dice_list[1]
       end
-
-      def sort_type_from_suffix(suffix)
-        case suffix
-        when "A", "S"
-          :asc
-        when "N"
-          :no_sort
-        else
-          @game_system.d66_sort_type
-        end
-      end
     end
   end
 end

data/lib/bcdice/common_command/lexer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "bcdice/normalize"
+
+module BCDice
+  module CommonCommand
+    class Lexer
+      SYMBOLS = {
+        "+" => :PLUS,
+        "-" => :MINUS,
+        "*" => :ASTERISK,
+        "/" => :SLASH,
+        "(" => :PARENL,
+        ")" => :PARENR,
+        "[" => :BRACKETL,
+        "]" => :BRACKETR,
+        "?" => :QUESTION,
+        "@" => :AT,
+      }.freeze
+
+      def initialize(source)
+        source = source.split(" ", 2).first
+        @scanner = StringScanner.new(source)
+      end
+
+      def next_token
+        return [false, "$"] if @scanner.eos?
+
+        if (number = @scanner.scan(/\d+/))
+          [:NUMBER, number.to_i]
+        elsif (cmp_op = @scanner.scan(/[<>!=]+/))
+          [:CMP_OP, Normalize.comparison_operator(cmp_op)]
+        else
+          char = @scanner.getch.upcase
+          type = SYMBOLS[char] || char.to_sym
+          [type, char]
+        end
+      end
+
+      def source
+        @scanner.string
+      end
+    end
+  end
+end

data/lib/bcdice/common_command/repeat.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module BCDice
+  module CommonCommand
+    # リピート
+    #
+    # 繰り返し回数を指定して、特定のコマンドを複数回実行する
+    # 例）
+    #   x5 choice[A,B,C,D] #=> `choice[A,B,C,D]`を5回実行する
+    #   rep2 CC<=75        #=> `CC<=75`を2回実行する
+    #   repeat10 2D6+5     #=> `2D6+6`を10回実行する
+    #
+    # このコマンドを入れ子させることは許容しない。繰り返し回数の爆発に繋がるためである。
+    # 以下は実行時にエラーとなる。
+    #   x10 repeat100 100D100
+    class Repeat
+      PREFIX_PATTERN = /(repeat|rep|x)\d+/.freeze
+
+      REPEAT_LIMIT = 100
+
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = parse(command)
+          cmd&.roll(game_system, randomizer)
+        end
+
+        private
+
+        def parse(command)
+          scanner = StringScanner.new(command)
+
+          secret = !scanner.scan(/s/i).nil?
+          keyword = scanner.scan(/repeat|rep|x/i)
+          repeat_times = scanner.scan(/\d+/)&.to_i
+          whitespace = scanner.scan(/\s+/)
+          if keyword.nil? || repeat_times.nil? || whitespace.nil?
+            return nil
+          end
+
+          trailer = scanner.post_match
+          if trailer.nil? || trailer.empty?
+            return nil
+          end
+
+          new(
+            secret: secret,
+            times: repeat_times,
+            trailer: trailer
+          )
+        end
+      end
+
+      def initialize(secret:, times:, trailer:)
+        @secret = secret
+        @times = times
+        @trailer = trailer
+      end
+
+      def roll(game_system, randomizer)
+        err = validate()
+        return err if err
+
+        results = Array.new(@times) do
+          cmd = game_system.class.new(@trailer)
+          cmd.randomizer = randomizer
+          cmd.eval()
+        end
+
+        if results.count(nil) == @times
+          return result_with_text("繰り返し対象のコマンドが実行できませんでした (#{@trailer})")
+        end
+
+        text = results.map.with_index(1) { |r, index| "\##{index}\n#{r.text}" }.join("\n\n")
+        secret = @secret || results.any?(&:secret?)
+
+        Result.new.tap do |r|
+          r.secret = secret
+          r.text = text
+        end
+      end
+
+      private
+
+      def validate
+        if /\A(repeat|rep|x)\d+/.match?(@trailer)
+          result_with_text("Repeatコマンドの重複はできません")
+        elsif @times < 1 || REPEAT_LIMIT < @times
+          result_with_text("繰り返し回数は1以上、#{REPEAT_LIMIT}以下としてください")
+        end
+      end
+
+      def result_with_text(text)
+        Result.new.tap do |r|
+          r.secret = @secret
+          r.text = text
+        end
+      end
+    end
+  end
+end