Add initial VX support (#67)

* Generalize rpgmxp-tool

* Add inital extraction support for vx

* Add Map extraction

* Add vx map compile support

* Add script support

* Add mapinfos support

* Add System.rvdata support

* Add generic generate_ruby_data fn

* Add rpgm-common-types crate for shared types

* Move MapInfos to common crate

* Move table to common crate

* Move SystemTestBattler to common crate

* Move Color to common crate

* Move Tone to common crate

Author: nathaniel-daniel

Cargo.lock

@@ -3,7 +3,8 @@ resolver = "2"
 members = [
     "rpgmxp-project",
     "rpgmxp-types",
-    "rpgmxp-tool",
+    "rpgm-tool",
+    "rpgmvx-types", "rpgm-common-types",
 ]
 
 [profile.release]
@@ -16,4 +17,4 @@ strip = "symbols"
 [profile.release-cargo-bloat]
 inherits = "release"
 debug = true
-strip = false
+strip = false

Cargo.toml

@@ -1,24 +1,24 @@
 # rpgxp-project
 
-## rpgmxp-tool
-`rpgmxp-tool` is a CLI to read and write RPGMaker XP game files.
+## rpgm-tool
+`rpgm-tool` is a CLI to read and write RPGMaker XP and VX game files.
 This includes rgssad and rxdata files.
 Currently, it is NOT capable of byte-for-byte round-tripping game files, but repacked files work normally in games.
 This is due to differences in compression and the fact that this library does not dedupe game assets as much as it needs to.
 
 ### Usage
 ```bash
 # Unpacking a game
-rpgmxp-tool unpack path/to/game/dir unpacked
+rpgm-tool unpack path/to/game/dir unpacked
 
 # Unpacking an rgssad
-rpgmxp-tool unpack path/to/game/dir/Game.rgssad unpacked
+rpgm-tool unpack path/to/game/dir/Game.rgssad unpacked
 
 # Packing a game
-rpgmxp-tool pack unpacked path/to/new/dir
+rpgm-tool pack unpacked path/to/new/dir
 
 # Packing an rgssad
-rpgmxp-tool pack unpacked path/to/new/dir/Game.rgssad
+rpgm-tool pack unpacked path/to/new/dir/Game.rgssad
 ```
 
 ## Notes
@@ -29,4 +29,5 @@ The following objects can be deduped inside an archive:
 ## Resources
  * https://github.com/selectivepaperclip/rpgm2renpy/blob/ff847ff9f9a00cabd6f6c894be4c72711d0c76fd/game/rpgm_constants.rpy
  * https://github.com/cstrahan/open-rpg-maker
- * https://www.rpg-maker.fr/dl/monos/aide/xp/index.html
+ * https://www.rpg-maker.fr/dl/monos/aide/xp/index.html
+ * https://www.rpg-maker.fr/dl/monos/aide/vx/index.html

README.md

@@ -0,0 +1,11 @@
+[package]
+name = "rpgm-common-types"
+version = "0.0.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+flate2 = { version = "1.0.33" }
+ruby-marshal = { git = "https://github.com/nathaniel-daniel/ruby-marshal-rs" }
+ruby-marshal-derive = { git = "https://github.com/nathaniel-daniel/ruby-marshal-rs" }
+serde = { version = "1.0.209", features = [ "derive" ] }

rpgm-common-types/Cargo.toml

@@ -0,0 +1,90 @@
+use ruby_marshal::FromValue;
+use ruby_marshal::FromValueContext;
+use ruby_marshal::FromValueError;
+use ruby_marshal::IntoValue;
+use ruby_marshal::IntoValueError;
+use ruby_marshal::SymbolValue;
+use ruby_marshal::UserDefinedValue;
+use ruby_marshal::Value;
+use ruby_marshal::ValueArena;
+use ruby_marshal::ValueHandle;
+
+pub const USER_DEFINED_NAME: &[u8] = b"Color";
+const SIZE: usize = 32;
+
+#[derive(Debug)]
+pub enum ColorFromValueError {
+    InvalidSize { size: usize },
+}
+
+impl std::fmt::Display for ColorFromValueError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::InvalidSize { size } => {
+                write!(f, "invalid Color data size of {size}, expected {SIZE}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for ColorFromValueError {}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct Color {
+    pub red: f64,
+    pub green: f64,
+    pub blue: f64,
+    pub alpha: f64,
+}
+
+impl<'a> FromValue<'a> for Color {
+    fn from_value(ctx: &FromValueContext, value: &Value) -> Result<Self, FromValueError> {
+        let user_defined: &UserDefinedValue = FromValue::from_value(ctx, value)?;
+        let name = user_defined.name();
+        let name: &SymbolValue = ctx.from_value(name.into())?;
+        let name = name.value();
+        if name != USER_DEFINED_NAME {
+            return Err(FromValueError::UnexpectedObjectName { name: name.into() });
+        }
+
+        let value = user_defined.value();
+
+        let value_len = value.len();
+        if value_len != SIZE {
+            return Err(FromValueError::new_other(
+                ColorFromValueError::InvalidSize { size: value_len },
+            ));
+        }
+
+        let (red, value) = value.split_at(8);
+        let (green, value) = value.split_at(8);
+        let (blue, value) = value.split_at(8);
+        let (alpha, _value) = value.split_at(8);
+
+        let red = f64::from_le_bytes(red.try_into().unwrap());
+        let green = f64::from_le_bytes(green.try_into().unwrap());
+        let blue = f64::from_le_bytes(blue.try_into().unwrap());
+        let alpha = f64::from_le_bytes(alpha.try_into().unwrap());
+
+        Ok(Self {
+            red,
+            green,
+            blue,
+            alpha,
+        })
+    }
+}
+
+impl IntoValue for Color {
+    fn into_value(self, arena: &mut ValueArena) -> Result<ValueHandle, IntoValueError> {
+        let name = arena.create_symbol(USER_DEFINED_NAME.into());
+
+        let mut value = Vec::with_capacity(32);
+        value.extend(self.red.to_le_bytes());
+        value.extend(self.green.to_le_bytes());
+        value.extend(self.blue.to_le_bytes());
+        value.extend(self.alpha.to_le_bytes());
+
+        Ok(arena.create_user_defined(name, value).into())
+    }
+}

rpgm-common-types/src/color.rs

@@ -0,0 +1,18 @@
+pub mod color;
+pub mod map_info;
+pub mod script;
+pub mod system_test_battler;
+pub mod table;
+pub mod tone;
+pub mod util;
+
+pub use self::color::Color;
+pub use self::color::ColorFromValueError;
+pub use self::map_info::*;
+pub use self::script::*;
+pub use self::system_test_battler::*;
+pub use self::table::*;
+pub use self::tone::Tone;
+pub use self::tone::ToneFromValueError;
+pub use self::util::ruby_string2string;
+pub use self::util::string2ruby_string;

rpgm-common-types/src/lib.rs

@@ -0,0 +1,20 @@
+#[derive(
+    Debug,
+    serde::Serialize,
+    serde::Deserialize,
+    ruby_marshal_derive::FromValue,
+    ruby_marshal_derive::IntoValue,
+)]
+#[ruby_marshal(object = b"RPG::MapInfo")]
+pub struct MapInfo {
+    pub scroll_x: i32,
+    #[ruby_marshal(
+        from_value = "crate::util::ruby_string2string",
+        into_value = "crate::util::string2ruby_string"
+    )]
+    pub name: String,
+    pub expanded: bool,
+    pub order: i32,
+    pub scroll_y: i32,
+    pub parent_id: i32,
+}