bcdice 3.16.1 → 3.17.0

data/i18n/ZombiLine/ja_jp.yml

@@ -0,0 +1,27 @@
+ja_jp:
+  ZombiLine:
+    success_critical: "成功(クリティカル)"
+    success_fumble: "成功(ファンブル)"
+    success: "成功"
+    failure_fumble: "失敗(ファンブル)"
+    failure: "失敗"
+    SST:
+      name: "ストレス症状表"
+      type: "1D10"
+      items:
+        - '憤怒：一番近い敵を攻撃（成功率+20%）しにいきます。近くに敵がいない場合、誰かのストレスを＋１させます。　頭に血が上り、誰かに怒りをぶつけます。'
+        - '逃避：落下してでも敵から逃げるように移動します。周囲に敵が居ない場合、現実逃避します。　耐えられなくなり、逃げ出します。'
+        - '幻覚：戦闘中は、「行動放棄（全AP）」します。戦闘以外なら、幻覚を見て笑います。　自分が望む幻覚が見えます。'
+        - '絶叫：戦闘中は、「注目を集める（2AP）」をします。戦闘以外なら、無意味に叫びます。　思わず叫んでしまいます。'
+        - '自傷：自ら【怪我】を負います。戦闘中は「自傷行為（1AP）」をして自分が【怪我】します。　思わず自分を傷つけます。'
+        - '不安：誰かのストレスを１上げます。近くに誰も居ない場合、泣き出します。　不安にかられて余計なことを言います。'
+        - '忌避：その場から一番近い対象に「石（1AP）」を投げます。それができない場合、【転倒】してうずくまります。　嫌悪感から全てを拒みます。'
+        - '暴走：一番近い敵を攻撃しにいきます。近くに敵がいない場合、周りの意見も聞かずに安直な行動をします。　冷静でいられなくなり、直情的になります。'
+        - '混乱：近くにいるランダムな対象に格闘で攻撃しにいきます。それができない場合、「行動放棄（全 AP）」します。　世界全てが敵に見えて攻撃します。'
+        - '開眼：ストレスは0まで下がります。あなたは教祖となって教義をひとつつくって「布教」できます。次の症状が出るまで効果は続きます。　ゾンビだらけの世界の真理を見つけます。'
+    IT:
+      name: "食材表"
+      items:
+        raw: '生モノ食材'
+        suspicious: '怪しい食材'
+        dangerous: '危ない食材'

data/i18n/ZombiLine/ko_kr.yml

@@ -0,0 +1,27 @@
+ko_kr:
+  ZombiLine:
+    success_critical: "성공(크리티컬)"
+    success_fumble: "성공(펌블)"
+    success: "성공"
+    failure_fumble: "실패(펌블)"
+    failure: "실패"
+    SST:
+      name: "스트레스 증상표"
+      type: "1D10"
+      items:
+        - '[분노] 가장 가까이 있는 적을 공격(성공률 +20%)합니다. 가까이 적이 없는 경우, 누군가의 스트레스를 +1시킵니다. / 설명: 머리에 피가 몰려 누군가에게 화를 터트립니다.'
+        - '[도피] 낙하하더라도 적에게서 도망치려 이동합니다. 주변에 적이 없는 경우, 현실도피를 하려 합니다. / 설명: 견딜 수 없게 되어 도망칩니다.'
+        - '[환상] 전투 중에는 「행동방치(전AP)」를 합니다. 전투 이외의 경우, 환상을 보며 웃음을 흘립니다. / 설명: 자신이 꿈꾸는 환상을 봅니다.'
+        - '[절규] 전투 중에는 비명을 지르며 「주목을 모은다(2AP)」를 합니다. 전투 이외의 경우, 무의미한 소리를 지릅니다. / 설명: 생각없이 비명을 지릅니다.'
+        - '[자해] 스스로 【상처】를 입습니다. 전투 중에는 「자해행위(1AP)」로 스스로에게 【상처】를 입힙니다. / 설명: 생각없이 자신에게 상처를 입힙니다.'
+        - '[불안] 누군가의 스트레스를 1 올립니다. 근처에 아무도 없는 경우, 울음을 터트립니다. / 설명: 불안해져 쓸데없는 말을 지껄입니다.'
+        - '[기피] 그 자리에서 가장 가까이 있는 대상에게 「돌(1AP)」을 던집니다. 그게 불가능한 경우, 【넘어짐】상태가 됩니다. / 설명: 혐오감으로 모든 것을 거부합니다.'
+        - '[폭주] 가장 가까이 있는 적에게 공격을 가합니다. 가까이 적이 없는 경우 주변의 의견을 듣지 않고 제멋대로 행동을 합니다. / 설명: 냉정을 찾지 못하고 제멋대로 행동합니다.'
+        - '[혼란] 가까이 있는 무작위 대상에게 격투로 공격을 가합니다. 그게 불가능한 경우 「행동방치(전AP)」를 합니다. / 설명: 세상 모든 것이 적으로 보여 공격합니다.'
+        - '[개안] 스트레스가 0까지 떨어집니다. 당신은 교조가 되어 교의를 한가지 정해 「포교」할 수 있습니다. 다음 증상이 나올 때까지 효과가 지속됩니다. / 설명: 좀비투성이 세상의 진리를 보았습니다.'
+    IT:
+      name: "식재료 표"
+      items:
+        raw: '신선 식재료'
+        suspicious: '수상한 식재료'
+        dangerous: '위험한 식재료'

data/i18n/ko_kr.yml

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

data/i18n/zh_hant.yml

@@ -4,5 +4,5 @@ zh_hant:
   fumble: 大失敗
   critical: 大成功
   RTT:
-  rtt_format: "隨機特技表(%<category_dice>d,%<row_dice>d) ＞ %<text>s"
-  rttn_format: "%<category_name>s領域隨機特技表(%<row_dice>d) ＞ %<text>s"
+    rtt_format: "隨機特技表(%<category_dice>d,%<row_dice>d) ＞ %<text>s"
+    rttn_format: "%<category_name>s領域隨機特技表(%<row_dice>d) ＞ %<text>s"

data/lib/bcdice/dice_table/d66_left_range_table.rb

@@ -6,6 +6,27 @@ module BCDice
   module DiceTable
     # 左側（十の位）のみ Range を用いる D66 表
     class D66LeftRangeTable < D66Table
+      class << self
+        def from_i18n(key, locale)
+          table = I18n.t(key, locale: locale)
+          converted_items = table[:items].map do |item|
+            [conv_string_range(item[0]), item[1]]
+          end
+          new(table[:name], table[:d66_sort_type], converted_items)
+        end
+
+        def conv_string_range(x)
+          if x.include?("..")
+            return Range.new(*x.split("..", 2).map { |n| Integer(n) })
+          end
+
+          raise(
+            ArgumentError,
+            "invalid format"
+          )
+        end
+      end
+
       # @param name [String] 表の名前
       # @param sort_type [Symbol] 出目入れ替えの方式 BCDice::D66SortType
       # @param items [Array<(Range, Array<String>)>] 表の項目の配列

data/lib/bcdice/game_system/Aionia.rb

@@ -17,29 +17,43 @@ module BCDice
         AB{n}>={dif} n=10面ダイスの数、dif=難易度
         - 技能判定（クリティカル・ファンブルあり）
         ABT{n}>={dif} n=10面ダイスの数、dif=難易度
+        - ダメージチェック
+        DMG>={dif} dif=ダメージ難易度
 
-        例:AB2>=5        （一般技能を活用して難易度5の技能判定。 クリファンなし。）
-        例:ABT3>=15      （専門技能を活用して難易度15の技能判定。クリファンあり。）
-        例:AB1+2>=8      （一般技能を活用せず難易度8の技能判定。 ボーナスとして+2点の補正あり。  クリファンなし。）
-        例:ABT3-3>=10    （専門技能を活用して難易度10の技能判定。ペナルティとして-3点の補正あり。クリファンあり。）
-        例:ABT2>=4/8/12  （一般技能を活用して難易度4/8/12の段階的な技能判定。クリファンあり。）
+        ※ 技能判定、ダメージチェックともにダイス結果、難易度に対して四則演算（+ - * /）を用いた複数ボーナスを含めることが可能です。計算結果の小数は切り捨てられます。
+
+        例:AB2>=5          （一般技能を活用して難易度5の技能判定。 クリファンなし。）
+        例:ABT3>=15        （専門技能を活用して難易度15の技能判定。クリファンあり。）
+        例:AB1+1+2>=8      （一般技能を活用せず難易度8の技能判定。 ボーナスとして+1と+2点の補正あり。  クリファンなし。）
+        例:ABT3-3>=10+2    （専門技能を活用して難易度10+2の技能判定。ペナルティとして-3点の補正あり。クリファンあり。）
+        例:ABT2>=4/8/12    （一般技能を活用して難易度4/8/12の段階的な技能判定。クリファンあり。）
+        例:DMG>=50         （難易度50の判定。）
+        例:DMG>=20+50      （難易度20+50の判定。）
       INFO_MESSAGE_TEXT
 
-      register_prefix('ABT?\d+([\+\-]\d+)?>=\d+(\/\d+)*')
+      register_prefix('ABT?', 'DMG')
 
       def eval_game_system_specific_command(command)
-        return roll_skills(command)
+        return roll_skills(command) || roll_damage_check(command)
       end
 
       def roll_skills(command)
-        m = %r{AB(T?)(\d+)([+-]\d+)?>=((\d+)((/\d+)*))}.match(command)
+        m = %r{^AB(T?)(\d+)((?:[-+]\d+)*)>=(\d+(?:/\d+)*)((?:[-+]\d+)*)$}.match(command)
         return nil unless m
 
         # 値の取得
         use_cf = m[1] != ''
         times = m[2].to_i
-        bonus = m[3].to_i
-        targets = m[4].split('/').map(&:to_i)
+
+        # 値の計算
+        bonus = m[3] != '' ? Arithmetic.eval(m[3], RoundType::FLOOR) : 0
+        return nil unless bonus
+
+        base_targets = m[4].split('/').map(&:to_i)
+        target_bonus = m[5] != '' ? Arithmetic.eval(m[5], RoundType::FLOOR) : 0
+        return nil unless target_bonus
+
+        targets = base_targets.map { |t| t + target_bonus }
         target = targets[0]
         min_target = targets.min
         max_target = targets.max
@@ -107,15 +121,8 @@ module BCDice
         end
 
         # ボーナスがある場合の処理
-        bonus_text = ''
-        bonus_result = ''
-        if bonus != 0
-          if bonus > 0
-            bonus_text = "+"
-          end
-          bonus_text += bonus.to_s
-          bonus_result = "#{total} ＞ "
-        end
+        bonus_text = m[3]
+        bonus_result = m[3] == '' ? '' : "#{total} ＞ "
 
         # Resultクラスに結果を入れる
         Result.new.tap do |r|
@@ -126,6 +133,48 @@ module BCDice
           r.failure = !is_success
         end
       end
+
+      def roll_damage_check(command)
+        parser = Command::Parser.new("DMG", round_type: BCDice::RoundType::FLOOR).restrict_cmp_op_to(:>=)
+        parsed = parser.parse(command)
+        return nil unless parsed
+
+        # 値の計算
+        dif = parsed.target_number
+        return nil unless dif
+
+        # ダイスロール
+        dice_result = @randomizer.roll_once(100)
+
+        # Result用変数宣言
+        is_success = false
+
+        # 結果判定
+        if dice_result < (dif / 5)
+          is_success = false
+          second_result = @randomizer.roll_once(100)
+          if second_result >= dif
+            result_str = "失敗 > 弱点追加 ＞ #{second_result} ＞ 戦闘不能状態"
+          else
+            result_str = "失敗 > 弱点追加 ＞ #{second_result} ＞ 死亡状態"
+          end
+        elsif dice_result < (dif / 2)
+          result_str = "失敗 > 弱点追加 > 戦闘不能状態"
+          is_success = false
+        elsif dice_result < dif
+          result_str = "失敗 > 戦闘不能状態"
+          is_success = false
+        else
+          result_str = "成功"
+          is_success = true
+        end
+
+        Result.new.tap do |r|
+          r.text = "(#{command}) ＞ #{dice_result} ＞ #{result_str}"
+          r.success = is_success
+          r.failure = !is_success
+        end
+      end
     end
   end
 end

data/lib/bcdice/game_system/Airgetlamh.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bcdice/base"
+
 module BCDice
   module GameSystem
     class Airgetlamh < Base
@@ -41,9 +43,7 @@ module BCDice
         ・15AAx4c0 → 15d10で目標値6、威力4、クリティカル無しの命中判定。
       MESSAGETEXT
 
-      register_prefix(
-        '\d*A[AL]'
-      )
+      register_prefix('\d*A[AL]')
 
       def initialize(command)
         super(command)
@@ -51,64 +51,87 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        # AA/ALコマンド：調査判定, 成功判定
-        if command =~ /(\d+)?A(A|L)(\d+)?((x|\*)(\d+)(\+(\d+))?)?(C(\d+))?$/i
-          diceCount = (Regexp.last_match(1) || 2).to_i
-          target = (Regexp.last_match(3) || 6).to_i
-          damage = (Regexp.last_match(6) || 0).to_i
-
-          if Regexp.last_match(2) == 'L' # 旧Ver対応
-            criticalTrigger = 0
-            criticalNumber = 0
-          else
-            criticalTrigger = (Regexp.last_match(8) || 0).to_i
-            criticalNumber = (Regexp.last_match(10) || 1).to_i
-          end
-          criticalNumber = 3 if criticalNumber > 4
-
-          return checkRoll(diceCount, target, damage, criticalTrigger, criticalNumber)
+        check_roll(command)
+      end
+
+      private
+
+      def parse_check_roll(command)
+        m = /(\d+)?A(A|L)(\d+)?(?:[X*](\d+)(?:\+(\d+))?)?(?:C(\d+))?$/i.match(command)
+        unless m
+          return nil
         end
 
-        return nil
+        dice_count = m[1]&.to_i || 2
+        target = m[3]&.to_i || 6
+        damage = m[4].to_i
+        critical_trigger = m[5].to_i
+        critical_number = m[6]&.to_i || 1
+
+        if m[2] == "L"
+          critical_trigger = 0
+          critical_number = 0
+        elsif critical_number > 4
+          critical_number = 3
+        end
+
+        return {
+          dice_count: dice_count,
+          target: target,
+          damage: damage,
+          critical_trigger: critical_trigger,
+          critical_number: critical_number,
+        }
       end
 
-      def checkRoll(diceCount, target, damage, criticalTrigger, criticalNumber)
-        totalSuccessCount = 0
-        totalCriticalCount = 0
+      def check_roll(command)
+        parsed = parse_check_roll(command)
+        unless parsed
+          return nil
+        end
+
+        dice_count = parsed[:dice_count]
+        target = parsed[:target]
+        damage = parsed[:damage]
+        critical_trigger = parsed[:critical_trigger]
+        critical_number = parsed[:critical_number]
+
+        total_success_count = 0
+        total_critical_count = 0
         text = ""
 
-        rollCount = diceCount
+        roll_count = dice_count
 
-        while rollCount > 0
-          diceArray = @randomizer.roll_barabara(rollCount, 10).sort
-          diceText = diceArray.join(",")
+        while roll_count > 0
+          dice_array = @randomizer.roll_barabara(roll_count, 10).sort
+          dice_text = dice_array.join(",")
 
-          successCount = diceArray.count { |i| i <= target }
-          criticalCount = diceArray.count { |i| i <= criticalNumber }
+          success_count = dice_array.count { |i| i <= target }
+          critical_count = dice_array.count { |i| i <= critical_number }
 
-          totalSuccessCount += successCount
-          totalCriticalCount += criticalCount
+          total_success_count += success_count
+          total_critical_count += critical_count
 
           text += "+" unless text.empty?
-          text += "#{successCount}[#{diceText}]"
+          text += "#{success_count}[#{dice_text}]"
 
-          rollCount = criticalCount
+          roll_count = critical_count
         end
 
         result = ""
-        isDamage = (damage != 0)
+        is_damage = (damage != 0)
 
-        if isDamage
-          totalDamage = totalSuccessCount * damage + totalCriticalCount * criticalTrigger
+        if is_damage
+          total_damage = total_success_count * damage + total_critical_count * critical_trigger
 
-          result += "(#{diceCount}D10\<\=#{target}) ＞ #{text} ＞ Hits：#{totalSuccessCount}*#{damage}"
-          result += " + Trigger：#{totalCriticalCount}*#{criticalTrigger}" if criticalTrigger > 0
-          result += " ＞ #{totalDamage}ダメージ"
+          result += "(#{dice_count}D10\<\=#{target}) ＞ #{text} ＞ Hits：#{total_success_count}*#{damage}"
+          result += " + Trigger：#{total_critical_count}*#{critical_trigger}" if critical_trigger > 0
+          result += " ＞ #{translate('Airgetlamh.damage', count: total_damage)}"
         else
-          result += "(#{diceCount}D10\<\=#{target}) ＞ #{text} ＞ 成功数：#{totalSuccessCount}"
+          result += "(#{dice_count}D10\<\=#{target}) ＞ #{text} ＞ #{translate('Airgetlamh.success_count', count: total_success_count)}"
         end
 
-        result += " / #{totalCriticalCount}クリティカル" if totalCriticalCount > 0
+        result += " / #{translate('Airgetlamh.critical', count: total_critical_count)}" if total_critical_count > 0
 
         return result
       end

data/lib/bcdice/game_system/Airgetlamh_Korean.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "bcdice/game_system/Airgetlamh"
+
+module BCDice
+  module GameSystem
+    class Airgetlamh_Korean < Airgetlamh
+      # ゲームシステムの識別子
+      ID = 'Airgetlamh:Korean'
+
+      # ゲームシステム名
+      NAME = '붉은 고탑의 에어게트람'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:붉은 고탑의 에어게트람'
+
+      HELP_MESSAGE = <<~MESSAGETEXT
+        【Reg2.0『THE ANSWERER』～】
+        ・조사 판정（성공 수 표시）：[n]AA[m]
+        ・명중 판정（대미지 표시）：[n]AA[m]*p[+t][Cx]
+        【～Reg1.1『승화(昇華)』】
+        ・조사 판정（성공 수 표시）：[n]AL[m]
+        ・명중 판정（대미지 표시）：[n]AL[m]*p
+        ----------------------------------------
+        []안의 커맨드는 생략 가능.
+
+        「n」으로 주사위 수（공격 횟수）지정. 생략 시「2」.
+        「m」으로 목표값 지정. 생략 시「6」.
+        「p」으로 위력 지정.「*」는「x」로 대체 가능.
+        「+t」으로 크리티컬 트리거 지정. 생략 가능.
+        「Cx」으로 크리티컬 값 지정. 생략 시「1」, 최대값「3」,「0」은 크리티컬 없음.
+
+        공격력 지정으로 명중 판정이 되며, 성공 수가 아닌 대미지를 결과로 표시합니다.
+        크리티컬 히트 수만큼 자동으로 추가 굴림 처리를 합니다.
+        （AL 커맨드에서는 크리티컬 처리를 하지 않습니다）
+
+        【사용 예시】
+        ・AL → 2d10으로 목표값 6의 조사 판정.
+        ・5AA7*12 → 5d10으로 목표값 7, 위력 12의 명중 판정.
+        ・AA7x28+5 → 2d10으로 목표값 7, 위력 28, 크리티컬 트리거 5의 명중 판정.
+        ・9aa5*10C2 → 9d10으로 목표값 5, 위력 10, 크리티컬 값 2의 명중 판정.
+        ・15AAx4c0 → 15d10으로 목표값 6, 위력 4, 크리티컬 없음의 명중 판정.
+      MESSAGETEXT
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+        @locale = :ko_kr
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/Alsetto.rb

@@ -45,76 +45,89 @@ module BCDice
       end
 
       def eval_game_system_specific_command(command)
-        # ALCコマンド：命中判定
-        # ALCコマンド：成功判定
-        if command =~ /(\d+)AL(C|G)?(\d+)?((x|\*)(\d+))?$/i
-          rapid = Regexp.last_match(1).to_i
-          isCritical = Regexp.last_match(2).nil?
-          if isCritical
-            criticalNumber = 1
-          else
-            if Regexp.last_match(2) == "G"
-              isCritical = true
-              criticalNumber = 2
-            else
-              criticalNumber = 0
-            end
-          end
-          target = (Regexp.last_match(3) || 3).to_i
-          damage = (Regexp.last_match(6) || 0).to_i
-          return checkRoll(rapid, target, damage, isCritical, criticalNumber)
+        check_roll(command)
+      end
+
+      private
+
+      def parse_check_roll(command)
+        m = /(\d+)AL(C|G)?(\d+)?((x|\*)(\d+))?$/i.match(command)
+        unless m
+          return nil
         end
 
-        return nil
+        rapid = m[1].to_i
+        enable_critical = m[2].nil? || m[2] == "G"
+        critical_number =
+          case m[2]
+          when "G"
+            2
+          when "C"
+            0
+          else
+            1
+          end
+        target = m[3]&.to_i || 3
+        damage = m[6].to_i
+
+        return {
+          rapid: rapid,
+          enable_critical: enable_critical,
+          critical_number: critical_number,
+          target: target,
+          damage: damage,
+        }
       end
 
-      def checkRoll(rapid, target, damage, isCritical, criticalNumber)
-        totalSuccessCount = 0
-        totalCriticalCount = 0
-        text = ""
-
-        rollCount = rapid
+      def check_roll(command)
+        parsed = parse_check_roll(command)
+        unless parsed
+          return nil
+        end
 
-        while rollCount > 0
-          diceArray = @randomizer.roll_barabara(rollCount, 6).sort
-          diceText = diceArray.join(",")
+        rapid = parsed[:rapid]
+        enable_critical = parsed[:enable_critical]
+        critical_number = parsed[:critical_number]
+        target = parsed[:target]
+        damage = parsed[:damage]
 
-          successCount = 0
-          criticalCount = 0
+        total_success_count = 0
+        total_critical_count = 0
+        text = ""
 
-          diceArray.each do |i|
-            if i <= target
-              successCount += 1
-            end
+        roll_count = rapid
 
-            if i <= criticalNumber
-              criticalCount += 1
-            end
-          end
+        while roll_count > 0
+          dice_array = @randomizer.roll_barabara(roll_count, 6).sort
+          dice_text = dice_array.join(",")
 
-          totalSuccessCount += successCount
-          totalCriticalCount += 1 unless criticalCount == 0
+          success_count = dice_array.count { |v| v <= target }
+          critical_count = dice_array.count { |v| v <= critical_number }
+          total_success_count += success_count
+          total_critical_count += 1 if critical_count > 0
 
           text += "+" unless text.empty?
-          text += "#{successCount}[#{diceText}]"
+          text += "#{success_count}[#{dice_text}]"
 
-          break unless isCritical
+          break unless enable_critical
 
-          rollCount = criticalCount
+          roll_count = critical_count
         end
 
-        isDamage = (damage != 0)
+        is_damage = (damage != 0)
 
-        if isDamage
-          totalDamage = totalSuccessCount * damage
+        if is_damage
+          total_damage = total_success_count * damage
 
-          result = "(#{rapid}D6\<\=#{target}) ＞ #{text} ＞ Hits：#{totalSuccessCount}*#{damage} ＞ #{totalDamage}ダメージ"
+          damage_text = translate("Alsetto.damage", total_damage: total_damage)
+          result = "(#{rapid}D6\<\=#{target}) ＞ #{text} ＞ Hits：#{total_success_count}*#{damage} ＞ #{damage_text}"
         else
-          result = "(#{rapid}D6\<\=#{target}) ＞ #{text} ＞ 成功数：#{totalSuccessCount}"
+          success_text = translate("Alsetto.success_count", success_count: total_success_count)
+          result = "(#{rapid}D6\<\=#{target}) ＞ #{text} ＞ #{success_text}"
         end
 
-        if isCritical
-          result += " / #{totalCriticalCount}トライアンフ"
+        if enable_critical
+          result += translate("Alsetto.triumph", critical_count: total_critical_count)
         end
 
         return result

data/lib/bcdice/game_system/Alsetto_Korean.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/Alsetto'
+
+module BCDice
+  module GameSystem
+    class Alsetto_Korean < Alsetto
+      # ゲームシステムの識別子
+      ID = 'Alsetto:Korean'
+
+      # ゲームシステム名
+      NAME = '시편의 알세토'
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = '国際化:Korean:시편의 알세토'
+
+      # ダイスボットの使い方
+      HELP_MESSAGE = <<~MESSAGETEXT
+        ・성공 판정：nAL[m]　　　　・트라이엄프 없음：nALC[m]
+        ・명중 판정：nAL[m]*p　　　・트라이엄프 없음：nALC[m]*p
+        ・명중 판정(건슬링거의 근원시)：nALG[m]*p
+        [] 내부는 생략 가능.
+
+        AL 커맨드는 트라이엄프 수만큼, 자동으로 추가 주사위 굴림 처리를 수행합니다.
+        「n」으로 주사위 수를 지정.
+        「m」으로 목표치를 지정. 생략 시에는 기본값인 「3」이 사용됩니다.
+        「p」로 공격력을 지정. 「*」 대신 「x」도 사용 가능.
+        공격력을 지정하면 명중 판정이 되며, 성공수가 아닌 대미지를 결과로 표시합니다.
+
+        ALC 커맨드는 트라이엄프 없이 성공수, 대미지를 결과로 표시합니다.
+        ALG 커맨드는 「2 이하」에서 트라이엄프 처리를 수행합니다.
+
+        【사용 예시】
+        ・5AL → 5d6에서 목표치 3.
+        ・5ALC → 5d6에서 목표치 3. 트라이엄프 없음.
+        ・6AL2 → 6d6에서 목표치 2.
+        ・4AL*5 → 4d6에서 목표치 3, 공격력 5의 명중 판정.
+        ・7AL2x10 → 7d6에서 목표치 2, 공격력 10의 명중 판정.
+        ・8ALC4x5 → 8d6에서 목표치 4, 공격력 5, 트라이엄프 없는 명중 판정.
+      MESSAGETEXT
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+
+        @locale = :ko_kr
+      end
+    end
+  end
+end