rvpacker-txt 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b4214a5f31ca357f08bb57ab08a8fdfeeed37aff4674d73dc2c866bdb3f30e
-  data.tar.gz: d35c5da8a2755b486ef5b98f9c9091f682b8d3143f3dde0f2adafa4348fc71e7
+  metadata.gz: 2b69421e26d7a2a85ce60f482712d941e23946887a3e9b8640752dd4441b4cea
+  data.tar.gz: 66fdd2d16bbd06ae1210105684805c9ec4a2beefef7f859568ae1faa37f6051e
 SHA512:
-  metadata.gz: db1067185a2c07d44c96393d9d4b1c63bd27d424d946558e23a9bd4c6f8f6a9f4961cbddba5f8ce32ac5d1074d15aa2cc6cf64a45d3a10400ac753cc8380b26d
-  data.tar.gz: 8a696a3a4cb22ac06425207218f8aedebbe1bc730fc36a474d589a6dd0d1b9c8320d270beb67235f7d75666caf35edc5fd7a83f5245ffe798aa76f50b29fa099
+  metadata.gz: '068699415ee5fe5faa764a20f66f60b6d359610503aff909dda3b62b42f78c83abfe7e5049cc8aab03b7c4e5f3ff3e77a879ff43f6a059ad021bb97beed0d74d'
+  data.tar.gz: e78c574fcf21bef8a4216f856ceeea67481281fe20047e78fd7a007c2b274e2e525a5a84a98c7bfcc1db8e4113c11b71837f6cd3f756002fde0c1ad4321811e3

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,40 @@
 
 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/)
+    current_string_index = 0
+    string.each_line do |line|
+        stripped = line.strip
 
-        skip_block = true if line.start_with?('=begin')
-        skip_block = false if line.start_with?('=end')
+        if stripped[0] == '#' || stripped.start_with?(/(Win|Lose)|_Fanfare/)
+            next
+        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 +44,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 +53,8 @@ def self.extract_quoted_strings(string)
                 buffer.push(char)
             end
         end
+
+        current_string_index += line.length
     end
 
     result
@@ -80,16 +96,54 @@ 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.txt or maps_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 = nil
+
+    maps_trans_map = nil
+    names_trans_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(maps_trans_output_path)
+            maps_trans_map = Hash[File.readlines(maps_output_path, chomp: true).zip(File.readlines(maps_trans_output_path, chomp: true))]
+            names_trans_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'
+            maps_lines = [IndexSet.new, IndexSet.new]
+        end
+    else
+        maps_lines = [IndexSet.new, IndexSet.new]
+    end
+
+    hash_index = 0
+    names_hash_index = 0
 
     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'
+                insert_at_index(names_trans_map, names_hash_index, display_name, '') unless names_trans_map.include?(display_name)
+            else
+                maps_lines[1].add(display_name)
+            end
+
+            names_hash_index += 1
+        end
 
         events = object.instance_variable_get(:@events)
         next if events.nil?
@@ -113,26 +167,56 @@ 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'
+                                    insert_at_index(maps_trans_map, hash_index, joined, '') unless maps_trans_map.include?(joined)
+                                else
+                                    maps_lines[0].add(joined)
+                                end
+
                                 line.clear
                                 in_sequence = false
+
+                                hash_index += 1
                             end
 
                             if code == 102 && parameter.is_a?(Array)
                                 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'
+                                                insert_at_index(maps_trans_map, hash_index, parsed, '') unless maps_trans_map.include?(parsed)
+                                            else
+                                                maps_lines[0].add(parsed)
+                                            end
+
+                                            hash_index += 1
+                                        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'
+                                        insert_at_index(maps_trans_map, hash_index, parsed, '') unless maps_trans_map.include?(parsed)
+                                    else
+                                        maps_lines[0].add(subbed)
+                                    end
+
+                                    hash_index += 1
+                                end
                             end
                         end
                     end
@@ -143,14 +227,21 @@ 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))
+    if processing_type == 'append'
+        File.binwrite(maps_output_path, maps_trans_map.keys.join("\n"))
+        File.binwrite(maps_trans_output_path, maps_trans_map.values.join("\n"))
+        File.binwrite(names_output_path, names_trans_map.keys.join("\n"))
+        File.binwrite(names_trans_output_path, names_trans_map.values.join("\n"))
+    else
+        File.binwrite(maps_output_path, maps_lines[0].join("\n"))
+        File.binwrite(maps_trans_output_path, "\n" * (maps_lines[0].empty? ? 0 : maps_lines[0].length - 1))
+        File.binwrite(names_output_path, maps_lines[1].join("\n"))
+        File.binwrite(names_trans_output_path, "\n" * (maps_lines[1].empty? ? 0 : maps_lines[1].length - 1))
+    end
 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,11 +249,37 @@ 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 = nil
+        other_trans_map = nil
+
+        if processing_type == 'append'
+            if File.exist?(other_trans_output_path)
+                internal_processing_type == 'append'
+                other_trans_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'
+                other_lines = IndexSet.new
+            end
+        else
+            other_lines = IndexSet.new
+        end
 
         if !filename.start_with?(/Common|Troops/)
+            hash_index = 0
             other_object_array.each do |object|
                 name = object.instance_variable_get(:@name)
                 nickname = object.instance_variable_get(:@nickname)
@@ -172,11 +289,21 @@ 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'
+                                insert_at_index(other_trans_map, hash_index, parsed, '') unless other_trans_map.include?(parsed)
+                            else
+                                other_lines.add(parsed)
+                            end
+
+                            hash_index += 1
+                        end
                     end
                 end
             end
         else
+            hash_index = 0
             other_object_array.each do |object|
                 pages = object.instance_variable_get(:@pages)
                 pages_length = pages.nil? ? 1 : pages.length
@@ -198,21 +325,47 @@ 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'
+                                        insert_at_index(other_trans_map, hash_index, joined, '') unless other_trans_map.include?(joined)
+                                    else
+                                        other_lines.add(joined)
+                                    end
+
                                     line.clear
                                     in_sequence = false
+
+                                    hash_index += 1
                                 end
 
                                 case code
                                     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'
+                                                        insert_at_index(other_trans_map, hash_index, subparameter, '') unless other_trans_map.include?(subparameter)
+                                                    else
+                                                        other_lines.add(subparameter)
+                                                    end
+
+                                                    hash_index += 1
+                                                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_trans_map, hash_index, subbed, '')
+                                            else
+                                                other_lines.add(subbed)
+                                            end
+
+                                            hash_index += 1
+                                        end
                                     else
                                         nil
                                 end
@@ -225,17 +378,54 @@ 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))
+        if processing_type == 'append'
+            File.binwrite(other_output_path, other_trans_map.keys.join("\n"))
+            File.binwrite(other_trans_output_path, other_trans_map.values.join("\n"))
+        else
+            File.binwrite(other_output_path, other_lines.join("\n"))
+            File.binwrite(other_trans_output_path, "\n" * (other_lines.empty? ? 0 : other_lines.length - 1))
+        end
     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 = nil
+    system_trans_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(system_trans_output_path)
+            system_trans_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.'
+            system_lines = IndexSet.new
+            processing_type = 'default'
+        end
+    else
+        system_lines = IndexSet.new
+    end
 
     elements = system_object.instance_variable_get(:@elements)
     skill_types = system_object.instance_variable_get(:@skill_types)
@@ -245,42 +435,151 @@ def self.read_system(system_file_path, output_path, logging)
     terms = system_object.instance_variable_get(:@terms) || system_object.instance_variable_get(:@words)
     game_title = system_object.instance_variable_get(:@game_title)
 
+    hash_index = 0
+
     [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'
+                    insert_at_index(system_trans_map, hash_index, string, '') unless system_trans_map.include?(string)
+                else
+                    system_lines.add(string)
+                end
+
+                hash_index += 1
+            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'
+            insert_at_index(system_trans_map, hash_index, currency_unit, '') unless system_trans_map.include?(currency_unit)
+        else
+            system_lines.add(currency_unit)
+        end
+
+        hash_index += 1
+    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'
+                    insert_at_index(system_trans_map, hash_index, value, '') unless system_trans_map.include?(value)
+                else
+                    system_lines.add(value)
+                end
+
+                hash_index += 1
+            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'
+                    insert_at_index(system_trans_map, hash_index, string, '') unless system_trans_map.include?(string)
+                else
+                    system_lines.add(string)
+                end
+
+                hash_index += 1
+            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'
+                    insert_at_index(system_trans_map, hash_index, game_title, '') unless system_trans_map.include?(game_title)
+                else
+                    system_lines.add(game_title)
+                end
+            else
+                if processing_type == 'append'
+                    insert_at_index(system_trans_map, hash_index, ini_game_title, '') unless system_trans_map.include?(ini_game_title)
+                else
+                    system_lines.add(ini_game_title)
+                end
+            end
+        else
+            if processing_type == 'append'
+                insert_at_index(system_trans_map, hash_index, ini_game_title, '') unless system_trans_map.include?(ini_game_title)
+            else
+                system_lines.add(ini_game_title)
+            end
+        end
+
+        hash_index += 1
+    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))
+    if processing_type == 'append'
+        File.binwrite(system_output_path, system_trans_map.keys.join("\n"))
+        File.binwrite(system_trans_output_path, system_trans_map.values.join("\n"))
+    else
+        File.binwrite(system_output_path, system_lines.join("\n"))
+        File.binwrite(system_trans_output_path, "\n" * (system_lines.empty? ? 0 : system_lines.length - 1))
+    end
+
 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 = nil
+    scripts_trans_map = nil
+
+    if processing_type == 'append'
+        if File.exist?(scripts_trans_output_path)
+            scripts_trans_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'
+            scripts_lines = IndexSet.new
+        end
+    else
+        scripts_lines = IndexSet.new
+    end
+
     codes_content = []
+    hash_index = 0
 
     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 +628,25 @@ def self.read_scripts(scripts_file_path, output_path, logging)
                 string.match?(/Clear image/) ||
                 string.match?(/Can Collapse/)
 
-            scripts_lines.add(string)
+            if processing_type == 'append'
+                insert_at_index(scripts_trans_map, hash_index, string, '') unless scripts_trans_map.include?(string)
+            else
+                scripts_lines.add(string)
+            end
+
+            hash_index += 1
         end
     end
 
-    puts "Parsed #{File.basename(scripts_file_path)}" if logging
+    puts "Parsed #{scripts_filename}" if logging
+
+    File.binwrite(scripts_plain_output_path, codes_content.join("\n"))
 
-    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
+    if processing_type == 'append'
+        File.binwrite(scripts_output_path, scripts_trans_map.keys.join("\n"))
+        File.binwrite(scripts_trans_output_path, scripts_trans_map.values.join("\n"))
+    else
+        File.binwrite(scripts_output_path, scripts_lines.join("\n"))
+        File.binwrite(scripts_trans_output_path, "\n" * (scripts_lines.empty? ? 0 : scripts_lines.length - 1))
+    end
+end

data/lib/write.rb

@@ -2,17 +2,58 @@
 
 require 'zlib'
 
-def self.shuffle_words(array)
-    array.map do |string|
-        re = /\S+/
-        words = string.scan(re)
-        shuffled = words.shuffle
+def self.extract_quoted_strings(string)
+    # Hash of string-index key-value pairs
+    result = {}
+
+    skip_block = false
+    in_quotes = false
+    quote_type = nil
+    buffer = []
+
+    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 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
 
-        (0..(words.length)).each do |i|
-            string.sub!(words[i], shuffled[i])
+            if in_quotes
+                buffer.push(char)
+            end
         end
 
-        string
+        current_string_index += line.length
+    end
+
+    result
+end
+
+def shuffle_words_in_array(array)
+    array.map do |string|
+        string.split.shuffle.join(' ')
     end
 end
 
@@ -309,7 +350,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 +384,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 +413,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 +435,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.0'
     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.0
 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-12 00:00:00.000000000 Z
 dependencies: []
 description:
 email: