bcdice 3.0.0.pre.alpha.1

data/lib/bcdice/loader.rb

@@ -0,0 +1,37 @@
+module BCDice
+  class << self
+    # クラス名を指定してゲームシステムのクラスを取得する
+    #
+    # @param class_name [String] クラス名
+    # @return [Class, nil]
+    def game_system_class(class_name)
+      BCDice::GameSystem.const_get(class_name)
+    rescue NameError
+      return nil
+    end
+
+    # 現在ロードされているゲームシステムのクラス一覧を返す
+    #
+    # @return [Array<Class>]
+    def all_game_systems()
+      BCDice::GameSystem.constants.map { |class_name| BCDice::GameSystem.const_get(class_name) }
+    end
+
+    # クラス名を指定して対象のソースコードを動的にロードし、そのクラスを取得する
+    #
+    # @param class_name [String] クラス名
+    # @return [Class, nil]
+    def dynamic_load(class_name)
+      # 対象ディレクトリの外にあるファイルをロードされないように制約を設ける
+      unless /\A[A-Z]\w*\z/.match?(class_name)
+        return nil
+      end
+
+      require "bcdice/game_system/#{class_name}"
+
+      return game_system_class(class_name)
+    rescue LoadError
+      return nil
+    end
+  end
+end

data/lib/bcdice/normalize.rb

@@ -0,0 +1,38 @@
+module BCDice
+  module Normalize
+    module_function
+
+    # 比較演算子をシンボルに正規化する
+    #
+    # @param op [String]
+    # @return [Symbol, nil]
+    def comparison_operator(op)
+      case op
+      when /<=|=</
+        :<=
+      when />=|=>/
+        :>=
+      when /<>|!=|=!/
+        :'!='
+      when /</
+        :<
+      when />/
+        :>
+      when /\=/
+        :==
+      end
+    end
+
+    # 目標値を正規化する
+    #
+    # @param val [String]
+    # @return [Integer, String] 整数か'?'
+    def target_number(val)
+      if val == "?"
+        val
+      else
+        val.to_i
+      end
+    end
+  end
+end

data/lib/bcdice/preprocessor.rb

@@ -0,0 +1,87 @@
+module BCDice
+  # 入力文字列に対して前処理を行う
+  #
+  # @example
+  #   Preprocessor.process(
+  #     "1d6+[2D6]+[40..50]+4D+(3*4) 切り取られる部分",
+  #     randomizer,
+  #     game_system
+  #   ) #=> "1d6+3+46+4D6+7"
+  class Preprocessor
+    # @param (see #initialize)
+    # @return [String]
+    def self.process(text, randomizer, game_system)
+      Preprocessor.new(text, randomizer, game_system).process()
+    end
+
+    # @param text [String]
+    # @param randomizer [Randomizer]
+    # @param game_system [Base]
+    def initialize(text, randomizer, game_system)
+      @text = text
+      @randomizer = randomizer
+      @game_system = game_system
+    end
+
+    # @return [String]
+    def process
+      trim_after_whitespace()
+      replace_preroll()
+      replace_range()
+      replace_parentheses()
+
+      @text = @game_system.change_text(@text)
+
+      replace_implicit_d6()
+
+      return @text
+    end
+
+    private
+
+    # 空白より前だけを取る
+    def trim_after_whitespace()
+      @text = @text.strip.split(/\s/, 2).first
+    end
+
+    # [1D6]のような部分を事前ダイスロールする
+    def replace_preroll()
+      @text = @text.gsub(/\[\d+D\d+\]/i) do |matched|
+        # Remove '[' and ']'
+        command = matched[1..-2].upcase
+        times, sides = command.split("D").map(&:to_i)
+
+        @randomizer.roll_sum(times, sides)
+      end
+    end
+
+    # [1...6]のような部分を事前ダイスロールする
+    def replace_range
+      @text = @text.gsub(/\[(\d+)\.\.\.(\d+)\]/) do |matched|
+        first = Regexp.last_match(1).to_i
+        last = Regexp.last_match(2).to_i
+
+        if first > last
+          matched
+        else
+          steps = last - first + 1
+          dice = @randomizer.roll_once(steps)
+
+          first + dice - 1
+        end
+      end
+    end
+
+    # カッコ書きの数式を事前計算する
+    def replace_parentheses
+      @text = @text.gsub(%r{\([\d/\+\*\-\(\)]+\)}) do |expr|
+        ArithmeticEvaluator.eval(expr, round_type: @game_system.round_type)
+      end
+    end
+
+    # nDをnD6に置き換える
+    def replace_implicit_d6
+      @text = @text.gsub(/(\d+)D([^\w]|$)/i) { "#{Regexp.last_match(1)}D6#{Regexp.last_match(2)}" }
+    end
+  end
+end

data/lib/bcdice/randomizer.rb

@@ -0,0 +1,137 @@
+module BCDice
+  # 乱数生成器
+  class Randomizer
+    UPPER_LIMIT_DICE_TIMES = 200
+    UPPER_LIMIT_DICE_SIDES = 1000
+
+    def initialize
+      @rand_results = []
+      @detailed_rand_results = []
+    end
+
+    # @return [Array<Array<(Integer, Integer)>>] ダイスの出目一覧
+    attr_reader :rand_results
+
+    # @return [Array<DetailedRandResult>]
+    attr_reader :detailed_rand_results
+
+    # 実行したダイスロールの詳細
+    # @!attribute [rw] kind
+    #   @return [Symbol]
+    # @!attribute [rw] sides
+    #   @return [Integer] ダイスロールしたダイスの面数
+    # @!attribute [rw] value
+    #   @return [Integer] 値
+    DetailedRandResult = Struct.new(:kind, :sides, :value)
+
+    # 複数個のダイスを振る
+    #
+    # @param times [Integer] 振るダイスの個数
+    # @param sides [Integer] ダイスの面数
+    # @return [Array<Integer>] ダイスの出目一覧
+    def roll_barabara(times, sides)
+      if times <= 0 || times > UPPER_LIMIT_DICE_TIMES
+        return []
+      end
+
+      Array.new(times) { roll_once(sides) }
+    end
+
+    # 複数個のダイスを振って、その合計を求める
+    #
+    # @param times [Integer] 振るダイスの個数
+    # @param sides [Integer] ダイスの面数
+    # @return [Integer] 出目の合計
+    def roll_sum(times, sides)
+      roll_barabara(times, sides).sum()
+    end
+
+    # 1回だけダイスロールを行う
+    #
+    # @param sides [Integer] ダイスの面数
+    # @return [Integer] 1以上 *sides* 以下の値のいずれか
+    def roll_once(sides)
+      if sides <= 0 || sides > UPPER_LIMIT_DICE_SIDES
+        return 0
+      end
+
+      dice = rand_inner(sides)
+      push_to_detail(:normal, sides, dice)
+
+      return dice
+    end
+
+    # ダイス表などでindexを参照する用のダイスロール
+    # @param sides [Integer]
+    # @return [Integer] 0以上 *sides* 未満の整数
+    def roll_index(sides)
+      roll_once(sides) - 1
+    end
+
+    # 十の位をd10を使って決定するためのダイスロール
+    # @return [Integer] 0以上90以下で10の倍数となる整数
+    def roll_tens_d10()
+      # rand_innerの戻り値を10倍すればすむ話なのだが、既存のテストとの互換性の為に処理をする
+      dice = rand_inner(10)
+      if dice == 10
+        dice = 0
+      end
+
+      ret = dice * 10
+
+      push_to_detail(:tens_d10, 10, ret)
+      return ret
+    end
+
+    # d10を0~9として扱うダイスロール
+    # @return [Integer] 0以上9以下の整数
+    def roll_d9()
+      dice = rand_inner(10) - 1
+
+      push_to_detail(:d9, 10, dice)
+      return dice
+    end
+
+    # D66のダイスロールを行う
+    # @param sort_type [Symbol] BCDice::D66SortType
+    # @return [Integer]
+    def roll_d66(sort_type)
+      dice_list = Array.new(2) { roll_once(6) }
+
+      case sort_type
+      when D66SortType::ASC
+        dice_list.sort!
+      when D66SortType::DESC
+        dice_list.sort!.reverse!
+      end
+
+      return dice_list[0] * 10 + dice_list[1]
+    end
+
+    private
+
+    # @param sides [Integer]
+    # @return [Integer] 1以上sides以下の整数
+    def rand_inner(sides)
+      dice = random(sides)
+
+      @rand_results << [dice, sides]
+      return dice
+    end
+
+    # モックで上書きする用
+    # @param sides [Integer]
+    # @return [Integer] 1以上sides以下の整数
+    def random(sides)
+      Kernel.rand(sides) + 1
+    end
+
+    # @param [Symbol] kind
+    # @param [Integer] sides
+    # @param [Integer] value
+    def push_to_detail(kind, sides, value)
+      detail = DetailedRandResult.new(kind, sides, value)
+      @detailed_rand_results.push(detail)
+    end
+  end
+end

data/lib/bcdice/repl.rb

@@ -0,0 +1,155 @@
+require "bcdice"
+require "readline"
+
+module BCDice
+  # Read-Eval-Print Loopクラス
+  class REPL
+    def initialize()
+      @game_system = GameSystem::DiceBot
+      @hisoty_file = nil
+      @debug = false
+    end
+
+    # @param value [Boolean]
+    # @return [Boolean]
+    attr_writer :debug
+
+    # コマンド履歴を保存するファイルのパスを指定する
+    #
+    # @param path [String]
+    # @return [void]
+    def history_file=(path)
+      @hisoty_file = path
+
+      if File.exist?(@hisoty_file)
+        File.open(@hisoty_file) do |f|
+          history = f.readlines.map(&:chomp)
+          Readline::HISTORY.push(*history)
+        end
+      end
+    end
+
+    # ゲームシステムを切り替える
+    # @param game_system [Game]
+    def load_game_system(game_system)
+      klass = BCDice.dynamic_load(game_system)
+      if klass
+        @game_system = klass
+      else
+        puts "#{game_system.inspect} not found"
+      end
+    end
+
+    alias game_system= load_game_system
+
+    # コマンドの履歴ファイルを保存してREPLを終了する
+    # @return [void]
+    def quit
+      if @hisoty_file
+        last_100_comamnds = Readline::HISTORY.to_a.reverse[0, 100].reverse
+        File.write(@hisoty_file, last_100_comamnds.join("\n"))
+      end
+
+      exit
+    end
+
+    # REPLを開始する
+    # @return [void]
+    def run
+      puts "BCDice REPL"
+      puts '>> "help" shows help messages.'
+      loop do
+        run_once()
+      end
+    end
+
+    private
+
+    def run_once
+      input = Readline.readline(header())&.strip
+      unless input
+        puts
+        return
+      end
+
+      if input.empty?
+        return
+      end
+
+      Readline::HISTORY.push(input)
+      eval_command(input)
+    rescue Interrupt
+      quit()
+    end
+
+    def header()
+      debug_mode = "(Debug) " if @debug
+      "[#{debug_mode}#{@game_system::ID}]> "
+    end
+
+    def eval_command(input)
+      args = input.split(" ")
+      if args.empty?
+        return
+      end
+
+      command = args.shift
+
+      block = REPL.commands[command]
+      if block
+        instance_exec(*args, &block)
+      else
+        eval_game_system(command)
+      end
+    end
+
+    class << self
+      attr_reader :commands
+
+      def command(*name, &block)
+        @commands ||= {}
+        name.each do |key|
+          @commands[key] = block
+        end
+      end
+    end
+
+    command "use", "set" do |game_system|
+      load_game_system(game_system)
+    end
+
+    command "debug" do |mode|
+      self.debug = !["off", "false"].include?(mode&.downcase)
+    end
+
+    command "history" do
+      puts Readline::HISTORY.to_a
+    end
+
+    command "help" do
+      puts <<~HELP
+        BCDice REPL commands:
+          use GAME_SYSTEM      # 使うゲームシステムを指定する
+          set GAME_SYSTEM      # 同上
+          debug [on, off]      # Debugモードの切替
+          debug [true, false]  # 同上
+          history              # コマンド履歴を表示
+          help                 # このメッセージを表示する
+          exit, quit, q        # REPLを終了する
+      HELP
+    end
+
+    command "exit", "quit", "q" do
+      quit()
+    end
+
+    def eval_game_system(command)
+      gs = @game_system.new(command)
+      gs.enable_debug if @debug
+      puts gs.eval()
+    rescue StandardError => e
+      puts e
+      puts e.backtrace
+    end
+  end
+end