rvpacker-ng 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 548008eb85d312d1f74cf7be57e145797b3a6e0506c66e7768159ab74dd26ced
+  data.tar.gz: f8ead7347cdc744c982395ec592021ee48c24643e752b809ed24b9aea78cf8b2
+SHA512:
+  metadata.gz: 8f298da9896242cacd9616f932cd17dfc5cf392d2e0810e055663d6b6995fd660559c77e201dc60f250c47f67536fc7fdf1e63e501b6dc74422213e0c17d62d7
+  data.tar.gz: 6a6520720f0eba8d9db96455caaaee8d0a11b7a8125a21de150196bca1fa5aedb4ca3701dda293e7b1f47bccd0dfa2322d401ec9046f3b71b3376c121b40e2e9

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.prettierrc

@@ -0,0 +1,9 @@
+{
+    "tabWidth": 2,
+    "useTabs": false,
+    "rubyToProc": true,
+    "rubyArrayLiteral": true,
+    "rubyHashLabel": true,
+    "rubyModifier": true
+}
+  

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rvpacker.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,17 @@
+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.

data/README.md

@@ -0,0 +1,107 @@
+# rvpacker
+
+A tool to unpack & pack RPGMaker data files into text so they can be version controlled & collaborated on. It's a port of Ruby 1.9.x's rvpacker to Ruby 3.x.
+
+rvpacker consists of 3 parts:
+
+* RPG library (stub classes for serialization of RPGMaker game data)
+* RGSS library (some more classes for RPGMaker serialization)
+* rvpacker (the script you call on the frontend)
+
+# Installation
+
+```
+$ gem install rvpacker-ng
+```
+
+Usage
+=====
+
+```
+$ rvpacker --help
+Options:
+  -a, --action=<s>          Action to perform on project (unpack|pack)
+  -d, --project=<s>         RPG Maker Project directory
+  -f, --force               Update target even when source is older than target
+  -t, --project-type=<s>    Project type (vx|ace|xp)
+  -V, --verbose             Print verbose information while processing
+  -D, --database=<s>        Only work on the given database
+  -h, --help                Show this message
+```
+
+For example, to unpack a RPG Maker VX Ace project in ~/Documents/RPGVXAce/Project1:
+
+```
+$ rvpacker --action unpack --project ~/Documents/RPGVXAce/Project1 --project-type ace
+```
+
+This will expand all Data/* files into (PROJECT)/YAML/ as YAML files (YAML is used because the object serialization data is retained, which ruby's YAML parser is very good at - otherwise I would have changed it to JSON). The Scripts will be unpacked as individual .rb files into (PROJECT)/Scripts/.
+
+To take a previously unpacked project, and pack it back up:
+
+```
+$ rvpacker --action pack --project ~/Documents/RPGVXAce/Project1 --project-type ace
+```
+
+This will take all of the yaml files in (PROJECT)/YAML and all the scripts in (PROJECT)/Scripts, and repack all of your (PROJECT)/Data/* files. You can trust this to completely reassemble your Data/ directory, so long as the Scripts/ and YAML/ directories remain intact.
+
+## FAQ
+
+### General
+
+This is great for teams that are collaborating on an RPG Maker project. Just add a few steps to your existing workflow:
+
+* Checkout the project from version control
+* Run 'rvpacker --action pack' on the project to repack it for the RPG Maker tool
+* Load up RPG Maker and do whatever you're going to do; save the project
+* Run 'rvpacker --action unpack' on the project
+* Commit everything to version control (ignore the Data directory since you don't need it anymore; use .gitignore or .hgignore or whatever)
+
+Now your project can be forked/merged in a much more safe/sane way, and you don't have to have someone bottlenecking the entire process.
+
+### Avoiding Map Collisions
+
+One thing that rvpacker really can't help you with right now (and, ironically, probably one of the reasons you want it) is map collisions. Consider this situation:
+
+* The project has 10 maps in it, total.
+* Developer A makes a new map. It gets saved by the editor as Map011
+* Developer B makes a new map, in a different branch. It also gets saved by the editor as Map011.
+* Developer A and Developer B attempt to merge their changes. The merge fails because of the collision on the Map011 file.
+
+The best way to avoid this that I can see is to use blocks of pre-allocated maps. You appoint one person in your project to be principally responsible for the map assets. It then becomes this person's responsibility to allocate maps in "blocks", so that people can work on maps in a distributed way without clobbering one another. The workflow looks like this:
+
+* The project has 10 maps in it, total.
+* Developer A needs to make 4 maps. He sends a request to the "map owner", requesting a block of 4 maps.
+* The map owner creates 4 default, blank maps, and names them all "Request #12345" for Developer A
+* Developer A starts working on his maps
+* Developer B needs to make 6 maps. He sends a request to the "map owner", requesting a block of 6 maps.
+* The map owner 4 default, blank maps, and names them all "Request #12346" or something similar for Developer B
+* Developer B starts working on his maps
+
+Using this workflow, it doesn't matter what order Developers A and B request their map blocks, or what order the map owner creates their map blocks. By giving the map owner the authority to create the map blocks, the individual developers can work freely in their map blocks. They can rename them, reorder them, change all of the map attributes (Size, tileset, whatever), without getting in danger of a map collision.
+
+While this may seem like unnecessary process, it is a reasonable workaround. For a better explanation of why rvpacker can't do this for you, read the next section.
+
+### Automatic ID generation
+
+You can add new elements to the YAML files manually, and leave their 'id:' field set to 'null'. This will cause the rvpacker pack action to automatically assign them a new ID number at the end of the sequence (e.g., if you have 17 items, the new one becomes ID 18). This is mainly handy for adding new scripts to the project without having to open the RPG maker and paste the script in; just make the new script file, add its entry in YAML/Scripts.yaml, and the designer will have your script accessible the next time they repack and open the project.
+
+Also, the rvpacker tool sets the ID of script files to an autoincrementing integer. The scripts exist in the database with a magic number that I can't recreate, and nothing in the editor (RPG VX Ace anyway) seems to care if the magic number changes. It doesn't even affect the ordering. So in order to support adding new scripts with null IDs, like everything else, the magic numbers on scripts are disregarded and a new ID number is forced on the scripts when the rvpacker pack action occurs.
+
+Note that this does not apply to Map files. Do not try changing the map ID numbers manually (see the "Avoiding Map Collisions" workflow, above, and "Why rvpacker can't help with map collisions", below).
+
+### Why rvpacker can't help with map collisions
+
+If you look at the map collision problem described above, the way out of this situation might seem obvious: "Rename Map011.yaml in one of the branches to Map012.yaml, and problem solved. However, there are several significant problems with this approach:
+
+* The ID numbers on the map files correspond to ID number entries in MapInfos.yaml (and the corresponding MapInfos.rvdata objects)
+* The ID numbers are used to specify a parent/child relationship between one or more maps
+* The ID numbers are used to specify the target of a map transition/warp event in event scripting
+
+This means that changing the ID number assigned to a map (and, thereby, making it possible to merge 2 maps with the same ID number) becomes very nontrivial. The event scripting portion, especially, presents a difficult problem for rvpacker to overcome. It is simple enough for rvpacker to change the IDs of any new map created, and to change the reference to that ID number from any child maps. However, the events are where it gets sticky. The format of event calls in RPG Maker map files is not terribly well defined, and even if it was, I sincerely doubt that you want rvpacker tearing around in the guts of your map events.
+
+## Credit to SiCrane
+
+The RPG and RGSS libraries were originally taken from SiCrane's YAML importer/exporter on the gamedev forums. I initially just put them in github so I wouldn't lose them, and added the rvpacker script frontend. They are starting to drift a bit, but SiCrane still gets original credit for the grand majority of the work that rvpacker does.
+
+http://www.gamedev.net/topic/646333-rpg-maker-vx-ace-data-conversion-utility/

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/rvpacker

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'optimist'
+require 'RGSS'
+
+opts =
+    Optimist.options do
+        opt :action,
+            'Action to perform on project (unpack|pack)',
+            short: 'a',
+            type: String
+        opt :project, 'RPG Maker Project directory', short: 'd', type: String
+        opt :force,
+            'Update target even when source is older than target',
+            short: 'f'
+        opt :project_type, 'Project type (vx|ace|xp)', short: 't', type: String
+        opt :verbose, 'Print verbose information while processing', short: 'V'
+        opt :database,
+            'Only work on the given database',
+            short: 'D',
+            type: String
+    end
+
+directions = { 'unpack' => :all_bin_to_text, 'pack' => :all_text_to_bin }
+projecttypes = { 'vx' => :vx, 'ace' => :ace, 'xp' => :xp }
+$VERBOSE = opts[:verbose]
+
+RGSS.serialize(
+    projecttypes[opts[:project_type]],
+    directions[opts[:action]],
+    opts[:project],
+    {
+        force: (opts[:force] ? true : false),
+        line_width: -1,
+        table_width: -1,
+        database: opts[:database]
+    }
+)

data/lib/RGSS/BasicCoder.rb

@@ -0,0 +1,53 @@
+module RGSS
+    module BasicCoder
+        def encode_with(coder)
+            ivars.each do |var|
+                name = var.to_s.sub(/^@/, '')
+                value = instance_variable_get(var)
+                coder[name] = encode(name, value)
+            end
+        end
+
+        def encode(name, value)
+            return value
+        end
+
+        def init_with(coder)
+            coder.map.each do |key, value|
+                sym = "@#{key}".to_sym
+                instance_variable_set(sym, decode(key, value))
+            end
+        end
+
+        def decode(name, value)
+            return value
+        end
+
+        def ivars
+            return instance_variables
+        end
+
+        INCLUDED_CLASSES = []
+        def self.included(mod)
+            INCLUDED_CLASSES.push(mod)
+        end
+
+        def self.set_ivars_methods(version)
+            INCLUDED_CLASSES.each do |c|
+                if version == :ace
+                    RGSS.reset_method(
+                        c,
+                        :ivars,
+                        -> { return instance_variables }
+                    )
+                else
+                    RGSS.reset_method(
+                        c,
+                        :ivars,
+                        -> { return instance_variables.sort }
+                    )
+                end
+            end
+        end
+    end
+end

data/lib/RGSS/serialize.rb

@@ -0,0 +1,448 @@
+=begin
+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.
+=end
+
+require 'psych'
+require 'fileutils'
+require 'zlib'
+require 'pp'
+require 'formatador'
+
+module RGSS
+    def self.change_extension(file, new_ext)
+        return File.basename(file, '.*') + new_ext
+    end
+
+    def self.sanitize_filename(filename)
+        return filename.gsub(/[^0-9A-Za-z]+/, '_')
+    end
+
+    def self.files_with_extension(directory, extension)
+        return(
+            Dir
+                .entries(directory)
+                .select { |file| File.extname(file) == extension }
+        )
+    end
+
+    def self.inflate(str)
+        text = Zlib::Inflate.inflate(str)
+        return text.force_encoding('UTF-8')
+    end
+
+    def self.deflate(str)
+        return Zlib::Deflate.deflate(str, Zlib::BEST_COMPRESSION)
+    end
+
+    def self.dump_data_file(file, data, time, options)
+        File.open(file, 'wb') { |f| Marshal.dump(data, f) }
+        File.utime(time, time, file)
+    end
+
+    def self.dump_yaml_file(file, data, time, options)
+        File.open(file, 'wb') { |f| Psych.dump(data, f, options) }
+        File.utime(time, time, file)
+    end
+
+    def self.dump_save(file, data, time, options)
+        File.open(file, 'wb') do |f|
+            data.each { |chunk| Marshal.dump(chunk, f) }
+        end
+        File.utime(time, time, file)
+    end
+
+    def self.dump_raw_file(file, data, time, options)
+        File.open(file, 'wb') { |f| f.write(data) }
+        File.utime(time, time, file)
+    end
+
+    def self.dump(dumper, file, data, time, options)
+        self.method(dumper).call(file, data, time, options)
+    rescue StandardError
+        warn "Exception dumping #{file}"
+        raise
+    end
+
+    def self.load_data_file(file)
+        File.open(file, 'rb') { |f| return Marshal.load(f) }
+    end
+
+    def self.load_yaml_file(file)
+        formatador = Formatador.new
+        obj = nil
+        File.open(file, 'rb') { |f| obj = Psych.load(f) }
+        max = 0
+        return obj unless obj.kind_of?(Array)
+        seen = {}
+        idx =
+            obj.each do |elem|
+                next if elem.nil?
+                if elem.instance_variable_defined?('@id')
+                    id = elem.instance_variable_get('@id')
+                else
+                    id = nil
+                    elem.instance_variable_set('@id', nil)
+                end
+                next if id.nil?
+
+                if seen.has_key?(id)
+                    formatador.display_line(
+                        "[red]#{file}: Duplicate ID #{id}[/]"
+                    )
+                    formatador.indent do
+                        formatador.indent do
+                            elem
+                                .pretty_inspect
+                                .split(/\n/)
+                                .each do |line|
+                                    formatador.display_line("[red]#{line}[/]")
+                                end
+                        end
+                        formatador.display_line
+                        formatador.display_line("[red]Last seen at:\n[/]")
+                        formatador.indent do
+                            elem
+                                .pretty_inspect
+                                .split(/\n/)
+                                .each do |line|
+                                    formatador.display_line("[red]#{line}[/]")
+                                end
+                        end
+                    end
+                    exit
+                end
+                seen[id] = elem
+                max = ((id + 1) unless id < max)
+            end
+        obj.each do |elem|
+            next if elem.nil?
+            id = elem.instance_variable_get('@id')
+            if id.nil?
+                elem.instance_variable_set('@id', max)
+                max += 1
+            end
+        end
+        return obj
+    end
+
+    def self.load_raw_file(file)
+        File.open(file, 'rb') { |f| return f.read }
+    end
+
+    def self.load_save(file)
+        File.open(file, 'rb') do |f|
+            data = []
+            while not f.eof?
+                o = Marshal.load(f)
+                data.push(o)
+            end
+            return data
+        end
+    end
+
+    def self.load(loader, file)
+        return self.method(loader).call(file)
+    rescue StandardError
+        warn "Exception loading #{file}"
+        raise
+    end
+
+    def self.scripts_to_text(dirs, src, dest, options)
+        formatador = Formatador.new
+        src_file = File.join(dirs[:data], src)
+        dest_file = File.join(dirs[:yaml], dest)
+        raise "Missing #{src}" unless File.exist?(src_file)
+
+        script_entries = load(:load_data_file, src_file)
+        check_time = !options[:force] && File.exist?(dest_file)
+        oldest_time = File.mtime(dest_file) if check_time
+
+        file_map, script_index, script_code = Hash.new(-1), [], {}
+
+        idx = 0
+        script_entries.each do |script|
+            idx += 1
+            magic_number, script_name, code = idx, script[1], inflate(script[2])
+            script_name.force_encoding('UTF-8')
+
+            if code.length > 0
+                filename =
+                    if script_name.empty?
+                        'blank'
+                    else
+                        sanitize_filename(script_name)
+                    end
+                key = filename.upcase
+                value = (file_map[key] += 1)
+                actual_filename =
+                    filename + (value == 0 ? '' : ".#{value}") + RUBY_EXT
+                script_index.push([magic_number, script_name, actual_filename])
+                full_filename = File.join(dirs[:script], actual_filename)
+                script_code[full_filename] = code
+                check_time = false unless File.exist?(full_filename)
+                oldest_time = [
+                    File.mtime(full_filename),
+                    oldest_time
+                ].min if check_time
+            else
+                script_index.push([magic_number, script_name, nil])
+            end
+        end
+
+        src_time = File.mtime(src_file)
+        if check_time && (src_time - 1) < oldest_time
+            if $VERBOSE
+                formatador.display_line('[yellow]Skipping scripts to text[/]')
+            end
+        else
+            if $VERBOSE
+                formatador.display_line('[green]Converting scripts to text[/]')
+            end
+            dump(:dump_yaml_file, dest_file, script_index, src_time, options)
+            script_code.each do |file, code|
+                dump(:dump_raw_file, file, code, src_time, options)
+            end
+        end
+    end
+
+    def self.scripts_to_binary(dirs, src, dest, options)
+        formatador = Formatador.new
+        src_file = File.join(dirs[:yaml], src)
+        dest_file = File.join(dirs[:data], dest)
+        raise "Missing #{src}" unless File.exist?(src_file)
+        check_time = !options[:force] && File.exist?(dest_file)
+        newest_time = File.mtime(src_file) if check_time
+
+        index = load(:load_yaml_file, src_file)
+        script_entries = []
+        index.each do |entry|
+            magic_number, script_name, filename = entry
+            code = ''
+            if filename
+                full_filename = File.join(dirs[:script], filename)
+                unless File.exist?(full_filename)
+                    raise "Missing script file #{filename}"
+                end
+                newest_time = [
+                    File.mtime(full_filename),
+                    newest_time
+                ].max if check_time
+                code = load(:load_raw_file, full_filename)
+            end
+            script_entries.push([magic_number, script_name, deflate(code)])
+        end
+        if check_time && (newest_time - 1) < File.mtime(dest_file)
+            if $VERBOSE
+                formatador.display_line('[yellow]Skipping scripts to binary[/]')
+            end
+        else
+            if $VERBOSE
+                formatador.display_line(
+                    '[green]Converting scripts to binary[/]'
+                )
+            end
+            dump(
+                :dump_data_file,
+                dest_file,
+                script_entries,
+                newest_time,
+                options
+            )
+        end
+    end
+
+    def self.process_file(
+        file,
+        src_file,
+        dest_file,
+        dest_ext,
+        loader,
+        dumper,
+        options
+    )
+        formatador = Formatador.new
+        fbase = File.basename(file, File.extname(file))
+        if (!options[:database].nil?) and
+               (options[:database].downcase != fbase.downcase)
+            return
+        end
+        src_time = File.mtime(src_file)
+        if !options[:force] && File.exist?(dest_file) &&
+               (src_time - 1) < File.mtime(dest_file)
+            formatador.display_line("[yellow]Skipping #{file}[/]") if $VERBOSE
+        else
+            if $VERBOSE
+                formatador.display_line(
+                    "[green]Converting #{file} to #{dest_ext}[/]"
+                )
+            end
+            data = load(loader, src_file)
+            dump(dumper, dest_file, data, src_time, options)
+        end
+    end
+
+    def self.convert(src, dest, options)
+        files = files_with_extension(src[:directory], src[:ext])
+        files -= src[:exclude]
+
+        files.each do |file|
+            src_file = File.join(src[:directory], file)
+            dest_file =
+                File.join(dest[:directory], change_extension(file, dest[:ext]))
+
+            process_file(
+                file,
+                src_file,
+                dest_file,
+                dest[:ext],
+                src[:load_file],
+                dest[:dump_file],
+                options
+            )
+        end
+    end
+
+    def self.convert_saves(base, src, dest, options)
+        save_files = files_with_extension(base, src[:ext])
+        save_files.each do |file|
+            src_file = File.join(base, file)
+            dest_file = File.join(base, change_extension(file, dest[:ext]))
+
+            process_file(
+                file,
+                src_file,
+                dest_file,
+                dest[:ext],
+                src[:load_save],
+                dest[:dump_save],
+                options
+            )
+        end
+    end
+
+    # [version] one of :ace, :vx, :xp
+    # [direction] one of :data_bin_to_text, :data_text_to_bin, :save_bin_to_text,
+    #             :save_text_to_bin, :scripts_bin_to_text, :scripts_text_to_bin,
+    #             :all_text_to_bin, :all_bin_to_text
+    # [directory] directory that project file is in
+    # [options] :force - ignores file dates when converting (default false)
+    #           :round_trip - create yaml data that matches original marshalled data skips
+    #                         data cleanup operations (default false)
+    #           :line_width - line width form YAML files, -1 for no line width limit
+    #                         (default 130)
+    #           :table_width - maximum number of entries per row for table data, -1 for no
+    #                          table row limit (default 20)
+    def self.serialize(version, direction, directory, options = {})
+        raise "#{directory} not found" unless File.exist?(directory)
+
+        setup_classes(version, options)
+        options = options.clone
+        options[:sort] = true if %i[vx xp].include?(version)
+        options[:flow_classes] = FLOW_CLASSES
+        options[:line_width] ||= 130
+
+        table_width = options[:table_width]
+        RGSS.reset_const(Table, :MAX_ROW_LENGTH, table_width ? table_width : 20)
+
+        base = File.realpath(directory)
+
+        dirs = {
+            base: base,
+            data: get_data_directory(base),
+            yaml: get_yaml_directory(base),
+            script: get_script_directory(base)
+        }
+
+        dirs.values.each { |d| FileUtils.mkdir(d) unless File.exist?(d) }
+
+        exts = { ace: ACE_DATA_EXT, vx: VX_DATA_EXT, xp: XP_DATA_EXT }
+
+        yaml_scripts = SCRIPTS_BASE + YAML_EXT
+        yaml = {
+            directory: dirs[:yaml],
+            exclude: [yaml_scripts],
+            ext: YAML_EXT,
+            load_file: :load_yaml_file,
+            dump_file: :dump_yaml_file,
+            load_save: :load_yaml_file,
+            dump_save: :dump_yaml_file
+        }
+
+        scripts = SCRIPTS_BASE + exts[version]
+        data = {
+            directory: dirs[:data],
+            exclude: [scripts],
+            ext: exts[version],
+            load_file: :load_data_file,
+            dump_file: :dump_data_file,
+            load_save: :load_save,
+            dump_save: :dump_save
+        }
+
+        if options[:database].nil? or options[:database].downcase == 'scripts'
+            convert_scripts = true
+        else
+            convert_scripts = false
+        end
+        if options[:database].nil? or options[:database].downcase == 'saves'
+            convert_saves = true
+        else
+            convert_saves = false
+        end
+
+        case direction
+        when :data_bin_to_text
+            convert(data, yaml, options)
+            if convert_scripts
+                scripts_to_text(dirs, scripts, yaml_scripts, options)
+            end
+        when :data_text_to_bin
+            convert(yaml, data, options)
+            if convert_scripts
+                scripts_to_binary(dirs, yaml_scripts, scripts, options)
+            end
+        when :save_bin_to_text
+            convert_saves(base, data, yaml, options) if convert_saves
+        when :save_text_to_bin
+            convert_saves(base, yaml, data, options) if convert_saves
+        when :scripts_bin_to_text
+            if convert_scripts
+                scripts_to_text(dirs, scripts, yaml_scripts, options)
+            end
+        when :scripts_text_to_bin
+            if convert_scripts
+                scripts_to_binary(dirs, yaml_scripts, scripts, options)
+            end
+        when :all_bin_to_text
+            convert(data, yaml, options)
+            if convert_scripts
+                scripts_to_text(dirs, scripts, yaml_scripts, options)
+            end
+            convert_saves(base, data, yaml, options) if convert_saves
+        when :all_text_to_bin
+            convert(yaml, data, options)
+            if convert_scripts
+                scripts_to_binary(dirs, yaml_scripts, scripts, options)
+            end
+            convert_saves(base, yaml, data, options) if convert_saves
+        else
+            raise "Unrecognized direction :#{direction}"
+        end
+    end
+end

data/lib/RGSS.rb

@@ -0,0 +1,409 @@
+=begin
+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.
+=end
+
+require 'scanf'
+
+class Table
+    def initialize(bytes)
+        @dim, @x, @y, @z, items, *@data = bytes.unpack('L5 S*')
+        unless items == @data.length
+            raise 'Size mismatch loading Table from data'
+        end
+        unless @x * @y * @z == items
+            raise 'Size mismatch loading Table from data'
+        end
+    end
+
+    MAX_ROW_LENGTH = 20
+
+    def encode_with(coder)
+        coder.style = Psych::Nodes::Mapping::BLOCK
+
+        coder['dim'] = @dim
+        coder['x'] = @x
+        coder['y'] = @y
+        coder['z'] = @z
+
+        if @x * @y * @z > 0
+            stride = @x < 2 ? (@y < 2 ? @z : @y) : @x
+            rows = @data.each_slice(stride).to_a
+            if MAX_ROW_LENGTH != -1 && stride > MAX_ROW_LENGTH
+                block_length = (stride + MAX_ROW_LENGTH - 1) / MAX_ROW_LENGTH
+                row_length = (stride + block_length - 1) / block_length
+                rows =
+                    rows
+                        .collect { |x| x.each_slice(row_length).to_a }
+                        .flatten(1)
+            end
+            rows = rows.collect { |x| x.collect { |y| '%04x' % y }.join(' ') }
+            coder['data'] = rows
+        else
+            coder['data'] = []
+        end
+    end
+
+    def init_with(coder)
+        @dim = coder['dim']
+        @x = coder['x']
+        @y = coder['y']
+        @z = coder['z']
+        @data =
+            coder['data'].collect { |x| x.split(' ').collect(&:hex) }.flatten
+        items = @x * @y * @z
+        unless items == @data.length
+            raise 'Size mismatch loading Table from YAML'
+        end
+    end
+
+    def _dump(*ignored)
+        return [@dim, @x, @y, @z, @x * @y * @z, *@data].pack('L5 S*')
+    end
+
+    def self._load(bytes)
+        Table.new(bytes)
+    end
+end
+
+class Color
+    def initialize(bytes)
+        @r, @g, @b, @a = *bytes.unpack('D4')
+    end
+
+    def _dump(*ignored)
+        return [@r, @g, @b, @a].pack('D4')
+    end
+
+    def self._load(bytes)
+        Color.new(bytes)
+    end
+end
+
+class Tone
+    def initialize(bytes)
+        @r, @g, @b, @a = *bytes.unpack('D4')
+    end
+
+    def _dump(*ignored)
+        return [@r, @g, @b, @a].pack('D4')
+    end
+
+    def self._load(bytes)
+        Tone.new(bytes)
+    end
+end
+
+class Rect
+    def initialize(bytes)
+        @x, @y, @width, @height = *bytes.unpack('i4')
+    end
+
+    def _dump(*ignored)
+        return [@x, @y, @width, @height].pack('i4')
+    end
+
+    def self._load(bytes)
+        Rect.new(bytes)
+    end
+end
+
+module RGSS
+    def self.remove_defined_method(scope, name)
+        if scope.instance_methods(false).include?(name)
+            scope.send(:remove_method, name)
+        end
+    end
+
+    def self.reset_method(scope, name, method)
+        remove_defined_method(scope, name)
+        scope.send(:define_method, name, method)
+    end
+
+    def self.reset_const(scope, sym, value)
+        scope.send(:remove_const, sym) if scope.const_defined?(sym)
+        scope.send(:const_set, sym, value)
+    end
+
+    def self.array_to_hash(arr, &block)
+        h = {}
+        arr.each_with_index do |val, index|
+            r = block_given? ? block.call(val) : val
+            h[index] = r unless r.nil?
+        end
+        if arr.length > 0
+            last = arr.length - 1
+            h[last] = nil unless h.has_key?(last)
+        end
+        return h
+    end
+
+    def self.hash_to_array(hash)
+        arr = []
+        hash.each { |k, v| arr[k] = v }
+        return arr
+    end
+
+    require 'RGSS/BasicCoder'
+    require 'RPG'
+
+    # creates an empty class in a potentially nested scope
+    def self.process(root, name, *args)
+        if args.length > 0
+            process(root.const_get(name), *args)
+        else
+            unless root.const_defined?(name, false)
+                root.const_set(name, Class.new)
+            end
+        end
+    end
+
+    # other classes that don't need definitions
+    [
+        # RGSS data structures
+        %i[RPG Actor],
+        %i[RPG Animation],
+        %i[RPG Animation Frame],
+        %i[RPG Animation Timing],
+        %i[RPG Area],
+        %i[RPG Armor],
+        %i[RPG AudioFile],
+        %i[RPG BaseItem],
+        %i[RPG BaseItem Feature],
+        %i[RPG BGM],
+        %i[RPG BGS],
+        %i[RPG Class],
+        %i[RPG Class Learning],
+        %i[RPG CommonEvent],
+        %i[RPG Enemy],
+        %i[RPG Enemy Action],
+        %i[RPG Enemy DropItem],
+        %i[RPG EquipItem],
+        %i[RPG Event],
+        %i[RPG Event Page],
+        %i[RPG Event Page Condition],
+        %i[RPG Event Page Graphic],
+        %i[RPG Item],
+        %i[RPG Map],
+        %i[RPG Map Encounter],
+        %i[RPG MapInfo],
+        %i[RPG ME],
+        %i[RPG MoveCommand],
+        %i[RPG MoveRoute],
+        %i[RPG SE],
+        %i[RPG Skill],
+        %i[RPG State],
+        %i[RPG System Terms],
+        %i[RPG System TestBattler],
+        %i[RPG System Vehicle],
+        %i[RPG System Words],
+        %i[RPG Tileset],
+        %i[RPG Troop],
+        %i[RPG Troop Member],
+        %i[RPG Troop Page],
+        %i[RPG Troop Page Condition],
+        %i[RPG UsableItem],
+        %i[RPG UsableItem Damage],
+        %i[RPG UsableItem Effect],
+        %i[RPG Weapon],
+        # Script classes serialized in save game files
+        [:Game_ActionResult],
+        [:Game_Actor],
+        [:Game_Actors],
+        [:Game_BaseItem],
+        [:Game_BattleAction],
+        [:Game_CommonEvent],
+        [:Game_Enemy],
+        [:Game_Event],
+        [:Game_Follower],
+        [:Game_Followers],
+        [:Game_Interpreter],
+        [:Game_Map],
+        [:Game_Message],
+        [:Game_Party],
+        [:Game_Picture],
+        [:Game_Pictures],
+        [:Game_Player],
+        [:Game_System],
+        [:Game_Timer],
+        [:Game_Troop],
+        [:Game_Screen],
+        [:Game_Vehicle],
+        [:Interpreter]
+    ].each { |x| process(Object, *x) }
+
+    def self.setup_system(version, options)
+        # convert variable and switch name arrays to a hash when serialized
+        # if round_trip isn't set change version_id to fixed number
+        if options[:round_trip]
+            iso = ->(val) { return val }
+            reset_method(RPG::System, :reduce_string, iso)
+            reset_method(RPG::System, :map_version, iso)
+            reset_method(Game_System, :map_version, iso)
+        else
+            reset_method(
+                RPG::System,
+                :reduce_string,
+                ->(str) do
+                    return nil if str.nil?
+                    stripped = str.strip
+                    return stripped.empty? ? nil : stripped
+                end
+            )
+
+            # These magic numbers should be different. If they are the same, the saved version
+            # of the map in save files will be used instead of any updated version of the map
+            reset_method(
+                RPG::System,
+                :map_version,
+                ->(ignored) { return 12_345_678 }
+            )
+            reset_method(
+                Game_System,
+                :map_version,
+                ->(ignored) { return 87_654_321 }
+            )
+        end
+    end
+
+    def self.setup_interpreter(version)
+        # Game_Interpreter is marshalled differently in VX Ace
+        if version == :ace
+            reset_method(Game_Interpreter, :marshal_dump, -> { return @data })
+            reset_method(
+                Game_Interpreter,
+                :marshal_load,
+                ->(obj) { @data = obj }
+            )
+        else
+            remove_defined_method(Game_Interpreter, :marshal_dump)
+            remove_defined_method(Game_Interpreter, :marshal_load)
+        end
+    end
+
+    def self.setup_event_command(version, options)
+        # format event commands to flow style for the event codes that aren't move commands
+        if options[:round_trip]
+            reset_method(RPG::EventCommand, :clean, -> {  })
+        else
+            reset_method(
+                RPG::EventCommand,
+                :clean,
+                -> { @parameters[0].rstrip! if @code == 401 }
+            )
+        end
+        reset_const(
+            RPG::EventCommand,
+            :MOVE_LIST_CODE,
+            version == :xp ? 209 : 205
+        )
+    end
+
+    def self.setup_classes(version, options)
+        setup_system(version, options)
+        setup_interpreter(version)
+        setup_event_command(version, options)
+        BasicCoder.set_ivars_methods(version)
+    end
+
+    FLOW_CLASSES = [Color, Tone, RPG::BGM, RPG::BGS, RPG::MoveCommand, RPG::SE]
+
+    SCRIPTS_BASE = 'Scripts'
+
+    ACE_DATA_EXT = '.rvdata2'
+    VX_DATA_EXT = '.rvdata'
+    XP_DATA_EXT = '.rxdata'
+    YAML_EXT = '.yaml'
+    RUBY_EXT = '.rb'
+
+    def self.get_data_directory(base)
+        return File.join(base, 'Data')
+    end
+
+    def self.get_yaml_directory(base)
+        return File.join(base, 'YAML')
+    end
+
+    def self.get_script_directory(base)
+        return File.join(base, 'Scripts')
+    end
+
+    class Game_Switches
+        include RGSS::BasicCoder
+
+        def encode(name, value)
+            return array_to_hash(value)
+        end
+
+        def decode(name, value)
+            return hash_to_array(value)
+        end
+    end
+
+    class Game_Variables
+        include RGSS::BasicCoder
+
+        def encode(name, value)
+            return array_to_hash(value)
+        end
+
+        def decode(name, value)
+            return hash_to_array(value)
+        end
+    end
+
+    class Game_SelfSwitches
+        include RGSS::BasicCoder
+
+        def encode(name, value)
+            return(
+                Hash[
+                    value.collect do |pair|
+                        key, value = pair
+                        next ['%03d %03d %s' % key, value]
+                    end
+                ]
+            )
+        end
+
+        def decode(name, value)
+            return(
+                Hash[
+                    value.collect do |pair|
+                        key, value = pair
+                        next [key.scanf('%d %d %s'), value]
+                    end
+                ]
+            )
+        end
+    end
+
+    class Game_System
+        include RGSS::BasicCoder
+
+        def encode(name, value)
+            if name == 'version_id'
+                return map_version(value)
+            else
+                return value
+            end
+        end
+    end
+
+    require 'RGSS/serialize'
+end

data/lib/RPG.rb

@@ -0,0 +1,60 @@
+require 'RGSS'
+module RPG
+    class System
+        include RGSS::BasicCoder
+        HASHED_VARS = %w[variables switches]
+    end
+
+    def self.array_to_hash(arr, &block)
+        h = {}
+        arr.each_with_index do |val, index|
+            r = block_given? ? block.call(val) : val
+            h[index] = r unless r.nil?
+        end
+        if arr.length > 0
+            last = arr.length - 1
+            h[last] = nil unless h.has_key?(last)
+        end
+        return h
+    end
+
+    def encode(name, value)
+        if HASHED_VARS.include?(name)
+            return array_to_hash(value) { |val| reduce_string(val) }
+        elsif name == 'version_id'
+            return map_version(value)
+        else
+            return value
+        end
+    end
+
+    def decode(name, value)
+        if HASHED_VARS.include?(name)
+            return hash_to_array(value)
+        else
+            return value
+        end
+    end
+
+    class EventCommand
+        def encode_with(coder)
+            if instance_variables.length != 3
+                raise 'Unexpected number of instance variables'
+            end
+            clean
+
+            case @code
+            when MOVE_LIST_CODE
+                # move list
+                coder.style = Psych::Nodes::Mapping::BLOCK
+            else
+                coder.style = Psych::Nodes::Mapping::FLOW
+            end
+            coder['i'], coder['c'], coder['p'] = @indent, @code, @parameters
+        end
+
+        def init_with(coder)
+            @indent, @code, @parameters = coder['i'], coder['c'], coder['p']
+        end
+    end
+end

data/lib/rvpacker/version.rb

@@ -0,0 +1,3 @@
+module RVPACKER
+  VERSION = "1.3.0"
+end

data/rvpacker.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/rvpacker/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rvpacker-ng'
+  spec.version = RVPACKER::VERSION
+  spec.authors = ['Howard Jeng', 'Andrew Kesterson', 'Solistra', 'Darkness9724']
+  spec.email = ['darkness9724@gmail.com']
+  spec.summary = 'Pack and unpack any RPG Maker VX Ace data files'
+  spec.homepage = 'https://gitlab.com/Darkness9724/rvpacker'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '2.3.10'
+  spec.add_development_dependency 'rake', '13.0.6'
+  spec.add_dependency 'optimist', '3.0.1'
+  spec.add_dependency 'psych', '4.0.3'
+  spec.add_dependency 'formatador', '0.3.0'
+  spec.add_dependency 'scanf', '1.0.0'
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: rvpacker-ng
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Howard Jeng
+- Andrew Kesterson
+- Solistra
+- Darkness9724
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.3
+- !ruby/object:Gem::Dependency
+  name: formatador
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: scanf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description:
+email:
+- darkness9724@gmail.com
+executables:
+- rvpacker
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".prettierrc"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/rvpacker
+- lib/RGSS.rb
+- lib/RGSS/BasicCoder.rb
+- lib/RGSS/serialize.rb
+- lib/RPG.rb
+- lib/rvpacker/version.rb
+- rvpacker.gemspec
+homepage: https://gitlab.com/Darkness9724/rvpacker
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.8
+signing_key:
+specification_version: 4
+summary: Pack and unpack any RPG Maker VX Ace data files
+test_files: []