bcdice 3.0.0.pre.alpha.1 → 3.1.0

data/lib/bcdice/arithmetic_evaluator.rb

@@ -1,167 +1,18 @@
+# frozen_string_literal: true
+
 module BCDice
-  #
-  # 四則演算を評価するクラス
-  #
-  class ArithmeticEvaluator
+  module ArithmeticEvaluator
     class << self
       # 四則演算を評価する
-      # @param expr [String] 評価する式
+      # @deprecated +Arithmetic.#eval+ を利用してください。
+      # @param expr [String, nil] 評価する式
       # @param round_type [Symbol] 端数処理の種類
       # @return [Integer] 評価結果を返す。不正な式の場合には0を返す。
       def eval(expr, round_type: RoundType::FLOOR)
-        ArithmeticEvaluator.new(expr, round_type: round_type).eval()
-      end
-    end
-
-    # @param [String, nil] expr 評価する式
-    # @param [Symbol] round_type 端数処理の種類
-    def initialize(expr, round_type: RoundType::FLOOR)
-      @expr = expr
-      @round_type = round_type
-
-      @error = false
-    end
-
-    # @return [Boolean] 式の評価時にエラーが発生したか
-    def error?
-      @error
-    end
-
-    # 四則演算を評価する
-    # 同一インスタンスでevalを二回以上実行した場合の挙動は未定義とする
-    #
-    # @return [Integer] 評価結果を返す。不正な式の場合には0を返す。
-    def eval
-      if @expr.nil?
-        return 0
-      end
-
-      unless @expr.is_a?(String)
-        raise TypeError, "expr must be String, not #{@expr.class}"
-      end
-
-      @tokens = tokenize(@expr)
-      @idx = 0
-      @error = false
+        return 0 unless expr
 
-      ret = expr()
-      if @error
-        return 0
-      else
-        return ret
+        Arithmetic.eval(expr, round_type) || 0
       end
     end
-
-    private
-
-    def tokenize(expr)
-      expr.gsub(%r{[\(\)\+\-\*/]}) { |e| " #{e} " }.split(" ")
-    end
-
-    def add
-      ret = mul()
-
-      loop do
-        if consume("+")
-          ret += mul()
-        elsif consume("-")
-          ret -= mul()
-        else
-          break
-        end
-      end
-
-      return ret
-    end
-    alias expr add
-
-    def mul
-      ret = unary()
-
-      loop do
-        if consume("*")
-          ret *= unary()
-        elsif consume("/")
-          ret = div(ret, unary())
-        else
-          break
-        end
-      end
-
-      return ret
-    end
-
-    def div(left, right)
-      if right.zero?
-        @error = true
-        return 0
-      end
-
-      case @round_type
-      when RoundType::CEIL
-        return (left.to_f / right).ceil
-      when RoundType::ROUND
-        return (left.to_f / right).round
-      when RoundType::FLOOR
-        return left / right
-      else
-        raise ArgumentError, "unknown round type: #{@round_type.inspect}"
-      end
-    end
-
-    def unary
-      if consume("+")
-        unary()
-      elsif consume("-")
-        -unary()
-      else
-        term()
-      end
-    end
-
-    def term
-      if consume("(")
-        ret = expr()
-        expect(")")
-        return ret
-      else
-        return expect_number()
-      end
-    end
-
-    def consume(str)
-      if @tokens[@idx] != str
-        return false
-      end
-
-      @idx += 1
-      return true
-    end
-
-    def expect(str)
-      if @tokens[@idx] != str
-        @error = true
-      end
-
-      @idx += 1
-    end
-
-    def expect_number()
-      unless integer?(@tokens[@idx])
-        @error = true
-        @idx += 1
-        return 0
-      end
-
-      ret = @tokens[@idx].to_i
-      @idx += 1
-      return ret
-    end
-
-    def integer?(str)
-      # Ruby 1.9 以降では Kernel.#Integer を使うべき
-      # Ruby 1.8 にもあるが、基数を指定できない問題がある
-      !/^\d+$/.match(str).nil?
-    end
   end
 end

data/lib/bcdice/base.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
+require "i18n"
+require "i18n/backend/fallbacks"
 require "bcdice/randomizer"
 require "bcdice/dice_table"
 require "bcdice/enum"
+require "bcdice/translate"
+require "bcdice/result"
+require "bcdice/command/parser"
+require "bcdice/deprecated/checker"
 
 module BCDice
   class Base
@@ -18,6 +24,10 @@ module BCDice
         @prefixes.concat(prefixes.flatten)
       end
 
+      def register_prefix_from_super_class
+        register_prefix(superclass.prefixes)
+      end
+
       # ゲームシステム固有のコマンドにマッチする正規表現を返す
       # 正規表現を一度生成したら、以後コマンドの登録はできないようにする
       #
@@ -50,21 +60,31 @@ module BCDice
 
         @command_pattern = /^S?(#{pattarns.join("|")})/i.freeze
       end
+
+      # @param command [String]
+      # @return [Result]
+      def eval(command)
+        new(command).eval
+      end
     end
 
+    include Translate
+    include Deprecated::Checker
+
     def initialize(command)
       @raw_input = command
 
       @sort_add_dice = false # 加算ダイスでダイス目をソートするかどうか
       @sort_barabara_dice = false # バラバラダイスでダイス目をソートするかどうか
 
-      @enabled_d66 = true # D66ダイスを利用するかどうか
       @d66_sort_type = D66SortType::NO_SORT # 入れ替えの種類 詳しくはBCDice::D66SortTypeを参照すること
 
       @enabled_d9 = false # D9ダイスを有効にするか（ガンドッグ）で使用
 
       @round_type = RoundType::FLOOR # 割り算をした時の端数の扱い (FLOOR: 切り捨て, CEIL: 切り上げ, ROUND: 四捨五入)
 
+      @sides_implicit_d = 6 # 1D のようにダイスの面数が指定されていない場合に何面ダイスにするか
+
       @upper_dice_reroll_threshold = nil # UpperDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
       @reroll_dice_reroll_threshold = nil # RerollDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
 
@@ -73,11 +93,7 @@ module BCDice
 
       @enabled_upcase_input = true # 入力を String#upcase するかどうか
 
-      @is_secret = false
-      @is_success = false
-      @is_failure = false
-      @is_critical = false
-      @is_fumble = false
+      @locale = :ja_jp # i18n用の言語設定
 
       @randomizer = BCDice::Randomizer.new
       @debug = false
@@ -95,6 +111,11 @@ module BCDice
     # @return [Symbol]
     attr_reader :round_type
 
+    # ダイスの面数が指定されていない場合に何面ダイスにするか
+    #
+    # @return [Integer]
+    attr_reader :sides_implicit_d
+
     # UpperDiceで振り足しをする出目の閾値
     #
     # @return [Integer, nil]
@@ -129,13 +150,6 @@ module BCDice
       @sort_barabara_dice
     end
 
-    # D66ダイスが有効か
-    #
-    # @return [Boolean]
-    def enabled_d66?
-      @enabled_d66
-    end
-
     # D9ダイスが有効か
     #
     # @return [Boolean]
@@ -143,50 +157,21 @@ module BCDice
       @enabled_d9
     end
 
-    # シークレットコマンドか
-    #
-    # @return [Boolean]
-    def secret?
-      @is_secret
-    end
-
-    # 結果が成功か
-    # @return [Boolean]
-    def success?
-      @is_success
-    end
-
-    # 結果が失敗か
-    # @return [Boolean]
-    def failure?
-      @is_failure
-    end
-
-    # 結果がクリティカルか
-    # @return [Boolean]
-    def critical?
-      @is_critical
-    end
-
-    # 結果がファンブルか
-    # @return [Boolean]
-    def fumble?
-      @is_fumble
-    end
-
     # デバッグを有用にする
     def enable_debug
       @debug = true
     end
 
     # コマンドを評価する
-    # @return [String, nil] コマンド実行結果。コマンドが実行できなかった場合はnilを返す
+    # @return [Result, nil] コマンド実行結果。コマンドが実行できなかった場合はnilを返す
     def eval
-      command = BCDice::Preprocessor.process(@raw_input, @randomizer, self)
-      upcased_command = command.upcase
+      command = BCDice::Preprocessor.process(@raw_input, self)
+
+      result = dice_command(command) || eval_common_command(@raw_input)
+      return nil unless result
 
-      result = dice_command(command)
-      result ||= eval_common_command(upcased_command)
+      result.rands = @randomizer.rand_results
+      result.detailed_rands = @randomizer.detailed_rand_results
 
       return result
     end
@@ -200,36 +185,43 @@ module BCDice
     end
 
     # @param total [Integer] コマンド合計値
-    # @param dice_total [Integer] ダイス目の合計値
-    # @param dice_list [Array<Integer>] ダイスの一覧
-    # @param sides [Integer] 振ったダイスの面数
+    # @param rand_results [Array<CommonCommand::AddDice::Randomizer::RandResult>] ダイスの一覧
     # @param cmp_op [Symbol] 比較演算子
     # @param target [Integer, String] 目標値の整数か'?'
-    # @return [String]
-    def check_result(total, dice_total, dice_list, sides, cmp_op, target)
+    # @return [Result, nil]
+    def check_result(total, rand_results, cmp_op, target)
+      ret = check_result_legacy(total, rand_results, cmp_op, target)
+      return ret if ret
+
+      sides_list = rand_results.map(&:sides)
+      value_list = rand_results.map(&:value)
+      dice_total = value_list.sum()
+
       ret =
-        case [dice_list.size, sides]
-        when [1, 100]
-          check_1D100(total, dice_total, cmp_op, target)
-        when [1, 20]
-          check_1D20(total, dice_total, cmp_op, target)
-        when [2, 6]
-          check_2D6(total, dice_total, dice_list, cmp_op, target)
+        case sides_list
+        when [100]
+          result_1d100(total, dice_total, cmp_op, target)
+        when [20]
+          result_1d20(total, dice_total, cmp_op, target)
+        when [6, 6]
+          result_2d6(total, dice_total, value_list, cmp_op, target)
         end
 
-      return ret unless ret.nil? || ret.empty?
+      return nil if ret == Result.nothing
+      return ret if ret
 
       ret =
-        case sides
-        when 10
-          check_nD10(total, dice_total, dice_list, cmp_op, target)
-        when 6
-          check_nD6(total, dice_total, dice_list, cmp_op, target)
+        case sides_list.uniq
+        when [10]
+          result_nd10(total, dice_total, value_list, cmp_op, target)
+        when [6]
+          result_nd6(total, dice_total, value_list, cmp_op, target)
         end
 
-      return ret unless ret.nil? || ret.empty?
+      return nil if ret == Result.nothing
+      return ret if ret
 
-      check_nDx(total, cmp_op, target)
+      return result_ndx(total, cmp_op, target)
     end
 
     # シャドウラン用グリッチ判定
@@ -242,12 +234,10 @@ module BCDice
     private
 
     def eval_common_command(command)
+      command = change_text(command)
       CommonCommand::COMMANDS.each do |klass|
-        cmd = klass.new(command, @randomizer, self)
-        out = cmd.eval()
-
-        @is_secret = cmd.secret?
-        return out if out
+        result = klass.eval(command, self, @randomizer)
+        return result if result
       end
 
       return nil
@@ -265,11 +255,17 @@ module BCDice
       command = command[1..-1] if secret # 先頭の 'S' をとる
 
       output = eval_game_system_specific_command(command)
-      @is_secret ||= secret
-      if output.nil? || output.empty? || output == "1"
+
+      if output.is_a?(Result)
+        output.secret = output.secret? || secret
+        return output
+      elsif output.nil? || output.empty? || output == "1"
         return nil
       else
-        return output.to_s
+        return Result.new.tap do |r|
+          r.text = output.to_s
+          r.secret = secret
+        end
       end
     end
 
@@ -277,39 +273,31 @@ module BCDice
     # @return [String, nil]
     def eval_game_system_specific_command(command); end
 
-    # 成功か失敗かを文字列で返す
+    # 成功か失敗か返す
     #
-    # @param (see #check_result)
-    # @return [String]
-    def check_nDx(total, cmp_op, target)
-      return " ＞ 失敗" if target.is_a?(String)
-
-      if total.send(cmp_op, target)
-        " ＞ 成功"
+    # @param total [Integer]
+    # @param cmp_op [Symbol]
+    # @param target [Number]
+    # @return [Result]
+    def result_ndx(total, cmp_op, target)
+      if target.is_a?(String)
+        nil
+      elsif total.send(cmp_op, target)
+        Result.success(translate("success"))
       else
-        " ＞ 失敗"
+        Result.failure(translate("failure"))
       end
     end
 
-    # @param (see #check_result)
-    # @return [nil]
-    def check_1D100(total, dice_total, cmp_op, target); end
+    def result_1d100(total, dice_total, cmp_op, target); end
 
-    # @param (see #check_result)
-    # @return [nil]
-    def check_1D20(total, dice_total, cmp_op, target); end
+    def result_1d20(total, dice_total, cmp_op, target); end
 
-    # @param (see #check_result)
-    # @return [nil]
-    def check_nD10(total, dice_total, dice_list, cmp_op, target); end
+    def result_nd10(total, dice_total, value_list, cmp_op, target); end
 
-    # @param (see #check_result)
-    # @return [nil]
-    def check_2D6(total, dice_total, dice_list, cmp_op, target); end
+    def result_2d6(total, dice_total, value_list, cmp_op, target); end
 
-    # @param (see #check_result)
-    # @return [nil]
-    def check_nD6(total, dice_total, dice_list, cmp_op, target); end
+    def result_nd6(total, dice_total, value_list, cmp_op, target); end
 
     def get_table_by_2d6(table)
       get_table_by_nD6(table, 2)
@@ -421,3 +409,8 @@ module BCDice
     end
   end
 end
+
+I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
+I18n.load_path << Dir[File.join(__dir__, "../../i18n/**/*.yml")]
+I18n.default_locale = :ja_jp
+I18n.fallbacks.defaults = [:ja_jp]