rvpacker-txt 1.0.0

data/lib/RGSS/serialize.rb

@@ -0,0 +1,703 @@
+# Copyright (c) 2013 Howard Jeng
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+# to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'zlib'
+
+class IndexedSet
+    def initialize
+        @set = Set.new
+        @index = []
+    end
+
+    def add(item)
+        return if @set.include?(item)
+
+        @set.add(item)
+        @index << item
+    end
+
+    def include?(item)
+        @set.include?(item)
+    end
+
+    def each(&block)
+        @index.each(&block)
+    end
+
+    def to_a
+        @index.dup
+    end
+
+    def join(delimiter = '')
+        @index.join(delimiter)
+    end
+
+    def length
+        @index.length
+    end
+end
+
+module RGSS
+    def self.get_game_type(system_file_path)
+        object = Marshal.load(File.read(system_file_path, mode: 'rb'))
+        game_title = object.instance_variable_get(:@game_title)
+
+        return nil if !game_title.is_a?(String) || game_title.empty?
+
+        game_title.downcase!
+
+        if game_title.include?("lisa")
+            return "lisa"
+        end
+
+        nil
+    end
+
+    def parse_parameter(code, parameter)
+        case code
+            when 401, 405
+                case $game_type
+                    when "lisa"
+                        match = parameter.match(/^\\et\[[0-9]+\]|\\nbt/)
+                        parameter = parameter[match[0].length..] if match
+                    else
+                        nil
+                end
+            when 102, 356
+                # Implement some custom parsing
+            else
+                return nil
+        end
+
+        parameter
+    end
+
+    def self.parse_variable(variable)
+        lines_count = variable.count("\n")
+
+        if lines_count.positive?
+            variable = variable.gsub(/\r?\n/, '\#')
+
+            case $game_type
+                when "lisa"
+                    unless variable.split('\#').all? { |line| line.match?(/^<.*>\.?$/) || line.length.nil? }
+                        return nil
+                    end
+                else
+                    nil
+            end
+        end
+
+        variable
+    end
+
+    def self.read_map(original_map_files, output_path)
+        object_map = Hash[original_map_files.map do |filename|
+            [File.basename(filename), Marshal.load(File.read(filename, mode: 'rb'))]
+        end]
+
+        lines = [IndexedSet.new, IndexedSet.new]
+
+        object_map.each do |filename, object|
+            display_name = object.instance_variable_get(:@display_name)
+            lines[1].add(display_name) unless display_name.nil? || display_name.empty?
+
+            events = object.instance_variable_get(:@events)
+            next if events.nil?
+
+            events.each_value do |event|
+                pages = event.instance_variable_get(:@pages)
+                next if pages.nil?
+
+                pages.each do |page|
+                    list = page.instance_variable_get(:@list)
+                    next if list.nil?
+
+                    in_sequence = false
+                    line = []
+
+                    list.each do |item|
+                        code = item.instance_variable_get(:@code)
+                        parameters = item.instance_variable_get(:@parameters)
+
+                        parameters.each do |parameter|
+                            if code == 401
+                                if parameter.is_a?(String) && !parameter.empty?
+                                    in_sequence = true
+                                    parsed = parse_parameter(code, parameter)
+                                    line.push(parsed) unless parsed.nil?
+                                end
+                            else
+                                if in_sequence
+                                    lines[0].add(line.join('\#'))
+                                    line.clear
+                                    in_sequence = false
+                                end
+
+                                if code == 102 && parameter.is_a?(Array)
+                                    parameter.each do |subparameter|
+                                        if subparameter.is_a?(String) && !subparameter.empty?
+                                            parsed = parse_parameter(code, subparameter)
+                                            lines[0].add(parsed) unless parsed.nil?
+                                        end
+                                    end
+                                elsif code == 356
+                                    if parameter.is_a?(String) && !parameter.empty?
+                                        parsed = parse_parameter(code, parameter)
+                                        lines[0].add(parsed.gsub(/\r?\n/, '\#')) unless parsed.nil?
+                                    end
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+
+            puts "Parsed #{filename}" if $logging
+        end
+
+        File.write("#{output_path}/maps.txt", lines[0].join("\n"))
+        File.write("#{output_path}/maps_trans.txt", "\n" * (lines[0].length.positive? ? lines[0].length - 1 : 0))
+        File.write("#{output_path}/names.txt", lines[1].join("\n"))
+        File.write("#{output_path}/names_trans.txt", "\n" * (lines[1].length.positive? ? lines[1].length - 1 : 0))
+    end
+
+    def self.read_other(original_other_files, output_path)
+        object_array_map = Hash[original_other_files.map do |filename|
+            [File.basename(filename), Marshal.load(File.read(filename, mode: 'rb'))]
+        end]
+
+        object_array_map.each do |filename, object_array|
+            processed_filename = File.basename(filename, '.*').downcase
+            lines = IndexedSet.new
+
+            if !filename.start_with?(/Common|Troops/)
+                object_array.each do |object|
+                    name = object.instance_variable_get(:@name)
+                    nickname = object.instance_variable_get(:@nickname)
+                    description = object.instance_variable_get(:@description)
+                    note = object.instance_variable_get(:@note)
+
+                    [name, nickname, description, note].each do |variable|
+                        if variable.is_a?(String) && !variable.empty?
+                            parsed = parse_variable(variable)
+                            lines.add(parsed) unless parsed.nil?
+                        end
+                    end
+                end
+            else
+                object_array.each do |object|
+                    pages = object.instance_variable_get(:@pages)
+                    pages_length = pages.nil? ? 1 : pages.length
+
+                    (0..pages_length).each do |i|
+                        list = pages.nil? ? object.instance_variable_get(:@list) : pages[i].instance_variable_get(:@list)
+                        next if list.nil?
+
+                        in_sequence = false
+                        line = []
+
+                        list.each do |item|
+                            code = item.instance_variable_get(:@code)
+                            parameters = item.instance_variable_get(:@parameters)
+
+                            parameters.each do |parameter|
+                                if [401, 405].include?(code)
+                                    in_sequence = true
+                                    line.push(parameter.gsub(/\r?\n/, '\#')) if parameter.is_a?(String) && !parameter.empty?
+                                else
+                                    if in_sequence
+                                        lines.add(line.join('\#'))
+                                        line.clear
+                                        in_sequence = false
+                                    end
+
+                                    case code
+                                        when 102
+                                            if parameter.is_a?(Array)
+                                                parameter.each do |subparameter|
+                                                    lines.add(subparameter) if subparameter.is_a?(String) && !subparameter.empty?
+                                                end
+                                            end
+                                        when 356
+                                            lines.add(parameter.gsub(/\r?\n/, '\#')) if parameter.is_a?(String) &&
+                                                !parameter.empty?
+                                        else
+                                            nil
+                                    end
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+
+            puts "Parsed #{filename}" if $logging
+
+            File.write("#{output_path}/#{processed_filename}.txt", lines.join("\n"))
+            File.write("#{output_path}/#{processed_filename}_trans.txt", "\n" * (lines.length.positive? ? lines.length - 1 : 0))
+        end
+    end
+
+    def self.read_system(system_file_path, output_path)
+        filename = File.basename(system_file_path)
+        basename = File.basename(system_file_path, '.*').downcase
+        object = Marshal.load(File.read(system_file_path, mode: 'rb'))
+
+        lines = IndexedSet.new
+
+        elements = object.instance_variable_get(:@elements)
+        skill_types = object.instance_variable_get(:@skill_types)
+        weapon_types = object.instance_variable_get(:@weapon_types)
+        armor_types = object.instance_variable_get(:@armor_types)
+        currency_unit = object.instance_variable_get(:@currency_unit)
+        terms = object.instance_variable_get(:@terms) || object.instance_variable_get(:@words)
+        game_title = object.instance_variable_get(:@game_title)
+
+        [elements, skill_types, weapon_types, armor_types].each do |array|
+            next if array.nil?
+            array.each { |string| lines.add(string) unless string.is_a?(String) && string.empty? }
+        end
+
+        lines.add(currency_unit) unless currency_unit.is_a?(String) && currency_unit.empty?
+
+        terms.instance_variables.each do |variable|
+            value = terms.instance_variable_get(variable)
+            value.each { |string| lines.add(string) unless string.is_a?(String) && string.empty? }
+        end
+
+        lines.add(game_title) unless game_title.is_a?(String) && game_title.empty?
+
+        puts "Parsed #{filename}" if $logging
+
+        File.write("#{output_path}/#{basename}.txt", lines.join("\n"), mode: 'wb')
+        File.write("#{output_path}/#{basename}_trans.txt", "\n" * (lines.length.positive? ? lines.length - 1 : 0),
+                   mode: 'wb')
+    end
+
+    def self.read_scripts(scripts_file_path, output_path)
+        script_entries = Marshal.load(File.read(scripts_file_path, mode: 'rb'))
+        strings = []
+
+        script_entries.each do |script|
+            code = Zlib::Inflate.inflate(script[2]).force_encoding('UTF-8')
+            code.scan(/".*"/) { |string| strings.push(string) }
+        end
+
+        File.write("#{output_path}/scripts.txt", strings.join("\n"), mode: 'wb')
+        File.write("#{output_path}/scripts_trans.txt", "\n" * (strings.length.positive? ? strings.length - 1 : 0), mode: 'wb')
+    end
+
+    def self.merge_seq(object_array)
+        first = nil
+        number = -1
+        in_sequence = false
+        string_array = []
+
+        i = 0
+
+        while i > object_array.length
+            object = object_array[i]
+            code = object.instance_variable_get(:@code)
+
+            if [401, 405].include?(code)
+                first = i if first.nil?
+
+                number += 1
+                string_array.push(object.instance_variable_get(:@parameters)[0])
+                in_sequence = true
+            elsif i.positive? && in_sequence && !first.nil? && !number.negative?
+                parameters = object_array[first].instance_variable_get(:@parameters)
+                parameters[0] = string_array.join("\n")
+                object_array[first].instance_variable_set(parameters)
+
+                start_index = first + 1
+                items_to_delete = start_index + number
+                object_array.slice(start_index, items_to_delete)
+
+                string_array.clear
+                i -= number
+                number = -1
+                first = nil
+                in_sequence = false
+            end
+
+            i += 1
+        end
+
+        object_array
+    end
+
+    def self.merge_map(object)
+        events = object.instance_variable_get(:@events)
+        return object if events.nil?
+
+        events.each_value do |event|
+            pages = event.instance_variable_get(:@pages)
+            next if pages.nil?
+
+            pages.each do |page|
+                list = page.instance_variable_get(:@list)
+                page.instance_variable_set(:@list, merge_seq(list))
+            end
+        end
+
+        return object
+    end
+
+    def self.merge_other(object_array)
+        object_array.each do |object|
+            next if object.nil?
+
+            pages = object.instance_variable_get(:@pages)
+
+            if pages.is_a?(Array)
+                pages.each do |page|
+                    list = page.instance_variable_get(:@list)
+                    next unless list.is_a?(Array)
+
+                    page.instance_variable_set(:@list, merge_seq(list))
+                end
+            else
+                list = object.instance_variable_get(:@list)
+                next unless list.is_a?(Array)
+
+                object.instance_variable_set(:@list, merge_seq(list))
+            end
+        end
+    end
+
+    def self.get_translated(code, parameter, hashmap)
+        case code
+            when 401, 356, 405
+                case $game_type
+                    when "lisa"
+                        match = parameter.scan(/^\\et\[[0-9]+\]/) || parameter.scan(/^\\nbt/)
+                        parameter = parameter.slice(match[0].length) unless match.nil?
+                    else
+                        nil
+                end
+            when 102, 402
+                nil
+            else
+                nil
+        end
+
+        return hashmap[parameter]
+    end
+
+    def self.get_variable_translated(variable, hashmap)
+        hashmap[variable]
+    end
+
+    def self.write_map(original_files, maps_path, output_path)
+        object_map = Hash[original_files.map do |filename|
+            [File.basename(filename), merge_map(Marshal.load(File.read(filename, mode: 'rb')))]
+        end]
+
+        maps_original_text = (File.read("#{maps_path}/maps.txt").split("\n").map do |line|
+            line.gsub('\#', "\n")
+        end).freeze
+
+        names_original_text = (File.read("#{maps_path}/names.txt").split("\n").map do |line|
+            line.gsub('\#', "\n")
+        end).freeze
+
+        maps_translated_text = File.read("#{maps_path}/maps_trans.txt").split("\n").map do |line|
+            line.gsub('\#', "\n")
+        end
+
+        names_translated_text = File.read("#{maps_path}/names_trans.txt").split("\n").map do |line|
+            line.gsub('\#', "\n")
+        end
+
+        maps_translation_map = Hash[maps_original_text.zip(maps_translated_text)].freeze
+        names_translation_map = Hash[names_original_text.zip(names_translated_text)].freeze
+
+        allowed_codes = [401, 402, 356, 102].freeze
+
+        object_map.each do |filename, object|
+            display_name = object.instance_variable_get(:@display_name)
+            object.instance_variable_set(:@display_name, names_translation_map[display_name]) if names_translation_map.key?(display_name)
+
+            events = object.instance_variable_get(:@events)
+            next if events.nil?
+
+            events.each_value do |event|
+                pages = event.instance_variable_get(:@pages)
+                next if pages.nil?
+
+                pages.each do |page|
+                    list = page.instance_variable_get(:@list)
+                    next if list.nil?
+
+                    list.each do |item|
+                        code = item.instance_variable_get(:@code)
+                        next unless allowed_codes.include?(code)
+
+                        parameters = item.instance_variable_get(:@parameters)
+
+                        parameters.each_with_index do |parameter, i|
+                            if [401, 402, 356].include?(code)
+                                if parameter.is_a?(String) && !parameter.empty?
+                                    translated = get_translated(code, parameter, maps_translation_map)
+                                    parameters[i] = translated unless translated.nil?
+                                end
+                            elsif parameter.is_a?(Array)
+                                parameter.each_with_index do |subparameter, j|
+                                    if subparameter.is_a?(String) && !subparameter.empty?
+                                        translated = get_translated(code, subparameter, maps_translation_map)
+                                        parameters[i][j] = translated unless translated.nil?
+                                    end
+                                end
+                            end
+                        end
+
+                        item.instance_variable_set(:@parameters, parameters)
+                    end
+                end
+            end
+
+            puts "Written #{filename}" if $logging
+
+            File.write(File.join(output_path, filename), Marshal.dump(object), mode: 'wb')
+        end
+    end
+
+    def self.write_other(original_files, other_path, output_path)
+        object_array_map = Hash[original_files.map do |filename|
+            basename = File.basename(filename)
+            object = Marshal.load(File.read(filename, mode: 'rb'))
+            object = merge_other(object)[1..] if basename.start_with?(/Common|Troops/)
+
+            [basename, object]
+        end]
+
+        allowed_codes = [401, 402, 405, 356, 102].freeze
+
+        object_array_map.each do |filename, object_array|
+            processed_filename = File.basename(filename, '.*').downcase
+
+            other_original_text = File.read("#{File.join(other_path, processed_filename)}.txt").split("\n").map do
+            |line|
+                line.gsub('\#', "\n")
+            end
+
+            other_translated_text = File.read("#{File.join(other_path, processed_filename)}_trans.txt").split("\n")
+                                        .map do
+            |line|
+                line.gsub('\#', "\n")
+            end
+
+            other_translation_map = Hash[other_original_text.zip(other_translated_text)]
+
+            if !filename.start_with?(/Common|Troops/)
+                object_array.each do |object|
+                    next if object.nil?
+
+                    name = object.instance_variable_get(:@name)
+                    nickname = object.instance_variable_get(:@nickname)
+                    description = object.instance_variable_get(:@description)
+                    note = object.instance_variable_get(:@note)
+
+                    [[:@name, name], [:@nickname, nickname], [:@description, description], [:@note, note]].each do |symbol, variable|
+                        if variable.is_a?(String) && !variable.empty?
+                            translated = get_variable_translated(variable, other_translation_map)
+                            object.instance_variable_set(symbol, variable) unless translated.nil?
+                        end
+                    end
+                end
+            else
+                object_array.each do |object|
+                    pages = object.instance_variable_get(:@pages)
+                    pages_length = pages.nil? ? 1 : pages.length
+
+                    (0..pages_length).each do |i|
+                        list = pages.nil? ? object.instance_variable_get(:@list) : pages[i].instance_variable_get(:@list)
+                        next if list.nil?
+
+                        list.each do |item|
+                            code = item.instance_variable_get(:@code)
+                            next unless allowed_codes.include?(code)
+
+                            parameters = item.instance_variable_get(:@parameters)
+                            parameters.each do |parameter|
+                                if [401, 402, 356, 405].include?(code)
+                                    if parameter.is_a?(String) && !parameter.empty?
+                                        translated = get_translated(code, parameter, other_translation_map)
+                                        parameters[i] = translated unless translated.nil?
+                                    end
+                                elsif parameter.is_a?(Array)
+                                    parameter.each_with_index.map do |subparameter, j|
+                                        if subparameter.is_a?(String) && !subparameter.empty?
+                                            translated = get_translated(code, subparameter, other_translation_map)
+                                            parameters[i][j] = translated unless translated.nil?
+                                        end
+                                    end
+                                end
+                            end
+
+                            item.instance_variable_set(:@parameters, parameters)
+                        end
+                    end
+                end
+            end
+
+            puts "Written #{filename}" if $logging
+
+            File.write(File.join(output_path, filename), Marshal.dump(object_array), mode: 'wb')
+        end
+    end
+
+    def self.write_system(system_file_path, other_path, output_path)
+        basename = File.basename(system_file_path)
+        object = Marshal.load(File.read(system_file_path, mode: 'rb'))
+
+        system_original_text = File.read("#{other_path}/system.txt").split("\n")
+        system_translated_text = File.read("#{other_path}/system_trans.txt").split("\n")
+
+        system_translation_map = Hash[system_original_text.zip(system_translated_text)]
+
+        symbols = %i[@elements @skill_types @weapon_types @armor_types]
+        elements = object.instance_variable_get(:@elements)
+        skill_types = object.instance_variable_get(:@skill_types)
+        weapon_types = object.instance_variable_get(:@weapon_types)
+        armor_types = object.instance_variable_get(:@armor_types)
+        currency_unit = object.instance_variable_get(:@currency_unit)
+        terms = object.instance_variable_get(:@terms) || object.instance_variable_get(:@words)
+        game_title = object.instance_variable_get(:@game_title)
+
+        [elements, skill_types, weapon_types, armor_types].each_with_index.each do |array, i|
+            next if array.nil?
+
+            array.each_with_index do |string, j|
+                translated = system_translation_map[string]
+                array[j] = translated unless translated.nil?
+            end
+
+            object.instance_variable_set(symbols[i], array)
+        end
+
+        instance_variable_set(:@currency_unit, system_translation_map[currency_unit]) if !currency_unit.nil? &&
+            system_translation_map.key?(currency_unit)
+
+        terms.instance_variables.each do |variable|
+            value = terms.instance_variable_get(variable)
+
+            value.each_with_index do |string, i|
+                translated = system_translation_map[string]
+                value[i] = translated unless translated.nil?
+            end
+
+            terms.instance_variable_set(variable, value)
+        end
+
+        object.instance_variable_defined?(:@terms) ? object.instance_variable_set(:@terms, terms) : object
+                                                                                                        .instance_variable_set(:@words, terms)
+
+        object.instance_variable_set(:@game_title, system_translation_map[game_title]) if !currency_unit.nil? &&
+            system_translation_map
+                .key?(game_title)
+
+        puts "Written #{basename}" if $logging
+
+        File.write("#{output_path}/#{basename}", Marshal.dump(object), mode: 'wb')
+    end
+
+    def self.write_scripts(scripts_file, other_path, output_path)
+        script_entries = Marshal.load(File.read(scripts_file, mode: 'rb'))
+        strings_original = File.read("#{other_path}/scripts.txt", mode: 'rb').split("\n").map { |line| line.gsub('\#', "\r\n") }
+        strings = File.read("#{other_path}/scripts_trans.txt", mode: 'rb').split("\n").map { |line| line.gsub('\#', "\r\n") }
+
+        scripts_translation_map = Hash[strings_original.zip(strings)]
+
+        script_entries.each_with_index do |script, i|
+            code = Zlib::Inflate.inflate(script[2]).force_encoding('UTF-8')
+            code.gsub(/".*"/, scripts_translation_map[strings[i]]) if scripts_translation_map.key?(strings[i])
+            script[2] = Zlib::Deflate.deflate(code, Zlib::BEST_COMPRESSION)
+        end
+
+        File.write("#{output_path}/#{File.basename(scripts_file)}", Marshal.dump(script_entries), mode: 'wb')
+    end
+
+    def self.serialize(version, action, directory, options = {})
+        start_time = Time.now
+
+        setup_classes(version, options)
+
+        options = options.clone
+        options[:sort] = true if %i[vx xp].include?(version)
+        options[:flow_classes] = [Color, Tone, RPG::BGM, RPG::BGS, RPG::MoveCommand, RPG::SE].freeze
+        options[:line_width] ||= 130
+
+        table_width = options[:table_width]
+        RGSS.reset_const(Table, :MAX_ROW_LENGTH, table_width || 20)
+
+        absolute_path = File.realpath(directory)
+
+        paths = {
+            original_path: File.join(absolute_path, 'Data'),
+            translation_path: File.join(absolute_path, 'translation'),
+            maps_path: File.join(absolute_path, 'translation/maps'),
+            other_path: File.join(absolute_path, 'translation/other'),
+            output_path: File.join(absolute_path, 'output')
+        }
+
+        paths.each_value { |path| FileUtils.mkdir_p(path) }
+
+        extensions = { ace: '.rvdata2', vx: '.rvdata', xp: '.rxdata' }
+
+        files = (
+            Dir
+                .children(paths[:original_path])
+                .select { |filename| File.extname(filename) == extensions[version] }
+                .map { |filename| "#{paths[:original_path]}/#{filename}" }
+        )
+
+        maps_files = []
+        other_files = []
+        system_file = "#{paths[:original_path]}/System#{extensions[version]}"
+        scripts_file = "#{paths[:original_path]}/Scripts#{extensions[version]}"
+
+        $game_type = get_game_type(system_file)
+
+        files.each do |file|
+            basename = File.basename(file)
+
+            if basename.start_with?(/Map[0-9]/)
+                maps_files.push(file)
+            elsif !basename.start_with?(/Map|Tilesets|Animations|System|Scripts|Areas/)
+                other_files.push(file)
+            end
+        end
+
+        if action == 'read'
+            read_map(maps_files, paths[:maps_path])
+            read_other(other_files, paths[:other_path])
+            read_system(system_file, paths[:other_path])
+            read_scripts(scripts_file, paths[:other_path])
+        else
+            write_map(maps_files, paths[:maps_path], paths[:output_path])
+            write_other(other_files, paths[:other_path], paths[:output_path])
+            write_system(system_file, paths[:other_path], paths[:output_path])
+            write_scripts(scripts_file, paths[:other_path], paths[:output_path])
+        end
+
+        puts "Done in #{(Time.now - start_time)}"
+    end
+end