diff --git a/Cargo.lock b/Cargo.lock index 21d5f59..189891c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -107,6 +107,8 @@ dependencies = [ "rbx_reflection_database", "rbx_xml", "reqwest", + "serde", + "serde_json", "tokio", ] @@ -913,9 +915,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" [[package]] name = "proc-macro2" -version = "1.0.71" +version = "1.0.76" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75cb1540fadbd5b8fbccc4dddad2734eba435053f725621c070711a14bb5f4b8" +checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c" dependencies = [ "unicode-ident", ] @@ -957,9 +959,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.33" +version = "1.0.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" dependencies = [ "proc-macro2", ] @@ -1230,18 +1232,18 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.193" +version = "1.0.195" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" +checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.193" +version = "1.0.195" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" +checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c" dependencies = [ "proc-macro2", "quote", @@ -1250,9 +1252,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.108" +version = "1.0.111" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" +checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4" dependencies = [ "itoa", "ryu", @@ -1298,9 +1300,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" [[package]] name = "syn" -version = "2.0.43" +version = "2.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53" +checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" dependencies = [ "proc-macro2", "quote", diff --git a/Cargo.toml b/Cargo.toml index 1c4129c..876de3e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,8 @@ rbx_dom_weak = "2.5.0" rbx_reflection_database = "0.2.7" rbx_xml = "0.13.1" reqwest = { version = "0.11.23", features = ["cookies"] } +serde = { version = "1.0.195", features = ["derive"] } +serde_json = "1.0.111" tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "fs"] } [profile.release] diff --git a/src/main.rs b/src/main.rs index ee2abf5..0ed9e3b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,6 +2,7 @@ use std::io::{Read,Seek}; use clap::{Args,Parser,Subcommand}; use anyhow::Result as AResult; use futures::StreamExt; +use rbx_dom_weak::types::Ref; type AssetID=u64; type AssetIDFileMap=Vec<(AssetID,std::path::PathBuf)>; @@ -38,6 +39,12 @@ struct Cli{ #[arg(long,value_parser=parse_key_val::)] asset_id:(AssetID,std::path::PathBuf), + #[arg(short,long)] + input:Option, + + #[arg(short,long)] + output:Option, + #[command(subcommand)] command:Commands, } @@ -46,6 +53,8 @@ struct Cli{ enum Commands{ Download, Upload, + Compile, + Decompile, } #[derive(Args)] @@ -74,6 +83,8 @@ async fn main()->AResult<()>{ match cli.command{ Commands::Download=>download_list(cookie,vec![cli.asset_id]).await, Commands::Upload=>upload_list(cookie,cli.group,vec![cli.asset_id]).await, + Commands::Compile=>compile(cli.input.unwrap(),cli.output.unwrap()), + Commands::Decompile=>decompile(cli.input.unwrap(),cli.output.unwrap()), } } @@ -194,3 +205,272 @@ async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult< }).await; Ok(()) } + +fn load_dom(input:&mut R)->AResult{ + let mut first_8=[0u8;8]; + if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){ + match &first_8[0..4]{ + b"{ + match &first_8[4..8]{ + b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg), + b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg), + other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))), + } + }, + _=>Err(anyhow::Error::msg("unsupported file type")), + } + }else{ + Err(anyhow::Error::msg("peek failed")) + } +} + +#[derive(PartialEq)] +enum Class{ + Folder, + ModuleScript, + LocalScript, + Script, + Model, +} + +struct TreeNode{ + name:String, + referent:Ref, + parent:Ref, + class:Class, + children:Vec, +} +impl TreeNode{ + fn new(name:String,referent:Ref,parent:Ref,class:Class)->Self{ + Self{ + name, + referent, + parent, + class, + children:Vec::new(), + } + } +} + +enum TrimStackInstruction{ + Referent(Ref), + IncrementScript, + DecrementScript, +} + +enum WriteStackInstruction<'a>{ + Node(&'a TreeNode), + PushFolder(std::path::Component<'a>), + PopFolder, + Destroy(Ref), +} + +#[derive(Default,serde::Deserialize,serde::Serialize)] +struct PropertiesOverride{ + //Name:Option, + ClassName:Option, +} +impl PropertiesOverride{ + fn is_some(&self)->bool{ + self.ClassName.is_some() + } +} + +fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeNode)->AResult<()>{ + file.push(node.name.as_str()); + match node.class{ + Class::Folder=>(), + Class::ModuleScript|Class::LocalScript|Class::Script=>{ + assert!(file.set_extension("lua"),"could not set extension"); + assert!(dom.get_by_ref(node.referent).is_some_and(|item|{ + //TODO: delete disabled scripts + if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get("Source"){ + std::fs::write(file,source).is_ok() + }else{false} + }),"some ting wong"); + }, + Class::Model=>{ + assert!(file.set_extension("rbxmx")); + let output=std::io::BufWriter::new(std::fs::File::create(file)?); + rbx_xml::to_writer_default(output,dom,&[node.referent])?; + }, + } + Ok(()) +} + +fn decompile(input_file:std::path::PathBuf,output_folder:std::path::PathBuf)->AResult<()>{ + //rules: + //Class Script|LocalScript|ModuleScript->$Name.lua + //Class Model->$Name.rbxmx + //overrides.json per-folder [Override{name,class}] + //Everything else goes into template.rbxlx + + //read file + let mut input=std::io::BufReader::new(std::fs::File::open(input_file)?); + let mut dom=load_dom(&mut input)?; + + let mut tree_refs=std::collections::HashMap::new(); + tree_refs.insert(dom.root_ref(),TreeNode::new( + "src".to_string(), + dom.root_ref(), + Ref::none(), + Class::Folder + )); + + //run rules + let mut stack=vec![dom.root()]; + while let Some(item)=stack.pop(){ + let class=match item.class.as_str(){ + "ModuleScript"=>Class::ModuleScript, + "LocalScript"=>Class::LocalScript, + "Script"=>Class::Script, + "Model"=>Class::Model, + _=>Class::Folder, + }; + let skip=match class{ + Class::Model=>true, + _=>false, + }; + if let Some(parent_node)=tree_refs.get_mut(&item.parent()){ + let referent=item.referent(); + let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class); + parent_node.children.push(referent); + tree_refs.insert(referent,node); + } + if skip{ + continue; + } + for &referent in item.children(){ + if let Some(c)=dom.get_by_ref(referent){ + stack.push(c); + } + } + } + + //trim empty folders + let mut script_count=0; + let mut stack:Vec=tree_refs.get(&dom.root_ref()).unwrap().children + .iter().map(|&c|TrimStackInstruction::Referent(c)).collect(); + while let Some(instruction)=stack.pop(){ + match instruction{ + TrimStackInstruction::IncrementScript=>script_count+=1, + TrimStackInstruction::DecrementScript=>script_count-=1, + TrimStackInstruction::Referent(referent)=>{ + let mut delete=None; + if let Some(node)=tree_refs.get_mut(&referent){ + if node.class==Class::Folder&&script_count!=0{ + node.class=Class::Model + } + if node.class==Class::Folder&&node.children.len()==0{ + delete=Some(node.parent); + }else{ + //how the hell do I do this better without recursion + let is_script=match node.class{ + Class::ModuleScript|Class::LocalScript|Class::Script=>true, + _=>false, + }; + //stack is popped from back + if is_script{ + stack.push(TrimStackInstruction::DecrementScript); + } + for &child_referent in &node.children{ + stack.push(TrimStackInstruction::Referent(child_referent)); + } + if is_script{ + stack.push(TrimStackInstruction::IncrementScript); + } + } + } + //trim referent + if let Some(parent_ref)=delete{ + let parent_node=tree_refs.get_mut(&parent_ref) + .expect("parent_ref does not exist in tree_refs"); + parent_node.children.remove( + parent_node.children.iter() + .position(|&r|r==referent) + .expect("parent.children does not contain referent") + ); + tree_refs.remove(&referent); + } + }, + } + } + + //generate folders, models, and scripts + //delete models and scripts from dom + { + let mut folder=output_folder.clone(); + let mut stack=vec![WriteStackInstruction::Node(tree_refs.get(&dom.root_ref()).unwrap())]; + while let Some(instruction)=stack.pop(){ + match instruction{ + WriteStackInstruction::PushFolder(component)=>folder.push(component), + WriteStackInstruction::PopFolder=>assert!(folder.pop(),"weirdness"), + WriteStackInstruction::Destroy(referent)=>dom.destroy(referent), + WriteStackInstruction::Node(node)=>{ + //properties.json to override class or other simple properties + let mut properties=PropertiesOverride::default(); + let has_children=node.children.len()!=0; + match node.class{ + Class::Folder=>(), + Class::ModuleScript=>{ + //.lua files are ModuleScript by default + if has_children{ + properties.ClassName=Some("ModuleScript".to_string()) + } + }, + Class::LocalScript=>properties.ClassName=Some("LocalScript".to_string()), + Class::Script=>properties.ClassName=Some("Script".to_string()), + Class::Model=>(), + } + if has_children||properties.is_some(){ + //push temp subfolder + let mut subfolder=folder.clone(); + subfolder.push(node.name.as_str()); + //make folder + std::fs::create_dir(subfolder.clone())?; + //write properties + if properties.is_some(){ + let mut file=subfolder.clone(); + file.push("properties"); + assert!(file.set_extension("json"),"could not set extension"); + std::fs::write(file,serde_json::to_string(&properties)?)? + } + //write item in subfolder + write_item(&dom,subfolder,node)?; + }else{ + //write item + write_item(&dom,folder.clone(),node)?; + } + //queue item to be deleted from dom after child objects are handled (stack is popped from the back) + match node.class{ + Class::Folder=>(), + _=>stack.push(WriteStackInstruction::Destroy(node.referent)), + } + if has_children{ + stack.push(WriteStackInstruction::PopFolder); + for referent in &node.children{ + if let Some(c)=tree_refs.get(referent){ + stack.push(WriteStackInstruction::Node(c)); + } + } + stack.push(WriteStackInstruction::PushFolder(std::path::Component::Normal(std::ffi::OsStr::new(node.name.as_str())))); + } + }, + } + } + } + //write what remains in template.rbxlx + { + let mut file=output_folder.clone(); + file.push("template"); + assert!(file.set_extension("rbxlx")); + let output=std::io::BufWriter::new(std::fs::File::create(file)?); + rbx_xml::to_writer_default(output,&dom,&[dom.root_ref()])?; + } + + Ok(()) +} + +fn compile(_folder:std::path::PathBuf,_file:std::path::PathBuf)->AResult<()>{ + Ok(()) +} \ No newline at end of file