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

data/i18n/ja_jp.yml

@@ -0,0 +1,5 @@
+ja_jp:
+  success: 成功
+  failure: 失敗
+  critical: クリティカル
+  fumble: ファンブル

data/i18n/ko_kr.yml

@@ -0,0 +1,7 @@
+ko_kr:
+  success: 성공
+  failure: 실패
+  fumble: 펌블
+  RTT:
+    rtt_format: '랜덤 특기 결정표(%<category_dice>d,%<row_dice>d) ＞ %<text>s'
+    rttn_format: '지정특기(%<category_name>s)표(%<row_dice>d) ＞ %<text>s'

data/i18n/zh_hant.yml

@@ -0,0 +1,3 @@
+zh_hant:
+  success: 成功
+  failure: 失敗

data/lib/bcdice/arithmetic/node.rb

@@ -0,0 +1,154 @@
+module BCDice
+  module Arithmetic
+    module Node
+      class BinaryOp
+        def initialize(lhs, op, rhs)
+          @lhs = lhs
+          @op = op
+          @rhs = rhs
+        end
+
+        def eval(round_type)
+          l = lhs.eval(round_type)
+          r = rhs.eval(round_type)
+          l.send(op, r)
+        end
+
+        def s_exp
+          "(#{op} #{lhs.s_exp} #{rhs.s_exp}}"
+        end
+
+        private
+
+        attr_reader :op, :lhs, :rhs
+      end
+
+      # 除算ノードの基底クラス
+      class DivideBase < BinaryOp
+        def initialize(lhs, rhs)
+          super(lhs, :/, rhs)
+        end
+
+        def eval(round_type)
+          l = lhs.eval(round_type)
+          r = rhs.eval(round_type)
+          divide_and_round(l, r, round_type)
+        end
+
+        private
+
+        # 除算および端数処理を行う
+        # @param [Integer] _dividend 被除数
+        # @param [Integer] _divisor 除数（0以外）
+        # @param [Symbol] _round_type ゲームシステムの端数処理設定
+        # @return [Integer]
+        def divide_and_round(_dividend, _divisor, _round_type)
+          raise NotImplementedError
+        end
+      end
+
+      # 除算（切り上げ）のノード
+      class DivideWithCeil < DivideBase
+        private
+
+        def op
+          "/C"
+        end
+
+        # 除算および端数処理を行う
+        # @param [Integer] dividend 被除数
+        # @param [Integer] divisor 除数（0以外）
+        # @param [Symbol] _round_type ゲームシステムの端数処理設定
+        # @return [Integer]
+        def divide_and_round(dividend, divisor, _round_type)
+          (dividend.to_f / divisor).ceil
+        end
+      end
+
+      # 除算（四捨五入）のノード
+      class DivideWithRound < DivideBase
+        private
+
+        def op
+          "/R"
+        end
+
+        # 除算および端数処理を行う
+        # @param [Integer] dividend 被除数
+        # @param [Integer] divisor 除数（0以外）
+        # @param [Symbol] _round_type ゲームシステムの端数処理設定
+        # @return [Integer]
+        def divide_and_round(dividend, divisor, _round_type)
+          (dividend.to_f / divisor).round
+        end
+      end
+
+      # 除算（切り捨て）のノード
+      class DivideWithFloor < DivideBase
+        private
+
+        def op
+          "/F"
+        end
+
+        # 除算および端数処理を行う
+        # @param [Integer] dividend 被除数
+        # @param [Integer] divisor 除数（0以外）
+        # @param [Symbol] _round_type ゲームシステムの端数処理設定
+        # @return [Integer]
+        def divide_and_round(dividend, divisor, _round_type)
+          dividend / divisor
+        end
+      end
+
+      # 除算（端数処理はゲームシステム依存）のノード
+      class DivideWithGameSystemDefault < DivideBase
+        private
+
+        # 除算および端数処理を行う
+        # @param [Integer] dividend 被除数
+        # @param [Integer] divisor 除数（0以外）
+        # @param [Symbol] round_type ゲームシステムの端数処理設定
+        # @return [Integer]
+        def divide_and_round(dividend, divisor, round_type)
+          case round_type
+          when RoundType::CEIL
+            (dividend.to_f / divisor).ceil
+          when RoundType::ROUND
+            (dividend.to_f / divisor).round
+          else # RoundType::FLOOR
+            dividend / divisor
+          end
+        end
+      end
+
+      class Negative
+        def initialize(body)
+          @body = body
+        end
+
+        def eval(round_type)
+          -@body.eval(round_type)
+        end
+
+        def s_exp
+          "(- #{@body.s_exp})"
+        end
+      end
+
+      class Number
+        def initialize(value)
+          @value = value
+        end
+
+        def eval(_round_type)
+          @value
+        end
+
+        def s_exp
+          @value.to_s
+        end
+      end
+    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,15 +60,23 @@ 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ダイスを有効にするか（ガンドッグ）で使用
@@ -73,11 +91,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
@@ -129,13 +143,6 @@ module BCDice
       @sort_barabara_dice
     end
 
-    # D66ダイスが有効か
-    #
-    # @return [Boolean]
-    def enabled_d66?
-      @enabled_d66
-    end
-
     # D9ダイスが有効か
     #
     # @return [Boolean]
@@ -143,50 +150,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)
-      result ||= eval_common_command(upcased_command)
+      result = dice_command(command) || eval_common_command(@raw_input)
+      return nil unless result
+
+      result.rands = @randomizer.rand_results
+      result.detailed_rands = @randomizer.detailed_rand_results
 
       return result
     end
@@ -200,36 +178,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 +227,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 +248,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 +266,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 +402,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]