rvpacker-txt 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b4214a5f31ca357f08bb57ab08a8fdfeeed37aff4674d73dc2c866bdb3f30e
-  data.tar.gz: d35c5da8a2755b486ef5b98f9c9091f682b8d3143f3dde0f2adafa4348fc71e7
+  metadata.gz: e3cdabd3e6867b3a5736a998345b2df35273565179c720c03acfb294bb121644
+  data.tar.gz: dd8ebfa554210a573d6aceef337ae4009759828a6fa53f5d19ad412c936165d0
 SHA512:
-  metadata.gz: db1067185a2c07d44c96393d9d4b1c63bd27d424d946558e23a9bd4c6f8f6a9f4961cbddba5f8ce32ac5d1074d15aa2cc6cf64a45d3a10400ac753cc8380b26d
-  data.tar.gz: 8a696a3a4cb22ac06425207218f8aedebbe1bc730fc36a474d589a6dd0d1b9c8320d270beb67235f7d75666caf35edc5fd7a83f5245ffe798aa76f50b29fa099
+  metadata.gz: 6146633f8ac594f5db5cdc7b9fd1914c3e011e242531f943c2dbcad48c00ee8bda79f06511db125e588be4cc6c6869e3c9bfccc24a7c1820418d4cd7688f5c6d
+  data.tar.gz: db7a233da1abe10a24c0c5180a06f022f46cf07685e33e3a7081ac8dc5082210c14042f7605482c7d5ad99a4efabad870a01c55e0efac3f3ec8249aec998d888

data/README.md

@@ -29,11 +29,16 @@ COMMANDS:
     read - Parses RPG Maker game files to .txt
     write - Writes parsed files back to their initial form
 OPTIONS:
-    -d, --input-dir DIR              Input directory of RPG Maker project
+    -i, --input-dir DIR              Input directory of RPG Maker project
+    -o, --output-dir DIR             Output directory of parsed/written files
         --disable-processing FILES   Don't process specified files (maps, other, system, plugins)
     -s, --shuffle NUM                Shuffle level (1: lines, 2: lines and words)
-        --disable-custom-parsing     Disables built-in custom parsing for some games
+        --disable_custom_processing  Disables built-in custom parsing/writing for some games
     -l, --log                        Log information while processing
+    -f, --force                      Force rewrite all files. Cannot be used with --append.
+                                     USE WITH CAUTION!
+    -a, --append                     When you update the rvpacker-txt, you probably should re-read your files with append, as some new text might be added to parser.
+                                     Cannot be used with --force
     -h, --help                       Show help message
 ```
 

data/bin/rvpacker-txt

@@ -34,14 +34,23 @@ def self.parse_options
             options[:shuffle_level] = num
         end
 
-        cmd.on('--disable-custom-parsing', 'Disables built-in custom parsing for some games') do
-            options[:disable_custom_parsing] = true
+        cmd.on('--disable_custom_processing', 'Disables built-in custom parsing/writing for some games') do
+            options[:disable_custom_processing] = true
         end
 
         cmd.on('-l', '--log', 'Log information while processing') do
             options[:logging] = true
         end
 
+        cmd.on('-f', '--force', 'Force rewrite all files. Cannot be used with --append.', 'USE WITH CAUTION!') do
+            options[:force] = true
+        end
+
+        cmd.on('-a', '--append', 'When you update the rvpacker-txt, you probably should re-read your files with append, as some new text might be added to parser.', 'Cannot be used with --force') do
+            raise '--append cannot be used beside --force.' if options[:force]
+            options[:append] = true
+        end
+
         cmd.on('-h', '--help', 'Show help message') do
             puts cmd
             exit
@@ -55,9 +64,7 @@ def self.parse_options
     options
 end
 
-def self.get_game_type(system_file_path, disable_custom_parsing)
-    return nil if disable_custom_parsing
-
+def self.get_game_type(system_file_path)
     object = Marshal.load(File.binread(system_file_path))
     game_title = object.instance_variable_get(:@game_title).to_s.downcase
     game_title.include?('lisa') ? 'lisa' : nil
@@ -68,10 +75,12 @@ start_time = Time.now
 options = parse_options
 input_dir = options[:input_dir]
 output_dir = options[:output_dir]
-disable_custom_parsing = options[:disable_custom_parsing]
+disable_custom_processing = options[:disable_custom_processing]
 shuffle_level = options[:shuffle_level]
 logging = options[:logging]
 disable_processing = options[:disable_processing]
+force = options[:force]
+append = options[:append]
 
 extensions = { xp: '.rxdata', vx: 'rvdata', ace: 'rvdata2' }
 
@@ -94,37 +103,57 @@ end || (raise "Couldn't determine project engine.")
 
 files = Dir.glob("#{paths[:original_path]}/*#{extensions[engine]}")
 
-maps_files = []
-other_files = []
-system_file = nil
-scripts_file = nil
+maps_files_paths = []
+other_files_paths = []
+system_file_path = nil
+scripts_file_path = nil
 
 files.each do |file|
     basename = File.basename(file)
 
     if basename.start_with?(/Map[0-9]/)
-        maps_files.push(file)
+        maps_files_paths.push(file)
     elsif !basename.start_with?(/Map|Tilesets|Animations|System|Scripts|Areas/)
-        other_files.push(file)
+        other_files_paths.push(file)
     elsif basename.start_with?('System')
-        system_file = file
+        system_file_path = file
     elsif basename.start_with?('Scripts')
-        scripts_file = file
+        scripts_file_path = file
     end
 end
 
-game_type = get_game_type(system_file, disable_custom_parsing)
+ini_file_path = File.join(input_dir, "Game.ini")
+
+game_type = disable_custom_processing ? nil : get_game_type(system_file_path)
+
+wait_time = 0
+processing_type = if force
+                      wait_time_start = Time.now
+
+                      puts "WARNING! You\'re about to forcefully rewrite all your translation files, including _trans files.\nIf you really want to do it, make sure you've made a backup of your _trans files, if you made some changes in them already.\nInput 'Y' to continue."
+                      exit unless gets.chomp == 'Y'
+
+                      wait_time = Time.now - wait_time_start
+                      'force'
+                  else
+                      append ? 'append' : 'default'
+                  end
+
+puts 'Custom processing for this game is enabled. Use --disable-custom-processing to disable it.' unless game_type.nil?
 
 if options[:action] == 'read'
-    read_map(maps_files, paths[:maps_path], logging, game_type) unless disable_processing[0]
-    read_other(other_files, paths[:other_path], logging, game_type) unless disable_processing[1]
-    read_system(system_file, paths[:other_path], logging) unless disable_processing[2]
-    read_scripts(scripts_file, paths[:other_path], logging) unless disable_processing[3]
+    read_map(maps_files_paths, paths[:maps_path], logging, game_type, processing_type) unless disable_processing[0]
+    read_other(other_files_paths, paths[:other_path], logging, game_type, processing_type) unless disable_processing[1]
+    read_system(system_file_path, ini_file_path, paths[:other_path], logging, processing_type) unless disable_processing[2]
+    read_scripts(scripts_file_path, paths[:other_path], logging, processing_type) unless disable_processing[3]
 else
-    write_map(maps_files, paths[:maps_path], paths[:output_path], shuffle_level, logging, game_type) unless disable_processing[0]
-    write_other(other_files, paths[:other_path], paths[:output_path], shuffle_level, logging, game_type) unless disable_processing[1]
-    write_system(system_file, paths[:other_path], paths[:output_path], shuffle_level, logging) unless disable_processing[2]
-    write_scripts(scripts_file, paths[:other_path], paths[:output_path], logging) unless disable_processing[3]
+    write_map(maps_files_paths, paths[:maps_path], paths[:output_path], shuffle_level, logging, game_type, processing_type) unless disable_processing[0]
+    write_other(other_files_paths, paths[:other_path], paths[:output_path], shuffle_level, logging, game_type, processing_type) unless disable_processing[1]
+    write_system(system_file_path, ini_file_path, paths[:other_path], paths[:output_path], shuffle_level, logging, processing_type) unless disable_processing[2]
+    write_scripts(scripts_file_path, paths[:other_path], paths[:output_path], logging, processing_type) unless disable_processing[3]
 end
 
-puts "Done in #{Time.now - start_time}"
+$wait_time = 0 if $wait_time.nil?
+end_time = Time.now - start_time - wait_time - $wait_time
+
+puts "Done in #{end_time}"

data/lib/classes.rb

@@ -77,7 +77,7 @@ class Rect
 end
 
 # Fuck using an array with set, that's just straight dumb and not efficient
-class IndexedSet
+class IndexSet
     def initialize
         @hash = Hash.new
     end

data/lib/read.rb

@@ -2,26 +2,41 @@
 
 require 'zlib'
 
+def self.insert_at_index(hash, index, key, value)
+    return hash[key] = value if index >= hash.size
+
+    temp_hash = hash.to_a
+    temp_hash.insert(index, [key, value])
+    hash.clear
+    hash.merge!(temp_hash.to_h)
+end
+
 def self.extract_quoted_strings(string)
-    result = []
+    # Hash of string-index key-value pairs
+    result = {}
 
     skip_block = false
     in_quotes = false
     quote_type = nil
     buffer = []
 
-    string.each_line(chomp: true) do |line|
-        line.strip!
-        next if line[0] == '#' || line.start_with?(/(Win|Lose)|_Fanfare/)
+    # 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/)
+            next
+        end
 
-        skip_block = true if line.start_with?('=begin')
-        skip_block = false if line.start_with?('=end')
+        skip_block = true if stripped.start_with?('=begin')
+        skip_block = false if stripped.start_with?('=end')
 
         next if skip_block
 
         buffer.push('\#') if in_quotes
 
-        line.each_char do |char|
+        line.each_char.each_with_index do |char, index|
             if %w[' "].include?(char)
                 unless quote_type.nil? || char == quote_type
                     buffer.push(char)
@@ -30,7 +45,7 @@ def self.extract_quoted_strings(string)
 
                 quote_type = char
                 in_quotes = !in_quotes
-                result.push(buffer.join)
+                result[buffer.join] = current_string_index + index
                 buffer.clear
                 next
             end
@@ -39,6 +54,8 @@ def self.extract_quoted_strings(string)
                 buffer.push(char)
             end
         end
+
+        current_string_index += line.length
     end
 
     result
@@ -54,7 +71,9 @@ def self.parse_parameter(code, parameter, game_type)
                 else
                     nil
             end
-        when 102, 356
+        when 102
+            # Implement some custom parsing
+        when 356
             # Implement some custom parsing
         else
             return nil
@@ -80,16 +99,47 @@ def self.parse_variable(variable, game_type)
     variable
 end
 
-def self.read_map(original_map_files, output_path, logging, game_type)
-    maps_object_map = Hash[original_map_files.map do |filename|
+def self.read_map(maps_files, output_path, logging, game_type, processing_type)
+    maps_output_path = File.join(output_path, 'maps.txt')
+    names_output_path = File.join(output_path, 'names.txt')
+    maps_trans_output_path = File.join(output_path, 'maps_trans.txt')
+    names_trans_output_path = File.join(output_path, 'names_trans.txt')
+
+    if processing_type == 'default' && (File.exist?(maps_trans_output_path) || File.exist?(names_trans_output_path))
+        puts 'maps_trans.txt or names_trans.txt file already exists. If you want to forcefully re-read all files, use --force flag, or --append if you want append new text to already existing files.'
+        return
+    end
+
+    maps_object_map = Hash[maps_files.map do |filename|
         [File.basename(filename), Marshal.load(File.binread(filename))]
     end]
 
-    maps_lines = [IndexedSet.new, IndexedSet.new]
+    maps_lines = IndexSet.new
+    names_lines = IndexSet.new
+
+    maps_translation_map = nil
+    names_translation_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(maps_trans_output_path)
+            maps_translation_map = Hash[File.readlines(maps_output_path, chomp: true).zip(File.readlines(maps_trans_output_path, chomp: true))]
+            names_translation_map = Hash[File.readlines(names_output_path, chomp: true).zip(File.readlines(names_trans_output_path, chomp: true))]
+        else
+            puts "Files aren't already parsed. Continuing as if --append flag was omitted."
+            processing_type = 'default'
+        end
+    end
 
     maps_object_map.each do |filename, object|
         display_name = object.instance_variable_get(:@display_name)
-        maps_lines[1].add(display_name) if display_name.is_a?(String) && !display_name.empty?
+
+        if display_name.is_a?(String) && !display_name.empty?
+            if processing_type == 'append' && !names_translation_map.include?(display_name)
+                insert_at_index(names_translation_map, names_lines.length, display_name, '')
+            end
+
+            names_lines.add(display_name)
+        end
 
         events = object.instance_variable_get(:@events)
         next if events.nil?
@@ -113,12 +163,20 @@ def self.read_map(original_map_files, output_path, logging, game_type)
                         if code == 401
                             if parameter.is_a?(String) && !parameter.empty?
                                 in_sequence = true
+
                                 parsed = parse_parameter(code, parameter, game_type)
                                 line.push(parsed) unless parsed.nil?
                             end
                         else
                             if in_sequence
-                                maps_lines[0].add(line.join('\#'))
+                                joined = line.join('\#')
+
+                                if processing_type == 'append' && !maps_translation_map.include?(joined)
+                                    insert_at_index(maps_translation_map, maps_lines.length, joined, '')
+                                end
+
+                                maps_lines.add(joined)
+
                                 line.clear
                                 in_sequence = false
                             end
@@ -127,12 +185,28 @@ def self.read_map(original_map_files, output_path, logging, game_type)
                                 parameter.each do |subparameter|
                                     if subparameter.is_a?(String) && !subparameter.empty?
                                         parsed = parse_parameter(code, subparameter, game_type)
-                                        maps_lines[0].add(parsed) unless parsed.nil?
+
+                                        unless parsed.nil?
+                                            if processing_type == 'append' && !maps_translation_map.include?(parsed)
+                                                insert_at_index(maps_translation_map, maps_lines.length, parsed, '')
+                                            end
+
+                                            maps_lines.add(parsed)
+                                        end
                                     end
                                 end
                             elsif code == 356 && parameter.is_a?(String) && !parameter.empty?
                                 parsed = parse_parameter(code, parameter, game_type)
-                                maps_lines[0].add(parsed.gsub(/\r?\n/, '\#')) unless parsed.nil?
+
+                                unless parsed.nil?
+                                    subbed = parsed.gsub(/\r?\n/, '\#')
+
+                                    if processing_type == 'append' && !maps_translation_map.include?(parsed)
+                                        insert_at_index(maps_translation_map, maps_lines.length, parsed, '')
+                                    end
+
+                                    maps_lines.add(subbed)
+                                end
                             end
                         end
                     end
@@ -143,14 +217,29 @@ def self.read_map(original_map_files, output_path, logging, game_type)
         puts "Parsed #{filename}" if logging
     end
 
-    File.binwrite("#{output_path}/maps.txt", maps_lines[0].join("\n"))
-    File.binwrite("#{output_path}/maps_trans.txt", "\n" * (maps_lines[0].empty? ? 0 : maps_lines[0].length - 1))
-    File.binwrite("#{output_path}/names.txt", maps_lines[1].join("\n"))
-    File.binwrite("#{output_path}/names_trans.txt", "\n" * (maps_lines[1].empty? ? 0 : maps_lines[1].length - 1))
+    maps_original_content,
+        maps_translated_content,
+        names_original_content,
+        names_translated_content = if processing_type == 'append'
+                                       [maps_translation_map.keys.join("\n"),
+                                        maps_translation_map.values.join("\n"),
+                                        names_translation_map.keys.join("\n"),
+                                        names_translation_map.values.join("\n")]
+                                   else
+                                       [maps_lines.join("\n"),
+                                        "\n" * (maps_lines.empty? ? 0 : maps_lines.length - 1),
+                                        names_lines.join("\n"),
+                                        "\n" * (names_lines.empty? ? 0 : names_lines.length - 1)]
+                                   end
+
+    File.binwrite(maps_output_path, maps_original_content)
+    File.binwrite(maps_trans_output_path, maps_translated_content)
+    File.binwrite(names_output_path, names_original_content)
+    File.binwrite(names_trans_output_path, names_translated_content)
 end
 
-def self.read_other(original_other_files, output_path, logging, game_type)
-    other_object_array_map = Hash[original_other_files.map do |filename|
+def self.read_other(other_files, output_path, logging, game_type, processing_type)
+    other_object_array_map = Hash[other_files.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/)
@@ -158,9 +247,31 @@ def self.read_other(original_other_files, output_path, logging, game_type)
         [basename, object]
     end]
 
+    internal_processing_type = processing_type
+
     other_object_array_map.each do |filename, other_object_array|
         processed_filename = File.basename(filename, '.*').downcase
-        other_lines = IndexedSet.new
+
+        other_output_path = File.join(output_path, "#{processed_filename}.txt")
+        other_trans_output_path = File.join(output_path, "#{processed_filename}_trans.txt")
+
+        if processing_type == 'default' && File.exist?(other_trans_output_path)
+            puts "#{processed_filename}_trans.txt file already exists. If you want to forcefully re-read all files, use --force flag, or --append if you want append new text to already existing files."
+            next
+        end
+
+        other_lines = IndexSet.new
+        other_translation_map = nil
+
+        if processing_type == 'append'
+            if File.exist?(other_trans_output_path)
+                internal_processing_type == 'append'
+                other_translation_map = Hash[File.readlines(other_output_path, chomp: true).zip(File.readlines(other_trans_output_path, chomp: true))]
+            else
+                puts "Files aren't already parsed. Continuing as if --append flag was omitted."
+                internal_processing_type = 'default'
+            end
+        end
 
         if !filename.start_with?(/Common|Troops/)
             other_object_array.each do |object|
@@ -172,7 +283,14 @@ def self.read_other(original_other_files, output_path, logging, game_type)
                 [name, nickname, description, note].each do |variable|
                     if variable.is_a?(String) && !variable.empty?
                         parsed = parse_variable(variable, game_type)
-                        other_lines.add(parsed) unless parsed.nil?
+
+                        unless parsed.nil?
+                            if internal_processing_type == 'append' && !other_translation_map.include?(parsed)
+                                insert_at_index(other_translation_map, other_lines.length, parsed, '')
+                            end
+
+                            other_lines.add(parsed)
+                        end
                     end
                 end
             end
@@ -198,7 +316,14 @@ def self.read_other(original_other_files, output_path, logging, game_type)
                                 line.push(parameter.gsub(/\r?\n/, '\#')) if parameter.is_a?(String) && !parameter.empty?
                             else
                                 if in_sequence
-                                    other_lines.add(line.join('\#'))
+                                    joined = line.join('\#')
+
+                                    if internal_processing_type == 'append' && !other_translation_map.include?(joined)
+                                        insert_at_index(other_translation_map, other_lines.length, joined, '')
+                                    end
+
+                                    other_lines.add(joined)
+
                                     line.clear
                                     in_sequence = false
                                 end
@@ -207,12 +332,25 @@ def self.read_other(original_other_files, output_path, logging, game_type)
                                     when 102
                                         if parameter.is_a?(Array)
                                             parameter.each do |subparameter|
-                                                other_lines.add(subparameter) if subparameter.is_a?(String) && !subparameter.empty?
+                                                if subparameter.is_a?(String) && !subparameter.empty?
+                                                    if internal_processing_type == 'append' && !other_translation_map.include?(subparameter)
+                                                        insert_at_index(other_translation_map, other_lines.length, subparameter, '')
+                                                    end
+
+                                                    other_lines.add(subparameter)
+                                                end
                                             end
                                         end
                                     when 356
-                                        other_lines.add(parameter.gsub(/\r?\n/, '\#')) if parameter.is_a?(String) &&
-                                            !parameter.empty?
+                                        if parameter.is_a?(String) && !parameter.empty?
+                                            subbed = parameter.gsub(/\r?\n/, '\#')
+
+                                            if internal_processing_type == 'append'
+                                                insert_at_index(other_translation_map, other_lines.length, subbed, '')
+                                            end
+
+                                            other_lines.add(subbed)
+                                        end
                                     else
                                         nil
                                 end
@@ -225,17 +363,52 @@ def self.read_other(original_other_files, output_path, logging, game_type)
 
         puts "Parsed #{filename}" if logging
 
-        File.binwrite("#{output_path}/#{processed_filename}.txt", other_lines.join("\n"))
-        File.binwrite("#{output_path}/#{processed_filename}_trans.txt", "\n" * (other_lines.empty? ? 0 : other_lines.length - 1))
+        original_content, translated_content = if processing_type == 'append'
+                                                   [other_translation_map.keys.join("\n"), other_translation_map.values.join("\n")]
+                                               else
+                                                   [other_lines.join("\n"), "\n" * (other_lines.empty? ? 0 : other_lines.length - 1)]
+                                               end
+
+        File.binwrite(other_output_path, original_content)
+        File.binwrite(other_trans_output_path, translated_content)
     end
 end
 
-def self.read_system(system_file_path, output_path, logging)
+def self.read_system(system_file_path, ini_file_path, output_path, logging, processing_type)
+    def self.read_ini_title(ini_file_path)
+        file_lines = File.readlines(ini_file_path, chomp: true)
+        file_lines.each do |line|
+            if line.start_with?('title')
+                parts = line.partition('=')
+                break parts[2].strip
+            end
+        end
+    end
+
     system_filename = File.basename(system_file_path)
     system_basename = File.basename(system_file_path, '.*').downcase
+
+    system_output_path = File.join(output_path, "#{system_basename}.txt")
+    system_trans_output_path = File.join(output_path, "#{system_basename}_trans.txt")
+
+    if processing_type == 'default' && File.exist?(system_trans_output_path)
+        puts "system_trans.txt file already exists. If you want to forcefully re-read all files, use --force flag, or --append if you want append new text to already existing files."
+        return
+    end
+
     system_object = Marshal.load(File.binread(system_file_path))
 
-    system_lines = IndexedSet.new
+    system_lines = IndexSet.new
+    system_translation_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(system_trans_output_path)
+            system_translation_map = Hash[File.readlines(system_output_path, chomp: true).zip(File.readlines(system_trans_output_path, chomp: true))]
+        else
+            puts "Files aren't already parsed. Continuing as if --append flag was omitted."
+            processing_type = 'default'
+        end
+    end
 
     elements = system_object.instance_variable_get(:@elements)
     skill_types = system_object.instance_variable_get(:@skill_types)
@@ -247,40 +420,133 @@ def self.read_system(system_file_path, output_path, logging)
 
     [elements, skill_types, weapon_types, armor_types].each do |array|
         next if array.nil?
-        array.each { |string| system_lines.add(string) if string.is_a?(String) && !string.empty? }
+
+        array.each do |string|
+            if string.is_a?(String) && !string.empty?
+                if processing_type == 'append' && !system_translation_map.include?(string)
+                    insert_at_index(system_translation_map, system_lines.length, string, '')
+                end
+
+                system_lines.add(string)
+            end
+        end
     end
 
-    system_lines.add(currency_unit) if currency_unit.is_a?(String) && !currency_unit.empty?
+    if currency_unit.is_a?(String) && !currency_unit.empty?
+        if processing_type == 'append' && !system_translation_map.include?(currency_unit)
+            insert_at_index(system_translation_map, system_lines.length, currency_unit, '')
+        end
+
+        system_lines.add(currency_unit)
+    end
 
     terms.instance_variables.each do |variable|
         value = terms.instance_variable_get(variable)
 
         if value.is_a?(String)
-            system_lines.add(value) unless value.empty?
+            unless value.empty?
+                if processing_type == 'append' && !system_translation_map.include?(value)
+                    insert_at_index(system_translation_map, system_lines.length, value, '')
+                end
+
+                system_lines.add(value)
+            end
+
             next
         end
 
-        value.each { |string| system_lines.add(string) if string.is_a?(String) && !string.empty? }
+        value.each do |string|
+            if string.is_a?(String) && !string.empty?
+                if processing_type == 'append' && !system_translation_map.include?(string)
+                    insert_at_index(system_translation_map, system_lines.length, string, '')
+                end
+
+                system_lines.add(string)
+            end
+        end
     end
 
-    system_lines.add(game_title) if game_title.is_a?(String) && !game_title.empty?
+    ini_game_title = read_ini_title(ini_file_path)
+
+    $wait_time = 0
+
+    if ini_game_title != game_title
+        if game_title.is_a?(String) && !game_title.empty?
+            wait_time_start = Time.now
+
+            puts "Game title from the Game.ini file and game title from the System file are different.\nWhich game title would you like to parse?\n(That doesn't affect anything major, just when you'll write the game back, translated game title will be applied both to the .ini and System file.)\n0, System title - #{game_title}\n1, Game.ini title - #{ini_game_title}"
+            choice = gets.chomp.to_i
+
+            $wait_time = Time.now - wait_time_start
+
+            if choice == 0
+                if processing_type == 'append' && !system_translation_map.include?(game_title)
+                    insert_at_index(system_translation_map, system_lines.length, game_title, '')
+                end
+
+                system_lines.add(game_title)
+            else
+                if processing_type == 'append' && !system_translation_map.include?(ini_game_title)
+                    insert_at_index(system_translation_map, system_lines.length, ini_game_title, '')
+                end
+
+                system_lines.add(ini_game_title)
+            end
+        else
+            if processing_type == 'append' && !system_translation_map.include?(ini_game_title)
+                insert_at_index(system_translation_map, system_lines.length, ini_game_title, '')
+            end
+
+            system_lines.add(ini_game_title)
+        end
+    end
 
     puts "Parsed #{system_filename}" if logging
 
-    File.binwrite("#{output_path}/#{system_basename}.txt", system_lines.join("\n"))
-    File.binwrite("#{output_path}/#{system_basename}_trans.txt", "\n" * (system_lines.empty? ? 0 : system_lines.length - 1))
+    original_content, translated_content = if processing_type == 'append'
+                                               [system_translation_map.keys.join("\n"), system_translation_map.values.join("\n")]
+                                           else
+                                               [system_lines.join("\n"), "\n" * (system_lines.empty? ? 0 : system_lines.length - 1)]
+                                           end
+
+    File.binwrite(system_output_path, original_content)
+    File.binwrite(system_trans_output_path, translated_content)
 end
 
-def self.read_scripts(scripts_file_path, output_path, logging)
+def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
+    scripts_filename = File.basename(scripts_file_path)
+    scripts_basename = File.basename(scripts_file_path, '.*').downcase
+
+    scripts_plain_output_path = File.join(output_path, "#{scripts_basename}_plain.txt")
+    scripts_output_path = File.join(output_path, "#{scripts_basename}.txt")
+    scripts_trans_output_path = File.join(output_path, "#{scripts_basename}_trans.txt")
+
+    if processing_type == 'default' && File.exist?(scripts_trans_output_path)
+        puts "scripts_trans.txt file already exists. If you want to forcefully re-read all files, use --force flag, or --append if you want append new text to already existing files."
+        return
+    end
+
     script_entries = Marshal.load(File.binread(scripts_file_path))
-    scripts_lines = IndexedSet.new
+
+    scripts_lines = IndexSet.new
+    scripts_translation_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(scripts_trans_output_path)
+            scripts_translation_map = Hash[File.readlines(scripts_output_path, chomp: true).zip(File.readlines(scripts_trans_output_path, chomp: true))]
+        else
+            puts "Files aren't already parsed. Continuing as if --append flag was omitted."
+            processing_type = 'default'
+        end
+    end
+
     codes_content = []
 
     script_entries.each do |script|
         code = Zlib::Inflate.inflate(script[2]).force_encoding('UTF-8')
         codes_content.push(code)
 
-        extract_quoted_strings(code).each do |string|
+        extract_quoted_strings(code).keys.each do |string|
             string.strip!
 
             # Removes the U+3000 Japanese typographical space to check if string, when stripped, is truly empty
@@ -329,13 +595,24 @@ def self.read_scripts(scripts_file_path, output_path, logging)
                 string.match?(/Clear image/) ||
                 string.match?(/Can Collapse/)
 
+            if processing_type == 'append' && !scripts_translation_map.include?(string)
+                insert_at_index(scripts_translation_map, scripts_lines.length, string, '')
+            end
+
             scripts_lines.add(string)
         end
     end
 
-    puts "Parsed #{File.basename(scripts_file_path)}" if logging
+    puts "Parsed #{scripts_filename}" if logging
 
-    File.binwrite("#{output_path}/scripts_plain.txt", codes_content.join("\n"))
-    File.binwrite("#{output_path}/scripts.txt", scripts_lines.join("\n"))
-    File.binwrite("#{output_path}/scripts_trans.txt", "\n" * (scripts_lines.empty? ? 0 : scripts_lines.length - 1))
-end
+    File.binwrite(scripts_plain_output_path, codes_content.join("\n"))
+
+    original_content, translated_content = if processing_type == 'append'
+                                               [scripts_translation_map.keys.join("\n"), scripts_translation_map.values.join("\n")]
+                                           else
+                                               [scripts_lines.join("\n"), "\n" * (scripts_lines.empty? ? 0 : scripts_lines.length - 1)]
+                                           end
+
+    File.binwrite(scripts_output_path, original_content)
+    File.binwrite(scripts_trans_output_path, translated_content)
+end

data/lib/write.rb

@@ -2,17 +2,61 @@
 
 require 'zlib'
 
-def self.shuffle_words(array)
-    array.map do |string|
-        re = /\S+/
-        words = string.scan(re)
-        shuffled = words.shuffle
-
-        (0..(words.length)).each do |i|
-            string.sub!(words[i], shuffled[i])
+def self.extract_quoted_strings(string)
+    # Hash of string-index key-value pairs
+    result = {}
+
+    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/)
+            next
         end
 
-        string
+        skip_block = true if stripped.start_with?('=begin')
+        skip_block = false if stripped.start_with?('=end')
+
+        next if skip_block
+
+        buffer.push('\#') if in_quotes
+
+        line.each_char.each_with_index do |char, index|
+            if %w[' "].include?(char)
+                unless quote_type.nil? || char == quote_type
+                    buffer.push(char)
+                    next
+                end
+
+                quote_type = char
+                in_quotes = !in_quotes
+                result[buffer.join] = current_string_index + index
+                buffer.clear
+                next
+            end
+
+            if in_quotes
+                buffer.push(char)
+            end
+        end
+
+        current_string_index += line.length
+    end
+
+    result
+end
+
+def shuffle_words(array)
+    array.each do |string|
+        words = string.scan(/\S+/)
+        shuffled_words = words.shuffle
+        string.gsub(/\S+/) { shuffled_words.pop || "" }
     end
 end
 
@@ -103,7 +147,7 @@ def self.get_parameter_translated(code, parameter, hashmap, game_type)
     lisa_start = nil
 
     case code
-        when 401, 356, 405
+        when 401, 405
             case game_type
                 when 'lisa'
                     match = parameter.scan(/^(\\et\[[0-9]+\]|\\nbt)/)
@@ -113,7 +157,9 @@ def self.get_parameter_translated(code, parameter, hashmap, game_type)
                     nil
             end
         when 102, 402
-            nil
+            # Implement some custom parsing
+        when 356
+            # Implement some custom parsing
         else
             nil
     end
@@ -309,7 +355,17 @@ def self.write_other(original_files, other_path, output_path, shuffle_level, log
     end
 end
 
-def self.write_system(system_file_path, other_path, output_path, shuffle_level, logging)
+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)
+    end
+
     system_basename = File.basename(system_file_path)
     system_object = Marshal.load(File.binread(system_file_path))
 
@@ -333,7 +389,6 @@ def self.write_system(system_file_path, other_path, output_path, shuffle_level,
     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])
-    game_title = system_object.instance_variable_get(system_symbols[7])
 
     [elements, skill_types, weapon_types, armor_types].each_with_index.each do |array, i|
         next unless array.is_a?(Array)
@@ -363,20 +418,19 @@ def self.write_system(system_file_path, other_path, output_path, shuffle_level,
         system_object.instance_variable_set(system_symbols[5], terms) :
         system_object.instance_variable_set(system_symbols[6], terms)
 
-    game_title_translated = system_translation_map[game_title]
+    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?
 
+    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))
 end
 
-def self.write_scripts(scripts_file, other_path, output_path, logging)
-    scripts_basename = File.basename(scripts_file)
-    script_entries = Marshal.load(File.binread(scripts_file))
-
-    scripts_original_text = File.readlines("#{other_path}/scripts.txt", encoding: 'UTF-8', chomp: true)
-                                .map { |line| line.gsub('\#', "\r\n") }
+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)
                                   .map { |line| line.gsub('\#', "\r\n") }
@@ -386,10 +440,58 @@ def self.write_scripts(scripts_file, other_path, output_path, logging)
     script_entries.each do |script|
         code = Zlib::Inflate.inflate(script[2]).force_encoding('UTF-8')
 
-        scripts_original_text.zip(scripts_translated_text).each do |original, translated|
-            # That may possibly break something, but until it does, who cares
-            # Honestly, it needs to be changed to find quoted strings like in `extract_quoted_strings` method
-            code.gsub!(original, translated) unless translated.nil?
+        (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]
         end
 
         script[2] = Zlib::Deflate.deflate(code, Zlib::BEST_COMPRESSION)

data/rvpacker-txt.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
     spec.name = 'rvpacker-txt'
-    spec.version = '1.4.0'
+    spec.version = '1.5.1'
     spec.authors = ['Howard Jeng', 'Andrew Kesterson', 'Solistra', 'Darkness9724', 'savannstm']
     spec.email = ['savannstm@gmail.com']
     spec.summary = 'Reads or writes RPG Maker XP/VX/VXAce game text to .txt files'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rvpacker-txt
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Howard Jeng
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-13 00:00:00.000000000 Z
 dependencies: []
 description:
 email: