bcdice 3.0.0.pre.alpha.1

data/lib/bcdice/game_system/CthulhuTech.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require 'bcdice/arithmetic_evaluator'
+
+# クトゥルフテックのダイスボット
+module BCDice
+  module GameSystem
+    class CthulhuTech < Base
+      register_prefix(['\d+D10.*'])
+
+      # ゲームシステムの識別子
+      ID = 'CthulhuTech'
+
+      # ゲームシステム名
+      NAME = 'クトゥルフテック'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'くとうるふてつく'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        ・行為判定（test）：nD10+m>=d
+        　n個のダイスを使用して、修正値m、難易度dで行為判定（test）を行います。
+        　修正値mは省略可能、複数指定可能（例：+2-4）です。
+        　成功、失敗、クリティカル、ファンブルを自動判定します。
+        　例）2D10>=12　4D10+2>=28　5D10+2-4>=32
+
+        ・対抗判定（contest）：nD10+m>d
+        　行為判定と同様ですが、防御側有利のため「>=」ではなく「>」を入力します。
+        　ダメージダイスも表示します。
+      INFO_MESSAGE_TEXT
+
+      # 行為判定のノード
+      class Test
+        # 判定で用いる比較演算子
+        #
+        # 対抗判定で変えられるように定数で定義する。
+        COMPARE_OP = :>=
+
+        # ノードを初期化する
+        # @param [Integer] num ダイス数
+        # @param [Integer] modifier 修正値
+        # @param [Integer] difficulty 難易度
+        def initialize(num, modifier, difficulty)
+          @num = num
+          @modifier = modifier
+          @difficulty = difficulty
+        end
+
+        # 判定を行う
+        # @param randomizer [Randoizer]
+        # @return [String] 判定結果
+        def execute(randomizer)
+          dice_values = randomizer.roll_barabara(@num, 10)
+
+          # ファンブル：出目の半分（小数点以下切り上げ）以上が1の場合
+          fumble = dice_values.count(1) >= (dice_values.length + 1) / 2
+
+          sorted_dice_values = dice_values.sort
+          roll_result = calculate_roll_result(sorted_dice_values)
+          test_value = roll_result + @modifier
+
+          diff = test_value - @difficulty
+
+          # diff と @difficulty との比較の演算子が変わるので、send で対応
+          # 例：COMPARE_OP が :>= ならば、diff >= 0 と同じ
+          success = !fumble && diff.send(self.class::COMPARE_OP, 0)
+
+          critical = diff >= 10
+
+          output_parts = [
+            "(#{expression()})",
+            test_value_expression(sorted_dice_values, roll_result),
+            test_value,
+            result_str(success, fumble, critical, diff)
+          ]
+
+          return output_parts.join(' ＞ ')
+        end
+
+        private
+
+        # 数式表現を返す
+        # @return [String]
+        def expression
+          modifier_str = Format.modifier(@modifier)
+          return "#{@num}D10#{modifier_str}#{self.class::COMPARE_OP}#{@difficulty}"
+        end
+
+        # 判定値の数式表現を返す
+        # @param [Array<Integer>] dice_values 出目の配列
+        # @param [Integer] roll_result ダイスロール結果の値
+        # @return [String]
+        def test_value_expression(dice_values, roll_result)
+          dice_str = dice_values.join(',')
+          modifier_str = Format.modifier(@modifier)
+
+          return "#{roll_result}[#{dice_str}]#{modifier_str}"
+        end
+
+        # 判定結果の文字列を返す
+        # @param [Boolean] success 成功したか
+        # @param [Boolean] fumble ファンブルだったか
+        # @param [Boolean] critical クリティカルだったか
+        # @param [Integer] _diff 判定値と難易度の差
+        # @return [String]
+        def result_str(success, fumble, critical, _diff)
+          return 'ファンブル' if fumble
+          return 'クリティカル' if critical
+
+          return success ? '成功' : '失敗'
+        end
+
+        # ダイスロール結果を計算する
+        #
+        # 以下のうち最大のものを返す。
+        #
+        # * 出目の最大値
+        # * ゾロ目の和の最大値
+        # * ストレート（昇順で連続する3個以上の値）の和の最大値
+        #
+        # @param [Array<Integer>] sorted_dice_values 昇順でソートされた出目の配列
+        # @return [Integer]
+        def calculate_roll_result(sorted_dice_values)
+          highest_single_roll = sorted_dice_values.last
+
+          candidates = [
+            highest_single_roll,
+            sum_of_highest_set_of_multiples(sorted_dice_values),
+            sum_of_largest_straight(sorted_dice_values)
+          ]
+
+          return candidates.max
+        end
+
+        # ゾロ目の和の最大値を求める
+        # @param [Array<Integer>] dice_values 出目の配列
+        # @return [Integer]
+        def sum_of_highest_set_of_multiples(dice_values)
+          dice_values.
+            # TODO: Ruby 2.2以降では group_by(&:itself) が使える
+            group_by { |i| i }.
+            # TODO: Ruby 2.4以降では value_group.sum が使える
+            map { |_, value_group| value_group.reduce(0, &:+) }
+                     .max
+        end
+
+        # ストレートの和の最大値を求める
+        #
+        # ストレートとは、昇順で3個以上連続した値のこと。
+        #
+        # @param [Array<Integer>] sorted_dice_values 昇順にソートされた出目の配列
+        # @return [Integer] ストレートの和の最大値
+        # @return [0] ストレートが存在しなかった場合
+        def sum_of_largest_straight(sorted_dice_values)
+          # 出目が3個未満ならば、ストレートは存在しない
+          return 0 if sorted_dice_values.length < 3
+
+          # ストレートの和の最大値
+          max_sum = 0
+
+          # 連続した値の数
+          n_consecutive_values = 0
+          # 連続した値の和
+          sum = 0
+          # 直前の値
+          # 初期値を負の値にして、最初の値と連続にならないようにする
+          last = -1
+
+          sorted_dice_values.uniq.each do |value|
+            # 値が連続でなければ、状態を初期化する（現在の値を連続1個目とする）
+            if value - last > 1
+              n_consecutive_values = 1
+              sum = value
+              last = value
+
+              next
+            end
+
+            # 連続した値なので溜める
+            n_consecutive_values += 1
+            sum += value
+            last = value
+
+            # ストレートならば、和の最大値を更新する
+            if n_consecutive_values >= 3 && sum > max_sum
+              max_sum = sum
+            end
+          end
+
+          return max_sum
+        end
+      end
+
+      # 対抗判定のノード
+      class Contest < Test
+        # 判定で用いる比較演算子
+        COMPARE_OP = :>
+
+        # 判定結果の文字列を返す
+        #
+        # 成功した場合（クリティカルを含む）、ダメージロールのコマンドを末尾に
+        # 追加する。
+        #
+        # @param [Boolean] success 成功したか
+        # @param [Integer] diff 判定値と難易度の差
+        # @return [String]
+        def result_str(success, _fumble, _critical, diff)
+          formatted = super
+
+          if success
+            damage_roll_num = (diff / 5.0).ceil
+            damage_roll = "#{damage_roll_num}D10"
+
+            "#{formatted}（ダメージ：#{damage_roll}）"
+          else
+            formatted
+          end
+        end
+      end
+
+      # ダイスボットを初期化する
+      def initialize(command)
+        super(command)
+
+        # 加算ロールで出目をソートする
+        @sort_add_dice = true
+      end
+
+      # ダイスボット固有コマンドの処理を行う
+      # @param [String] command コマンド
+      # @return [String] ダイスボット固有コマンドの結果
+      # @return [nil] 無効なコマンドだった場合
+      def eval_game_system_specific_command(command)
+        node = parse(command)
+        return nil unless node
+
+        return node.execute(@randomizer)
+      end
+
+      private
+
+      # 判定コマンドの正規表現
+      TEST_RE = /\A(\d+)D10((?:[-+]\d+)+)?(>=?)(\d+)\z/.freeze
+
+      # 構文解析する
+      # @param [String] command コマンド
+      # @return [Test, Contest] 判定のノード
+      # @return [nil] 無効なコマンドだった場合
+      def parse(command)
+        m = TEST_RE.match(command)
+        return nil unless m
+
+        num = m[1].to_i
+        modifier = m[2] ? ArithmeticEvaluator.eval(m[2]) : 0
+        node_class = m[3] == '>' ? Contest : Test
+        difficulty = m[4].to_i
+
+        return node_class.new(num, modifier, difficulty)
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Cthulhu_ChineseTraditional.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Cthulhu_ChineseTraditional < Base
+      # ゲームシステムの識別子
+      ID = 'Cthulhu:ChineseTraditional'
+
+      # ゲームシステム名
+      NAME = '克蘇魯神話'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Chinese Traditional:克蘇魯神話7'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGE_TEXT
+        c=爆擊率 ／ f=大失敗值 ／ s=特殊
+
+        1d100<=n    c・f・s全關閉（只進行單純數值比較判定）
+
+        ・cfs付註判定指令
+
+        CC	 1d100擲骰 c=1、f=100
+        CCB  同上、c=5、f=96
+
+        例：CC<=80  （以技能值80來判定。cf適用於1%規則）
+        例：CCB<=55 （以技能值55來判定。cf適用於5%規則）
+
+        ・關於組合骰組
+
+        CBR(x,y)	c=1、f=100
+        CBRB(x,y)	c=5、f=96
+
+        ・關於對抗骰
+        RES(x-y)	c=1、f=100
+        RESB(x-y)	c=5、f=96
+
+        ※故障率判定
+
+        ・CC(x) c=1、f=100
+        x=故障率。擲出骰值x以上時、需在大失敗發生同時輸出（參照「大失敗＆故障」）
+        沒有大失敗時，無論成功或失敗只需參考[故障]來輸出(並非成功或失敗來輸出，而是覆蓋上去並對其輸出)
+
+        ・CCB(x) c=5、f=96
+        同上
+
+        ・瘋狂表
+        ・短期瘋期　Short／長期瘋狂　Longer
+
+      INFO_MESSAGE_TEXT
+
+      register_prefix(['CC(B)?\(\d+\)', 'CC(B)?.*', 'RES(B)?.*', 'CBR(B)?\(\d+,\d+\)'])
+
+      def initialize
+        # $isDebug = true
+        super
+        @special_percentage  = 20
+        @critical_percentage = 1
+        @fumble_percentage   = 1
+      end
+
+      def eval_game_system_specific_command(command)
+        case command
+        when /CCB/i
+          # 5%
+          @critical_percentage = 5
+          @fumble_percentage   = 5
+          return getCheckResult(command)
+        when /CC/i
+          # 1%
+          @critical_percentage = 1
+          @fumble_percentage   = 1
+          return getCheckResult(command)
+        when /RESB/i
+          # 5%
+          @critical_percentage = 5
+          @fumble_percentage   = 5
+          return getRegistResult(command)
+        when /CBRB/i
+          # 5%
+          @critical_percentage = 5
+          @fumble_percentage   = 5
+          return getCombineRoll(command)
+        when /RES/i
+          # 1%
+          @critical_percentage = 1
+          @fumble_percentage   = 1
+          return getRegistResult(command)
+        when /CBR/i
+          # 1%
+          @critical_percentage = 1
+          @fumble_percentage   = 1
+          return getCombineRoll(command)
+        end
+
+        return nil
+      end
+
+      def getCheckResult(command)
+        broken_num = 0
+        diff = 0
+
+        if (m = /CC(B)?(\d+)<=(\d+)/i.match(command))
+          # /\(\d+\)/の()はpattern-killerにカイシャクされる
+          broken_num = m[2].to_i
+          diff = m[3].to_i
+        elsif (m = /CC(B)?<=(\d+)/i.match(command))
+          diff = m[2].to_i
+        end
+
+        output = ""
+
+        if diff > 0
+          output = "(1D100<=#{diff})"
+
+          if broken_num > 0
+            output += " 故障率[#{broken_num}]"
+          end
+
+          total_n = @randomizer.roll_once(100)
+
+          output += " ＞ #{total_n}"
+          output += " ＞ #{getCheckResultText(total_n, diff, broken_num)}"
+        else
+          total_n = @randomizer.roll_once(100)
+          output = "(1D100) ＞ #{total_n}"
+        end
+
+        return output
+      end
+
+      def getCheckResultText(total_n, diff, broken_num = 0)
+        result = ""
+        diff_special = 0
+        fumble = false
+
+        if @special_percentage > 0
+          # 需有special的數值設定才能做爆擊/大失敗的判定
+          diff_special = (diff * @special_percentage / 100).floor
+          if diff_special < 1
+            diff_special = 1
+          end
+        end
+
+        if (total_n <= diff) && (total_n < 100)
+          result = "成功"
+
+          if diff_special > 0
+            if total_n <= @critical_percentage
+              if total_n <= diff_special
+                result = "決定性的成功/特殊"
+              else
+                result = "決定性的成功"
+              end
+            else
+              if total_n <= diff_special
+                result = "特殊"
+              end
+            end
+          end
+        else
+          result = "失敗"
+
+          if diff_special > 0
+            if (total_n >= (101 - @fumble_percentage)) && (diff < 100)
+              result = "致命性失敗"
+              fumble = true
+            end
+          end
+        end
+
+        if broken_num > 0
+          if total_n >= broken_num
+            if fumble
+              result += "/故障"
+            else
+              result = "故障"
+            end
+          end
+        end
+
+        return result
+      end
+
+      def getRegistResult(command)
+        m = /RES(B)?([-\d]+)/i.match(command)
+        unless m
+          return "1"
+        end
+
+        value = m[2].to_i
+        target = value * 5 + 50
+
+        if target < 5
+          return "(1d100<=#{target}) ＞ 自動失敗"
+        end
+
+        if target > 95
+          return "(1d100<=#{target}) ＞ 自動成功"
+        end
+
+        # 通常判定
+        total_n = @randomizer.roll_once(100)
+        result = getCheckResultText(total_n, target)
+
+        return "(1d100<=#{target}) ＞ #{total_n} ＞ #{result}"
+      end
+
+      def getCombineRoll(command)
+        m = /CBR(B)?\((\d+),(\d+)\)/i.match(command)
+        unless m
+          return "1"
+        end
+
+        diff_1 = m[2].to_i
+        diff_2 = m[3].to_i
+
+        total = @randomizer.roll_once(100)
+
+        result_1 = getCheckResultText(total, diff_1)
+        result_2 = getCheckResultText(total, diff_2)
+
+        successList = ["決定性成功/特殊", "決定性成功", "特殊", "成功"]
+
+        succesCount = 0
+        succesCount += 1 if successList.include?(result_1)
+        succesCount += 1 if successList.include?(result_2)
+        debug("succesCount", succesCount)
+
+        rank =
+          if succesCount >= 2
+            "成功"
+          elsif succesCount == 1
+            "部分性成功"
+          else
+            "失敗"
+          end
+
+        return "(1d100<=#{diff_1},#{diff_2}) ＞ #{total}[#{result_1},#{result_2}] ＞ #{rank}"
+      end
+    end
+  end
+end