diff --git a/src/main.rs b/src/main.rs
index aa058f7..231679e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,290 +6,290 @@ use anyhow::Result as AResult;
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
- #[command(subcommand)]
- command: Commands,
+ #[command(subcommand)]
+ command: Commands,
}
#[derive(Subcommand)]
enum Commands {
- Download(MapList),
- DownloadTextures(PathBufList),
- ConvertTextures,
- DownloadMeshes(PathBufList),
- Extract(PathBufList),
- WriteAttributes,
- Interactive,
- Replace,
- Scan,
- UnzipAll,
- Upload,
+ Download(MapList),
+ DownloadTextures(PathBufList),
+ ConvertTextures,
+ DownloadMeshes(PathBufList),
+ Extract(PathBufList),
+ WriteAttributes,
+ Interactive,
+ Replace,
+ Scan,
+ UnzipAll,
+ Upload,
}
#[derive(Args)]
struct PathBufList {
- paths:Vec<std::path::PathBuf>
+ paths:Vec<std::path::PathBuf>
}
#[derive(Args)]
struct MapList {
- maps: Vec<u64>,
+ maps: Vec<u64>,
}
fn class_is_a(class: &str, superclass: &str) -> bool {
- if class==superclass {
- return true
- }
- let class_descriptor=rbx_reflection_database::get().classes.get(class);
- if let Some(descriptor) = &class_descriptor {
- if let Some(class_super) = &descriptor.superclass {
- return class_is_a(&class_super, superclass)
- }
- }
- return false
+ if class==superclass {
+ return true
+ }
+ let class_descriptor=rbx_reflection_database::get().classes.get(class);
+ if let Some(descriptor) = &class_descriptor {
+ if let Some(class_super) = &descriptor.superclass {
+ return class_is_a(&class_super, superclass)
+ }
+ }
+ return false
}
fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
- for &referent in instance.children() {
- if let Some(c) = dom.get_by_ref(referent) {
- if class_is_a(c.class.as_str(), superclass) {
- objects.push(c.referent());//copy ref
- }
- recursive_collect_superclass(objects,dom,c,superclass);
- }
- }
+ for &referent in instance.children() {
+ if let Some(c) = dom.get_by_ref(referent) {
+ if class_is_a(c.class.as_str(), superclass) {
+ objects.push(c.referent());//copy ref
+ }
+ recursive_collect_superclass(objects,dom,c,superclass);
+ }
+ }
}
fn recursive_collect_regex(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, regex: &lazy_regex::Lazy<lazy_regex::Regex>){
- for &referent in instance.children() {
- if let Some(c) = dom.get_by_ref(referent) {
- if regex.captures(c.name.as_str()).is_some(){
- objects.push(c.referent());//copy ref
- }
- recursive_collect_regex(objects,dom,c,regex);
- }
- }
+ for &referent in instance.children() {
+ if let Some(c) = dom.get_by_ref(referent) {
+ if regex.captures(c.name.as_str()).is_some(){
+ objects.push(c.referent());//copy ref
+ }
+ recursive_collect_regex(objects,dom,c,regex);
+ }
+ }
}
fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance) -> String{
- let mut full_name=instance.name.clone();
- let mut pref=instance.parent();
- while let Some(parent)=dom.get_by_ref(pref){
- full_name.insert(0, '.');
- full_name.insert_str(0, &parent.name);
- pref=parent.parent();
- }
- full_name
+ let mut full_name=instance.name.clone();
+ let mut pref=instance.parent();
+ while let Some(parent)=dom.get_by_ref(pref){
+ full_name.insert(0, '.');
+ full_name.insert_str(0, &parent.name);
+ pref=parent.parent();
+ }
+ full_name
}
//download
- //download list of maps to maps/unprocessed
+ //download list of maps to maps/unprocessed
//scan (scripts)
- //iter maps/unprocessed
- //passing moves to maps/verified
- //failing moves to maps/blocked
+ //iter maps/unprocessed
+ //passing moves to maps/verified
+ //failing moves to maps/blocked
//replace (edits & deletions)
- //iter maps/blocked
- //replace scripts and put in maps/unprocessed
+ //iter maps/blocked
+ //replace scripts and put in maps/unprocessed
//upload
- //iter maps/verified
- //interactively print DisplayName/Creator and ask for target upload ids
+ //iter maps/verified
+ //interactively print DisplayName/Creator and ask for target upload ids
//interactive
- //iter maps/unprocessed
- //for each unique script, load it into the file current.lua and have it open in sublime text
- //I can edit the file and it will edit it in place
- //I pass/fail(with comment)/allow each script
+ //iter maps/unprocessed
+ //for each unique script, load it into the file current.lua and have it open in sublime text
+ //I can edit the file and it will edit it in place
+ //I pass/fail(with comment)/allow each script
fn get_script_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
- let mut scripts = std::vec::Vec::new();
- recursive_collect_superclass(&mut scripts, dom, dom.root(),"LuaSourceContainer");
- scripts
+ let mut scripts = std::vec::Vec::new();
+ recursive_collect_superclass(&mut scripts, dom, dom.root(),"LuaSourceContainer");
+ scripts
}
fn get_button_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
- let mut buttons = std::vec::Vec::new();
- recursive_collect_regex(&mut buttons, dom, dom.root(),lazy_regex::regex!(r"Button(\d+)$"));
- buttons
+ let mut buttons = std::vec::Vec::new();
+ recursive_collect_regex(&mut buttons, dom, dom.root(),lazy_regex::regex!(r"Button(\d+)$"));
+ buttons
}
fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
- let mut objects = std::vec::Vec::new();
- recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
- //get ids
- //clear vec
- //next class
- objects
+ let mut objects = std::vec::Vec::new();
+ recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
+ //get ids
+ //clear vec
+ //next class
+ objects
}
fn get_mesh_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
- let mut objects = std::vec::Vec::new();
- recursive_collect_superclass(&mut objects, dom, dom.root(),"FileMesh");
- recursive_collect_superclass(&mut objects, dom, dom.root(),"MeshPart");
- //get ids
- //clear vec
- //next class
- objects
+ let mut objects = std::vec::Vec::new();
+ recursive_collect_superclass(&mut objects, dom, dom.root(),"FileMesh");
+ recursive_collect_superclass(&mut objects, dom, dom.root(),"MeshPart");
+ //get ids
+ //clear vec
+ //next class
+ objects
}
enum ReaderType<'a, R:Read+Seek>{
- GZip(flate2::read::GzDecoder<&'a mut R>),
- Raw(&'a mut R),
+ GZip(flate2::read::GzDecoder<&'a mut R>),
+ Raw(&'a mut R),
}
fn maybe_gzip_decode<R:Read+Seek>(input:&mut R)->AResult<ReaderType<R>>{
- let mut first_2=[0u8;2];
- if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_2),std::io::Seek::rewind(input)){
- match &first_2{
- b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
- _=>Ok(ReaderType::Raw(input)),
- }
- }else{
- Err(anyhow::Error::msg("failed to peek"))
- }
+ let mut first_2=[0u8;2];
+ if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_2),std::io::Seek::rewind(input)){
+ match &first_2{
+ b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
+ _=>Ok(ReaderType::Raw(input)),
+ }
+ }else{
+ Err(anyhow::Error::msg("failed to peek"))
+ }
}
fn load_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
- 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"<rob"=>{
- 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"))
- }
+ 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"<rob"=>{
+ 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"))
+ }
}
fn get_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
- match maybe_gzip_decode(input){
- Ok(ReaderType::GZip(mut readable)) => {
- //gzip
- let mut extracted:Vec<u8>=Vec::new();
- readable.read_to_end(&mut extracted)?;
- Ok(load_dom(&mut std::io::Cursor::new(extracted))?)
- },
- Ok(ReaderType::Raw(readable)) => Ok(load_dom(readable)?),
- Err(e) => Err(e)?,
- }
+ match maybe_gzip_decode(input){
+ Ok(ReaderType::GZip(mut readable)) => {
+ //gzip
+ let mut extracted:Vec<u8>=Vec::new();
+ readable.read_to_end(&mut extracted)?;
+ Ok(load_dom(&mut std::io::Cursor::new(extracted))?)
+ },
+ Ok(ReaderType::Raw(readable)) => Ok(load_dom(readable)?),
+ Err(e) => Err(e)?,
+ }
}
fn get_id() -> AResult<u32>{
- match std::fs::read_to_string("id"){
- Ok(id_file)=>Ok(id_file.parse::<u32>()?),
- Err(e) => match e.kind() {
- std::io::ErrorKind::NotFound => Ok(0),//implicitly take on id=0
- _ => Err(e)?,
- }
- }
+ match std::fs::read_to_string("id"){
+ Ok(id_file)=>Ok(id_file.parse::<u32>()?),
+ Err(e) => match e.kind() {
+ std::io::ErrorKind::NotFound => Ok(0),//implicitly take on id=0
+ _ => Err(e)?,
+ }
+ }
}
fn get_set_from_file(file:&str) -> AResult<std::collections::HashSet<String>>{
- let mut set=std::collections::HashSet::<String>::new();
- for entry in std::fs::read_dir(file)? {
- set.insert(std::fs::read_to_string(entry?.path())?);
- }
- Ok(set)
+ let mut set=std::collections::HashSet::<String>::new();
+ for entry in std::fs::read_dir(file)? {
+ set.insert(std::fs::read_to_string(entry?.path())?);
+ }
+ Ok(set)
}
fn get_allowed_set() -> AResult<std::collections::HashSet<String>>{
- get_set_from_file("scripts/allowed")
+ get_set_from_file("scripts/allowed")
}
fn get_blocked() -> AResult<std::collections::HashSet<String>>{
- get_set_from_file("scripts/blocked")
+ get_set_from_file("scripts/blocked")
}
fn get_allowed_map() -> AResult<std::collections::HashMap::<u32,String>>{
- let mut allowed_map = std::collections::HashMap::<u32,String>::new();
- for entry in std::fs::read_dir("scripts/allowed")? {
- let entry=entry?;
- allowed_map.insert(entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?,std::fs::read_to_string(entry.path())?);
- }
- Ok(allowed_map)
+ let mut allowed_map = std::collections::HashMap::<u32,String>::new();
+ for entry in std::fs::read_dir("scripts/allowed")? {
+ let entry=entry?;
+ allowed_map.insert(entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?,std::fs::read_to_string(entry.path())?);
+ }
+ Ok(allowed_map)
}
fn get_replace_map() -> AResult<std::collections::HashMap::<String,u32>>{
- let mut replace = std::collections::HashMap::<String,u32>::new();
- for entry in std::fs::read_dir("scripts/replace")? {
- let entry=entry?;
- replace.insert(std::fs::read_to_string(entry.path())?,entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?);
- }
- Ok(replace)
+ let mut replace = std::collections::HashMap::<String,u32>::new();
+ for entry in std::fs::read_dir("scripts/replace")? {
+ let entry=entry?;
+ replace.insert(std::fs::read_to_string(entry.path())?,entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?);
+ }
+ Ok(replace)
}
fn check_source_illegal_keywords(source:&String)->bool{
- source.find("getfenv").is_some()||source.find("require").is_some()
+ source.find("getfenv").is_some()||source.find("require").is_some()
}
fn find_first_child_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&'a rbx_dom_weak::Instance,name:&'a str,class:&'a str) -> Option<&'a rbx_dom_weak::Instance> {
- for &referent in instance.children() {
- if let Some(c) = dom.get_by_ref(referent) {
- if c.name==name&&class_is_a(c.class.as_str(),class) {
- return Some(c);
- }
- }
- }
- None
+ for &referent in instance.children() {
+ if let Some(c) = dom.get_by_ref(referent) {
+ if c.name==name&&class_is_a(c.class.as_str(),class) {
+ return Some(c);
+ }
+ }
+ }
+ None
}
fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String)>{
- let workspace_children=dom.root().children();
- if workspace_children.len()!=1{
- return Err(anyhow::Error::msg("there can only be one model"));
- }
- if let Some(model_instance) = dom.get_by_ref(workspace_children[0]) {
- if let (Some(creator),Some(displayname))=(find_first_child_class(dom, model_instance, "Creator", "StringValue"),find_first_child_class(dom, model_instance, "DisplayName", "StringValue")){
- if let (
- Some(rbx_dom_weak::types::Variant::String(creator_string)),
- Some(rbx_dom_weak::types::Variant::String(displayname_string))
- )=(
- creator.properties.get("Value"),
- displayname.properties.get("Value")
- ){
- return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
- }
- }
- }
- return Err(anyhow::Error::msg("no stuff in map"));
+ let workspace_children=dom.root().children();
+ if workspace_children.len()!=1{
+ return Err(anyhow::Error::msg("there can only be one model"));
+ }
+ if let Some(model_instance) = dom.get_by_ref(workspace_children[0]) {
+ if let (Some(creator),Some(displayname))=(find_first_child_class(dom, model_instance, "Creator", "StringValue"),find_first_child_class(dom, model_instance, "DisplayName", "StringValue")){
+ if let (
+ Some(rbx_dom_weak::types::Variant::String(creator_string)),
+ Some(rbx_dom_weak::types::Variant::String(displayname_string))
+ )=(
+ creator.properties.get("Value"),
+ displayname.properties.get("Value")
+ ){
+ return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
+ }
+ }
+ }
+ return Err(anyhow::Error::msg("no stuff in map"));
}
fn download(map_list: Vec<u64>) -> AResult<()>{
- let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
- let shared_args=&[
- "-q",
- "--header",
- header.as_str(),
- "-O",
- ];
- let processes_result:Result<Vec<_>, _>=map_list.iter().map(|map_id|{
- std::process::Command::new("wget")
- .args(shared_args)
- .arg(format!("maps/unprocessed/{}.rbxm",map_id))
- .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",map_id))
- .spawn()
- }).collect();
- //naively wait for all because idk how to make an async progress bar lmao
- for child in processes_result?{
- let output=child.wait_with_output()?;
- println!("map exit_success:{}",output.status.success());
- }
- Ok(())
+ let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+ let shared_args=&[
+ "-q",
+ "--header",
+ header.as_str(),
+ "-O",
+ ];
+ let processes_result:Result<Vec<_>, _>=map_list.iter().map(|map_id|{
+ std::process::Command::new("wget")
+ .args(shared_args)
+ .arg(format!("maps/unprocessed/{}.rbxm",map_id))
+ .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",map_id))
+ .spawn()
+ }).collect();
+ //naively wait for all because idk how to make an async progress bar lmao
+ for child in processes_result?{
+ let output=child.wait_with_output()?;
+ println!("map exit_success:{}",output.status.success());
+ }
+ Ok(())
}
struct RobloxAssetId(u64);
struct RobloxAssetIdParseErr;
impl std::str::FromStr for RobloxAssetId {
- type Err=RobloxAssetIdParseErr;
- fn from_str(s: &str) -> Result<Self, Self::Err>{
- let regman=lazy_regex::regex!(r"(\d+)$");
- if let Some(captures) = regman.captures(s) {
- if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
- if let Ok(id) = captures[0].parse::<u64>() {
- return Ok(Self(id));
- }
- }
- }
- Err(RobloxAssetIdParseErr)
- }
+ type Err=RobloxAssetIdParseErr;
+ fn from_str(s: &str) -> Result<Self, Self::Err>{
+ let regman=lazy_regex::regex!(r"(\d+)$");
+ if let Some(captures) = regman.captures(s) {
+ if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
+ if let Ok(id) = captures[0].parse::<u64>() {
+ return Ok(Self(id));
+ }
+ }
+ }
+ Err(RobloxAssetIdParseErr)
+ }
}
/* The ones I'm interested in:
Beam.Texture
@@ -318,723 +318,723 @@ SurfaceAppearance.RoughnessMap
SurfaceAppearance.TexturePack
*/
fn download_textures(paths: Vec<std::path::PathBuf>) -> AResult<()>{
- println!("download_textures paths:{:?}",paths);
- let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
- let shared_args=&[
- "-q",
- "--header",
- header.as_str(),
- "-O",
- ];
- let mut texture_list=std::collections::HashSet::new();
- for path in paths {
- let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
+ println!("download_textures paths:{:?}",paths);
+ let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+ let shared_args=&[
+ "-q",
+ "--header",
+ header.as_str(),
+ "-O",
+ ];
+ let mut texture_list=std::collections::HashSet::new();
+ for path in paths {
+ let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
- match get_dom(&mut input){
- Ok(dom)=>{
- let object_refs = get_texture_refs(&dom);
- for &object_ref in object_refs.iter() {
- if let Some(object)=dom.get_by_ref(object_ref){
- if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("Texture") {
- println!("Texture content:{:?}",content);
- if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
- texture_list.insert(asset_id.0);
- }
- }
- }
- }
- },
- Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
- }
- }
- println!("Texture list:{:?}",texture_list);
- let processes_result:Result<Vec<_>, _>=texture_list.iter().map(|asset_id|{
- std::process::Command::new("wget")
- .args(shared_args)
- .arg(format!("textures/unprocessed/{}",asset_id))
- .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
- .spawn()
- }).collect();
- //naively wait for all because idk how to make an async progress bar lmao
- for child in processes_result?{
- let output=child.wait_with_output()?;
- println!("texture exit_success:{}",output.status.success());
- }
- Ok(())
+ match get_dom(&mut input){
+ Ok(dom)=>{
+ let object_refs = get_texture_refs(&dom);
+ for &object_ref in object_refs.iter() {
+ if let Some(object)=dom.get_by_ref(object_ref){
+ if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("Texture") {
+ println!("Texture content:{:?}",content);
+ if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+ texture_list.insert(asset_id.0);
+ }
+ }
+ }
+ }
+ },
+ Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
+ }
+ }
+ println!("Texture list:{:?}",texture_list);
+ let processes_result:Result<Vec<_>, _>=texture_list.iter().map(|asset_id|{
+ std::process::Command::new("wget")
+ .args(shared_args)
+ .arg(format!("textures/unprocessed/{}",asset_id))
+ .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+ .spawn()
+ }).collect();
+ //naively wait for all because idk how to make an async progress bar lmao
+ for child in processes_result?{
+ let output=child.wait_with_output()?;
+ println!("texture exit_success:{}",output.status.success());
+ }
+ Ok(())
}
fn download_meshes(paths: Vec<std::path::PathBuf>) -> AResult<()>{
- println!("download_meshes paths:{:?}",paths);
- let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
- let shared_args=&[
- "-q",
- "--header",
- header.as_str(),
- "-O",
- ];
- let mut mesh_list=std::collections::HashSet::new();
- for path in paths {
- let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
+ println!("download_meshes paths:{:?}",paths);
+ let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+ let shared_args=&[
+ "-q",
+ "--header",
+ header.as_str(),
+ "-O",
+ ];
+ let mut mesh_list=std::collections::HashSet::new();
+ for path in paths {
+ let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
- match get_dom(&mut input){
- Ok(dom)=>{
- let object_refs = get_mesh_refs(&dom);
- for &object_ref in object_refs.iter() {
- if let Some(object)=dom.get_by_ref(object_ref){
- if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("MeshId") {
- println!("Mesh content:{:?}",content);
- if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
- mesh_list.insert(asset_id.0);
- }
- }
- }
- }
- },
- Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
- }
- }
- println!("Mesh list:{:?}",mesh_list);
- let processes_result:Result<Vec<_>, _>=mesh_list.iter().map(|asset_id|{
- std::process::Command::new("wget")
- .args(shared_args)
- .arg(format!("meshes/unprocessed/{}",asset_id))
- .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
- .spawn()
- }).collect();
- //naively wait for all because idk how to make an async progress bar lmao
- for child in processes_result?{
- let output=child.wait_with_output()?;
- println!("Mesh exit_success:{}",output.status.success());
- }
- Ok(())
+ match get_dom(&mut input){
+ Ok(dom)=>{
+ let object_refs = get_mesh_refs(&dom);
+ for &object_ref in object_refs.iter() {
+ if let Some(object)=dom.get_by_ref(object_ref){
+ if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("MeshId") {
+ println!("Mesh content:{:?}",content);
+ if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+ mesh_list.insert(asset_id.0);
+ }
+ }
+ }
+ }
+ },
+ Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
+ }
+ }
+ println!("Mesh list:{:?}",mesh_list);
+ let processes_result:Result<Vec<_>, _>=mesh_list.iter().map(|asset_id|{
+ std::process::Command::new("wget")
+ .args(shared_args)
+ .arg(format!("meshes/unprocessed/{}",asset_id))
+ .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+ .spawn()
+ }).collect();
+ //naively wait for all because idk how to make an async progress bar lmao
+ for child in processes_result?{
+ let output=child.wait_with_output()?;
+ println!("Mesh exit_success:{}",output.status.success());
+ }
+ Ok(())
}
fn load_image<R:Read+Seek+std::io::BufRead>(input:&mut R)->AResult<image::DynamicImage>{
- let mut fourcc=[0u8;4];
- input.read_exact(&mut fourcc)?;
- input.rewind()?;
- match &fourcc{
- b"\x89PNG"=>Ok(image::load(input,image::ImageFormat::Png)?),
- b"\xFF\xD8\xFF\xE0"=>Ok(image::load(input,image::ImageFormat::Jpeg)?),//JFIF
- b"<rob"=>Err(anyhow::Error::msg("Roblox xml garbage is not supported yet")),
- other=>Err(anyhow::Error::msg(format!("Unknown texture format {:?}",other))),
- }
+ let mut fourcc=[0u8;4];
+ input.read_exact(&mut fourcc)?;
+ input.rewind()?;
+ match &fourcc{
+ b"\x89PNG"=>Ok(image::load(input,image::ImageFormat::Png)?),
+ b"\xFF\xD8\xFF\xE0"=>Ok(image::load(input,image::ImageFormat::Jpeg)?),//JFIF
+ b"<rob"=>Err(anyhow::Error::msg("Roblox xml garbage is not supported yet")),
+ other=>Err(anyhow::Error::msg(format!("Unknown texture format {:?}",other))),
+ }
}
fn convert(file_thing:std::fs::DirEntry) -> AResult<()>{
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let mut extracted_input=None;
- let image=match maybe_gzip_decode(&mut input){
- Ok(ReaderType::GZip(mut readable)) => {
- //gzip
- let mut extracted:Vec<u8>=Vec::new();
- //read the entire thing to the end so that I can clone the data and write a png to processed images
- readable.read_to_end(&mut extracted)?;
- extracted_input=Some(extracted.clone());
- load_image(&mut std::io::Cursor::new(extracted))
- },
- Ok(ReaderType::Raw(readable)) => load_image(readable),
- Err(e) => Err(e)?,
- }?.to_rgba8();//this sets a=255, arcane is actually supposed to look like that
+ let mut extracted_input=None;
+ let image=match maybe_gzip_decode(&mut input){
+ Ok(ReaderType::GZip(mut readable)) => {
+ //gzip
+ let mut extracted:Vec<u8>=Vec::new();
+ //read the entire thing to the end so that I can clone the data and write a png to processed images
+ readable.read_to_end(&mut extracted)?;
+ extracted_input=Some(extracted.clone());
+ load_image(&mut std::io::Cursor::new(extracted))
+ },
+ Ok(ReaderType::Raw(readable)) => load_image(readable),
+ Err(e) => Err(e)?,
+ }?.to_rgba8();//this sets a=255, arcane is actually supposed to look like that
- let format=if image.width()%4!=0||image.height()%4!=0{
- image_dds::ImageFormat::R8G8B8A8Srgb
- }else{
- image_dds::ImageFormat::BC7Srgb
- };
- //this fails if the image dimensions are not a multiple of 4
- let dds = image_dds::dds_from_image(
- &image,
- format,
- image_dds::Quality::Slow,
- image_dds::Mipmaps::GeneratedAutomatic,
- )?;
+ let format=if image.width()%4!=0||image.height()%4!=0{
+ image_dds::ImageFormat::R8G8B8A8Srgb
+ }else{
+ image_dds::ImageFormat::BC7Srgb
+ };
+ //this fails if the image dimensions are not a multiple of 4
+ let dds = image_dds::dds_from_image(
+ &image,
+ format,
+ image_dds::Quality::Slow,
+ image_dds::Mipmaps::GeneratedAutomatic,
+ )?;
- //write dds
- let mut dest=std::path::PathBuf::from("textures/dds");
- dest.push(file_thing.file_name());
- dest.set_extension("dds");
- let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
- dds.write(&mut writer)?;
+ //write dds
+ let mut dest=std::path::PathBuf::from("textures/dds");
+ dest.push(file_thing.file_name());
+ dest.set_extension("dds");
+ let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
+ dds.write(&mut writer)?;
- if let Some(mut extracted)=extracted_input{
- //write extracted to processed
- let mut dest=std::path::PathBuf::from("textures/processed");
- dest.push(file_thing.file_name());
- std::fs::write(dest, &mut extracted)?;
- //delete ugly gzip file
- std::fs::remove_file(file_thing.path())?;
- }else{
- //move file to processed
- let mut dest=std::path::PathBuf::from("textures/processed");
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- Ok(())
+ if let Some(mut extracted)=extracted_input{
+ //write extracted to processed
+ let mut dest=std::path::PathBuf::from("textures/processed");
+ dest.push(file_thing.file_name());
+ std::fs::write(dest, &mut extracted)?;
+ //delete ugly gzip file
+ std::fs::remove_file(file_thing.path())?;
+ }else{
+ //move file to processed
+ let mut dest=std::path::PathBuf::from("textures/processed");
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ Ok(())
}
fn convert_textures() -> AResult<()>{
- let start = std::time::Instant::now();
- let mut threads=Vec::new();
- for entry in std::fs::read_dir("textures/unprocessed")? {
- let file_thing=entry?;
- threads.push(std::thread::spawn(move ||{
- let file_name=format!("{:?}",file_thing);
- let result=convert(file_thing);
- if let Err(e)=result{
- println!("error processing file:{:?} error message:{:?}",file_name,e);
- }
- }));
- }
- let mut i=0;
- let n_threads=threads.len();
- for thread in threads{
- i+=1;
- if let Err(e)=thread.join(){
- println!("thread error: {:?}",e);
- }else{
- println!("{}/{}",i,n_threads);
- }
- }
- println!("{:?}", start.elapsed());
- Ok(())
+ let start = std::time::Instant::now();
+ let mut threads=Vec::new();
+ for entry in std::fs::read_dir("textures/unprocessed")? {
+ let file_thing=entry?;
+ threads.push(std::thread::spawn(move ||{
+ let file_name=format!("{:?}",file_thing);
+ let result=convert(file_thing);
+ if let Err(e)=result{
+ println!("error processing file:{:?} error message:{:?}",file_name,e);
+ }
+ }));
+ }
+ let mut i=0;
+ let n_threads=threads.len();
+ for thread in threads{
+ i+=1;
+ if let Err(e)=thread.join(){
+ println!("thread error: {:?}",e);
+ }else{
+ println!("{}/{}",i,n_threads);
+ }
+ }
+ println!("{:?}", start.elapsed());
+ Ok(())
}
enum Scan{
- Passed,
- Blocked,
- Flagged,
+ Passed,
+ Blocked,
+ Flagged,
}
fn scan() -> AResult<()>{
- let mut id = get_id()?;
- //Construct allowed scripts
- let allowed_set = get_allowed_set()?;
- let mut blocked = get_blocked()?;
+ let mut id = get_id()?;
+ //Construct allowed scripts
+ let allowed_set = get_allowed_set()?;
+ let mut blocked = get_blocked()?;
- for entry in std::fs::read_dir("maps/unprocessed")? {
- let file_thing=entry?;
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ for entry in std::fs::read_dir("maps/unprocessed")? {
+ let file_thing=entry?;
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let dom = get_dom(&mut input)?;
+ let dom = get_dom(&mut input)?;
- let script_refs = get_script_refs(&dom);
+ let script_refs = get_script_refs(&dom);
- //check scribb
- let mut fail_count=0;
- let mut fail_type=Scan::Passed;
- for &script_ref in script_refs.iter() {
- if let Some(script)=dom.get_by_ref(script_ref){
- if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
- //flag keywords and instantly fail
- if check_source_illegal_keywords(s){
- println!("{:?} - flagged.",file_thing.file_name());
- fail_type=Scan::Flagged;
- break;
- }
- if allowed_set.contains(s) {
- continue;
- }else{
- fail_type=Scan::Blocked;//no need to check for Flagged, it breaks the loop.
- fail_count+=1;
- if !blocked.contains(s) {
- blocked.insert(s.clone());//all fixed! just clone!
- std::fs::write(format!("scripts/blocked/{}.lua",id),s)?;
- id+=1;
- }
- }
- }else{
- panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
- }
- }else{
- panic!("FATAL: failed to get_by_ref {:?}",script_ref);
- }
- }
- let mut dest=match fail_type {
- Scan::Passed => std::path::PathBuf::from("maps/processed"),
- Scan::Blocked => {
- println!("{:?} - {} {} not allowed.",file_thing.file_name(),fail_count,if fail_count==1 {"script"}else{"scripts"});
- std::path::PathBuf::from("maps/blocked")
- }
- Scan::Flagged => std::path::PathBuf::from("maps/flagged")
- };
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- std::fs::write("id",id.to_string())?;
- Ok(())
+ //check scribb
+ let mut fail_count=0;
+ let mut fail_type=Scan::Passed;
+ for &script_ref in script_refs.iter() {
+ if let Some(script)=dom.get_by_ref(script_ref){
+ if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
+ //flag keywords and instantly fail
+ if check_source_illegal_keywords(s){
+ println!("{:?} - flagged.",file_thing.file_name());
+ fail_type=Scan::Flagged;
+ break;
+ }
+ if allowed_set.contains(s) {
+ continue;
+ }else{
+ fail_type=Scan::Blocked;//no need to check for Flagged, it breaks the loop.
+ fail_count+=1;
+ if !blocked.contains(s) {
+ blocked.insert(s.clone());//all fixed! just clone!
+ std::fs::write(format!("scripts/blocked/{}.lua",id),s)?;
+ id+=1;
+ }
+ }
+ }else{
+ panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+ }
+ }else{
+ panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+ }
+ }
+ let mut dest=match fail_type {
+ Scan::Passed => std::path::PathBuf::from("maps/processed"),
+ Scan::Blocked => {
+ println!("{:?} - {} {} not allowed.",file_thing.file_name(),fail_count,if fail_count==1 {"script"}else{"scripts"});
+ std::path::PathBuf::from("maps/blocked")
+ }
+ Scan::Flagged => std::path::PathBuf::from("maps/flagged")
+ };
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ std::fs::write("id",id.to_string())?;
+ Ok(())
}
fn extract(paths: Vec<std::path::PathBuf>) -> AResult<()>{
- let mut id = 0;
- //Construct allowed scripts
- let mut script_set = std::collections::HashSet::<String>::new();
+ let mut id = 0;
+ //Construct allowed scripts
+ let mut script_set = std::collections::HashSet::<String>::new();
- for path in paths {
- let file_name=path.file_name();
- let mut input = std::io::BufReader::new(std::fs::File::open(&path)?);
+ for path in paths {
+ let file_name=path.file_name();
+ let mut input = std::io::BufReader::new(std::fs::File::open(&path)?);
- let dom = get_dom(&mut input)?;
+ let dom = get_dom(&mut input)?;
- let script_refs = get_script_refs(&dom);
+ let script_refs = get_script_refs(&dom);
- //extract scribb
- for &script_ref in script_refs.iter() {
- if let Some(script)=dom.get_by_ref(script_ref){
- if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
- if script_set.contains(s) {
- continue;
- }else{
- script_set.insert(s.clone());
- std::fs::write(format!("scripts/extracted/{:?}_{}_{}.lua",file_name,id,script.name),s)?;
- id+=1;
- }
- }else{
- panic!("FATAL: failed to get source for {:?}",file_name);
- }
- }else{
- panic!("FATAL: failed to get_by_ref {:?}",script_ref);
- }
- }
- }
- println!("extracted {} {}",id,if id==1 {"script"}else{"scripts"});
- Ok(())
+ //extract scribb
+ for &script_ref in script_refs.iter() {
+ if let Some(script)=dom.get_by_ref(script_ref){
+ if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
+ if script_set.contains(s) {
+ continue;
+ }else{
+ script_set.insert(s.clone());
+ std::fs::write(format!("scripts/extracted/{:?}_{}_{}.lua",file_name,id,script.name),s)?;
+ id+=1;
+ }
+ }else{
+ panic!("FATAL: failed to get source for {:?}",file_name);
+ }
+ }else{
+ panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+ }
+ }
+ }
+ println!("extracted {} {}",id,if id==1 {"script"}else{"scripts"});
+ Ok(())
}
fn replace() -> AResult<()>{
- let allowed_map=get_allowed_map()?;
- let replace_map=get_replace_map()?;
+ let allowed_map=get_allowed_map()?;
+ let replace_map=get_replace_map()?;
- for entry in std::fs::read_dir("maps/blocked")? {
- let file_thing=entry?;
+ for entry in std::fs::read_dir("maps/blocked")? {
+ let file_thing=entry?;
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let mut dom = get_dom(&mut input)?;
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ let mut dom = get_dom(&mut input)?;
- let script_refs = get_script_refs(&dom);
+ let script_refs = get_script_refs(&dom);
- //check scribb
- let mut any_failed=false;
- for &script_ref in script_refs.iter() {
- if let Some(script)=dom.get_by_ref(script_ref){
- if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
- if let (Some(replace_id),Some(replace_script))=(replace_map.get(source),dom.get_by_ref_mut(script.referent())) {
- println!("replace {}",replace_id);
- //replace the source
- if let Some(replace_source)=allowed_map.get(replace_id){
- replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
- }else{
- println!("failed to get replacement source {}",replace_id);
- any_failed=true;
- }
- }else{
- println!("failed to failed to get replace_id and replace_script");
- any_failed=true;
- }
- }else{
- panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
- }
- }else{
- panic!("FATAL: failed to get_by_ref {:?}",script_ref);
- }
- }
- if any_failed {
- println!("One or more scripts failed to replace.");
- }else{
- let mut dest=std::path::PathBuf::from("maps/unprocessed");
- dest.set_file_name(file_thing.file_name());
- let output = std::io::BufWriter::new(std::fs::File::open(dest)?);
- rbx_binary::to_writer(output, &dom, &[dom.root_ref()])?;
- }
- }
- Ok(())
+ //check scribb
+ let mut any_failed=false;
+ for &script_ref in script_refs.iter() {
+ if let Some(script)=dom.get_by_ref(script_ref){
+ if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
+ if let (Some(replace_id),Some(replace_script))=(replace_map.get(source),dom.get_by_ref_mut(script.referent())) {
+ println!("replace {}",replace_id);
+ //replace the source
+ if let Some(replace_source)=allowed_map.get(replace_id){
+ replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
+ }else{
+ println!("failed to get replacement source {}",replace_id);
+ any_failed=true;
+ }
+ }else{
+ println!("failed to failed to get replace_id and replace_script");
+ any_failed=true;
+ }
+ }else{
+ panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+ }
+ }else{
+ panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+ }
+ }
+ if any_failed {
+ println!("One or more scripts failed to replace.");
+ }else{
+ let mut dest=std::path::PathBuf::from("maps/unprocessed");
+ dest.set_file_name(file_thing.file_name());
+ let output = std::io::BufWriter::new(std::fs::File::open(dest)?);
+ rbx_binary::to_writer(output, &dom, &[dom.root_ref()])?;
+ }
+ }
+ Ok(())
}
enum UploadAction {
- Upload(u64),
- Skip,
- New,
- Delete,
+ Upload(u64),
+ Skip,
+ New,
+ Delete,
}
struct ParseUploadActionErr;
impl std::str::FromStr for UploadAction {
- type Err=ParseUploadActionErr;
- fn from_str(s: &str) -> Result<Self, Self::Err>{
- if s=="skip\n"{
- Ok(Self::Skip)
- }else if s=="new\n"{
- Ok(Self::New)
- }else if s=="delete\n"{
- Ok(Self::Delete)
- }else if let Ok(asset_id)=s[..s.len()-1].parse::<u64>(){
- Ok(Self::Upload(asset_id))
- }else{
- Err(ParseUploadActionErr)
- }
- }
+ type Err=ParseUploadActionErr;
+ fn from_str(s: &str) -> Result<Self, Self::Err>{
+ if s=="skip\n"{
+ Ok(Self::Skip)
+ }else if s=="new\n"{
+ Ok(Self::New)
+ }else if s=="delete\n"{
+ Ok(Self::Delete)
+ }else if let Ok(asset_id)=s[..s.len()-1].parse::<u64>(){
+ Ok(Self::Upload(asset_id))
+ }else{
+ Err(ParseUploadActionErr)
+ }
+ }
}
fn upload() -> AResult<()>{
- //interactive prompt per upload:
- for entry in std::fs::read_dir("maps/passed")? {
- let file_thing=entry?;
- println!("map file: {:?}",file_thing.file_name());
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ //interactive prompt per upload:
+ for entry in std::fs::read_dir("maps/passed")? {
+ let file_thing=entry?;
+ println!("map file: {:?}",file_thing.file_name());
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let dom = get_dom(&mut input)?;
- let (modelname,creator,displayname) = get_mapinfo(&dom)?;
+ let dom = get_dom(&mut input)?;
+ let (modelname,creator,displayname) = get_mapinfo(&dom)?;
- //Creator: [auto fill creator]
- //DisplayName: [auto fill DisplayName]
- //id: ["New" for blank because of my double enter key]
- print!("Model name: {}\nCreator: {}\nDisplayName: {}\nAction or Upload Asset Id: ",modelname,creator,displayname);
- std::io::Write::flush(&mut std::io::stdout())?;
- let upload_action;
- loop{
- let mut upload_action_string = String::new();
- std::io::stdin().read_line(&mut upload_action_string)?;
- if let Ok(parsed_upload_action)=upload_action_string.parse::<UploadAction>(){
- upload_action=parsed_upload_action;
- break;
- }else{
- print!("Action or Upload Asset Id: ");
- std::io::Write::flush(&mut std::io::stdout())?;
- }
- }
- match upload_action {
- UploadAction::Upload(asset_id) => {
- let status=std::process::Command::new("../rbxcompiler-linux-amd64")
- .arg("--compile=false")
- .arg("--group=6980477")
- .arg(format!("--asset={}",asset_id))
- .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
- .status()?;
- match status.code() {
- Some(0)=>{
- //move file
- let mut dest=std::path::PathBuf::from("maps/uploaded");
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- Some(code)=>println!("upload failed! code={}",code),
- None => println!("no status code!"),
- }
- }
- UploadAction::Skip => continue,
- UploadAction::New => {
- let output=std::process::Command::new("../rbxcompiler-linux-amd64")
- .arg("--compile=false")
- .arg("--group=6980477")
- .arg("--new-asset=true")
- .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
- .output()?;
- match output.status.code() {
- Some(0)=>{
- //print output
- println!("{}", std::str::from_utf8(output.stdout.as_slice())?);
- //move file
- let mut dest=std::path::PathBuf::from("maps/uploaded");
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- Some(code)=>println!("upload failed! code={}",code),
- None => println!("no status code!"),
- }
- }
- UploadAction::Delete => std::fs::remove_file(file_thing.path())?,
- }
- }
- Ok(())
+ //Creator: [auto fill creator]
+ //DisplayName: [auto fill DisplayName]
+ //id: ["New" for blank because of my double enter key]
+ print!("Model name: {}\nCreator: {}\nDisplayName: {}\nAction or Upload Asset Id: ",modelname,creator,displayname);
+ std::io::Write::flush(&mut std::io::stdout())?;
+ let upload_action;
+ loop{
+ let mut upload_action_string = String::new();
+ std::io::stdin().read_line(&mut upload_action_string)?;
+ if let Ok(parsed_upload_action)=upload_action_string.parse::<UploadAction>(){
+ upload_action=parsed_upload_action;
+ break;
+ }else{
+ print!("Action or Upload Asset Id: ");
+ std::io::Write::flush(&mut std::io::stdout())?;
+ }
+ }
+ match upload_action {
+ UploadAction::Upload(asset_id) => {
+ let status=std::process::Command::new("../rbxcompiler-linux-amd64")
+ .arg("--compile=false")
+ .arg("--group=6980477")
+ .arg(format!("--asset={}",asset_id))
+ .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
+ .status()?;
+ match status.code() {
+ Some(0)=>{
+ //move file
+ let mut dest=std::path::PathBuf::from("maps/uploaded");
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ Some(code)=>println!("upload failed! code={}",code),
+ None => println!("no status code!"),
+ }
+ }
+ UploadAction::Skip => continue,
+ UploadAction::New => {
+ let output=std::process::Command::new("../rbxcompiler-linux-amd64")
+ .arg("--compile=false")
+ .arg("--group=6980477")
+ .arg("--new-asset=true")
+ .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
+ .output()?;
+ match output.status.code() {
+ Some(0)=>{
+ //print output
+ println!("{}", std::str::from_utf8(output.stdout.as_slice())?);
+ //move file
+ let mut dest=std::path::PathBuf::from("maps/uploaded");
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ Some(code)=>println!("upload failed! code={}",code),
+ None => println!("no status code!"),
+ }
+ }
+ UploadAction::Delete => std::fs::remove_file(file_thing.path())?,
+ }
+ }
+ Ok(())
}
enum Interactive{
- Passed,
- Blocked,
- Flagged,
+ Passed,
+ Blocked,
+ Flagged,
}
enum ScriptAction {
- Pass,
- Replace(u32),
- Flag,
- Block,
- Delete,
+ Pass,
+ Replace(u32),
+ Flag,
+ Block,
+ Delete,
}
enum ScriptActionParseResult {
- Pass,
- Block,
- Exit,
- Delete,
+ Pass,
+ Block,
+ Exit,
+ Delete,
}
struct ParseScriptActionErr;
impl std::str::FromStr for ScriptActionParseResult {
- type Err=ParseScriptActionErr;
- fn from_str(s: &str) -> Result<Self, Self::Err>{
- if s=="pass\n"||s=="1\n"{
- Ok(Self::Pass)
- }else if s=="block\n"{
- Ok(Self::Block)
- }else if s=="exit\n"{
- Ok(Self::Exit)
- }else if s=="delete\n"{
- Ok(Self::Delete)
- }else{
- Err(ParseScriptActionErr)
- }
- }
+ type Err=ParseScriptActionErr;
+ fn from_str(s: &str) -> Result<Self, Self::Err>{
+ if s=="pass\n"||s=="1\n"{
+ Ok(Self::Pass)
+ }else if s=="block\n"{
+ Ok(Self::Block)
+ }else if s=="exit\n"{
+ Ok(Self::Exit)
+ }else if s=="delete\n"{
+ Ok(Self::Delete)
+ }else{
+ Err(ParseScriptActionErr)
+ }
+ }
}
fn interactive() -> AResult<()>{
- let mut id=get_id()?;
- //Construct allowed scripts
- let mut allowed_set=get_allowed_set()?;
- let mut allowed_map=get_allowed_map()?;
- let mut replace_map=get_replace_map()?;
- let mut blocked = get_blocked()?;
+ let mut id=get_id()?;
+ //Construct allowed scripts
+ let mut allowed_set=get_allowed_set()?;
+ let mut allowed_map=get_allowed_map()?;
+ let mut replace_map=get_replace_map()?;
+ let mut blocked = get_blocked()?;
- 'map_loop: for entry in std::fs::read_dir("maps/unprocessed")? {
- let file_thing=entry?;
- println!("processing map={:?}",file_thing.file_name());
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let mut dom = get_dom(&mut input)?;
+ 'map_loop: for entry in std::fs::read_dir("maps/unprocessed")? {
+ let file_thing=entry?;
+ println!("processing map={:?}",file_thing.file_name());
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ let mut dom = get_dom(&mut input)?;
- let script_refs = get_script_refs(&dom);
+ let script_refs = get_script_refs(&dom);
- //check scribb
- let mut script_count=0;
- let mut replace_count=0;
- let mut block_count=0;
- let mut fail_type=Interactive::Passed;
- for &script_ref in script_refs.iter() {
- if let Some(script)=dom.get_by_ref(script_ref){
- if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
- script_count+=1;
- let source_action=if check_source_illegal_keywords(source) {
- ScriptAction::Flag//script triggers flagging -> Flag
- } else if blocked.contains(source) {
- ScriptAction::Block//script is blocked -> Block
- } else if allowed_set.contains(source) {
- ScriptAction::Pass//script is allowed -> Pass
- }else if let Some(replace_id)=replace_map.get(source) {
- ScriptAction::Replace(*replace_id)
- }else{
- //interactive logic goes here
- print!("unresolved source location={}\naction: ",get_full_name(&dom, script));
- std::io::Write::flush(&mut std::io::stdout())?;
- //load source into current.lua
- std::fs::write("current.lua",source)?;
- //prompt action in terminal
- //wait for input
- let script_action;
- loop{
- let mut action_string = String::new();
- std::io::stdin().read_line(&mut action_string)?;
- if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
- script_action=parsed_script_action;
- break;
- }else{
- print!("action: ");
- std::io::Write::flush(&mut std::io::stdout())?;
- }
- }
- //update allowed/replace/blocked
- match script_action{
- ScriptActionParseResult::Pass => {
- //if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
- let modified_source=std::fs::read_to_string("current.lua")?;
- if &modified_source==source{
- //it's always new.
- //insert allowed_set
- allowed_set.insert(modified_source.clone());
- //insert allowed_map
- allowed_map.insert(id,modified_source.clone());
- //write allowed/id.lua
- std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
- id+=1;
- ScriptAction::Pass
- }else{
- //insert allowed_set
- allowed_set.insert(modified_source.clone());
- //insert allowed_map
- allowed_map.insert(id,modified_source.clone());
- //insert replace_map
- replace_map.insert(source.clone(),id);//this cannot be reached if it already exists
- //write allowed/id.lua
- std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
- //write replace/id.lua
- std::fs::write(format!("scripts/replace/{}.lua",id),source)?;
- let ret=ScriptAction::Replace(id);
- id+=1;
- ret
- }
- },
- ScriptActionParseResult::Block => {
- blocked.insert(source.clone());
- std::fs::write(format!("scripts/blocked/{}.lua",id),source)?;
- id+=1;
- ScriptAction::Block
- },
- ScriptActionParseResult::Exit => break 'map_loop,
- ScriptActionParseResult::Delete => ScriptAction::Delete,
- }
- };
-
- let location=get_full_name(&dom, script);
- match source_action{
- ScriptAction::Pass => println!("passed source location={}",location),
- ScriptAction::Replace(replace_id)=>{
- //replace the source
- if let (Some(replace_source),Some(replace_script))=(allowed_map.get(&replace_id),dom.get_by_ref_mut(script.referent())){
- replace_count+=1;
- println!("replaced source id={} location={}",replace_id,location);
- replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
- }else{
- panic!("failed to get replacement source id={} location={}",replace_id,location);
- }
- },
- ScriptAction::Delete => {
- println!("deleted source location={}",location);
- replace_count+=1;//trigger a new file generation
- dom.destroy(script.referent());
- },
- ScriptAction::Flag => {
- println!("flagged source location={}",location);
- fail_type=Interactive::Flagged;
- },
- ScriptAction::Block => {
- block_count+=1;
- println!("blocked source location={}",location);
- match fail_type{
- Interactive::Passed => fail_type=Interactive::Blocked,
- _=>(),
- }
- },
- }
- }else{
- panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
- }
- }else{
- panic!("FATAL: failed to get_by_ref {:?}",script_ref);
- }
- }
- let mut dest=match fail_type{
- Interactive::Passed => {
- println!("map={:?} passed with {} {}",file_thing.file_name(),script_count,if script_count==1 {"script"}else{"scripts"});
- if replace_count==0{
- std::path::PathBuf::from("maps/passed")
- }else{
- //create new file
- println!("{} {} replaced - generating new file...",replace_count,if replace_count==1 {"script was"}else{"scripts were"});
- let mut dest=std::path::PathBuf::from("maps/passed");
- dest.push(file_thing.file_name());
- let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
- //write workspace:GetChildren()[1]
- let workspace_children=dom.root().children();
- if workspace_children.len()!=1{
- return Err(anyhow::Error::msg("there can only be one model"));
- }
- rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
- //move original to processed folder
- std::path::PathBuf::from("maps/unaltered")
- }
- },//write map into maps/processed
- Interactive::Blocked => {
- println!("map={:?} blocked with {}/{} {} blocked",file_thing.file_name(),block_count,script_count,if script_count==1 {"script"}else{"scripts"});
- std::path::PathBuf::from("maps/blocked")
- },//write map into maps/blocked
- Interactive::Flagged => {
- println!("map={:?} flagged",file_thing.file_name());
- std::path::PathBuf::from("maps/flagged")
- },//write map into maps/flagged
- };
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- std::fs::write("id",id.to_string())?;
- Ok(())
+ //check scribb
+ let mut script_count=0;
+ let mut replace_count=0;
+ let mut block_count=0;
+ let mut fail_type=Interactive::Passed;
+ for &script_ref in script_refs.iter() {
+ if let Some(script)=dom.get_by_ref(script_ref){
+ if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
+ script_count+=1;
+ let source_action=if check_source_illegal_keywords(source) {
+ ScriptAction::Flag//script triggers flagging -> Flag
+ } else if blocked.contains(source) {
+ ScriptAction::Block//script is blocked -> Block
+ } else if allowed_set.contains(source) {
+ ScriptAction::Pass//script is allowed -> Pass
+ }else if let Some(replace_id)=replace_map.get(source) {
+ ScriptAction::Replace(*replace_id)
+ }else{
+ //interactive logic goes here
+ print!("unresolved source location={}\naction: ",get_full_name(&dom, script));
+ std::io::Write::flush(&mut std::io::stdout())?;
+ //load source into current.lua
+ std::fs::write("current.lua",source)?;
+ //prompt action in terminal
+ //wait for input
+ let script_action;
+ loop{
+ let mut action_string = String::new();
+ std::io::stdin().read_line(&mut action_string)?;
+ if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
+ script_action=parsed_script_action;
+ break;
+ }else{
+ print!("action: ");
+ std::io::Write::flush(&mut std::io::stdout())?;
+ }
+ }
+ //update allowed/replace/blocked
+ match script_action{
+ ScriptActionParseResult::Pass => {
+ //if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
+ let modified_source=std::fs::read_to_string("current.lua")?;
+ if &modified_source==source{
+ //it's always new.
+ //insert allowed_set
+ allowed_set.insert(modified_source.clone());
+ //insert allowed_map
+ allowed_map.insert(id,modified_source.clone());
+ //write allowed/id.lua
+ std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
+ id+=1;
+ ScriptAction::Pass
+ }else{
+ //insert allowed_set
+ allowed_set.insert(modified_source.clone());
+ //insert allowed_map
+ allowed_map.insert(id,modified_source.clone());
+ //insert replace_map
+ replace_map.insert(source.clone(),id);//this cannot be reached if it already exists
+ //write allowed/id.lua
+ std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
+ //write replace/id.lua
+ std::fs::write(format!("scripts/replace/{}.lua",id),source)?;
+ let ret=ScriptAction::Replace(id);
+ id+=1;
+ ret
+ }
+ },
+ ScriptActionParseResult::Block => {
+ blocked.insert(source.clone());
+ std::fs::write(format!("scripts/blocked/{}.lua",id),source)?;
+ id+=1;
+ ScriptAction::Block
+ },
+ ScriptActionParseResult::Exit => break 'map_loop,
+ ScriptActionParseResult::Delete => ScriptAction::Delete,
+ }
+ };
+
+ let location=get_full_name(&dom, script);
+ match source_action{
+ ScriptAction::Pass => println!("passed source location={}",location),
+ ScriptAction::Replace(replace_id)=>{
+ //replace the source
+ if let (Some(replace_source),Some(replace_script))=(allowed_map.get(&replace_id),dom.get_by_ref_mut(script.referent())){
+ replace_count+=1;
+ println!("replaced source id={} location={}",replace_id,location);
+ replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
+ }else{
+ panic!("failed to get replacement source id={} location={}",replace_id,location);
+ }
+ },
+ ScriptAction::Delete => {
+ println!("deleted source location={}",location);
+ replace_count+=1;//trigger a new file generation
+ dom.destroy(script.referent());
+ },
+ ScriptAction::Flag => {
+ println!("flagged source location={}",location);
+ fail_type=Interactive::Flagged;
+ },
+ ScriptAction::Block => {
+ block_count+=1;
+ println!("blocked source location={}",location);
+ match fail_type{
+ Interactive::Passed => fail_type=Interactive::Blocked,
+ _=>(),
+ }
+ },
+ }
+ }else{
+ panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+ }
+ }else{
+ panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+ }
+ }
+ let mut dest=match fail_type{
+ Interactive::Passed => {
+ println!("map={:?} passed with {} {}",file_thing.file_name(),script_count,if script_count==1 {"script"}else{"scripts"});
+ if replace_count==0{
+ std::path::PathBuf::from("maps/passed")
+ }else{
+ //create new file
+ println!("{} {} replaced - generating new file...",replace_count,if replace_count==1 {"script was"}else{"scripts were"});
+ let mut dest=std::path::PathBuf::from("maps/passed");
+ dest.push(file_thing.file_name());
+ let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
+ //write workspace:GetChildren()[1]
+ let workspace_children=dom.root().children();
+ if workspace_children.len()!=1{
+ return Err(anyhow::Error::msg("there can only be one model"));
+ }
+ rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
+ //move original to processed folder
+ std::path::PathBuf::from("maps/unaltered")
+ }
+ },//write map into maps/processed
+ Interactive::Blocked => {
+ println!("map={:?} blocked with {}/{} {} blocked",file_thing.file_name(),block_count,script_count,if script_count==1 {"script"}else{"scripts"});
+ std::path::PathBuf::from("maps/blocked")
+ },//write map into maps/blocked
+ Interactive::Flagged => {
+ println!("map={:?} flagged",file_thing.file_name());
+ std::path::PathBuf::from("maps/flagged")
+ },//write map into maps/flagged
+ };
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ std::fs::write("id",id.to_string())?;
+ Ok(())
}
fn unzip_all()->AResult<()>{
- for entry in std::fs::read_dir("maps/unprocessed")? {
- let file_thing=entry?;
- println!("processing map={:?}",file_thing.file_name());
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- match maybe_gzip_decode(&mut input){
- Ok(ReaderType::GZip(mut readable)) => {
- //gzip
- let mut extracted:Vec<u8>=Vec::new();
- //read the entire thing to the end so that I can clone the data and write a png to processed images
- readable.read_to_end(&mut extracted)?;
- //write extracted
- let mut dest=std::path::PathBuf::from("maps/unzipped");
- dest.push(file_thing.file_name());
- std::fs::write(dest, &mut extracted)?;
- //delete ugly gzip file
- std::fs::remove_file(file_thing.path())?;
- },
- Ok(ReaderType::Raw(_)) => (),
- Err(e) => Err(e)?,
- }
- }
- Ok(())
+ for entry in std::fs::read_dir("maps/unprocessed")? {
+ let file_thing=entry?;
+ println!("processing map={:?}",file_thing.file_name());
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ match maybe_gzip_decode(&mut input){
+ Ok(ReaderType::GZip(mut readable)) => {
+ //gzip
+ let mut extracted:Vec<u8>=Vec::new();
+ //read the entire thing to the end so that I can clone the data and write a png to processed images
+ readable.read_to_end(&mut extracted)?;
+ //write extracted
+ let mut dest=std::path::PathBuf::from("maps/unzipped");
+ dest.push(file_thing.file_name());
+ std::fs::write(dest, &mut extracted)?;
+ //delete ugly gzip file
+ std::fs::remove_file(file_thing.path())?;
+ },
+ Ok(ReaderType::Raw(_)) => (),
+ Err(e) => Err(e)?,
+ }
+ }
+ Ok(())
}
fn write_attributes() -> AResult<()>{
- for entry in std::fs::read_dir("maps/unprocessed")? {
- let file_thing=entry?;
- println!("processing map={:?}",file_thing.file_name());
- let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
- let mut dom = get_dom(&mut input)?;
+ for entry in std::fs::read_dir("maps/unprocessed")? {
+ let file_thing=entry?;
+ println!("processing map={:?}",file_thing.file_name());
+ let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+ let mut dom = get_dom(&mut input)?;
- let button_refs = get_button_refs(&dom);
+ let button_refs = get_button_refs(&dom);
- for &button_ref in &button_refs {
- if let Some(button)=dom.get_by_ref_mut(button_ref){
- match button.properties.get_mut("Attributes"){
- Some(rbx_dom_weak::types::Variant::Attributes(attributes))=>{
- println!("Appending Ref={} to existing attributes for {}",button_ref,button.name);
- attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
- },
- None=>{
- println!("Creating new attributes with Ref={} for {}",button_ref,button.name);
- let mut attributes=rbx_dom_weak::types::Attributes::new();
- attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
- button.properties.insert("Attributes".to_string(),rbx_dom_weak::types::Variant::Attributes(attributes));
- }
- _=>unreachable!("Fetching attributes did not return attributes."),
- }
- }
- }
- let mut dest={
- let mut dest=std::path::PathBuf::from("maps/attributes");
- dest.push(file_thing.file_name());
- let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
- //write workspace:GetChildren()[1]
- let workspace_children=dom.root().children();
- if workspace_children.len()!=1{
- return Err(anyhow::Error::msg("there can only be one model"));
- }
- rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
- //move original to processed folder
- std::path::PathBuf::from("maps/unaltered")
- };
- dest.push(file_thing.file_name());
- std::fs::rename(file_thing.path(), dest)?;
- }
- Ok(())
+ for &button_ref in &button_refs {
+ if let Some(button)=dom.get_by_ref_mut(button_ref){
+ match button.properties.get_mut("Attributes"){
+ Some(rbx_dom_weak::types::Variant::Attributes(attributes))=>{
+ println!("Appending Ref={} to existing attributes for {}",button_ref,button.name);
+ attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
+ },
+ None=>{
+ println!("Creating new attributes with Ref={} for {}",button_ref,button.name);
+ let mut attributes=rbx_dom_weak::types::Attributes::new();
+ attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
+ button.properties.insert("Attributes".to_string(),rbx_dom_weak::types::Variant::Attributes(attributes));
+ }
+ _=>unreachable!("Fetching attributes did not return attributes."),
+ }
+ }
+ }
+ let mut dest={
+ let mut dest=std::path::PathBuf::from("maps/attributes");
+ dest.push(file_thing.file_name());
+ let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
+ //write workspace:GetChildren()[1]
+ let workspace_children=dom.root().children();
+ if workspace_children.len()!=1{
+ return Err(anyhow::Error::msg("there can only be one model"));
+ }
+ rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
+ //move original to processed folder
+ std::path::PathBuf::from("maps/unaltered")
+ };
+ dest.push(file_thing.file_name());
+ std::fs::rename(file_thing.path(), dest)?;
+ }
+ Ok(())
}
fn main() -> AResult<()> {
- let cli = Cli::parse();
- match cli.command {
- Commands::Download(map_list)=>download(map_list.maps),
- Commands::DownloadTextures(pathlist)=>download_textures(pathlist.paths),
- Commands::ConvertTextures=>convert_textures(),
- Commands::DownloadMeshes(pathlist)=>download_meshes(pathlist.paths),
- Commands::Extract(pathlist)=>extract(pathlist.paths),
- Commands::WriteAttributes=>write_attributes(),
- Commands::Interactive=>interactive(),
- Commands::Replace=>replace(),
- Commands::Scan=>scan(),
- Commands::UnzipAll=>unzip_all(),
- Commands::Upload=>upload(),
- }
+ let cli = Cli::parse();
+ match cli.command {
+ Commands::Download(map_list)=>download(map_list.maps),
+ Commands::DownloadTextures(pathlist)=>download_textures(pathlist.paths),
+ Commands::ConvertTextures=>convert_textures(),
+ Commands::DownloadMeshes(pathlist)=>download_meshes(pathlist.paths),
+ Commands::Extract(pathlist)=>extract(pathlist.paths),
+ Commands::WriteAttributes=>write_attributes(),
+ Commands::Interactive=>interactive(),
+ Commands::Replace=>replace(),
+ Commands::Scan=>scan(),
+ Commands::UnzipAll=>unzip_all(),
+ Commands::Upload=>upload(),
+ }
}