bcdice 3.14.0 → 3.15.0

data/lib/bcdice/game_system/Magius.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Magius < Base
+      # ゲームシステムの識別子
+      ID = 'Magius'
+
+      # ゲームシステム名
+      NAME = 'MAGIUS'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'まきうす'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■能力値判定　MA+x>=t        x:修正値 t:目標値
+        例)MA>=7: ダイスを2個振って、その結果を表示
+
+        ■技能値判定　MS+x>=t        x:修正値 t:目標値
+        例)MS>=7: ダイスを3個振って、そのうち上位2つを採用し、結果を表示
+
+      INFO_MESSAGETEXT
+
+      register_prefix('M[AS]')
+
+      def initialize(command)
+        super(command)
+
+        @sort_barabara_dice = true # バラバラロール（Bコマンド）でソート有
+      end
+
+      def eval_game_system_specific_command(command)
+        resolute_ability_action(command) ||
+          resolute_skill_action(command)
+      end
+
+      private
+
+      def with_symbol(number)
+        if number == 0
+          return ""
+        elsif number > 0
+          return "+#{number}"
+        else
+          return number.to_s
+        end
+      end
+
+      # 能力値判定
+      # @param [String] command
+      # @return [Result]
+      def get_result_of_ability_action(total, _dice_add, target)
+        if total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      def resolute_ability_action(command)
+        m = /MA([+-]\d+)*>=(\d+)/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+        target = m[2].to_i
+
+        dices = @randomizer.roll_barabara(2, 6).sort
+        dice_text = dices.join(",")
+        dice_add = dices.sum
+        total = dice_add + modify
+
+        result = get_result_of_ability_action(total, dice_add, target)
+
+        sequence = [
+          "(#{command})",
+          "[#{dice_text}]#{with_symbol(modify)}",
+          total,
+          result.text,
+        ].compact
+
+        result.text = sequence.join(" ＞ ")
+
+        return result
+      end
+
+      # 技能値値判定
+      # @param [String] command
+      # @return [Result]
+      def get_result_of_skill_action(total, _dice_add, target)
+        if total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      def resolute_skill_action(command)
+        m = /MS([+-]\d+)*>=(\d+)/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+        target = m[2].to_i
+
+        dices = @randomizer.roll_barabara(3, 6).sort
+        dice_text = dices.join(",")
+        dice_add = dices[1].to_i + dices[2].to_i
+        total = dice_add + modify
+
+        result = get_result_of_skill_action(total, dice_add, target)
+
+        sequence = [
+          "(#{command})",
+          "[#{dice_text}]#{with_symbol(modify)}",
+          total,
+          result.text,
+        ].compact
+
+        result.text = sequence.join(" ＞ ")
+
+        return result
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Magius_3rdNewTokyoCity.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/Magius'
+
+module BCDice
+  module GameSystem
+    class Magius_3rdNewTokyoCity < Magius
+      # ゲームシステムの識別子
+      ID = 'Magius_3rdNewTokyoCity'
+
+      # ゲームシステム名
+      NAME = 'MAGIUS:新世紀エヴァンゲリオンRPG 決戦！第3新東京市'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'まきうすしんせいきえうあんけりおんRPGけつせんたい3しんとうきようし'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■能力値判定　MA+x>=t        x:修正値 t:目標値
+        例)MA>=7: ダイスを2個振って、その結果(成功,失敗,絶対成功,絶対失敗)を表示
+
+        ■技能値判定　MS+x>=t        x:修正値 t:目標値
+        例)MS>=7: ダイスを3個振って、そのうち上位2つを採用し、結果(成功,失敗,絶対成功,絶対失敗)を表示
+
+      INFO_MESSAGETEXT
+
+      register_prefix('M[AS]')
+
+      private
+
+      # 能力値判定の結果取得
+      # @param [Integer] total, dice_add, target
+      # @return [Result]
+      def get_result_of_ability_action(total, dice_add, target)
+        if dice_add == 12
+          return Result.critical("絶対成功")
+        elsif dice_add == 2
+          return Result.fumble("絶対失敗")
+        elsif total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      # 技能値判定の結果取得
+      # @param [Integer] total, dice_add, target
+      # @return [Result]
+      def get_result_of_skill_action(total, dice_add, target)
+        if dice_add == 12
+          return Result.critical("絶対成功")
+        elsif dice_add == 2
+          return Result.fumble("絶対失敗")
+        elsif total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/MonotoneMuseum_Korean.rb

@@ -22,11 +22,11 @@ module BCDice
         　　크리티컬, 펌블치는 생략가능합니다. ([]자체를 생략가능)
         　　자동성공, 자동실패, 성공, 실패를 자동표기합니다.
         ・각종표
-        　・감정표　ET／감정표 2.0　ET2
-        　・징조표　OT／징조표ver2.0　OT2／징조표ver3.0　OT3
+        　・감정표　ET／감정표 2.0　ET2／개정판 감정표 MET
+        　・징조표　OT／징조표ver2.0　OT2／징조표ver3.0　OT3 / 개정판 전투 징조표 MBOT / 개정판 비전투 징조표 MNOT
         　・일그러짐표　DT／일그러짐표ver2.0　DT2／일그러짐표(야외)　DTO／일그러짐표(바다)　DTS／일그러짐표(저택・성)　DTM
-        　・세계왜곡표　　WDT／세계왜곡표2.0　WDT2
-        　・영구소실표　EDT
+        　・세계왜곡표　　WDT／세계왜곡표2.0　WDT2／개정판 왜곡표 MDT／개정판 세계왜곡표 MWDT
+        　・영구소실표　EDT／개정판 영구소실표 MEDT
         ・D66다이스 있음
       INFO_MESSAGE_TEXT
 

data/lib/bcdice/game_system/NSSQ.rb

@@ -54,7 +54,7 @@ module BCDice
         total = largest_two.sum + modifier
         num_1 = dice_list.count(1)
 
-        additional_result =
+        result =
           if largest_two == [6, 6]
             Result.critical(" ＞ 絶対成功！")
           elsif largest_two == [1, 1]
@@ -73,10 +73,11 @@ module BCDice
         sequence = [
           "(#{command})",
           "[#{dice_list.join(',')}]#{Format.modifier(modifier)}",
-          "#{total}[#{largest_two.join(',')}]#{additional_result.text}#{fp_result}",
+          "#{total}[#{largest_two.join(',')}]#{result.text}#{fp_result}",
         ]
 
-        return sequence.join(" ＞ ")
+        result.text = sequence.join(" ＞ ")
+        return result
       end
 
       # ダメージロール
@@ -90,24 +91,29 @@ module BCDice
         resist = m[4].to_i
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
+        normal_damage = damage(dice_list, resist)
 
-        result = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}ダメージ"
+        result = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist}"
 
         critical_target = critical_up ? 1 : 2
 
         if dice_list.count(6) - dice_list.count(1) >= critical_target
-          result += " クリティカルヒット！\n"
-          result += additional_damage_roll(increase_critical_dice, resist)
+          result += critical_damage_roll(increase_critical_dice, resist, normal_damage)
+          result = Result.critical(result)
+        else
+          result += " ＞ #{normal_damage}ダメージ"
+          result = normal_damage > 0 ? Result.success(result) : Result.failure(result)
         end
 
         return result
       end
 
-      def additional_damage_roll(increase_critical_dice, resist)
+      def critical_damage_roll(increase_critical_dice, resist, normal_damage)
         dice_count = increase_critical_dice ? 8 : 4
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
-        "(#{dice_count}DR#{resist}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}ダメージ"
+        critical_damage = damage(dice_list, resist)
+        return " ＞ クリティカルヒット！ ＞ (#{dice_count}DR#{resist}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{normal_damage + critical_damage}ダメージ"
       end
 
       # 回復ロール
@@ -119,8 +125,10 @@ module BCDice
         resist = m[2]&.to_i || 3
 
         dice_list = @randomizer.roll_barabara(dice_count, 6)
+        heal_amount = damage(dice_list, resist)
+        result_text = "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{heal_amount}回復"
 
-        return "(#{command}) ＞ [#{dice_list.join(',')}]#{resist} ＞ #{damage(dice_list, resist)}回復"
+        return heal_amount > 0 ? Result.success(result_text) : Result.failure(result_text)
       end
 
       def damage(dice_list, resist)

data/lib/bcdice/game_system/NervWhitePaper.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class NervWhitePaper < Base
+      # ゲームシステムの識別子
+      ID = 'NervWhitePaper'
+
+      # ゲームシステム名
+      NAME = '新世紀エヴァンゲリオンRPG NERV白書/使徒降臨'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'しんせいきえうあんけりおんああるひいしいねるふはくしよしとこおりん'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■通常ロール(NR)：成功、失敗、絶対成功、絶対失敗を表示します。
+        例) NR
+
+        ■長所ロール(NA)：成功、失敗、絶対成功、絶対失敗を表示します。
+        例) NA
+
+        ■短所ロール(ND)：成功、失敗、絶対成功、絶対失敗を表示します。
+        例) ND
+
+      INFO_MESSAGETEXT
+
+      register_prefix('N[RAD]')
+
+      def eval_game_system_specific_command(command)
+        resolute_regular_action(command) ||
+          resolute_advantage_action(command) ||
+          resolute_disadvantage_action(command)
+      end
+
+      private
+
+      # 通常ロールによる判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_regular_action(command)
+        m = /NR/.match(command)
+        return nil unless m
+
+        dices = @randomizer.roll_barabara(2, 6)
+        dice_text = dices.join(",")
+        dice_add = dices.sum
+
+        output = "(NR) ＞ #{dice_text}"
+
+        if dice_add == 7
+          output += " ＞ 絶対成功"
+          return Result.critical(output)
+        elsif dice_add == 2
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dice_add == 12
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dice_add.modulo(2) == 0
+          output += " ＞ 失敗"
+          return Result.failure(output)
+        else
+          output += " ＞ 成功"
+          return Result.success(output)
+        end
+      end
+
+      # 長所ロールによる判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_advantage_action(command)
+        m = /NA/.match(command)
+        return nil unless m
+
+        dices = @randomizer.roll_barabara(2, 6)
+        dice_text = dices.join(",")
+        dice_add = dices.sum
+
+        output = "(NA) ＞ #{dice_text}"
+
+        if dice_add == 7
+          output += " ＞ 絶対成功"
+          return Result.critical(output)
+        elsif dice_add == 2
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dice_add == 12
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dices[0] == dices[1]
+          output += " ＞ 失敗"
+          return Result.failure(output)
+        else
+          output += " ＞ 成功"
+          return Result.success(output)
+        end
+      end
+
+      # 短所ロールによる判定
+      # @param [String] command
+      # @return [Result]
+      def resolute_disadvantage_action(command)
+        m = /ND/.match(command)
+        return nil unless m
+
+        dices = @randomizer.roll_barabara(2, 6)
+        dice_text = dices.join(",")
+        dice_add = dices.sum
+
+        output = "(ND) ＞ #{dice_text}"
+
+        if dice_add == 7
+          output += " ＞ 絶対成功"
+          return Result.critical(output)
+        elsif dice_add == 2
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dice_add == 12
+          output += " ＞ 絶対失敗"
+          return Result.fumble(output)
+        elsif dice_add != 7
+          output += " ＞ 失敗"
+          return Result.failure(output)
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/RogueLikeHalf.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class RogueLikeHalf < Base
+      # ゲームシステムの識別子
+      ID = 'RogueLikeHalf'
+
+      # ゲームシステム名
+      NAME = 'ローグライクハーフ'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = 'ろおくらいくはあふ'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~INFO_MESSAGETEXT
+        ■判定　RH+x>=t        x:技量点 t:達成値(威力)
+
+        例)RH+1>=5: ダイスを1個振って、技量点1,達成値5の結果を表示(クリティカル・ファンブルも表示)
+
+        ■D33　D33+x        x:修正値
+
+        例)D33: 3面ダイスを2個振って、その結果を表示。
+
+        ■宝物表　NTT+x     x:修正値
+      INFO_MESSAGETEXT
+
+      def initialize(command)
+        super(command)
+
+        @sort_barabara_dice = true # バラバラロール（Bコマンド）でソート有
+      end
+
+      def eval_game_system_specific_command(command)
+        resolute_action(command) ||
+          resolute_d33(command) ||
+          roll_table_command(command)
+      end
+
+      private
+
+      def with_symbol(number)
+        if number == 0
+          return "+0"
+        elsif number > 0
+          return "+#{number}"
+        else
+          return number.to_s
+        end
+      end
+
+      # 判定ロール
+      # @param [String] command
+      # @return [Result]
+      def get_result_of_action(total, die, target)
+        if die == 6
+          return Result.critical("クリティカル")
+        elsif die == 1
+          return Result.fumble("ファンブル")
+        elsif total >= target
+          return Result.success("成功")
+        else
+          return Result.failure("失敗")
+        end
+      end
+
+      def resolute_action(command)
+        m = /RH([+-]\d)*(>=(\d+))?/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+        target = m[3].to_i
+        target = 4 if target == 0
+
+        die = @randomizer.roll_once(6)
+        die_text = die.to_s
+        total = die + modify
+
+        result = get_result_of_action(total, die, target)
+
+        command_text = "(RH#{with_symbol(modify)}>=#{target})"
+        sequence = [
+          command_text,
+          "[#{die_text}]#{with_symbol(modify)}",
+          total,
+          result.text,
+        ].compact
+
+        result.text = sequence.join(" ＞ ")
+
+        return result
+      end
+
+      # D33ロール
+      # @param [String] command
+      # @return [Result]
+      def resolute_d33(command)
+        m = /D33([+-]\d+)*/.match(command)
+        return nil unless m
+
+        modify = m[1] ? Arithmetic.eval(m[1], @round_type) : 0
+
+        dice = @randomizer.roll_barabara(2, 3)
+        dice_text = dice.join("")
+        dice_total = dice[0] * 3 + dice[1] + modify
+        dice_total = 12 if dice_total > 12
+        dice_total = 4 if dice_total < 4
+        p = dice_total.divmod(3)
+        if p[1] == 0
+          p[0] = p[0] - 1
+          p[1] = 3
+        end
+        total = p[0] * 10 + p[1]
+
+        sequence = [
+          "(#{command})",
+          dice_text,
+        ].compact
+
+        if modify != 0
+          sequence = [
+            "(#{command})",
+            "#{dice_text}#{with_symbol(modify)}",
+            total,
+          ].compact
+        end
+
+        return Result.new(sequence.join(" ＞ "))
+      end
+
+      def roll_table_command(command)
+        command = command.upcase
+        result = []
+
+        m = /([A-Z]+)(([+]|-)(\d+))?/.match(command)
+        return result unless m
+
+        command = m[1]
+        operator = m[3]
+        value = m[4].to_i
+
+        return get_another_table_result(command, operator, value)
+      end
+
+      def get_another_table_result(command, operator, value)
+        result = ""
+
+        table_name = command
+        table = TABLES[table_name]
+        return result if table.nil?
+
+        index = get_table_index(operator, value, 1, 6)
+
+        info = table.choice(index)
+        result = "#{info.table_name}:#{info.value}:#{info.body}"
+
+        return result
+      end
+
+      def get_table_index(operator, value, dice_count, dice_type)
+        modify = 0
+
+        case operator
+        when "+"
+          modify = value
+        when "-"
+          modify = value * -1
+        end
+
+        index = @randomizer.roll_sum(dice_count, dice_type)
+        index += modify
+
+        index = [index, dice_count * 1].max
+        index = [index, dice_count * dice_type + 1].min
+
+        return index
+      end
+
+      TABLES = {
+        "NTT" => DiceTable::Table.new(
+          "宝物表",
+          "1D6",
+          [
+            "金貨１枚",
+            "１ｄ６枚の金貨",
+            "２ｄ６枚の金貨（下限は金貨５枚）",
+            "１個のアクセサリー（１ｄ６×１ｄ６枚の金貨と同等の価値）",
+            "１個の宝石・小（１ｄ６×５枚の金貨と同等の価値。下限は金貨１５枚の価値）",
+            "１個の宝石・大（２ｄ６×５枚の金貨と同等の価値。下限は金貨３０枚の価値）",
+            "【魔法の宝物表】でダイスロールを行うこと。",
+          ]
+        )
+      }.freeze
+
+      register_prefix('RH', 'D33', TABLES.keys)
+    end
+  end
+end

data/lib/bcdice/game_system/RuneQuestRoleplayingInGlorantha.rb

@@ -14,13 +14,16 @@ module BCDice
 
       # ダイスボットの使い方
       HELP_MESSAGE = <<~MESSAGETEXT
-        ・判定コマンド クリティカル、スペシャル、ファンブルを含めた判定を行う。
-        RQG<=成功率
+        ・判定コマンド 決定的成功、効果的成功、ファンブルを含めた判定を行う。
+        RQG<=成功率      (基本書式)
+        RQG成功率        (省略記法)
 
-        例1：RQG<=80 （技能値80で判定）
+        例1：RQG<=80    （技能値80で判定）
         例2：RQG<=80+20 （技能値100で判定）
+        例3：RQG80      （省略書式で技能値80の判定）
+        例4：RQG80+20   （省略書式で技能値100の判定）
 
-        ・抵抗判定コマンド（能動-受動） クリティカル、スペシャル、ファンブルを含めた判定を行う。
+        ・抵抗判定コマンド（能動-受動） 決定的成功、効果的成功、ファンブルを含めた判定を行う。
         RES(能動能力-受動能力)m増強値
         増強値は省略可能。
 
@@ -28,7 +31,7 @@ module BCDice
         例2：RES(9-11)m20 (能動能力9 vs 受動能力11、+20%の増強が能動側に入る判定)
         例3：RES(9)m50    (能動能力と受動能力の差が9で、+50%の増強が能動側に入る判定)
 
-        ・抵抗判定コマンド(能動側のみ) クリティカル、スペシャル、ファンブルは含めず判定を行う。
+        ・抵抗判定コマンド(能動側のみ) 決定的成功、効果的成功、ファンブルは含めず判定を行う。
         RSA(能動能力)m増強値
         増強値は省略可能。
 
@@ -55,18 +58,18 @@ module BCDice
 
       # 技能などの一般判定
       def do_ability_roll(command)
-        m = %r{\A(RQG)(<=([+-/*\d]+))?$}.match(command)
+        m = %r{\A(RQG)((<=)?([+-/*\d]+))?$}.match(command)
         unless m
           return nil
         end
 
         roll_value = @randomizer.roll_once(100)
-        unless m[3]
+        unless m[4]
           # RQGのみ指定された場合は1d100を振ったのと同じ挙動
           return "(1D100) ＞ #{roll_value}"
         end
 
-        ability_value = Arithmetic.eval(m[3], RoundType::ROUND)
+        ability_value = Arithmetic.eval(m[4], RoundType::ROUND)
         result_prefix_str = "(1D100<=#{ability_value}) ＞"
 
         if ability_value == 0
@@ -125,7 +128,7 @@ module BCDice
         active_value = active_ability_value * 5 + modifiy_value
         result_prefix_str = "(1D100<=#{active_value}) ＞ #{roll_value} ＞"
 
-        note_str = "クリティカル/スペシャル、ファンブルは未処理。必要なら確認すること。"
+        note_str = "決定的成功、効果的成功、ファンブルは未処理。必要なら確認すること。"
 
         if roll_value >= 96
           # 96以上は無条件で失敗
@@ -146,8 +149,8 @@ module BCDice
         funmble_value = ((100 - success_value.to_f) / 20).round
 
         if (roll_value == 1) || (roll_value <= critical_value)
-          # クリティカル(01は必ずクリティカル)
-          Result.critical("#{result_str} クリティカル/スペシャル")
+          # 決定的成功(01は必ず決定的成功)
+          Result.critical("#{result_str} 決定的成功")
         elsif (roll_value == 100) || (roll_value >= (100 - funmble_value + 1))
           # ファンブル(00は必ずファンブル)
           Result.fumble("#{result_str} ファンブル")
@@ -155,8 +158,8 @@ module BCDice
           # 失敗(96以上は必ず失敗、出目が01-05ではなく技能値より上なら失敗)
           Result.failure("#{result_str} 失敗")
         elsif roll_value <= special_value
-          # スペシャル
-          Result.success("#{result_str} スペシャル")
+          # 効果的成功
+          Result.success("#{result_str} 効果的成功")
         elsif (roll_value <= 5) || (roll_value <= success_value)
           # 成功(05以下は必ず成功)
           Result.success("#{result_str} 成功")