rvpacker-txt 1.5.2 → 1.7.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 || "" }
-    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
+        select_words_re = /\S+/
+        words = string.scan(select_words_re).shuffle
+        string.gsub(select_words_re) { words.pop || '' }
     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?
@@ -214,47 +161,95 @@ def self.write_map(original_files, maps_path, output_path, shuffle_level, loggin
     maps_translation_map = Hash[maps_original_text.zip(maps_translated_text)].freeze
     names_translation_map = Hash[names_original_text.zip(names_translated_text)].freeze
 
-    allowed_codes = [401, 402, 356, 102].freeze
+    # 401 - dialogue lines
+    # 102 - dialogue choices array
+    # 402 - one of the dialogue choices from the array
+    # 356 - system lines/special texts (do they even exist before mv?)
+    allowed_codes = [401, 102, 402, 356].freeze
 
     maps_object_map.each do |filename, object|
-        display_name = object.instance_variable_get(:@display_name)
+        display_name = object.display_name
         display_name_gotten = names_translation_map[display_name]
-        object.instance_variable_set(:@display_name, display_name_gotten) unless display_name_gotten.nil?
+        object.display_name = display_name_gotten unless display_name_gotten.nil?
 
-        events = object.instance_variable_get(:@events)
+        events = object.events
         next if events.nil?
 
         events.each_value do |event|
-            pages = event.instance_variable_get(:@pages)
+            pages = event.pages
             next if pages.nil?
 
             pages.each do |page|
-                list = page.instance_variable_get(:@list)
+                list = page.list
                 next if list.nil?
 
-                list.each do |item|
-                    code = item.instance_variable_get(:@code)
-                    next unless allowed_codes.include?(code)
+                in_sequence = false
+                line = []
+                item_indices = []
 
-                    parameters = item.instance_variable_get(:@parameters)
+                list.each_with_index do |item, it|
+                    code = item.code
 
-                    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?
+                    unless allowed_codes.include?(code)
+                        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('\#')
+
+                                split_length = split.length
+                                line_length = line.length
+
+                                item_indices.each_with_index do |index, i|
+                                    list[index].parameters[0] = i < split_length ? split[i] : ''
                                 end
+
+                                list[item_indices.last].parameters[0] = split[line_length..].join("\n") if split_length > line_length
                             end
                         end
+                        next
                     end
 
-                    item.instance_variable_set(:@parameters, parameters)
+                    parameters = item.parameters
+
+                    if code == 401
+                        next unless parameters[0].is_a?(String) && !parameters[0].empty?
+
+                        in_sequence = true
+                        line.push(parameters[0])
+                        item_indices.push(it)
+                    elsif code == 356
+                        parameter = parameters[0]
+                        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[0] = translated unless translated.nil? || translated.empty?
+                    elsif code == 402
+                        parameter = parameters[1]
+                        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[1] = translated unless translated.nil? || translated.empty?
+                    elsif code == 102 && parameters[0].is_a?(Array)
+                        parameters[0].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[0][sp] = translated unless translated.nil? || translated.empty?
+                        end
+                    end
+
+                    item.parameters = parameters
                 end
             end
         end
@@ -265,25 +260,35 @@ 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]
 
-    allowed_codes = [401, 402, 405, 356, 102].freeze
+    # 401 - dialogue lines
+    # 405 - credits lines
+    # 102 - dialogue choices array
+    # 402 - one of the dialogue choices from the array
+    # 356 - system lines/special texts (do they even exist before mv?)
+    allowed_codes = [401, 405, 102, 402, 356].freeze
 
     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!
@@ -296,54 +301,110 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
             other_object_array.each do |object|
                 next if object.nil?
 
-                variables_symbols = %i[@name @nickname @description @note].freeze
+                name = object.name
+                nickname = object.nickname
+                description = object.description
+                note = object.note
+
+                [name, nickname, description, note].each_with_index do |variable, i|
+                    next unless variable.is_a?(String)
+
+                    variable = variable.strip
+                    next if variable.empty?
 
-                name = object.instance_variable_get(variables_symbols[0])
-                nickname = object.instance_variable_get(variables_symbols[1])
-                description = object.instance_variable_get(variables_symbols[2])
-                note = object.instance_variable_get(variables_symbols[3])
+                    variable = variable.gsub(/\r\n/, "\n")
 
-                [[variables_symbols[0], name],
-                 [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?
+                    translated = get_variable_translated(variable, other_translation_map, game_type)
+
+                    if i.zero?
+                        object.name = translated unless translated.nil? || translated.empty?
+                    elsif i == 1
+                        object.nickname = translated unless translated.nil? || translated.empty?
+                    elsif i == 2
+                        object.description = translated unless translated.nil? || translated.empty?
+                    else
+                        object.note = translated unless translated.nil? || translated.empty?
                     end
                 end
             end
         else
             other_object_array.each do |object|
-                pages = object.instance_variable_get(:@pages)
+                next if object.nil?
+
+                pages = object.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.list : pages[pg].instance_variable_get(:@list) # for some reason .list access doesn't work (wtf?)
                     next if list.nil?
 
-                    list.each do |item|
-                        code = item.instance_variable_get(:@code)
-                        next unless allowed_codes.include?(code)
+                    in_sequence = false
+                    line = []
+                    item_indices = []
 
-                        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?
+                    list.each_with_index do |item, it|
+                        code = item.code
+
+                        unless allowed_codes.include?(code)
+                            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('\#')
+
+                                    split_length = split.length
+                                    line_length = line.length
+
+                                    item_indices.each_with_index do |index, i|
+                                        list[index].parameters[0] = i < split_length ? split[i] : ''
                                     end
+
+                                    list[item_indices.last].parameters[0] = split[line_length..].join("\n") if split_length > line_length
                                 end
                             end
+                            next
                         end
 
-                        item.instance_variable_set(:@parameters, parameters)
+                        parameters = item.parameters
+
+                        if [401, 405].include?(code)
+                            next unless parameters[0].is_a?(String) && !parameters[0].empty?
+
+                            in_sequence = true
+                            line.push(parameters[0])
+                            item_indices.push(it)
+                        elsif code == 356
+                            parameter = parameters[0]
+                            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[0] = translated unless translated.nil? || translated.empty?
+                        elsif code == 402
+                            parameter = parameters[1]
+                            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[1] = translated unless translated.nil? || translated.empty?
+                        elsif code == 102 && parameters[0].is_a?(Array)
+                            parameters[0].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[0][sp] = translated unless translated.nil? || translated.empty?
+                            end
+                        end
+
+                        item.parameters = parameters
                     end
                 end
             end
@@ -355,24 +416,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.downcase.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!
@@ -381,123 +452,120 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
 
     system_translation_map = Hash[system_original_text.zip(system_translated_text)].freeze
 
-    system_symbols = %i[@elements @skill_types @weapon_types @armor_types @currency_unit @terms @words @game_title].freeze
-
-    elements = system_object.instance_variable_get(system_symbols[0])
-    skill_types = system_object.instance_variable_get(system_symbols[1])
-    weapon_types = system_object.instance_variable_get(system_symbols[2])
-    armor_types = system_object.instance_variable_get(system_symbols[3])
-    currency_unit = system_object.instance_variable_get(system_symbols[4])
-    terms = system_object.instance_variable_get(system_symbols[5]) || system_object.instance_variable_get(system_symbols[6])
+    elements = system_object.elements
+    skill_types = system_object.skill_types
+    weapon_types = system_object.weapon_types
+    armor_types = system_object.armor_types
+    currency_unit = system_object.currency_unit
+    terms = system_object.terms || system_object.words
 
     [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 }
-        system_object.instance_variable_set(system_symbols[i], array)
+        array.map! do |string|
+            stripped = string.strip
+            return string if stripped.empty?
+
+            translated = system_translation_map[stripped]
+            !translated.nil? && !translated.empty? ? translated : stripped
+        end
+
+        if i.zero?
+            system_object.elements = array
+        elsif i == 1
+            system_object.skill_types = array
+        elsif i == 2
+            system_object.weapon_types = array
+        else
+            system_object.armor_types = array
+        end
     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?
+    system_object.currency_unit = currency_unit_translated if currency_unit.is_a?(String) &&
+        (!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)
     end
 
-    system_object.instance_variable_defined?(system_symbols[5]) ?
-        system_object.instance_variable_set(system_symbols[5], terms) :
-        system_object.instance_variable_set(system_symbols[6], terms)
+    system_object.terms.nil? ?
+        system_object.words = terms :
+        system_object.terms = 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.game_title = 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 = []
 
+    # This code was fun before `that` game used Windows-1252 degree symbol
     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]
+        unless code.valid_encoding?
+            # who the fuck uses the degree symbol from FUCKING WINDOWS-1252 and NOT UTF-8
+            # also, String#encode does NOT FUCKING WORK and for some reason raises on the
+            # fucking degree symbol from windows-1252 when trying to encode
+            code.force_encoding('Windows-1252')
+        end
+
+        # 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")) - debug line
+    File.binwrite(File.join(output_path, scripts_basename), Marshal.dump(script_entries))
 end