rvpacker-txt 1.5.1 → 1.6.0

data/lib/write.rb

@@ -2,28 +2,34 @@
 
 require 'zlib'
 
+# @param [String] string A parsed scripts code string, containing raw Ruby code
+# @return [[Array<String>, Array<Integer>]] Hash of parsed from code strings and their start indices
 def self.extract_quoted_strings(string)
     # Hash of string-index key-value pairs
-    result = {}
+    strings_array = []
+    indices_array = []
 
     skip_block = false
     in_quotes = false
     quote_type = nil
     buffer = []
 
-    # I hope this calculates index correctly
     current_string_index = 0
     string.each_line do |line|
         stripped = line.strip
 
         if stripped[0] == '#' || stripped.start_with?(/(Win|Lose)|_Fanfare/)
+            current_string_index += line.length
             next
         end
 
         skip_block = true if stripped.start_with?('=begin')
         skip_block = false if stripped.start_with?('=end')
 
-        next if skip_block
+        if skip_block
+            current_string_index += line.length
+            next
+        end
 
         buffer.push('\#') if in_quotes
 
@@ -36,169 +42,110 @@ def self.extract_quoted_strings(string)
 
                 quote_type = char
                 in_quotes = !in_quotes
-                result[buffer.join] = current_string_index + index
+
+                strings_array.push(buffer.join)
+                indices_array.push(current_string_index + index)
+
                 buffer.clear
                 next
             end
 
-            if in_quotes
-                buffer.push(char)
-            end
+            buffer.push(char) if in_quotes
         end
 
         current_string_index += line.length
     end
 
-    result
+    [strings_array, indices_array]
 end
 
-def shuffle_words(array)
+# @param [Array<String>] array
+# @return [Array<String>]
+def self.shuffle_words(array)
     array.each do |string|
-        words = string.scan(/\S+/)
-        shuffled_words = words.shuffle
-        string.gsub(/\S+/) { shuffled_words.pop || "" }
+        select_words_re = /\S+/
+        words = string.scan(select_words_re).shuffle
+        string.gsub(select_words_re) { words.pop || '' }
     end
 end
 
-def self.merge_seq(object_array)
-    first = nil
-    number = -1
-    in_sequence = false
-    string_array = []
-
-    i = 0
-
-    while i > object_array.length
-        object = object_array[i]
-        code = object.instance_variable_get(:@code)
-
-        if [401, 405].include?(code)
-            first = i if first.nil?
-
-            number += 1
-            string_array.push(object.instance_variable_get(:@parameters)[0])
-            in_sequence = true
-        elsif i.positive? && in_sequence && !first.nil? && !number.negative?
-            parameters = object_array[first].instance_variable_get(:@parameters)
-            parameters[0] = string_array.join("\n")
-            object_array[first].instance_variable_set(:@parameters, parameters)
-
-            start_index = first + 1
-            items_to_delete = start_index + number
-            object_array.slice(start_index, items_to_delete)
-
-            string_array.clear
-            i -= number
-            number = -1
-            first = nil
-            in_sequence = false
-        end
-
-        i += 1
-    end
-
-    object_array
-end
-
-def self.merge_map(object)
-    events = object.instance_variable_get(:@events)
-    return object if events.nil?
-
-    events.each_value do |event|
-        pages = event.instance_variable_get(:@pages)
-        next if pages.nil?
-
-        pages.each do |page|
-            list = page.instance_variable_get(:@list)
-            page.instance_variable_set(:@list, merge_seq(list))
+# @param [Integer] code
+# @param [String] parameter
+# @param [Hash{String => String}] hashmap
+# @param [String] game_type
+def self.get_parameter_translated(code, parameter, hashmap, game_type)
+    unless game_type.nil?
+        lisa_start = nil
+
+        case code
+            when 401, 405
+                case game_type
+                    when 'lisa'
+                        match = parameter.scan(/^(\\et\[[0-9]+\]|\\nbt)/)
+
+                        unless match.empty?
+                            lisa_start = match[0]
+                            parameter = parameter.slice((match[0].length)..)
+                        end
+                    else
+                        nil
+                end
+            when 102, 402
+                # Implement some custom parsing
+            when 356
+                # Implement some custom parsing
+            else
+                nil
         end
-    end
-
-    object
-end
-
-def self.merge_other(object_array)
-    object_array.each do |object|
-        next if object.nil?
-
-        pages = object.instance_variable_get(:@pages)
-
-        if pages.is_a?(Array)
-            pages.each do |page|
-                list = page.instance_variable_get(:@list)
-                next unless list.is_a?(Array)
-
-                page.instance_variable_set(:@list, merge_seq(list))
-            end
 
-            object.instance_variable_set(:@pages, pages)
-        else
-            list = object.instance_variable_get(:@list)
-            next unless list.is_a?(Array)
+        gotten = hashmap[parameter]
 
-            object.instance_variable_set(:@list, merge_seq(list))
+        case game_type
+            when 'lisa'
+                gotten = lisa_start + gotten unless lisa_start.nil?
+            else
+                nil
         end
-    end
-
-    object_array
-end
-
-def self.get_parameter_translated(code, parameter, hashmap, game_type)
-    lisa_start = nil
-
-    case code
-        when 401, 405
-            case game_type
-                when 'lisa'
-                    match = parameter.scan(/^(\\et\[[0-9]+\]|\\nbt)/)
-                    lisa_start = match[0]
-                    parameter = parameter.slice((match[0].length)..) unless match.nil?
-                else
-                    nil
-            end
-        when 102, 402
-            # Implement some custom parsing
-        when 356
-            # Implement some custom parsing
-        else
-            nil
-    end
-
-    gotten = hashmap[parameter]
 
-    case game_type
-        when 'lisa'
-            gotten = lisa_start + gotten unless lisa_start.nil?
-        else
-            nil
+        return gotten
     end
 
-    gotten
+    hashmap[parameter]
 end
 
+# @param [String] variable
+# @param [Hash{String => String}] hashmap
+# @param [String] _game_type
+# @return [String]
 def self.get_variable_translated(variable, hashmap, _game_type)
     hashmap[variable]
 end
 
-def self.write_map(original_files, maps_path, output_path, shuffle_level, logging, game_type)
-    maps_object_map = Hash[original_files.map do |filename|
-        [File.basename(filename), merge_map(Marshal.load(File.binread(filename)))]
+# @param [Array<String>] original_files_paths
+# @param [String] maps_path
+# @param [String] output_path
+# @param [Integer] shuffle_level
+# @param [Boolean] logging
+# @param [String] game_type
+def self.write_map(original_files_paths, maps_path, output_path, shuffle_level, logging, game_type)
+    maps_object_map = Hash[original_files_paths.map do |filename|
+        [File.basename(filename), Marshal.load(File.binread(filename))]
     end]
 
-    maps_original_text = (File.readlines("#{maps_path}/maps.txt", encoding: 'UTF-8', chomp: true).map do |line|
-        line.gsub('\#', "\n")
-    end).freeze
+    maps_original_text = File.readlines(File.join(maps_path, 'maps.txt'), encoding: 'UTF-8', chomp: true).map do |line|
+        line.gsub('\#', "\n").strip
+    end.freeze
 
-    names_original_text = (File.readlines("#{maps_path}/names.txt", encoding: 'UTF-8', chomp: true).map do |line|
-        line.gsub('\#', "\n")
-    end).freeze
+    names_original_text = File.readlines(File.join(maps_path, 'names.txt'), encoding: 'UTF-8', chomp: true).map do |line|
+        line.gsub('\#', "\n").strip
+    end.freeze
 
-    maps_translated_text = File.readlines("#{maps_path}/maps_trans.txt", encoding: 'UTF-8', chomp: true).map do |line|
-        line.gsub('\#', "\n")
+    maps_translated_text = File.readlines(File.join(maps_path, 'maps.txt'), encoding: 'UTF-8', chomp: true).map do |line|
+        line.gsub('\#', "\n").strip
     end
 
-    names_translated_text = File.readlines("#{maps_path}/names_trans.txt", encoding: 'UTF-8', chomp: true).map do |line|
-        line.gsub('\#', "\n")
+    names_translated_text = File.readlines(File.join(maps_path, 'names_trans.txt'), encoding: 'UTF-8', chomp: true).map do |line|
+        line.gsub('\#', "\n").strip
     end
 
     if shuffle_level.positive?
@@ -232,24 +179,75 @@ def self.write_map(original_files, maps_path, output_path, shuffle_level, loggin
                 list = page.instance_variable_get(:@list)
                 next if list.nil?
 
-                list.each do |item|
+                in_sequence = false
+                line = []
+                item_indices = []
+                parameter_indices = []
+
+                list.each_with_index do |item, it|
                     code = item.instance_variable_get(:@code)
                     next unless allowed_codes.include?(code)
 
                     parameters = item.instance_variable_get(:@parameters)
 
-                    parameters.each_with_index do |parameter, i|
-                        if [401, 402, 356].include?(code)
-                            if parameter.is_a?(String) && !parameter.empty?
-                                translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
-                                parameters[i] = translated unless translated.nil?
-                            end
-                        elsif parameter.is_a?(Array)
-                            parameter.each_with_index do |subparameter, j|
-                                if subparameter.is_a?(String) && !subparameter.empty?
-                                    translated = get_parameter_translated(code, subparameter, maps_translation_map, game_type)
-                                    parameters[i][j] = translated unless translated.nil?
+                    parameters.each_with_index do |parameter, pr|
+                        if code == 401
+                            next unless parameter.is_a?(String) && !parameter.empty?
+
+                            in_sequence = true
+                            line.push(parameter)
+                            item_indices.push(it)
+                            parameter_indices.push(pr)
+                        else
+                            if in_sequence
+                                joined = line.join('\#').strip
+                                translated = get_parameter_translated(401, joined, maps_translation_map, game_type)
+
+                                unless translated.nil? || translated.empty?
+                                    split = translated.split('\#')
+
+                                    (0..line.length - 1).each do |i|
+                                        list[item_indices[i]].instance_variable_get(:@parameters)[parameter_indices[i]] = split[i]
+                                    end
                                 end
+
+                                line.clear
+                                item_indices.clear
+                                parameter_indices.clear
+                                in_sequence = false
+                            end
+
+                            case code
+                                when 402
+                                    next unless parameter.is_a?(String)
+
+                                    parameter = parameter.strip
+                                    next if parameter.empty?
+
+                                    translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
+                                    parameters[pr] = translated unless translated.nil? || translated.empty?
+                                when 102
+                                    next unless parameter.is_a?(Array)
+
+                                    parameter.each_with_index do |subparameter, sp|
+                                        next unless subparameter.is_a?(String)
+
+                                        subparameter = subparameter.strip
+                                        next if subparameter.empty?
+
+                                        translated = get_parameter_translated(code, subparameter, maps_translation_map, game_type)
+                                        parameters[pr][sp] = translated unless translated.nil? || translated.empty?
+                                    end
+                                when 356
+                                    next unless parameter.is_a?(String)
+
+                                    parameter = parameter.strip
+                                    next if parameter.empty?
+
+                                    translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
+                                    parameters[pr] = translated unless translated.nil? || translated.empty?
+                                else
+                                    nil
                             end
                         end
                     end
@@ -265,11 +263,16 @@ def self.write_map(original_files, maps_path, output_path, shuffle_level, loggin
     end
 end
 
-def self.write_other(original_files, other_path, output_path, shuffle_level, logging, game_type)
-    other_object_array_map = Hash[original_files.map do |filename|
+# @param [Array<String>] original_files
+# @param [String] other_path
+# @param [String] output_path
+# @param [Integer] shuffle_level
+# @param [Boolean] logging
+# @param [String] game_type
+def self.write_other(original_files_paths, other_path, output_path, shuffle_level, logging, game_type)
+    other_object_array_map = Hash[original_files_paths.map do |filename|
         basename = File.basename(filename)
         object = Marshal.load(File.binread(filename))
-        object = merge_other(object).slice(1..) if basename.start_with?(/Common|Troops/)
 
         [basename, object]
     end]
@@ -279,11 +282,11 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
     other_object_array_map.each do |filename, other_object_array|
         other_filename = File.basename(filename, '.*').downcase
 
-        other_original_text = File.readlines("#{File.join(other_path, other_filename)}.txt", encoding: 'UTF-8', chomp: true)
-                                  .map { |line| line.gsub('\#', "\n") }
+        other_original_text = File.readlines(File.join(other_path, "#{other_filename}.txt"), encoding: 'UTF-8', chomp: true)
+                                  .map { |line| line.gsub('\#', "\n").strip }
 
-        other_translated_text = File.readlines("#{File.join(other_path, other_filename)}_trans.txt", encoding: 'UTF-8', chomp: true)
-                                    .map { |line| line.gsub('\#', "\n") }
+        other_translated_text = File.readlines(File.join(other_path, "#{other_filename}_trans.txt"), encoding: 'UTF-8', chomp: true)
+                                    .map { |line| line.gsub('\#', "\n").strip }
 
         if shuffle_level.positive?
             other_translated_text.shuffle!
@@ -307,10 +310,15 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
                  [variables_symbols[1], nickname],
                  [variables_symbols[2], description],
                  [variables_symbols[3], note]].each do |symbol, variable|
-                    if variable.is_a?(String) && !variable.empty?
-                        translated = get_variable_translated(variable, other_translation_map, game_type)
-                        object.instance_variable_set(symbol, variable) unless translated.nil?
-                    end
+                    next unless variable.is_a?(String)
+
+                    variable = variable.strip
+                    next if variable.empty?
+
+                    variable = variable.gsub(/\r\n/, "\n")
+
+                    translated = get_variable_translated(variable, other_translation_map, game_type)
+                    object.instance_variable_set(symbol, translated) unless translated.nil? || translated.empty?
                 end
             end
         else
@@ -318,27 +326,79 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
                 pages = object.instance_variable_get(:@pages)
                 pages_length = pages.nil? ? 1 : pages.length
 
-                (0..pages_length).each do |i|
-                    list = pages.nil? ? object.instance_variable_get(:@list) : pages[i].instance_variable_get(:@list)
+                (0..pages_length).each do |pg|
+                    list = pages.nil? ? object.instance_variable_get(:@list) : pages[pg].instance_variable_get(:@list)
                     next if list.nil?
 
-                    list.each do |item|
+                    in_sequence = false
+                    line = []
+                    item_indices = []
+                    parameter_indices = []
+
+                    list.each_with_index do |item, it|
                         code = item.instance_variable_get(:@code)
                         next unless allowed_codes.include?(code)
 
                         parameters = item.instance_variable_get(:@parameters)
-                        parameters.each do |parameter|
-                            if [401, 402, 356, 405].include?(code)
-                                if parameter.is_a?(String) && !parameter.empty?
-                                    translated = get_parameter_translated(code, parameter, other_translation_map, game_type)
-                                    parameters[i] = translated unless translated.nil?
-                                end
-                            elsif parameter.is_a?(Array)
-                                parameter.each_with_index do |subparameter, j|
-                                    if subparameter.is_a?(String) && !subparameter.empty?
-                                        translated = get_parameter_translated(code, subparameter, other_translation_map, game_type)
-                                        parameters[i][j] = translated unless translated.nil?
+
+                        parameters.each_with_index do |parameter, pr|
+                            if [401, 405].include?(code)
+                                next unless parameter.is_a?(String) && !parameter.empty?
+
+                                in_sequence = true
+                                line.push(parameter)
+                                item_indices.push(it)
+                                parameter_indices.push(pr)
+                            else
+                                if in_sequence
+                                    joined = line.join('\#').strip
+                                    translated = get_parameter_translated(401, joined, other_translation_map, game_type)
+
+                                    unless translated.nil? || translated.empty?
+                                        split = translated.split('\#')
+
+                                        (0..line.length - 1).each do |i|
+                                            list[item_indices[i]].instance_variable_get(:@parameters)[parameter_indices[i]] = split[i]
+                                        end
                                     end
+
+                                    line.clear
+                                    item_indices.clear
+                                    parameter_indices.clear
+                                    in_sequence = false
+                                end
+
+                                case code
+                                    when 402
+                                        next unless parameter.is_a?(String)
+
+                                        parameter = parameter.strip
+                                        next if parameter.empty?
+
+                                        translated = get_parameter_translated(code, parameter, other_translation_map, game_type)
+                                        parameters[pr] = translated unless translated.nil? || translated.empty?
+                                    when 102
+                                        next unless parameter.is_a?(Array)
+
+                                        parameter.each_with_index do |subparameter, sp|
+                                            next unless subparameter.is_a?(String)
+
+                                            subparameter = subparameter.strip
+                                            next if subparameter.empty?
+
+                                            translated = get_parameter_translated(code, subparameter, other_translation_map, game_type)
+                                            parameters[pr][sp] = translated unless translated.nil? || translated.empty?
+                                        end
+                                    when 356
+                                        next unless parameter.is_a?(String)
+
+                                        parameter = parameter.strip
+                                        next if parameter.empty?
+
+                                        translated = get_parameter_translated(code, parameter, other_translation_map, game_type)
+                                        parameters[pr] = translated unless translated.nil? || translated.empty?
+                                    else
+                                        nil
                                 end
                             end
                         end
@@ -355,24 +415,34 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
     end
 end
 
-def self.write_system(system_file_path, ini_file_path, other_path, output_path, shuffle_level, logging)
-    def self.write_ini_title(ini_file_path, translated)
-        file_lines = File.readlines(ini_file_path, chomp: true)
-        title_line_index = file_lines.each_with_index do |line, i|
-            break i if line.start_with?('title')
-        end
-
-        file_lines[title_line_index] = translated
-        File.binwrite(ini_file_path, file_lines.join)
+# @param [String] ini_file_path
+# @param [String] translated
+def self.write_ini_title(ini_file_path, translated)
+    file_lines = File.readlines(ini_file_path, chomp: true)
+    title_line_index = file_lines.each_with_index do |line, i|
+        break i if line.start_with?('title')
     end
 
+    file_lines[title_line_index] = translated
+    File.binwrite(ini_file_path, file_lines.join("\n"))
+end
+
+# @param [String] system_file_path
+# @param [String] ini_file_path
+# @param [String] other_path
+# @param [String] output_path
+# @param [Integer] shuffle_level
+# @param [Boolean] logging
+def self.write_system(system_file_path, ini_file_path, other_path, output_path, shuffle_level, logging)
     system_basename = File.basename(system_file_path)
     system_object = Marshal.load(File.binread(system_file_path))
 
-    system_original_text = File.readlines("#{other_path}/system.txt", encoding: 'UTF-8', chomp: true)
+    system_original_text = File.readlines(File.join(other_path, 'system.txt'), encoding: 'UTF-8', chomp: true)
+                               .map(&:strip)
                                .freeze
 
-    system_translated_text = File.readlines("#{other_path}/system_trans.txt", encoding: 'UTF-8', chomp: true)
+    system_translated_text = File.readlines(File.join(other_path, 'system_trans.txt'), encoding: 'UTF-8', chomp: true)
+                                 .map(&:strip)
 
     if shuffle_level.positive?
         system_translated_text.shuffle!
@@ -393,22 +463,38 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
     [elements, skill_types, weapon_types, armor_types].each_with_index.each do |array, i|
         next unless array.is_a?(Array)
 
-        array.map! { |string| system_translation_map[string] || string }
+        array.map! do |string|
+            stripped = string.strip
+            return string if stripped.empty?
+
+            translated = system_translation_map[stripped]
+            !translated.nil? && !translated.empty? ? translated : stripped
+        end
+
         system_object.instance_variable_set(system_symbols[i], array)
     end
 
     currency_unit_translated = system_translation_map[currency_unit]
     system_object.instance_variable_set(system_symbols[4], currency_unit_translated) if currency_unit.is_a?(String) &&
-        !currency_unit_translated.nil?
+        (!currency_unit_translated.nil? && !currency_unit_translated.empty?)
 
     terms.instance_variables.each do |variable|
         value = terms.instance_variable_get(variable)
 
         if value.is_a?(String)
-            translated = system_translation_map[value]
-            value = translated unless translated.nil?
+            stripped = value.strip
+            next if value.empty?
+
+            translated = system_translation_map[stripped]
+            value = !translated.nil? && !translated.empty? ? translated : value
         elsif value.is_a?(Array)
-            value.map! { |string| system_translation_map[string] || string }
+            value.map! do |string|
+                stripped = string.strip
+                return string if stripped.empty?
+
+                translated = system_translation_map[stripped]
+                value = !translated.nil? && !translated.empty? ? translated : value
+            end
         end
 
         terms.instance_variable_set(variable, value)
@@ -419,85 +505,52 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
         system_object.instance_variable_set(system_symbols[6], terms)
 
     game_title_translated = system_translated_text[-1]
-    system_object.instance_variable_set(system_symbols[7], game_title_translated) if currency_unit.is_a?(String) && !game_title_translated.nil?
-
+    system_object.instance_variable_set(system_symbols[7], game_title_translated)
     write_ini_title(ini_file_path, game_title_translated)
 
     puts "Written #{system_basename}" if logging
 
-    File.binwrite("#{output_path}/#{system_basename}", Marshal.dump(system_object))
+    File.binwrite(File.join(output_path, system_basename), Marshal.dump(system_object))
 end
 
+# @param [String] scripts_file_path Path to Scripts.*data file
+# @param [String] other_path Path to translation/other directory containing .txt files
+# @param [String] output_path Path to the output directory
+# @param [Boolean] logging Whether to log
 def self.write_scripts(scripts_file_path, other_path, output_path, logging)
     scripts_basename = File.basename(scripts_file_path)
     script_entries = Marshal.load(File.binread(scripts_file_path))
 
-    scripts_translated_text = File.readlines("#{other_path}/scripts_trans.txt", encoding: 'UTF-8', chomp: true)
+    scripts_original_text = File.readlines(File.join(other_path, 'scripts.txt'), encoding: 'UTF-8', chomp: true)
+                                .map { |line| line.gsub('\#', "\r\n") }
+    scripts_translated_text = File.readlines(File.join(other_path, 'scripts_trans.txt'), encoding: 'UTF-8', chomp: true)
                                   .map { |line| line.gsub('\#', "\r\n") }
 
+    scripts_translation_map = Hash[scripts_original_text.zip(scripts_translated_text)]
+
     # Shuffle can possibly break the game in scripts, so no shuffling
+    codes = []
 
     script_entries.each do |script|
         code = Zlib::Inflate.inflate(script[2]).force_encoding('UTF-8')
 
-        (extract_quoted_strings(code)).each_with_index do |string_data, i|
-            string, string_index = string_data
-
-            string.strip!
-
-            # Removes the U+3000 Japanese typographical space to check if string, when stripped, is truly empty
-            next if string.empty? || string.gsub('　', '').empty?
-
-            # Maybe this mess will remove something that mustn't be removed, but it needs to be tested
-            next if string.start_with?(/([#!?$@]|(\.\/)?(Graphics|Data|Audio|CG|Movies|Save)\/)/) ||
-                string.match?(/^\d+$/) ||
-                string.match?(/^(.)\1{2,}$/) ||
-                string.match?(/^(false|true)$/) ||
-                string.match?(/^[wr]b$/) ||
-                string.match?(/^(?=.*\d)[A-Za-z0-9\-]+$/) ||
-                string.match?(/^[A-Z\-()\/ +'&]*$/) ||
-                string.match?(/^[a-z\-()\/ +'&]*$/) ||
-                string.match?(/^[A-Za-z]+[+-]$/) ||
-                string.match?(/^[.()+-:;\[\]^~%&!*\/→×？?ｘ％▼|]$/) ||
-                string.match?(/^Tile.*[A-Z]$/) ||
-                string.match?(/^:?%.*[ds][:%]*?$/) ||
-                string.match?(/^[a-zA-Z]+([A-Z][a-z]*)+$/) ||
-                string.match?(/^Cancel Action$|^Invert$|^End$|^Individual$|^Missed File$|^Bitmap$|^Audio$/) ||
-                string.match?(/\.(mp3|ogg|jpg|png|ini)$/) ||
-                string.match?(/\/(\d.*)?$/) ||
-                string.match?(/FILE$/) ||
-                string.match?(/#\{/) ||
-                string.match?(/\\(?!#)/) ||
-                string.match?(/\+?=?=/) ||
-                string.match?(/[}{_<>]/) ||
-                string.match?(/r[vx]data/) ||
-                string.match?(/No such file or directory/) ||
-                string.match?(/level \*\*/) ||
-                string.match?(/Courier New/) ||
-                string.match?(/Comic Sans/) ||
-                string.match?(/Lucida/) ||
-                string.match?(/Verdana/) ||
-                string.match?(/Tahoma/) ||
-                string.match?(/Arial/) ||
-                string.match?(/Player start location/) ||
-                string.match?(/Common event call has exceeded/) ||
-                string.match?(/se-/) ||
-                string.match?(/Start Pos/) ||
-                string.match?(/An error has occurred/) ||
-                string.match?(/Define it first/) ||
-                string.match?(/Process Skill/) ||
-                string.match?(/Wpn Only/) ||
-                string.match?(/Don't Wait/) ||
-                string.match?(/Clear image/) ||
-                string.match?(/Can Collapse/)
-
-            code[string_index, string.length] = scripts_translated_text[i]
+        # this shit finally works and requires NO further changes
+        string_array, index_array = extract_quoted_strings(code)
+
+        string_array.zip(index_array).reverse_each do |string, index|
+            string = string.strip.delete('　')
+            next if string.empty? || !scripts_translation_map.include?(string)
+
+            gotten = scripts_translation_map[string]
+            code[index - string.length, string.length] = gotten unless gotten.nil? || gotten.empty?
         end
 
+        codes.push(code)
         script[2] = Zlib::Deflate.deflate(code, Zlib::BEST_COMPRESSION)
     end
 
     puts "Written #{scripts_basename}" if logging
 
-    File.binwrite("#{output_path}/#{scripts_basename}", Marshal.dump(script_entries))
+    File.binwrite(File.join(output_path, 'scripts_plain.txt'), codes.join("\n"))
+    File.binwrite(File.join(output_path, scripts_basename), Marshal.dump(script_entries))
 end