bcdice 3.0.0.pre.alpha.1 → 3.1.0

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

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

@@ -0,0 +1,433 @@
+#
+# 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/upper_dice/node"
+require "bcdice/arithmetic/node"
+
+module BCDice
+  module CommonCommand
+    module UpperDice
+      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 = [
+     9,     9,    36,    37,     3,     9,     9,    21,    22,    49,
+     8,     8,    21,    22,     9,     8,     8,    14,    15,     9,
+    21,    22,     4,    16,     8,    21,    22,     9,    10,     8,
+    36,    37,     9,    21,    22,    38,    17,     8,    21,    22,
+     9,    25,     8,    27,    15,     9,    21,    22,    28,    29,
+     8,    21,    22,     9,    44,     8,    39,    40,     9,    21,
+    22,    39,    40,     8,    21,    22,     9,    25,     8,    39,
+    40,     9,    21,    22,    36,    37,     8,    21,    22,     9,
+    17,     8,    39,    40,     9,    21,    22,    39,    40,     8,
+    21,    22,     9,   nil,     8,    39,    40,   nil,    21,    22,
+    39,    40,     8,    58,    56,    57,    59,    36,    37 ]
+
+racc_action_check = [
+     2,     8,    34,    34,     0,    17,    14,     8,     8,    34,
+     2,     8,    14,    14,    15,    17,    14,     5,     5,    16,
+    15,    15,     1,     5,    15,    16,    16,    21,     4,    16,
+    18,    18,    22,    21,    21,    18,     7,    21,    22,    22,
+    25,    11,    22,    12,    12,    27,    25,    25,    13,    13,
+    25,    27,    27,    28,    24,    27,    19,    19,    29,    28,
+    28,    30,    30,    28,    29,    29,    36,    26,    29,    33,
+    33,    37,    36,    36,    45,    45,    36,    37,    37,    39,
+    32,    37,    47,    47,    40,    39,    39,    48,    48,    39,
+    40,    40,    44,   nil,    40,    50,    50,   nil,    44,    44,
+    51,    51,    44,    53,    53,    53,    53,    54,    54 ]
+
+racc_action_pointer = [
+    -3,    22,    -2,   nil,    28,     9,   nil,    32,    -1,   nil,
+   nil,    20,    35,    40,     4,    12,    17,     3,    22,    46,
+   nil,    25,    30,   nil,    34,    38,    46,    43,    51,    56,
+    51,   nil,    76,    59,    -6,   nil,    64,    69,   nil,    77,
+    82,   nil,   nil,   nil,    90,    66,   nil,    72,    77,   nil,
+    85,    90,   nil,   100,    99,   nil,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -4,   -35,   -35,    -5,   -35,    -6,   -17,   -35,   -35,   -34,
+    60,   -12,    -6,    -7,   -35,   -35,   -35,   -35,   -35,   -21,
+   -24,   -35,   -35,   -32,    -1,   -35,   -12,   -35,   -35,   -35,
+    -8,   -16,   -32,    -9,   -35,   -18,   -35,   -35,   -33,   -35,
+   -35,   -30,   -31,    -3,   -35,   -13,    -2,   -10,   -11,   -14,
+   -19,   -20,   -22,   -25,   -15,   -23,   -26,   -27,   -28,   -29 ]
+
+racc_goto_table = [
+    18,    30,    33,    41,    42,    24,     6,     1,    34,     2,
+     5,    12,    11,     7,    30,    47,    48,    45,    31,    26,
+    46,    52,    53,    50,    51,    32,    43,    55,    35,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    54 ]
+
+racc_goto_check = [
+    10,     9,     9,    13,    13,     5,    11,     1,    10,     2,
+     3,     6,     4,    12,     9,     9,     9,    10,    11,     4,
+     5,    13,    13,     9,     9,    12,     7,    14,    12,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    10 ]
+
+racc_goto_pointer = [
+   nil,     7,     9,     8,     7,    -6,     6,     2,   nil,   -13,
+    -8,     4,    11,   -18,   -26 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    13,    19,
+   nil,   nil,    23,    20,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  4, 23, :_reduce_1,
+  5, 23, :_reduce_2,
+  5, 23, :_reduce_3,
+  0, 24, :_reduce_4,
+  1, 24, :_reduce_5,
+  0, 26, :_reduce_6,
+  1, 26, :_reduce_7,
+  2, 30, :_reduce_8,
+  2, 30, :_reduce_9,
+  3, 30, :_reduce_10,
+  3, 30, :_reduce_11,
+  0, 27, :_reduce_12,
+  2, 27, :_reduce_13,
+  3, 28, :_reduce_14,
+  2, 29, :_reduce_15,
+  3, 25, :_reduce_16,
+  1, 25, :_reduce_17,
+  3, 33, :_reduce_18,
+  3, 32, :_reduce_19,
+  3, 32, :_reduce_20,
+  1, 32, :_reduce_none,
+  3, 31, :_reduce_22,
+  4, 31, :_reduce_23,
+  1, 31, :_reduce_none,
+  0, 36, :_reduce_25,
+  1, 36, :_reduce_26,
+  1, 36, :_reduce_27,
+  1, 36, :_reduce_28,
+  1, 36, :_reduce_29,
+  2, 35, :_reduce_30,
+  2, 35, :_reduce_31,
+  1, 35, :_reduce_none,
+  3, 34, :_reduce_33,
+  1, 34, :_reduce_34 ]
+
+racc_reduce_n = 35
+
+racc_shift_n = 60
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :R => 3,
+  :U => 4,
+  :C => 5,
+  :F => 6,
+  :S => 7,
+  :PLUS => 8,
+  :MINUS => 9,
+  :ASTERISK => 10,
+  :SLASH => 11,
+  :PARENL => 12,
+  :PARENR => 13,
+  :BRACKETL => 14,
+  :BRACKETR => 15,
+  :LESS => 16,
+  :GREATER => 17,
+  :EQUAL => 18,
+  :NOT => 19,
+  :AT => 20,
+  :CMP_OP => 21 }
+
+racc_nt_base = 22
+
+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",
+  "R",
+  "U",
+  "C",
+  "F",
+  "S",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "BRACKETL",
+  "BRACKETR",
+  "LESS",
+  "GREATER",
+  "EQUAL",
+  "NOT",
+  "AT",
+  "CMP_OP",
+  "$start",
+  "expr",
+  "secret",
+  "notations",
+  "modifier",
+  "target",
+  "bracket",
+  "at",
+  "modifier_expr",
+  "mul",
+  "add",
+  "dice",
+  "term",
+  "unary",
+  "round_type" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+          result = UpperDice::Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            modifier: val[2],
+            cmp_op: val[3][:cmp_op],
+            target_number: val[3][:target]
+          )
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+          result = UpperDice::Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            modifier: val[3],
+            cmp_op: val[4][:cmp_op],
+            target_number: val[4][:target],
+            reroll_threshold: val[2]
+          )
+
+    result
+end
+
+def _reduce_3(val, _values, result)
+          result = UpperDice::Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            modifier: val[2],
+            cmp_op: val[3][:cmp_op],
+            target_number: val[3][:target],
+            reroll_threshold: val[4]
+          )
+
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = false
+    result
+end
+
+def _reduce_5(val, _values, result)
+ result = true
+    result
+end
+
+def _reduce_6(val, _values, result)
+ result = Arithmetic::Node::Number.new(0)
+    result
+end
+
+def _reduce_7(val, _values, result)
+ result = val[0]
+    result
+end
+
+def _reduce_8(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+def _reduce_12(val, _values, result)
+ result = {}
+    result
+end
+
+def _reduce_13(val, _values, result)
+            cmp_op, target = val
+            raise ParseError unless cmp_op
+
+            result = {cmp_op: cmp_op, target: target}
+
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_16(val, _values, result)
+               notations = val[0]
+               notations.push(val[2])
+               result = notations
+
+    result
+end
+
+def _reduce_17(val, _values, result)
+ result = [val[0]]
+    result
+end
+
+def _reduce_18(val, _values, result)
+          times = val[0]
+          sides = val[2]
+          result = UpperDice::Node::Notation.new(times, sides)
+
+    result
+end
+
+def _reduce_19(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_20(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+# reduce 21 omitted
+
+def _reduce_22(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
+    result
+end
+
+def _reduce_23(val, _values, result)
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+
+    result
+end
+
+# reduce 24 omitted
+
+def _reduce_25(val, _values, result)
+ result = Arithmetic::Node::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_28(val, _values, result)
+ result = Arithmetic::Node::DivideWithRound
+    result
+end
+
+def _reduce_29(val, _values, result)
+ result = Arithmetic::Node::DivideWithFloor
+    result
+end
+
+def _reduce_30(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_31(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+# reduce 32 omitted
+
+def _reduce_33(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_34(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 UpperDice
+  end   # module CommonCommand
+end   # module BCDice