default to current name and confirm override

.cargo/config.toml

@@ -0,0 +1,2 @@
+[registries.strafesnet]
+index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "map-tool"
-version = "1.4.0"
+name = "mapfixer"
+version = "1.1.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,20 +9,13 @@ edition = "2021"
 anyhow = "1.0.75"
 clap = { version = "4.4.2", features = ["derive"] }
 flate2 = "1.0.27"
-image = "0.24.7"
-image_dds = "0.1.1"
 lazy-regex = "3.1.0"
-rbx_binary = "0.7.1"
-rbx_dom_weak = "2.5.0"
-rbx_reflection_database = "0.2.7"
-rbx_xml = "0.13.1"
-vbsp = "0.5.0"
-vmdl = "0.1.1"
-vmt-parser = "0.1.1"
-vpk = "0.2.0"
-vtf = "0.2.1"
+rbx_binary = { version = "0.7.4", registry = "strafesnet"}
+rbx_dom_weak = { version = "2.7.0", registry = "strafesnet"}
+rbx_reflection_database = { version = "0.2.10", registry = "strafesnet"}
+rbx_xml = { version = "0.13.3", registry = "strafesnet"}
 
-#[profile.release]
-#lto = true
-#strip = true
-#codegen-units = 1
+[profile.release]
+lto = true
+strip = true
+codegen-units = 1

src/main.rs

@@ -14,19 +14,10 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
-	Download(MapList),
-	DownloadTextures(PathBufList),
-	ExtractTextures(PathBufList),
-	ConvertTextures,
-	VPKContents,
-	BSPContents,
-	DownloadMeshes(PathBufList),
-	Extract(PathBufList),
-	WriteAttributes,
+	ExtractScripts(PathBufList),
 	Interactive,
 	Replace,
 	Scan,
-	UnzipAll,
 	Upload,
 }
 
@@ -43,19 +34,10 @@ struct MapList {
 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::ExtractTextures(pathlist)=>extract_textures(vec![cli.path.unwrap()],pathlist.paths),
-		Commands::VPKContents=>vpk_contents(cli.path.unwrap()),
-		Commands::BSPContents=>bsp_contents(cli.path.unwrap()),
-		Commands::ConvertTextures=>convert_textures(),
-		Commands::DownloadMeshes(pathlist)=>download_meshes(pathlist.paths),
-		Commands::Extract(pathlist)=>extract(pathlist.paths),
-		Commands::WriteAttributes=>write_attributes(),
+		Commands::ExtractScripts(pathlist)=>extract_scripts(pathlist.paths),
 		Commands::Interactive=>interactive(),
 		Commands::Replace=>replace(),
 		Commands::Scan=>scan(),
-		Commands::UnzipAll=>unzip_all(),
 		Commands::Upload=>upload(),
 	}
 }
@@ -82,16 +64,6 @@ fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types:
 		}
 	}
 }
-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);
-		}
-	}
-}
 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();
@@ -103,8 +75,6 @@ fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance) ->
 	full_name
 }
 
-//download
-	//download list of maps to maps/unprocessed
 //scan (scripts)
 	//iter maps/unprocessed
 	//passing moves to maps/verified
@@ -112,9 +82,6 @@ fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance) ->
 //replace (edits & deletions)
 	//iter maps/blocked
 	//replace scripts and put in maps/unprocessed
-//upload
-	//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
@@ -126,28 +93,6 @@ fn get_script_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
 	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
-}
-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
-}
-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
-}
 
 enum ReaderType<'a, R:Read+Seek>{
 	GZip(flate2::read::GzDecoder<&'a mut R>),
@@ -256,7 +201,7 @@ fn find_first_child_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&'a rbx_dom
 	None
 }
 
-fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String)>{
+fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String,rbx_dom_weak::types::Ref)>{
 	let workspace_children=dom.root().children();
 	if workspace_children.len()!=1{
 		return Err(anyhow::Error::msg("there can only be one model"));
@@ -270,34 +215,11 @@ fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String)>{
 				creator.properties.get("Value"),
 				displayname.properties.get("Value")
 			){
-				return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
+				return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone(),displayname.referent()));
 			}
 		}
 	}
-	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(())
+	Err(anyhow::Error::msg("no stuff in map"))
 }
 
 struct RobloxAssetId(u64);
@@ -316,213 +238,6 @@ impl std::str::FromStr for RobloxAssetId {
 		Err(RobloxAssetIdParseErr)
 	}
 }
-/* The ones I'm interested in:
-Beam.Texture
-Decal.Texture
-FileMesh.MeshId
-FileMesh.TextureId
-MaterialVariant.ColorMap
-MaterialVariant.MetalnessMap
-MaterialVariant.NormalMap
-MaterialVariant.RoughnessMap
-MeshPart.MeshId
-MeshPart.TextureID
-ParticleEmitter.Texture
-Sky.MoonTextureId
-Sky.SkyboxBk
-Sky.SkyboxDn
-Sky.SkyboxFt
-Sky.SkyboxLf
-Sky.SkyboxRt
-Sky.SkyboxUp
-Sky.SunTextureId
-SurfaceAppearance.ColorMap
-SurfaceAppearance.MetalnessMap
-SurfaceAppearance.NormalMap
-SurfaceAppearance.RoughnessMap
-SurfaceAppearance.TexturePack
-*/
-fn download_textures(paths: Vec<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())?);
-
-		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<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())?);
-
-		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))),
-	}
-}
-
-fn convert(file_thing:std::fs::DirEntry) -> AResult<()>{
-	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 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=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=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=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(())
-}
 
 enum Scan{
 	Passed,
@@ -589,7 +304,7 @@ fn scan() -> AResult<()>{
 	Ok(())
 }
 
-fn extract(paths: Vec<PathBuf>) -> AResult<()>{
+fn extract_scripts(paths: Vec<PathBuf>) -> AResult<()>{
 	let mut id = 0;
 	//Construct allowed scripts
 	let mut script_set = std::collections::HashSet::<String>::new();
@@ -710,32 +425,33 @@ fn upload() -> AResult<()>{
 		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 (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())?;
+		print!("Model name: {}\nCreator: {}\nDisplayName: {}\n",modelname,creator,displayname);
 		let upload_action;
 		loop{
+			print!("Action or Upload Asset Id: ");
+			std::io::Write::flush(&mut std::io::stdout())?;
 			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()))
+				let status=std::process::Command::new("asset-tool")
+				.args([
+					"upload-asset",
+					"--cookie-envvar","RBXCOOKIE",
+					"--group-id","6980477"
+				])
+				.arg("--asset-id").arg(asset_id.to_string())
+				.arg("--input-file").arg(file_thing.path().into_os_string().into_string().unwrap())
 				.status()?;
 				match status.code() {
 					Some(0)=>{
@@ -750,11 +466,14 @@ fn upload() -> AResult<()>{
 			}
 			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()))
+				let output=std::process::Command::new("asset-tool")
+				.args([
+					"create-asset",
+					"--cookie-envvar","RBXCOOKIE",
+					"--group-id","6980477"
+				])
+				.arg("--model-name").arg(modelname.as_str())
+				.arg("--input-file").arg(file_thing.path().into_os_string().into_string().unwrap())
 				.output()?;
 				match output.status.code() {
 					Some(0)=>{
@@ -811,6 +530,27 @@ impl std::str::FromStr for ScriptActionParseResult {
 	}
 }
 
+fn is_first_letter_lowercase(s:&str)->bool{
+	s.chars().next().map(char::is_lowercase).unwrap_or(false)
+}
+
+fn is_title_case(display_name:&str)->bool{
+	display_name.len()!=0
+	&&!is_first_letter_lowercase(display_name)
+	&&{
+		let display_name_pattern=lazy_regex::regex!(r"\b\S+");
+		display_name_pattern.find_iter(display_name)
+		.all(|capture|match capture.as_str(){
+			"a"=>true,
+			"an"=>true,
+			"and"=>true,
+			"the"=>true,
+			"of"=>true,
+			other=>!is_first_letter_lowercase(other),
+		})
+	}
+}
+
 fn interactive() -> AResult<()>{
 	let mut id=get_id()?;
 	//Construct allowed scripts
@@ -818,21 +558,103 @@ fn interactive() -> AResult<()>{
 	let mut allowed_map=get_allowed_map()?;
 	let mut replace_map=get_replace_map()?;
 	let mut blocked = get_blocked()?;
+	let model_name_pattern=lazy_regex::regex!(r"^[a-z0-9_]+$");
 
 	'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 (modelname,creator,displayname,displayname_ref)=get_mapinfo(&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;
+
+		//if model name is illegal prompt for new name
+		print!("Model name: {}\nCreator: {}\nDisplayName: {}\n",modelname,creator,displayname);
+		if !model_name_pattern.is_match(modelname.as_str()){
+			//illegal
+			let new_model_name;
+			loop{
+				print!("Enter new model name: ");
+				std::io::Write::flush(&mut std::io::stdout())?;
+				let mut input_string=String::new();
+				std::io::stdin().read_line(&mut input_string)?;
+				let input_final=match input_string.trim(){
+					""=>modelname.as_str(),
+					other=>other,
+				};
+				if model_name_pattern.is_match(input_final)
+				||{
+					//If you entered a new model name and it still doesn't like it, allow override
+					println!("Final model name: {}",input_final);
+					print!("Are you sure you want this model name? [y/N]:");
+					std::io::Write::flush(&mut std::io::stdout())?;
+					let mut input_string=String::new();
+					std::io::stdin().read_line(&mut input_string)?;
+					match input_string.trim(){
+						"y"=>true,
+						_=>false,
+					}
+				}{
+					new_model_name=input_final.to_owned();
+					break;
+				}
+			}
+			let model_instance=dom.get_by_ref_mut(dom.root().children()[0]).unwrap();
+			model_instance.name=new_model_name;
+			//mark file as edited so a new file is generated
+			replace_count+=1;
+		}
+		if !is_title_case(displayname.as_str()){
+			//illegal
+			let new_display_name;
+			loop{
+				print!("Enter new display name: ");
+				std::io::Write::flush(&mut std::io::stdout())?;
+				let mut input_string=String::new();
+				std::io::stdin().read_line(&mut input_string)?;
+				let input_final=match input_string.trim(){
+					""=>displayname.as_str(),
+					other=>other,
+				};
+				if is_title_case(input_string.trim())
+				||{
+					//If you entered a new display name and it still doesn't like it, allow override
+					println!("Final display name: {}",input_final);
+					print!("Are you sure you want this display name? [y/N]:");
+					std::io::Write::flush(&mut std::io::stdout())?;
+					let mut input_string=String::new();
+					std::io::stdin().read_line(&mut input_string)?;
+					match input_string.trim(){
+						"y"=>true,
+						_=>false,
+					}
+				}{
+					new_display_name=input_final.to_owned();
+					break;
+				}
+			}
+			let displayname_instance=dom.get_by_ref_mut(displayname_ref).unwrap();
+			assert!(displayname_instance.properties.insert("Value".to_owned(),new_display_name.into()).is_some(),"StringValue we have a problem");
+			//mark file as edited so a new file is generated
+			replace_count+=1;
+		}
+
+		let script_refs = get_script_refs(&dom)
+		//grab the full path to the object in case it's deleted by another operation
+		.into_iter()
+		.filter_map(|referent|
+			dom.get_by_ref(referent)
+			.map(|script|
+				(referent,get_full_name(&dom,script))
+			)
+		).collect::<Vec<_>>();
+
+		//check scribb
 		let mut fail_type=Interactive::Passed;
-		for &script_ref in script_refs.iter() {
+		for (script_ref,script_full_name) in script_refs{
 			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;
@@ -846,22 +668,20 @@ fn interactive() -> AResult<()>{
 						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())?;
+						print!("unresolved source location={}\n",get_full_name(&dom, script));
 						//load source into current.lua
 						std::fs::write("current.lua",source)?;
 						//prompt action in terminal
 						//wait for input
 						let script_action;
 						loop{
+							print!("action: ");
+							std::io::Write::flush(&mut std::io::stdout())?;
 							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
@@ -905,7 +725,7 @@ fn interactive() -> AResult<()>{
 							ScriptActionParseResult::Delete => ScriptAction::Delete,
 						}
 					};
-					
+
 					let location=get_full_name(&dom, script);
 					match source_action{
 						ScriptAction::Pass => println!("passed source location={}",location),
@@ -941,7 +761,7 @@ fn interactive() -> AResult<()>{
 					panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
 				}
 			}else{
-				panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+				println!("WARNING: script was deleted: {}",script_full_name);
 			}
 		}
 		let mut dest=match fail_type{
@@ -980,298 +800,3 @@ fn interactive() -> AResult<()>{
 	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=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)?;
-
-		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=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
-			PathBuf::from("maps/unaltered")
-		};
-		dest.push(file_thing.file_name());
-		std::fs::rename(file_thing.path(), dest)?;
-	}
-	Ok(())
-}
-
-enum VMTContent{
-	VMT(String),
-	VTF(String),
-	Patch(vmt_parser::material::PatchMaterial),
-	Unsupported,//don't want to deal with whatever vmt variant
-	Unresolved,//could not locate a texture because of vmt content
-}
-impl VMTContent{
-	fn vtf(opt:Option<String>)->Self{
-		match opt{
-			Some(s)=>Self::VTF(s),
-			None=>Self::Unresolved,
-		}
-	}
-}
-
-fn get_some_texture(material:vmt_parser::material::Material)->AResult<VMTContent>{
-	//just grab some texture from somewhere for now
-	Ok(match material{
-		vmt_parser::material::Material::LightMappedGeneric(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::VertexLitGeneric(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),//this just dies if there is none
-		vmt_parser::material::Material::VertexLitGenericDx6(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),
-		vmt_parser::material::Material::UnlitGeneric(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::UnlitTwoTexture(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Water(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::WorldVertexTransition(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::EyeRefract(mat)=>VMTContent::vtf(Some(mat.cornea_texture)),
-		vmt_parser::material::Material::SubRect(mat)=>VMTContent::VMT(mat.material),//recursive
-		vmt_parser::material::Material::Sprite(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::SpriteCard(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Cable(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Refract(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Modulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::DecalModulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Sky(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Replacements(_mat)=>VMTContent::Unsupported,
-		vmt_parser::material::Material::Patch(mat)=>VMTContent::Patch(mat),
-		_=>return Err(anyhow::Error::msg("vmt failed to parse")),
-	})
-}
-
-fn get_vmt<F:Fn(String)->AResult<Option<Vec<u8>>>>(find_stuff:&F,search_name:String)->AResult<vmt_parser::material::Material>{
-	if let Some(stuff)=find_stuff(search_name)?{
-		//decode vmt and then write
-		let stuff=String::from_utf8(stuff)?;
-		let material=vmt_parser::from_str(stuff.as_str())?;
-		println!("vmt material={:?}",material);
-		return Ok(material);
-	}
-	Err(anyhow::Error::msg("vmt not found"))
-}
-
-fn recursive_vmt_loader<F:Fn(String)->AResult<Option<Vec<u8>>>>(find_stuff:&F,material:vmt_parser::material::Material)->AResult<Option<Vec<u8>>>{
-	match get_some_texture(material)?{
-		VMTContent::VMT(s)=>recursive_vmt_loader(find_stuff,get_vmt(find_stuff,s)?),
-		VMTContent::VTF(s)=>{
-			let mut texture_file_name=PathBuf::from("materials");
-			texture_file_name.push(s);
-			texture_file_name.set_extension("vtf");
-			find_stuff(texture_file_name.into_os_string().into_string().unwrap())
-		},
-		VMTContent::Patch(mat)=>recursive_vmt_loader(find_stuff,
-			mat.resolve(|search_name|{
-				match find_stuff(search_name.to_string())?{
-					Some(bytes)=>Ok(String::from_utf8(bytes)?),
-					None=>Err(anyhow::Error::msg("could not find vmt")),
-				}
-			})?
-		),
-		VMTContent::Unsupported=>{println!("Unsupported vmt");Ok(None)},//print and move on
-		VMTContent::Unresolved=>{println!("Unresolved vmt");Ok(None)},
-	}
-}
-
-fn extract_textures(paths:Vec<PathBuf>,vpk_paths:Vec<PathBuf>)->AResult<()>{
-	let vpk_list:Vec<vpk::VPK>=vpk_paths.into_iter().map(|vpk_path|vpk::VPK::read(&vpk_path).expect("vpk file does not exist")).collect();
-	for path in paths{
-		let mut deduplicate=std::collections::HashSet::new();
-		let bsp=vbsp::Bsp::read(std::fs::read(path)?.as_ref())?;
-		for texture in bsp.textures(){
-			deduplicate.insert(PathBuf::from(texture.name()));
-		}
-		//dedupe prop models
-		let mut model_dedupe=std::collections::HashSet::new();
-		for prop in bsp.static_props(){
-			model_dedupe.insert(prop.model());
-		}
-
-		//grab texture names from props
-		for model_name in model_dedupe{
-			//.mdl, .vvd, .dx90.vtx
-			let mut path=PathBuf::from(model_name);
-			let file_name=PathBuf::from(path.file_stem().unwrap());
-			path.pop();
-			path.push(file_name);
-			let mut vvd_path=path.clone();
-			let mut vtx_path=path.clone();
-			vvd_path.set_extension("vvd");
-			vtx_path.set_extension("dx90.vtx");
-			match (bsp.pack.get(model_name),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
-				(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
-					match (vmdl::mdl::Mdl::read(mdl_file.as_ref()),vmdl::vvd::Vvd::read(vvd_file.as_ref()),vmdl::vtx::Vtx::read(vtx_file.as_ref())){
-						(Ok(mdl),Ok(vvd),Ok(vtx))=>{
-							let model=vmdl::Model::from_parts(mdl,vtx,vvd);
-							for texture in model.textures(){
-								for search_path in &texture.search_paths{
-									let mut path=PathBuf::from(search_path.as_str());
-									path.push(texture.name.as_str());
-									deduplicate.insert(path);
-								}
-							}
-						},
-						_=>println!("model_name={} error",model_name),
-					}
-				},
-				_=>println!("no model name={}",model_name),
-			}
-		}
-
-		let pack=&bsp.pack;
-		let vpk_list=&vpk_list;
-		std::thread::scope(move|s|{
-			let mut thread_handles=Vec::new();
-			for texture_name in deduplicate{
-				let mut found_texture=false;
-				//LMAO imagine having to write type names
-				let write_image=|mut stuff,write_file_name|{
-					let image=vtf::from_bytes(&mut stuff)?.highres_image.decode(0)?.to_rgba8();
-
-					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=PathBuf::from("textures/dds");
-					dest.push(write_file_name);
-					dest.set_extension("dds");
-					std::fs::create_dir_all(dest.parent().unwrap())?;
-					let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
-					dds.write(&mut writer)?;
-					Ok::<(),anyhow::Error>(())
-				};
-				let find_stuff=|search_file_name:String|{
-					println!("search_file_name={}",search_file_name);
-					match pack.get(search_file_name.as_str())?{
-						Some(file)=>return Ok(Some(file)),
-						_=>(),
-					}
-					//search pak list
-					for vpk_index in vpk_list{
-						if let Some(vpk_entry)=vpk_index.tree.get(search_file_name.as_str()){
-							return Ok(Some(match vpk_entry.get()?{
-								std::borrow::Cow::Borrowed(bytes)=>bytes.to_vec(),
-								std::borrow::Cow::Owned(bytes)=>bytes,
-							}));
-						}
-					}
-					Ok::<Option<Vec<u8>>,anyhow::Error>(None)
-				};
-				let loader=|texture_name:String|{
-					let mut texture_file_name=PathBuf::from("materials");
-					//lower case
-					let texture_file_name_lowercase=texture_name.to_lowercase();
-					texture_file_name.push(texture_file_name_lowercase.clone());
-					//remove stem and search for both vtf and vmt files
-					let stem=PathBuf::from(texture_file_name.file_stem().unwrap());
-					texture_file_name.pop();
-					texture_file_name.push(stem);
-					//somehow search for both files
-					let mut texture_file_name_vmt=texture_file_name.clone();
-					texture_file_name.set_extension("vtf");
-					texture_file_name_vmt.set_extension("vmt");
-					if let Some(stuff)=find_stuff(texture_file_name.to_string_lossy().to_string())?{
-						return Ok(Some(stuff))
-					}
-					recursive_vmt_loader(&find_stuff,get_vmt(&find_stuff,texture_file_name_vmt.to_string_lossy().to_string())?)
-				};
-				if let Some(stuff)=loader(texture_name.to_string_lossy().to_string())?{
-					found_texture=true;
-					let texture_name=texture_name.clone();
-					thread_handles.push(s.spawn(move||write_image(stuff,texture_name)));
-				}
-				if !found_texture{
-					println!("no data");
-				}
-			}
-			for thread in thread_handles{
-				match thread.join(){
-					Ok(Err(e))=>println!("write error: {:?}",e),
-					Err(e)=>println!("thread error: {:?}",e),
-					Ok(_)=>(),
-				}
-			}
-			Ok::<(),anyhow::Error>(())
-		})?
-	}
-	Ok(())
-}
-
-fn vpk_contents(vpk_path:PathBuf)->AResult<()>{
-	let vpk_index=vpk::VPK::read(&vpk_path)?;
-	for (label,entry) in vpk_index.tree.into_iter(){
-		println!("vpk label={} entry={:?}",label,entry);
-	}
-	Ok(())
-}
-
-fn bsp_contents(path:PathBuf)->AResult<()>{
-	let bsp=vbsp::Bsp::read(std::fs::read(path)?.as_ref())?;
-	for file_name in bsp.pack.into_zip().into_inner().unwrap().file_names(){
-		println!("file_name={:?}",file_name);
-	}
-	Ok(())
-}