bcdice 3.16.1 → 3.17.0

data/lib/bcdice/game_system/ZombiLine_Korean.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'bcdice/game_system/ZombiLine'
+
+module BCDice
+  module GameSystem
+    class ZombiLine_Korean < ZombiLine
+      # ゲームシステムの識別子
+      ID = "ZombiLine:Korean"
+
+      # ゲームシステム名
+      NAME = "좀비 라인"
+
+      # ゲームシステム名の読みがな
+      SORT_KEY = "国際化:Korean:좀비 라인"
+
+      HELP_MESSAGE = <<~TEXT
+        ■ 판정 (xZL<=y)
+        　x：주사위 개수(생략 시 1)
+        　y：성공률
+
+        ■ 각종 표
+        　스트레스 증상표 SST
+        　식재료 표 IT
+      TEXT
+
+      register_prefix_from_super_class()
+
+      def initialize(command)
+        super(command)
+        @locale = :ko_kr
+      end
+
+      TABLES = translate_tables(:ko_kr).freeze
+    end
+  end
+end

data/lib/bcdice/game_system/cthulhu7th_Korean/full_auto.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Cthulhu7th_Korean < Base
+      class FullAuto
+        BONUS_DICE_RANGE = (-2..2).freeze
+
+        # 連射処理を止める条件（難易度の閾値）: 연사 처리를 중지하는 조건(난이도 임계값)
+        # @return [Hash<String, Integer>]
+        #
+        # 成功の種類の小文字表記 => 難易度の閾値 : 성공 유형의 소문자 표기 => 난이도 임계값
+        ROLL_FULL_AUTO_DIFFICULTY_THRESHOLD = {
+          # レギュラー : 보통 성공
+          "r" => 0,
+          # ハード : 어려운 성공
+          "h" => 1,
+          # イクストリーム : 극단적 성공
+          "e" => 2
+        }.freeze
+
+        def self.eval(command, randomizer)
+          new.eval(command, randomizer)
+        end
+
+        def eval(command, randomizer)
+          @randomizer = randomizer
+          get_full_auto_result(command)
+        end
+
+        private
+
+        include Rollable
+
+        def get_full_auto_result(command)
+          m = /^FAR\((-?\d+),(-?\d+),(-?\d+)(?:,(-?\d+)?)?(?:,(-?\w+)?)?(?:,(-?\d+)?)?\)$/i.match(command)
+          unless m
+            return nil
+          end
+
+          bullet_count = m[1].to_i
+          diff = m[2].to_i
+          broken_number = m[3].to_i
+          bonus_dice_count = m[4].to_i
+          stop_count = m[5]&.downcase || ""
+          bullet_set_count_cap = m[6]&.to_i || diff / 10
+
+          output = ""
+
+          # 最大で（8回*（PC技能値最大値/10））＝72発しか撃てないはずなので上限 : 최대 (8회 * (PC 능력치 최대값 / 10)) = 72발밖에 쏠 수 없으므로 상한선
+          bullet_count_limit = 100
+          if bullet_count > bullet_count_limit
+            output += "탄환이 너무 많습니다. 장전된 탄환을 #{bullet_count_limit}발로 변경합니다.\n"
+            bullet_count = bullet_count_limit
+          end
+
+          # ボレーの上限の設定がおかしい場合の注意表示 : 연사 상한선 설정이 잘못된 경우의 주의 표시
+          if (bullet_set_count_cap > diff / 10) && (diff > 39) && !m[6].nil?
+            bullet_set_count_cap = diff / 10
+            output += "연사할 탄환 수의 상한은 [기능치÷10(소수점 버림)]발이므로, 그보다 큰 수를 지정할 수 없습니다. 연사할 탄환 수를 #{bullet_set_count_cap}발로 변경합니다.\n"
+          elsif (diff <= 39) && (bullet_set_count_cap > 3) && !m[6].nil?
+            bullet_set_count_cap = 3
+            output += "기능치가 39 이하일 때 연사할 탄환 수의 상한 및 하한은 3발입니다. 연사할 탄환 수를 #{bullet_set_count_cap}발로 변경합니다.\n"
+          end
+
+          # ボレーの下限の設定がおかしい場合の注意表示およびエラー表示 : 연사 하한값 설정이 잘못된 경우의 주의 표시 및 오류 표시
+          return "연사할 탄환 수는 양수여야 합니다." if (bullet_set_count_cap <= 0) && !m[6].nil?
+
+          if (bullet_set_count_cap < 3) && !m[6].nil?
+            bullet_set_count_cap = 3
+            output += "연사할 탄환 수의 하한은 3발입니다. 연사할 탄환 수를 3발로 변경합니다.\n"
+          end
+
+          return "탄환은 양수여야 합니다." if bullet_count <= 0
+          return "목표치는 양수여야 합니다." if diff <= 0
+
+          if broken_number < 0
+            output += "고장 수치는 양수여야 합니다. 마이너스 부호를 제외합니다.\n"
+            broken_number = broken_number.abs
+          end
+
+          unless BONUS_DICE_RANGE.include?(bonus_dice_count)
+            return "오류. 보너스, 페널티 주사위의 값은 #{BONUS_DICE_RANGE.min}~#{BONUS_DICE_RANGE.max}여야 합니다."
+          end
+
+          output += "보너스, 페널티 주사위[#{bonus_dice_count}]"
+          output += roll_full_auto(bullet_count, diff, broken_number, bonus_dice_count, stop_count, bullet_set_count_cap)
+
+          return output
+        end
+
+        def roll_full_auto(bullet_count, diff, broken_number, dice_num, stop_count, bullet_set_count_cap)
+          output = ""
+          loop_count = 0
+
+          counts = {
+            hit_bullet: 0,
+            impale_bullet: 0,
+            bullet: bullet_count,
+          }
+
+          # 難易度変更用ループ : 난이도 변경용 루프
+          4.times do |more_difficulty|
+            output += get_next_difficulty_message(more_difficulty)
+
+            # ペナルティダイスを減らしながらロール用ループ : 페널티 주사위를 줄이면서 주사위를 굴리는 루프
+            while dice_num >= BONUS_DICE_RANGE.min
+
+              loop_count += 1
+              hit_result, total, total_list = get_hit_result_infos(dice_num, diff, more_difficulty)
+              output += "\n#{loop_count}번째: ＞ #{total_list.join(', ')} ＞ #{hit_result}"
+
+              if total >= broken_number
+                output += "　총알 걸림(고장)"
+                return get_hit_result_text(output, counts)
+              end
+
+              hit_type = get_hit_type(more_difficulty, hit_result)
+              hit_bullet, impale_bullet, lost_bullet = get_bullet_results(counts[:bullet], hit_type, diff, bullet_set_count_cap)
+
+              output += "　（#{hit_bullet}발 명중, #{impale_bullet}발 관통）"
+
+              counts[:hit_bullet] += hit_bullet
+              counts[:impale_bullet] += impale_bullet
+              counts[:bullet] -= lost_bullet
+
+              return get_hit_result_text(output, counts) if counts[:bullet] <= 0
+
+              dice_num -= 1
+            end
+
+            # 指定された難易度となった場合、連射処理を途中で止める : 지정된 난이도에 도달하면 연사 처리를 중단
+            if should_stop_roll_full_auto?(stop_count, more_difficulty)
+              output += "\n【지정한 난이도가 되었으므로, 처리를 종료합니다.】"
+              break
+            end
+
+            dice_num += 1
+          end
+
+          return get_hit_result_text(output, counts)
+        end
+
+        # 連射処理を止めるべきかどうかを返す : 연사 처리를 중지해야 하는지 여부를 반환
+        # @param [String] stop_count 成功の種類
+        # @param [Integer] difficulty 難易度
+        # @return [Boolean]
+        def should_stop_roll_full_auto?(stop_count, difficulty)
+          difficulty_threshold = ROLL_FULL_AUTO_DIFFICULTY_THRESHOLD[stop_count]
+          return difficulty_threshold && difficulty >= difficulty_threshold
+        end
+
+        def get_hit_result_infos(dice_num, diff, more_difficulty)
+          total, total_list = roll_with_bonus(dice_num)
+
+          fumbleable = get_fumbleable(more_difficulty)
+          hit_result = ResultLevel.from_values(total, diff, fumbleable).to_s
+
+          return hit_result, total, total_list
+        end
+
+        def get_hit_result_text(output, counts)
+          return "#{output}\n＞ #{counts[:hit_bullet]}발 명중, #{counts[:impale_bullet]}발 관통, 남은 탄환 #{counts[:bullet]}발"
+        end
+
+        def get_hit_type(more_difficulty, hit_result)
+          success_list, impale_bullet_list = get_success_list_impale_bullet_list(more_difficulty)
+
+          return :hit if success_list.include?(hit_result)
+          return :impale if impale_bullet_list.include?(hit_result)
+
+          return ""
+        end
+
+        def get_bullet_results(bullet_count, hit_type, diff, bullet_set_count_cap)
+          bullet_set_count = get_set_of_bullet(diff, bullet_set_count_cap)
+          hit_bullet_count_base = get_hit_bullet_count_base(diff, bullet_set_count)
+          impale_bullet_count_base = (bullet_set_count / 2.to_f)
+
+          lost_bullet_count = 0
+          hit_bullet_count = 0
+          impale_bullet_count = 0
+
+          if !last_bullet_turn?(bullet_count, bullet_set_count)
+
+            case hit_type
+            when :hit
+              hit_bullet_count = hit_bullet_count_base # 通常命中した弾数の計算 : 명중한 탄환 수 계산
+
+            when :impale
+              impale_bullet_count = impale_bullet_count_base.floor # 貫通した弾数の計算 : 관통한 탄환 수 계산
+              hit_bullet_count = impale_bullet_count_base.ceil
+            end
+
+            lost_bullet_count = bullet_set_count
+
+          else
+
+            case hit_type
+            when :hit
+              hit_bullet_count = get_last_hit_bullet_count(bullet_count)
+
+            when :impale
+              impale_bullet_count = get_last_hit_bullet_count(bullet_count)
+              hit_bullet_count = bullet_count - impale_bullet_count
+            end
+
+            lost_bullet_count = bullet_count
+          end
+
+          return hit_bullet_count, impale_bullet_count, lost_bullet_count
+        end
+
+        def get_success_list_impale_bullet_list(more_difficulty)
+          success_list = []
+          impale_bullet_list = []
+
+          case more_difficulty
+          when 0
+            success_list = ["어려운 성공", "보통 성공"]
+            impale_bullet_list = ["대성공", "극단적 성공"]
+          when 1
+            success_list = ["어려운 성공"]
+            impale_bullet_list = ["대성공", "극단적 성공"]
+          when 2
+            success_list = []
+            impale_bullet_list = ["대성공", "극단적 성공"]
+          when 3
+            success_list = ["대성공"]
+            impale_bullet_list = []
+          end
+
+          return success_list, impale_bullet_list
+        end
+
+        def get_next_difficulty_message(more_difficulty)
+          case more_difficulty
+          when 1
+            return "\n【난이도를 어려운 성공으로 변경】"
+          when 2
+            return "\n【난이도를 극단적 성공으로 변경】"
+          when 3
+            return "\n【난이도를 대성공으로 변경】"
+          end
+
+          return ""
+        end
+
+        def get_set_of_bullet(diff, bullet_set_count_cap)
+          bullet_set_count = diff / 10
+
+          if bullet_set_count_cap < bullet_set_count
+            bullet_set_count = bullet_set_count_cap
+          end
+
+          if (diff >= 1) && (diff < 30)
+            bullet_set_count = 3 # 技能値が29以下での最低値保障処理 : 기능치가 29 이하일 때의 최저치 보장 처리
+          end
+
+          return bullet_set_count
+        end
+
+        def get_hit_bullet_count_base(diff, bullet_set_count)
+          hit_bullet_count_base = (bullet_set_count / 2)
+
+          if (diff >= 1) && (diff < 30)
+            hit_bullet_count_base = 1 # 技能値29以下での最低値保障 : 기능치 29 이하일 때의 최저치 보장
+          end
+
+          return hit_bullet_count_base
+        end
+
+        def last_bullet_turn?(bullet_count, bullet_set_count)
+          ((bullet_count - bullet_set_count) < 0)
+        end
+
+        def get_last_hit_bullet_count(bullet_count)
+          # 残弾1での最低値保障処理 : 잔탄 1개일 때의 최저치 보장 처리
+          if bullet_count == 1
+            return 1
+          end
+
+          count = (bullet_count / 2.to_f).floor
+          return count
+        end
+
+        def get_fumbleable(more_difficulty)
+          # 成功が49以下の出目のみとなるため、ファンブル値は上昇 : 성공이 49 이하일 때만 적용되므로, 펌블치 상승
+          return (more_difficulty >= 1)
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/cthulhu7th_Korean/rollable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module BCDice
+  module GameSystem
+    class Cthulhu7th_Korean < Base
+      module Rollable
+        private
+
+        # 1D100の一の位用のダイスロール
+        # 0から9までの値を返す
+        #
+        # @return [Integer]
+        def roll_ones_d10
+          dice = @randomizer.roll_once(10)
+          return 0 if dice == 10
+
+          return dice
+        end
+
+        # @param bonus [Integer] ボーナス・ペナルティダイスの数。負の数ならペナルティダイス。
+        # @return [Array<(Integer, Array<Integer>)>]
+        def roll_with_bonus(bonus)
+          tens_list = Array.new(bonus.abs + 1) { @randomizer.roll_tens_d10 }
+          ones = roll_ones_d10()
+
+          dice_list = tens_list.map do |tens|
+            dice = tens + ones
+            dice == 0 ? 100 : dice
+          end
+
+          dice =
+            if bonus >= 0
+              dice_list.min
+            else
+              dice_list.max
+            end
+
+          return dice, dice_list
+        end
+      end
+    end
+  end
+end

data/lib/bcdice/game_system/sword_world/rating_options.rb

@@ -22,6 +22,9 @@ module BCDice
         # @return [Integer, nil]
         attr_accessor :rateup
 
+        # @return [Integer, nil]
+        attr_accessor :add_damage
+
         # @return [Boolean, nil]
         attr_accessor :greatest_fortune
 
@@ -31,6 +34,9 @@ module BCDice
         # @return [Integer, nil]
         attr_accessor :tmp_fixed_val
 
+        # @return [Integer, nil]
+        attr_accessor :set_zero_val
+
         # @return [Integer, nil]
         attr_accessor :modifier
 
@@ -40,6 +46,9 @@ module BCDice
         # @return [Integer, nil]
         attr_accessor :modifier_after_one_and_a_half
 
+        # @return [Integer, nil]
+        attr_accessor :modifier_after_double
+
         def settable_first_roll_adjust_option?
           return first_modify.nil? && first_to.nil? && first_modify_ssp.nil?
         end

data/lib/bcdice/game_system/sword_world/rating_parsed.rb

@@ -25,6 +25,9 @@ module BCDice
         # @return [Integer]
         attr_accessor :rateup
 
+        # @return [Integer]
+        attr_accessor :add_damage
+
         # @return [Boolean]
         attr_accessor :greatest_fortune
 
@@ -34,6 +37,9 @@ module BCDice
         # @return [Integer]
         attr_accessor :tmp_fixed_val
 
+        # @return [Integer]
+        attr_accessor :set_zero_val
+
         # @return [Integer]
         attr_accessor :modifier
 
@@ -43,6 +49,9 @@ module BCDice
         # @return [Integer, nil]
         attr_accessor :modifier_after_one_and_a_half
 
+        # @return [Integer, nil]
+        attr_accessor :modifier_after_double
+
         def initialize(rate, modifier)
           @rate = rate
           @modifier = modifier
@@ -53,10 +62,13 @@ module BCDice
           @first_modify_ssp = 0
           @greatest_fortune = false
           @rateup = 0
+          @add_damage = 0
           @semi_fixed_val = 0
           @tmp_fixed_val = 0
+          @set_zero_val = 0
           @modifier_after_half = nil
           @modifier_after_one_and_a_half = nil
+          @modifier_after_double = nil
         end
 
         # @return [Boolean]
@@ -69,6 +81,11 @@ module BCDice
           return !@modifier_after_one_and_a_half.nil?
         end
 
+        # @return [Boolean]
+        def double
+          return !@modifier_after_double.nil?
+        end
+
         # @return [Integer]
         def min_critical
           if @semi_fixed_val <= 1
@@ -92,9 +109,11 @@ module BCDice
           output += "m[~#{Format.modifier(first_modify_ssp)}]" if first_modify_ssp != 0
           output += "m[#{first_to}]" if first_to != 0
           output += "r[#{rateup}]" if rateup != 0
+          output += "ad[#{add_damage}]" if add_damage != 0
           output += "gf" if @greatest_fortune
           output += "sf[#{semi_fixed_val}]" if semi_fixed_val != 0
           output += "tf[#{tmp_fixed_val}]" if tmp_fixed_val != 0
+          output += "sz[#{set_zero_val}]" if set_zero_val != 0
           output += "a[#{Format.modifier(kept_modify)}]" if kept_modify != 0
 
           if @modifier != 0