rvpacker-txt 1.8.5 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4be9adddaac27a84654c48292e0fa8949daf9b48a6b97520585e5bc9678c4593
-  data.tar.gz: a108f9445ec1e2151c39eeda9f262c2505e763efbbc790b8c7a788bf9ffdd1bf
+  metadata.gz: ea9153be0a603a97b9e717c2406e5ca7dd650973b6905d2189fa9025fce0e596
+  data.tar.gz: 4505485e158a91d4f57d81da8ef5faf19ae74d152dae5da99d6f7fa3cd28401d
 SHA512:
-  metadata.gz: 318bedbdef111ee55225cb8cc71c5cb9f0751c186daa314722f6f09900e69ee2ffaedf11850185d484189c7879630c900d19a586dad6b0c948daa023991c8d45
-  data.tar.gz: ffb4a43103686e875a3de87964c53f2d7ae81b1d64f06433164992bc25a7f31a603837a8358a8e33b7b84be9fb3343e4690f5f9c901d1c50cfbe9c3192bdc243
+  metadata.gz: b2b12ddb9a56f214daa46f8e4f47186ce44336713a98fbeebc279c9c8616f99c042100ff5be3d28cad99f35624cc52849a7abffbe68e19714e2454d211039df9
+  data.tar.gz: b2d1b0bdb6e74e68a26591fb11b06eb4ef964122a2bc251e36b0be40dbec24e8153fbbca0b15bfe7c56bad96377c489fe556cc0332311aa22ac5d94168d91447

data/README.md

@@ -21,26 +21,27 @@ You can get a help message on usage using `rvpacker-txt -h`.
 
 ```
 $ rvpacker-txt -h
-This tool allows to parse RPG Maker project to .txt files and back.
+This tool allows to parse RPG Maker games to .txt files and write them back to their initial form.
 
-Usage: rvpacker-txt COMMAND [options]
+Usage: rvpacker-txt COMMAND [OPTIONS]
 
 COMMANDS:
-    read - Parses RPG Maker game files to .txt
-    write - Writes parsed files back to their initial form
+    read - Parses files from "original" or "data" folders of input directory to "translation" folder of output directory.
+    write - Writes translated files using original files from "original" or "data" folder of input directory and writes results to "output" folder of output directory.
 OPTIONS:
-    -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, scripts)
-    -s, --shuffle NUM                Shuffle level (1: lines, 2: lines and words)
-        --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
+    -i, --input-dir PATH             When reading: Input directory, containing folders "original" or "data" with original game files.
+                                     When writing: Input directory, containing folders "original" or "data" and "translation" with original game files and .txt files with translation respectively.
+    -o, --output-dir PATH            When reading: Output directory, where a "translation" folder will be created, containing parsed .txt files with the text from the game.
+                                     When writing: Output directory, where an "output" folder will be created, containing compiled RPG Maker files with your translation.
+        --disable-processing FILES   Skips processing specified files.
+                                     Example: --disable-processing=maps,other,system.
+                                     [Allowed values: maps, other, system, scripts]
+        --disable-custom-processing  Disables built-in custom parsing/writing for some games.
+    -r, --romanize                   When reading: If you parsing text from a Japanese game, that contains symbols like 「」,
+                                     which are just the Japanese quotation marks, it automatically replaces these symbols by their roman equivalents.
+                                     When writing: Use to correctly write files back if you have parsed them with --romanize flag.
+    -l, --log                        Enables logging.
+    -h, --help                       Prints the program's help message or for the entered subcommand.
 ```
 
 For example, to read a RPG Maker VX Ace project in E:/Documents/RPGMakerGame to .txt files:

data/bin/rvpacker-txt

@@ -7,28 +7,79 @@ require 'fileutils'
 require 'classes'
 
 def self.parse_options
-    options = { disable_processing: {}, input_dir: './', output_dir: './', shuffle_level: 0 }
+    options = { action: nil,
+                input_path: './',
+                output_path: './',
+                disable_processing: {
+                    maps: false,
+                    other: false,
+                    system: false,
+                    scripts: false
+                },
+                disable_custom_processing: false,
+                romanize: false,
+                logging: false,
+                force: false,
+                append: false,
+                shuffle_level: 0 }
+
+    options[:action] = ARGV[0]
+
+    unless %w[read write].include?(options[:action])
+        if %w[-h --help].include?(options[:action])
+            options[:action] = 'none'
+        elsif options[:action].nil?
+            raise 'COMMAND argument is required. Use rvpacker-txt -h for help.'
+        else
+            raise 'Invalid command. Allowed commands: read, write.'
+        end
+    end
 
     read_command_description = 'Parses files from "original" or "data" folders of input directory to "translation" folder of output directory.'
     write_command_description = 'Writes translated files using original files from "original" or "data" folder of input directory and writes results to "output" folder of output directory.'
-    banner_text = "This tool allows to parse RPG Maker games to .txt files and write them back to their initial form.\n\nUsage: rvpacker-txt COMMAND [options]\n\nCOMMANDS:\n    read - #{read_command_description}\n    write - #{write_command_description}\nOPTIONS:\n"
+    banner_text = "This tool allows to parse RPG Maker games to .txt files and write them back to their initial form.\n\nUsage: rvpacker-txt COMMAND [OPTIONS]\n\nCOMMANDS:\n    read - #{read_command_description}\n    write - #{write_command_description}\nOPTIONS:"
+
+    banner,
+        input_dir_description,
+        output_dir_description,
+        romanize_description =
+        case options[:action]
+            when 'read'
+                ["#{read_command_description}\n\nOPTIONS:\n",
+                 ['Input directory, containing folders "original" or "data" with original game files.'],
+                 ['Output directory, where a "translation" folder will be created, containing parsed .txt files with the text from the game.'],
+                 ['If you parsing text from a Japanese game, that contains symbols like 「」, which are just the Japanese quotation marks,',
+                  'it automatically replaces these symbols by their roman equivalents.']]
+            when 'write'
+                ["#{write_command_description}\n\nOPTIONS:\n",
+                 ['Input directory, containing folders "original" or "data" and "translation" with original game files and .txt files with translation respectively.'],
+                 ['Output directory, where an "output" folder will be created, containing compiled RPG Maker files with your translation.'],
+                 ['Use to correctly write files back if you have parsed them with --romanize flag.']]
+            else
+                [banner_text,
+                 ['When reading: Input directory, containing folders "original" or "data" with original game files.',
+                  'When writing: Input directory, containing folders "original" or "data" and "translation" with original game files and .txt files with translation respectively.'],
+                 ['When reading: Output directory, where a "translation" folder will be created, containing parsed .txt files with the text from the game.',
+                  'When writing: Output directory, where an "output" folder will be created, containing compiled RPG Maker files with your translation.'],
+                 ['When reading: If you parsing text from a Japanese game, that contains symbols like 「」,',
+                  'which are just the Japanese quotation marks, it automatically replaces these symbols by their roman equivalents.',
+                  'When writing: Use to correctly write files back if you have parsed them with --romanize flag.']]
+        end
 
-    OptionParser.new(banner_text) do |cmd|
+    OptionParser.new(banner) do |cmd|
         cmd.on('-i', '--input-dir PATH', String,
-               'When reading: Input directory, containing folders "original" or "data" with original game files.',
-               'When writing: Input directory, containing folders "original" or "data" and "translation" with original game files and .txt files with translation respectively.') do |dir|
-            options[:input_dir] = File.exist?(dir) ? File.realpath(dir) : (raise "#{dir} not found")
-            options[:output_dir] = options[:input_dir]
+               *input_dir_description) do |dir|
+            options[:input_path] = File.exist?(dir) ? File.realpath(dir) : (raise "#{dir} not found")
+            options[:output_path] = options[:input_path]
         end
 
         cmd.on('-o', '--output-dir PATH', String,
-               'When reading: Output directory, where an "output" folder will be created, containing compiled RPG Maker files with your translation.',
-               'When writing: Output directory, where a "translation" folder will be created, containing parsed .txt files with the text from the game.') do |dir|
-            options[:output_dir] = File.exist?(dir) ? File.realpath(dir) : (raise "#{dir} not found")
+               *output_dir_description) do |dir|
+            options[:output_path] = File.exist?(dir) ? File.realpath(dir) : (raise "#{dir} not found")
         end
 
         cmd.on('--disable-processing FILES', Array,
-               'Skips processing the specified files.',
+               'Skips processing specified files.',
                'Example: --disable-processing=maps,other,system.',
                '[Allowed values: maps, other, system, scripts]') do |files|
             files.each do |file|
@@ -38,50 +89,51 @@ def self.parse_options
             end
         end
 
-        cmd.on('-s', '--shuffle-level NUMBER', Integer,
-               'With value 1, shuffles all translation lines. With value 2, shuffles all words and lines in translation text.',
-               'Example: --shuffle-level 1.',
-               '[Allowed values: 0, 1, 2]',
-               '[Default value: 0]',
-               '[Write flag]') do |num|
-            raise 'Allowed values: 0, 1, 2' if num > 2
-            options[:shuffle_level] = num
-        end
-
-        cmd.on('--disable-custom-processing', 'Disables built-in custom parsing/writing for some games.') do
+        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', 'Enables logging.') do
-            options[:logging] = true
+        cmd.on('-r', '--romanize',
+               *romanize_description) do
+            options[:romanize] = true
         end
 
-        cmd.on('-f', '--force',
-               'Force rewrite all files. Cannot be used with --append.',
-               'USE WITH CAUTION!',
-               '[Read flag]') do
-            options[:force] = true
+        if options[:action] == 'read'
+            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 the rvpacker-txt or the game which files you've parsed receives an update, you probably should re-read game files with --append,",
+                   ' which will append any new text to your files without overwriting the progress.',
+                   'Cannot be used with --force.') do
+                raise '--append cannot be used with --force.' if options[:force]
+                options[:append] = true
+            end
+        elsif options[:action] == 'write'
+            cmd.on('-s', '--shuffle-level NUMBER', Integer,
+                   'With value 1, shuffles all translation lines. With value 2, shuffles all words and lines in translation text.',
+                   'Example: --shuffle-level 1.',
+                   '[Allowed values: 0, 1, 2]',
+                   '[Default value: 0]') do |num|
+                raise 'Allowed values: 0, 1, 2.' if num > 2
+                options[:shuffle_level] = num
+            end
         end
 
-        cmd.on('-a', '--append',
-               "When the rvpacker-txt or the game which files you've parsed receives an update,",
-               'you probably should re-read game files with --append, which will append any new text to your files without overwriting the progress',
-               'Cannot be used with --force',
-               '[Read flag]') do
-            raise '--append cannot be used with --force.' if options[:force]
-            options[:append] = true
+        cmd.on('-l', '--log', 'Enables logging.') do
+            options[:logging] = true
         end
 
-        cmd.on('-h', '--help', 'Show help message') do
+        cmd.on('-h', '--help', "Prints the program's help message or for the entered subcommand.") do
             puts cmd
             exit
         end
     end.parse!
 
-    options[:action] = ARGV.shift
-    raise 'COMMAND argument is required. Use rvpacker-txt -h for help.' if options[:action].nil?
-    raise 'Invalid command. Allowed commands are: read, write.' unless %w[read write].include?(options[:action])
-
     options
 end
 
@@ -89,34 +141,44 @@ end
 # @return [String, nil]
 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 = object.game_title.to_s.downcase
     game_title.include?('lisa') ? 'lisa' : nil
 end
 
 start_time = Time.now
 
 options = parse_options
-input_dir = options[:input_dir]
-output_dir = options[:output_dir]
+# @type [String]
+input_path = options[:input_path]
+# @type [String]
+output_path = options[:output_path]
+# @type [Boolean]
 disable_custom_processing = options[:disable_custom_processing]
+# @type [Integer]
 shuffle_level = options[:shuffle_level]
+# @type [Boolean]
 logging = options[:logging]
+# @type [Hash{Symbol => Boolean}]
 disable_processing = options[:disable_processing]
+# @type [Boolean]
 force = options[:force]
+# @type [Boolean]
 append = options[:append]
+# @type [Boolean]
+romanize = options[:romanize]
 
 extensions = { xp: 'rxdata', vx: 'rvdata', ace: 'rvdata2' }
 
-original_directory = Dir.glob(File.join(input_dir, '{data,original}'), File::FNM_CASEFOLD).first
+original_directory = Dir.glob(File.join(input_path, '{data,original}'), File::FNM_CASEFOLD).first
 raise '"Data" or "original" directory not found within input directory.' unless original_directory
 
-maps_path = File.join(input_dir, 'translation', 'maps')
-other_path = File.join(input_dir, 'translation', 'other')
+maps_path = File.join(input_path, 'translation', 'maps')
+other_path = File.join(input_path, 'translation', 'other')
 
 FileUtils.mkdir_p(maps_path)
 FileUtils.mkdir_p(other_path)
 
-engine = extensions.each { |sym, ext| break sym if File.exist?(File.join(original_directory, "System.#{ext}")) } ||
+engine = extensions.each_pair { |sym, ext| break sym if File.exist?(File.join(original_directory, "System.#{ext}")) } ||
     (raise "Couldn't determine project engine.")
 
 files = Dir.glob("#{original_directory}/*#{extensions[engine]}")
@@ -141,45 +203,47 @@ files.each do |file|
     end
 end
 
-ini_file_path = File.join(input_dir, 'Game.ini')
+ini_file_path = File.join(input_path, '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.",
-                           "If 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.",
-                           "Input '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?
 
+$wait_time = 0
+
 if options[:action] == 'read'
     require 'read'
-    read_map(maps_files_paths, maps_path, logging, game_type, processing_type) unless disable_processing[:maps]
-    read_other(other_files_paths, other_path, logging, game_type, processing_type) unless disable_processing[:other]
-    read_system(system_file_path, ini_file_path, other_path, logging, processing_type) unless disable_processing[:system]
-    read_scripts(scripts_file_path, other_path, logging, processing_type) unless disable_processing[:scripts]
+
+    processing_mode = if force
+                          wait_time_start = Time.now
+
+                          puts "WARNING! You're about to forcefully rewrite all your translation files, including _trans files.",
+                               "If 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.",
+                               "Input 'Y' to continue."
+                          exit unless $stdin.gets.chomp == 'Y'
+
+                          $wait_time += Time.now - wait_time_start
+                          :force
+                      elsif append
+                          :append
+                      else
+                          :default
+                      end
+
+    read_map(maps_files_paths, maps_path, romanize, logging, game_type, processing_mode) unless disable_processing[:maps]
+    read_other(other_files_paths, other_path, romanize, logging, game_type, processing_mode) unless disable_processing[:other]
+    read_system(system_file_path, ini_file_path, other_path, romanize, logging, processing_mode) unless disable_processing[:system]
+    read_scripts(scripts_file_path, other_path, romanize, logging, processing_mode) unless disable_processing[:scripts]
 else
     require 'write'
-    output_path = File.join(output_dir, 'output')
+
+    output_path = File.join(output_path, 'output')
     FileUtils.mkdir_p(output_path)
 
-    write_map(maps_files_paths, maps_path, output_path, shuffle_level, logging, game_type) unless disable_processing[:maps]
-    write_other(other_files_paths, other_path, output_path, shuffle_level, logging, game_type) unless disable_processing[:other]
-    write_system(system_file_path, ini_file_path, other_path, output_path, shuffle_level, logging) unless disable_processing[:system]
-    write_scripts(scripts_file_path, other_path, output_path, logging) unless disable_processing[:scripts]
+    write_map(maps_files_paths, maps_path, output_path, shuffle_level, romanize, logging, game_type) unless disable_processing[:maps]
+    write_other(other_files_paths, other_path, output_path, shuffle_level, romanize, logging, game_type) unless disable_processing[:other]
+    write_system(system_file_path, ini_file_path, other_path, output_path, shuffle_level, romanize, logging) unless disable_processing[:system]
+    write_scripts(scripts_file_path, other_path, output_path, romanize, logging) unless disable_processing[:scripts]
 end
 
-$wait_time = 0 if $wait_time.nil?
-elapsed_time = Time.now - start_time - wait_time - $wait_time
-
-puts "Done in #{elapsed_time}"
+puts "Done in #{Time.now - start_time - $wait_time}"

data/lib/classes.rb

@@ -83,7 +83,7 @@ class IndexSet
 
     def add(item)
         return if @hash.include?(item)
-        @hash[item] = hash.size
+        @hash[item] = @hash.size
         @hash
     end
 
@@ -188,7 +188,9 @@ module RGSS
         end
     end
 
-    classes_nested_array = [
+    # All used Ruby classes inside RPG Maker XP, VX, VX Ace games, that must be initialized to properly
+    # Marshal.load() files from these games
+    CLASSES_NESTED_ARRAY = [
         # RGSS data structures
         %i[RPG Actor],
         %i[RPG Animation],
@@ -239,7 +241,7 @@ module RGSS
         %i[RPG Weapon]
     ].freeze
 
-    classes_nested_array.each do |symbol_array|
+    CLASSES_NESTED_ARRAY.each do |symbol_array|
         process(Object, *symbol_array)
     end
 end

data/lib/read.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'extensions'
 require 'zlib'
 
+STRING_IS_ONLY_SYMBOLS_RE = /^[.()+-:;\[\]^~%&!*\/→×？?ｘ％▼| ]+$/
+APPEND_FLAG_OMIT_MSG = "Files aren't already parsed. Continuing as if --append flag was omitted."
+
 class Hash
     def insert_at_index(index, key, value)
         return self[key] = value if index >= size
@@ -49,16 +53,16 @@ def self.extract_quoted_strings(string)
                 next
             end
 
-            if in_quotes
-                if char == "\r"
-                    next
-                elsif char == "\n"
-                    buffer.push('\#')
-                    next
-                end
+            next unless in_quotes
 
-                buffer.push(char)
+            if char == "\r"
+                next
+            elsif char == "\n"
+                buffer.push('\#')
+                next
             end
+
+            buffer.push(char)
         end
     end
 
@@ -70,7 +74,7 @@ end
 # @param [String] game_type
 # @return [String]
 def self.parse_parameter(code, parameter, game_type)
-    return nil if parameter.match?(/^[.()+-:;\[\]^~%&!*\/→×？?ｘ％▼| ]+$/)
+    return nil if parameter.match?(STRING_IS_ONLY_SYMBOLS_RE)
 
     unless game_type.nil?
         case code
@@ -99,7 +103,7 @@ end
 # @param [String] _game_type
 # @return [String]
 def self.parse_variable(variable, _game_type)
-    return nil if parameter.match?(/^[.()+-:;\[\]^~%&!*\/→×？?ｘ％▼| ]+$/)
+    return nil if variable.match?(STRING_IS_ONLY_SYMBOLS_RE)
     variable = variable.gsub(/\r?\n/, '\#') if variable.count("\n").positive?
 
     return nil if variable.split('\#').all? { |line| line.strip.match?(/(^#? ?<.*>\.?$)|^$/) }
@@ -110,18 +114,19 @@ def self.parse_variable(variable, _game_type)
     variable
 end
 
-# @param [Array<String>] maps_files_paths
-# @param [String] output_path
-# @param [Boolean] logging
-# @param [String] game_type
-# @param [String] processing_type
-def self.read_map(maps_files_paths, output_path, logging, game_type, processing_type)
+# @param [Array<String>] maps_files_paths Array of paths to original maps files
+# @param [String] output_path Path to output directory
+# @param [Boolean] romanize Whether to romanize text
+# @param [Boolean] logging Whether to log
+# @param [String] game_type Game type for custom processing
+# @param [String] processing_mode Whether to read in default mode, force rewrite or append new text to existing files
+def self.read_map(maps_files_paths, output_path, romanize, logging, game_type, processing_mode)
     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))
+    if processing_mode == :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
@@ -134,15 +139,15 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
     maps_translation_map = nil
     names_translation_map = nil
 
-    if processing_type == :append
+    if processing_mode == :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
+            puts APPEND_FLAG_OMIT_MSG
+            processing_mode = :default
         end
     end
 
@@ -158,7 +163,9 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
             display_name = display_name.strip
 
             unless display_name.empty?
-                names_translation_map.insert_at_index(names_lines.length, display_name, '') if processing_type == :append &&
+                display_name = romanize_string(display_name) if romanize
+
+                names_translation_map.insert_at_index(names_lines.length, display_name, '') if processing_mode == :append &&
                     !names_translation_map.include?(display_name)
 
                 names_lines.add(display_name)
@@ -187,13 +194,17 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
                             joined = line.join('\#').strip
                             parsed = parse_parameter(401, joined, game_type)
 
-                            maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
-                                !maps_translation_map.include?(parsed)
+                            unless parsed.nil?
+                                parsed = romanize_string(parsed) if romanize
 
-                            maps_lines.add(parsed)
+                                maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_mode == :append &&
+                                    !maps_translation_map.include?(parsed)
+
+                                maps_lines.add(parsed)
 
-                            line.clear
-                            in_sequence = false
+                                line.clear
+                                in_sequence = false
+                            end
                         end
                         next
                     end
@@ -215,7 +226,9 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
                             parsed = parse_parameter(code, subparameter, game_type)
                             next if parsed.nil?
 
-                            maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
+                            parsed = romanize_string(parsed) if romanize
+
+                            maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_mode == :append &&
                                 !maps_translation_map.include?(parsed)
 
                             maps_lines.add(parsed)
@@ -228,8 +241,9 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
                         next if parsed.nil?
 
                         parsed = parsed.gsub(/\r?\n/, '\#')
+                        parsed = romanize_string(parsed) if romanize
 
-                        maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
+                        maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_mode == :append &&
                             !maps_translation_map.include?(parsed)
 
                         maps_lines.add(parsed)
@@ -244,7 +258,7 @@ def self.read_map(maps_files_paths, output_path, logging, game_type, processing_
     maps_original_content,
         maps_translated_content,
         names_original_content,
-        names_translated_content = if processing_type == :append
+        names_translated_content = if processing_mode == :append
                                        [maps_translation_map.keys.join("\n"),
                                         maps_translation_map.values.join("\n"),
                                         names_translation_map.keys.join("\n"),
@@ -264,13 +278,14 @@ end
 
 # @param [Array<String>] other_files_paths
 # @param [String] output_path
-# @param [Boolean] logging
-# @param [String] game_type
-# @param [String] processing_type
-def self.read_other(other_files_paths, output_path, logging, game_type, processing_type)
+# @param [Boolean] romanize Whether to romanize text
+# @param [Boolean] logging Whether to log
+# @param [String] game_type Game type for custom processing
+# @param [String] processing_mode Whether to read in default mode, force rewrite or append new text to existing files
+def self.read_other(other_files_paths, output_path, romanize, logging, game_type, processing_mode)
     other_object_array_map = Hash[other_files_paths.map { |f| [File.basename(f), Marshal.load(File.binread(f))] }]
 
-    inner_processing_type = processing_type
+    inner_processing_type = processing_mode
     # 401 - dialogue lines
     # 405 - credits lines
     # 102 - dialogue choices array
@@ -283,7 +298,7 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
         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)
+        if processing_mode == :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
@@ -291,13 +306,13 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
         other_lines = IndexSet.new
         other_translation_map = nil
 
-        if processing_type == :append
+        if processing_mode == :append
             if File.exist?(other_trans_output_path)
                 inner_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."
+                puts APPEND_FLAG_OMIT_MSG
                 inner_processing_type = :default
             end
         end
@@ -321,6 +336,7 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
                     next if parsed.nil?
 
                     parsed = parsed.gsub(/\r?\n/, '\#')
+                    parsed = romanize_string(parsed) if romanize
 
                     other_translation_map.insert_at_index(other_lines.length, parsed, '') if inner_processing_type == :append &&
                         !other_translation_map.include?(parsed)
@@ -350,13 +366,17 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
                                 joined = line.join('\#').strip
                                 parsed = parse_parameter(401, joined, game_type)
 
-                                other_translation_map.insert_at_index(other_lines.length, parsed, '') if inner_processing_type == :append &&
-                                    !other_translation_map.include?(parsed)
+                                unless parsed.nil?
+                                    parsed = romanize_string(parsed) if romanize
 
-                                other_lines.add(parsed)
+                                    other_translation_map.insert_at_index(other_lines.length, parsed, '') if inner_processing_type == :append &&
+                                        !other_translation_map.include?(parsed)
 
-                                line.clear
-                                in_sequence = false
+                                    other_lines.add(parsed)
+
+                                    line.clear
+                                    in_sequence = false
+                                end
                             end
                             next
                         end
@@ -375,6 +395,8 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
                                 subparameter = subparameter.strip
                                 next if subparameter.empty?
 
+                                subparameter = romanize_string(subparameter) if romanize
+
                                 other_translation_map.insert_at_index(other_lines.length, subparameter, '') if inner_processing_type == :append &&
                                     !other_translation_map.include?(subparameter)
 
@@ -385,6 +407,7 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
                             next if parameter.empty?
 
                             parameter = parameter.gsub(/\r?\n/, '\#')
+                            parameter = romanize_string(parameter) if romanize
 
                             other_translation_map.insert_at_index(other_lines.length, parameter, '') if inner_processing_type == :append &&
                                 !other_translation_map.include?(parameter)
@@ -395,6 +418,7 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
                             next if parameter.empty?
 
                             parameter = parameter.gsub(/\r?\n/, '\#')
+                            parameter = romanize_string(parameter) if romanize
 
                             other_translation_map.insert_at_index(other_lines.length, parameter, '') if inner_processing_type == :append &&
                                 !other_translation_map.include?(parameter)
@@ -408,7 +432,7 @@ def self.read_other(other_files_paths, output_path, logging, game_type, processi
 
         puts "Parsed #{filename}" if logging
 
-        original_content, translated_content = if processing_type == :append
+        original_content, translated_content = if processing_mode == :append
                                                    [other_translation_map.keys.join("\n"),
                                                     other_translation_map.values.join("\n")]
                                                else
@@ -435,16 +459,17 @@ end
 # @param [String] system_file_path
 # @param [String] ini_file_path
 # @param [String] output_path
-# @param [Boolean] logging
-# @param [String] processing_type
-def self.read_system(system_file_path, ini_file_path, output_path, logging, processing_type)
+# @param [Boolean] romanize Whether to romanize text
+# @param [Boolean] logging Whether to log
+# @param [String] processing_mode Whether to read in default mode, force rewrite or append new text to existing files
+def self.read_system(system_file_path, ini_file_path, output_path, romanize, logging, processing_mode)
     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)
+    if processing_mode == :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
@@ -454,13 +479,13 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
     system_lines = IndexSet.new
     system_translation_map = nil
 
-    if processing_type == :append
+    if processing_mode == :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
+            puts APPEND_FLAG_OMIT_MSG
+            processing_mode = :default
         end
     end
 
@@ -480,7 +505,9 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
             string = string.strip
             next if string.empty?
 
-            system_translation_map.insert_at_index(system_lines.length, string, '') if processing_type == :append &&
+            string = romanize_string(string) if romanize
+
+            system_translation_map.insert_at_index(system_lines.length, string, '') if processing_mode == :append &&
                 !system_translation_map.include?(string)
 
             system_lines.add(string)
@@ -491,7 +518,9 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
         currency_unit = currency_unit.strip
 
         unless currency_unit.empty?
-            system_translation_map.insert_at_index(system_lines.length, currency_unit, '') if processing_type == :append &&
+            currency_unit = romanize_string(currency_unit) if romanize
+
+            system_translation_map.insert_at_index(system_lines.length, currency_unit, '') if processing_mode == :append &&
                 !system_translation_map.include?(currency_unit)
 
             system_lines.add(currency_unit)
@@ -505,7 +534,9 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
             value = value.strip
 
             unless value.empty?
-                system_translation_map.insert_at_index(system_lines.length, value, '') if processing_type == :append &&
+                value = romanize_string(string) if romanize
+
+                system_translation_map.insert_at_index(system_lines.length, value, '') if processing_mode == :append &&
                     !system_translation_map.include?(value)
 
                 system_lines.add(value)
@@ -517,7 +548,9 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
                 string = string.strip
                 next if string.empty?
 
-                system_translation_map.insert_at_index(system_lines.length, string, '') if processing_type == :append &&
+                string = romanize_string(string) if romanize
+
+                system_translation_map.insert_at_index(system_lines.length, string, '') if processing_mode == :append &&
                     !system_translation_map.include?(string)
 
                 system_lines.add(string)
@@ -528,15 +561,16 @@ def self.read_system(system_file_path, ini_file_path, output_path, logging, proc
     # Game title from System file and ini file may differ, but requesting user request to determine which line do they want is LAME
     # So just throw that ini ass and continue
     ini_game_title = read_ini_title(ini_file_path).strip
+    ini_game_title = romanize_string(ini_game_title) if romanize
 
-    system_translation_map.insert_at_index(system_lines.length, ini_game_title, '') if processing_type == :append &&
+    system_translation_map.insert_at_index(system_lines.length, ini_game_title, '') if processing_mode == :append &&
         !system_translation_map.include?(ini_game_title)
 
     system_lines.add(ini_game_title)
 
     puts "Parsed #{system_filename}" if logging
 
-    original_content, translated_content = if processing_type == :append
+    original_content, translated_content = if processing_mode == :append
                                                [system_translation_map.keys.join("\n"),
                                                 system_translation_map.values.join("\n")]
                                            else
@@ -550,9 +584,10 @@ end
 
 # @param [String] scripts_file_path
 # @param [String] output_path
-# @param [Boolean] logging
-# @param [String] processing_type
-def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
+# @param [Boolean] romanize Whether to romanize text
+# @param [Boolean] logging Whether to log
+# @param [String] processing_mode Whether to read in default mode, force rewrite or append new text to existing files
+def self.read_scripts(scripts_file_path, output_path, romanize, logging, processing_mode)
     scripts_filename = File.basename(scripts_file_path)
     scripts_basename = File.basename(scripts_file_path, '.*').downcase
 
@@ -560,7 +595,7 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
     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)
+    if processing_mode == :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
@@ -570,13 +605,13 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
     scripts_lines = IndexSet.new
     scripts_translation_map = nil
 
-    if processing_type == :append
+    if processing_mode == :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
+            puts APPEND_FLAG_OMIT_MSG
+            processing_mode = :default
         end
     end
 
@@ -613,7 +648,7 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
                 string.match?(/^[^\p{L}]+$/) ||
                 string.match?(/^\d+$/) ||
                 string.match?(/%.*(\d|\+|\*)d\]?:?$/) ||
-                string.match?(/^\[(ON|OFF)\]$/) ||
+                string.match?(/^\[((ON|OFF)|P[EMRT])\]$/) ||
                 string.match?(/^\[\]$/) ||
                 string.match?(/^(.)\1{2,}$/) ||
                 string.match?(/^(false|true)$/) ||
@@ -621,10 +656,13 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
                 string.match?(/^(?=.*\d)[A-Za-z0-9\-]+$/) ||
                 string.match?(/^[a-z\-()\/ +'&]*$/) ||
                 string.match?(/^[A-Za-z]+[+-]$/) ||
-                string.match?(/^[.()+-:;\[\]^~%&!*\/→×？?ｘ％▼| ]+$/) ||
+                string.match?(STRING_IS_ONLY_SYMBOLS_RE) ||
                 string.match?(/^Tile.*[A-Z]$/) ||
                 string.match?(/^[a-zA-Z][a-z]+([A-Z][a-z]*)+$/) ||
                 string.match?(/^Cancel Action$|^Invert$|^End$|^Individual$|^Missed File$|^Bitmap$|^Audio$/) ||
+                string.match?(/^(?=.*%d)(?=.*%m)(?=.*%Y).*$/) ||
+                string.match?(/^\\\\ALPHAC/) ||
+                string.match?(/^[A-Z]{,3}-[A-Z][A-Za-z]+/) ||
                 string.match?(/\.(mp3|ogg|jpg|png|ini|txt)$/i) ||
                 string.match?(/\/(\d.*)?$/) ||
                 string.match?(/FILE$/) ||
@@ -648,7 +686,9 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
                 string.match?(/Clear image/) ||
                 string.match?(/Can Collapse/)
 
-            scripts_translation_map.insert_at_index(scripts_lines.length, string, '') if processing_type == :append &&
+            string = romanize_string(string) if romanize
+
+            scripts_translation_map.insert_at_index(scripts_lines.length, string, '') if processing_mode == :append &&
                 !scripts_translation_map.include?(string)
 
             scripts_lines.add(string)
@@ -659,7 +699,7 @@ def self.read_scripts(scripts_file_path, output_path, logging, processing_type)
 
     File.binwrite(scripts_plain_output_path, codes_content.join("\n"))
 
-    original_content, translated_content = if processing_type == :append
+    original_content, translated_content = if processing_mode == :append
                                                [scripts_translation_map.keys.join("\n"),
                                                 scripts_translation_map.values.join("\n")]
                                            else

data/lib/write.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'zlib'
+require 'extensions'
 
 # @param [String] string A parsed scripts code string, containing raw Ruby code
 # @return [Array<Array<String, Integer>>] Hash of parsed from code strings and their start indices
@@ -58,8 +59,8 @@ def self.extract_quoted_strings(string)
     [strings_array, indices_array]
 end
 
-# @param [Array<String>] array
-# @return [Array<String>]
+# @param [Array<String>] array Array of strings
+# @return [Array<String>] Array of shuffled strings
 def self.shuffle_words(array)
     array.each do |string|
         select_words_re = /\S+/
@@ -70,7 +71,7 @@ end
 
 # @param [Integer] code
 # @param [String] parameter
-# @param [Hash{String => String}] hashmap
+# @param [Hash{String => String}] hashmap Translation hashmap (as everything in Ruby passed by reference, this pass is free!)
 # @param [String] game_type
 def self.get_parameter_translated(code, parameter, hashmap, game_type)
     unless game_type.nil?
@@ -115,20 +116,21 @@ def self.get_parameter_translated(code, parameter, hashmap, game_type)
 end
 
 # @param [String] variable
-# @param [Hash{String => String}] hashmap
+# @param [Hash{String => String}] hashmap Translation hashmap (as everything in Ruby passed by reference, this pass is free!)
 # @param [String] _game_type
 # @return [String]
 def self.get_variable_translated(variable, hashmap, _game_type)
     hashmap[variable]
 end
 
-# @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)
+# @param [Array<String>] original_files_paths Array of paths to original files
+# @param [String] maps_path Path to directory containing .txt maps files
+# @param [String] output_path Path to output directory
+# @param [Integer] shuffle_level Level of shuffle
+# @param [Boolean] romanize If files were read with romanize, this option will romanize original game text to compare with parsed
+# @param [Boolean] logging Whether to log
+# @param [String] game_type Game type for custom parsing
+def self.write_map(original_files_paths, maps_path, output_path, shuffle_level, romanize, logging, game_type)
     maps_object_map = Hash[original_files_paths.map { |f| [File.basename(f), Marshal.load(File.binread(f))] }]
 
     maps_original_text = File.readlines(File.join(maps_path, 'maps.txt'), encoding: 'UTF-8', chomp: true).map do |line|
@@ -192,6 +194,8 @@ def self.write_map(original_files_paths, maps_path, output_path, shuffle_level,
                     unless allowed_codes.include?(code)
                         if in_sequence
                             joined = line.join('\#').strip
+                            joined = romanize_string(joined) if romanize
+
                             translated = get_parameter_translated(401, joined, maps_translation_map, game_type)
 
                             unless translated.nil? || translated.empty?
@@ -225,6 +229,8 @@ def self.write_map(original_files_paths, maps_path, output_path, shuffle_level,
                             subparameter = subparameter.strip
                             next if subparameter.empty?
 
+                            subparameter = romanize_string(subparameter) if romanize
+
                             translated = get_parameter_translated(code, subparameter, maps_translation_map, game_type)
                             parameters[0][sp] = translated unless translated.nil? || translated.empty?
                         end
@@ -232,12 +238,16 @@ def self.write_map(original_files_paths, maps_path, output_path, shuffle_level,
                         parameter = parameters[0].strip
                         next if parameter.empty?
 
+                        parameter = romanize_string(parameter) if romanize
+
                         translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
                         parameters[0] = translated unless translated.nil? || translated.empty?
                     elsif parameters[1].is_a?(String)
                         parameter = parameters[1].strip
                         next if parameter.empty?
 
+                        parameter = romanize_string(parameter) if romanize
+
                         translated = get_parameter_translated(code, parameter, maps_translation_map, game_type)
                         parameters[1] = translated unless translated.nil? || translated.empty?
                     end
@@ -264,10 +274,11 @@ end
 # @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)
+# @param [Integer] shuffle_level Level of shuffle
+# @param [Boolean] romanize If files were read with romanize, this option will romanize original game text to compare with parsed
+# @param [Boolean] logging Whether to log
+# @param [String] game_type Game type for custom parsing
+def self.write_other(original_files_paths, other_path, output_path, shuffle_level, romanize, logging, game_type)
     other_object_array_map = Hash[original_files_paths.map { |f| [File.basename(f), Marshal.load(File.binread(f))] }]
 
     # 401 - dialogue lines
@@ -309,6 +320,8 @@ def self.write_other(original_files_paths, other_path, output_path, shuffle_leve
                     next if variable.empty?
 
                     variable = variable.gsub(/\r\n/, "\n")
+                    variable = romanize_string(variable) if romanize
+
                     translated = get_variable_translated(variable, other_translation_map, game_type)
 
                     unless translated.nil? || translated.empty?
@@ -345,6 +358,8 @@ def self.write_other(original_files_paths, other_path, output_path, shuffle_leve
                         unless allowed_codes.include?(code)
                             if in_sequence
                                 joined = line.join('\#').strip
+                                joined = romanize_string(joined) if romanize
+
                                 translated = get_parameter_translated(401, joined, other_translation_map, game_type)
 
                                 unless translated.nil? || translated.empty?
@@ -378,6 +393,8 @@ def self.write_other(original_files_paths, other_path, output_path, shuffle_leve
                                 subparameter = subparameter.strip
                                 next if subparameter.empty?
 
+                                subparameter = romanize_string(subparameter) if romanize
+
                                 translated = get_parameter_translated(code, subparameter, other_translation_map, game_type)
                                 parameters[0][sp] = translated unless translated.nil? || translated.empty?
                             end
@@ -385,12 +402,16 @@ def self.write_other(original_files_paths, other_path, output_path, shuffle_leve
                             parameter = parameters[0].strip
                             next if parameter.empty?
 
+                            parameter = romanize_string(parameter) if romanize
+
                             translated = get_parameter_translated(code, parameter, other_translation_map, game_type)
                             parameters[0] = translated unless translated.nil? || translated.empty?
                         elsif parameters[1].is_a?(String)
                             parameter = parameters[1].strip
                             next if parameter.empty?
 
+                            parameter = romanize_string(parameter) if romanize
+
                             translated = get_parameter_translated(code, parameter, other_translation_map, game_type)
                             parameters[1] = translated unless translated.nil? || translated.empty?
                         end
@@ -421,6 +442,7 @@ end
 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 { |line, i| break i if line.downcase.start_with?('title') }
+    return if title_line_index.is_a?(Array)
 
     file_lines[title_line_index] = translated
     File.binwrite(ini_file_path, file_lines.join("\n"))
@@ -430,9 +452,10 @@ end
 # @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)
+# @param [Integer] shuffle_level Level of shuffle
+# @param [Boolean] romanize If files were read with romanize, this option will romanize original game text to compare with parsed
+# @param [Boolean] logging Whether to log
+def self.write_system(system_file_path, ini_file_path, other_path, output_path, shuffle_level, romanize, logging)
     system_basename = File.basename(system_file_path)
     system_object = Marshal.load(File.binread(system_file_path))
 
@@ -455,7 +478,7 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
     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
+    terms_vocabulary = system_object.terms || system_object.words
 
     [elements, skill_types, weapon_types, armor_types].each_with_index do |array, i|
         next unless array.is_a?(Array)
@@ -464,6 +487,8 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
             string = string.strip
             next if string.empty?
 
+            string = romanize_string(string) if romanize
+
             translated = system_translation_map[string]
             array[i] = translated unless translated.nil? || translated.empty?
         end
@@ -479,35 +504,42 @@ def self.write_system(system_file_path, ini_file_path, other_path, output_path,
         end
     end
 
+    currency_unit = romanize_string(currency_unit) if romanize
     currency_unit_translated = system_translation_map[currency_unit]
     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)
+    terms_vocabulary.instance_variables.each do |variable|
+        value = terms_vocabulary.instance_variable_get(variable)
 
         if value.is_a?(String)
-            stripped = value.strip
+            value = value.strip
             next if value.empty?
 
-            translated = system_translation_map[stripped]
+            value = romanize_string(value) if romanize
+
+            translated = system_translation_map[value]
             value = translated unless translated.nil? || translated.empty?
         elsif value.is_a?(Array)
             value.each_with_index do |string, i|
                 string = string.strip
                 next if string.empty?
 
+                string = romanize_string(string) if romanize
+
                 translated = system_translation_map[string]
                 value[i] = translated unless translated.nil? || translated.empty?
             end
         end
 
-        terms.instance_variable_set(variable, value)
+        terms_vocabulary.instance_variable_set(variable, value)
     end
 
-    system_object.terms.nil? ?
-        system_object.words = terms :
-        system_object.terms = terms
+    if system_object.terms.nil?
+        system_object.words = terms_vocabulary
+    else
+        system_object.terms = terms_vocabulary
+    end
 
     game_title_translated = system_translated_text[-1]
 
@@ -523,8 +555,9 @@ 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] romanize If files were read with romanize, this option will romanize original game text to compare with parsed
 # @param [Boolean] logging Whether to log
-def self.write_scripts(scripts_file_path, other_path, output_path, logging)
+def self.write_scripts(scripts_file_path, other_path, output_path, romanize, logging)
     scripts_basename = File.basename(scripts_file_path)
     script_entries = Marshal.load(File.binread(scripts_file_path))
 
@@ -564,6 +597,8 @@ def self.write_scripts(scripts_file_path, other_path, output_path, logging)
             string = string.strip.delete('　')
             next if string.empty? || !scripts_translation_map.include?(string)
 
+            string = romanize_string(string) if romanize
+
             gotten = scripts_translation_map[string]
             code[index - string.length, string.length] = gotten unless gotten.nil? || gotten.empty?
         end

data/rvpacker-txt.gemspec

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

metadata

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