holy refactor

The physics algorithm expects vertices to align exactly with faces.  Since the face normal is calculated via the cross product of vertex positions, this allows the face normals to be exact with respect to the vertex positions.

Cargo.toml

@@ -24,7 +24,3 @@ resolver = "2"
 #lto = true
 strip = true
 codegen-units = 1
-
-[profile.dev]
-strip = false
-opt-level = 3

engine/graphics/Cargo.toml

@@ -11,4 +11,4 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "25.0.0"
+wgpu = "26.0.1"

engine/graphics/src/graphics.rs

@@ -953,6 +953,7 @@ impl GraphicsState{
 						}),
 						store:wgpu::StoreOp::Store,
 					},
+					depth_slice:None,
 				})],
 				depth_stencil_attachment:Some(wgpu::RenderPassDepthStencilAttachment{
 					view:&self.depth_view,

engine/physics/src/body.rs

@@ -18,6 +18,17 @@ impl<T> std::ops::Neg for Body<T>{
 		}
 	}
 }
+impl<T:Copy> std::ops::Neg for &Body<T>{
+	type Output=Body<T>;
+	fn neg(self)->Self::Output{
+		Body{
+			position:self.position,
+			velocity:-self.velocity,
+			acceleration:self.acceleration,
+			time:-self.time,
+		}
+	}
+}
 
 impl<T> Body<T>
 	where Time<T>:Copy,

engine/physics/src/face_crawler.rs

@@ -119,10 +119,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Edge(edge_id)=>{
 				//test each face collision time, ignoring roots with zero or conflicting derivative
-				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
 				let &[ev0,ev1]=edge_verts.as_ref();
-				let delta_pos=body.position*2-(mesh.vert(ev0)+mesh.vert(ev1));
+				let (v0,v1)=(mesh.vert(ev0),mesh.vert(ev1));
+				let edge_n=v1-v0;
+				let delta_pos=body.position*2-(v0+v1);
 				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces

engine/physics/src/model.rs

@@ -1,8 +1,8 @@
 use std::collections::{HashSet,HashMap};
 use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::model::{self,MeshId,PolygonIter};
-use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
+use strafesnet_common::model::{self,MeshId};
+use strafesnet_common::integer::{self,vec3,Fixed,Planar32Vec3,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
 
 type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
@@ -74,7 +74,7 @@ struct Face{
 	dot:Planar64,
 }
 #[derive(Debug)]
-struct Vert(Planar64Vec3);
+struct Vert(Planar32Vec3);
 pub trait MeshQuery{
 	type Face:Copy;
 	type Edge:Copy+DirectedEdge;
@@ -235,7 +235,7 @@ impl PhysicsMesh{
 		}
 	}
 	#[inline]
-	pub fn complete_mesh_view(&self)->PhysicsMeshView{
+	pub fn complete_mesh_view(&self)->PhysicsMeshView<'_>{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:self.complete_mesh(),
@@ -246,13 +246,13 @@ impl PhysicsMesh{
 		&self.submeshes
 	}
 	#[inline]
-	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView{
+	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView<'_>{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:&self.submeshes()[submesh_id.get() as usize],
 		}
 	}
-	pub fn submesh_views(&self)->impl Iterator<Item=PhysicsMeshView>{
+	pub fn submesh_views(&self)->impl Iterator<Item=PhysicsMeshView<'_>>{
 		self.submeshes().iter().map(|topology|PhysicsMeshView{
 			data:&self.data,
 			topology,
@@ -503,9 +503,6 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
-		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
-	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
@@ -703,7 +700,7 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh>{
+	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh<'_>>{
 		//start on any vertex
 		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 		//cross edge-face boundary if it's uncrossable
@@ -748,7 +745,7 @@ impl MinkowskiMesh<'_>{
 	//
 	// Most of the calculation time is just calculating the starting point
 	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh>>{
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
 		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
@@ -759,7 +756,7 @@ impl MinkowskiMesh<'_>{
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),range.start_bound()).and_then(|fev|{
+		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
 			//continue forwards along the body parabola
 			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 		})
@@ -768,7 +765,7 @@ impl MinkowskiMesh<'_>{
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
-		let infinity_body=-relative_body.clone();
+		let infinity_body=-relative_body;
 		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
 			//continue backwards along the body parabola
 			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
@@ -1007,7 +1004,8 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
 		unimplemented!();
-		vec![]
+		#[expect(unreachable_code)]
+		Vec::new()
 	}
 }
 

engine/physics/src/physics.rs

@@ -100,6 +100,7 @@ enum TransientAcceleration{
 		time:Time,
 	},
 	//walk target will never be reached
+	#[expect(dead_code)]
 	Unreachable{
 		acceleration:Planar64Vec3,
 	}
@@ -184,6 +185,7 @@ struct PhysicsModels{
 	intersect_attributes:HashMap<IntersectAttributesId,gameplay_attributes::IntersectAttributes>,
 }
 impl PhysicsModels{
+	#[expect(dead_code)]
 	fn clear(&mut self){
 		self.meshes.clear();
 		self.contact_models.clear();
@@ -191,7 +193,7 @@ impl PhysicsModels{
 		self.contact_attributes.clear();
 		self.intersect_attributes.clear();
 	}
-	fn mesh(&self,convex_mesh_id:ConvexMeshId)->TransformedMesh{
+	fn mesh(&self,convex_mesh_id:ConvexMeshId)->TransformedMesh<'_>{
 		let (mesh_id,transform)=match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>{
 				let model=&self.contact_models[&model_id];
@@ -208,14 +210,14 @@ impl PhysicsModels{
 		)
 	}
 	//it's a bit weird to have three functions, but it's always going to be one of these
-	fn contact_mesh(&self,contact:&ContactCollision)->TransformedMesh{
+	fn contact_mesh(&self,contact:&ContactCollision)->TransformedMesh<'_>{
 		let model=&self.contact_models[&contact.model_id];
 		TransformedMesh::new(
 			self.meshes[&model.mesh_id].submesh_view(contact.submesh_id),
 			&model.transform
 		)
 	}
-	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh{
+	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh<'_>{
 		let model=&self.intersect_models[&intersect.model_id];
 		TransformedMesh::new(
 			self.meshes[&model.mesh_id].submesh_view(intersect.submesh_id),
@@ -284,6 +286,7 @@ impl PhysicsCamera{
 	fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
+	#[expect(dead_code)]
 	fn simulate_move_rotation(&self,mouse_delta:glam::IVec2)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos+mouse_delta)
 	}
@@ -351,6 +354,7 @@ mod gameplay{
 		pub fn unordered_checkpoint_count(&self)->u32{
 			self.unordered_checkpoints.len() as u32
 		}
+		#[expect(dead_code)]
 		pub fn set_mode_id(&mut self,mode_id:gameplay_modes::ModeId){
 			self.clear();
 			self.mode_id=mode_id;
@@ -417,7 +421,7 @@ impl HitboxMesh{
 		}
 	}
 	#[inline]
-	fn transformed_mesh(&self)->TransformedMesh{
+	fn transformed_mesh(&self)->TransformedMesh<'_>{
 		TransformedMesh::new(self.mesh.complete_mesh_view(),&self.transform)
 	}
 }
@@ -485,6 +489,7 @@ enum MoveState{
 	Air,
 	Walk(ContactMoveState),
 	Ladder(ContactMoveState),
+	#[expect(dead_code)]
 	Water,
 	Fly,
 }
@@ -863,6 +868,12 @@ impl Default for PhysicsState{
 }
 
 impl PhysicsState{
+	pub fn new_with_body(body:Body)->Self{
+		Self{
+			body,
+			..Self::default()
+		}
+	}
 	pub fn camera_body(&self)->Body{
 		Body{
 			position:self.body.position+self.style.camera_offset,
@@ -1264,6 +1275,7 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
 	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);
 }
+#[expect(dead_code)]
 fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
@@ -1920,7 +1932,7 @@ mod test{
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
-		test_collision_axis_aligned(relative_body.clone(),expected_collision_time);
+		test_collision_axis_aligned(relative_body,expected_collision_time);
 		test_collision_rotated(relative_body,expected_collision_time);
 	}
 	#[test]

engine/physics/src/push_solve.rs

@@ -192,7 +192,7 @@ fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Optio
 const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->(Ray,Conts<'a>){
 	(get_push_ray_0(point),Conts::new_const())
 }
-fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
+fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts<'_>)>{
 	get_push_ray_1(point,c0)
 		.map(|ray|(ray,Conts::from_iter([c0])))
 }

integration-testing/.gitignore

@@ -0,0 +1 @@
+/test_files

integration-testing/src/error.rs

@@ -0,0 +1,28 @@
+#[expect(dead_code)]
+#[derive(Debug)]
+pub enum ReplayError{
+	IO(std::io::Error),
+	SNF(strafesnet_snf::Error),
+	SNFM(strafesnet_snf::map::Error),
+	SNFB(strafesnet_snf::bot::Error),
+}
+impl From<std::io::Error> for ReplayError{
+	fn from(value:std::io::Error)->Self{
+		Self::IO(value)
+	}
+}
+impl From<strafesnet_snf::Error> for ReplayError{
+	fn from(value:strafesnet_snf::Error)->Self{
+		Self::SNF(value)
+	}
+}
+impl From<strafesnet_snf::map::Error> for ReplayError{
+	fn from(value:strafesnet_snf::map::Error)->Self{
+		Self::SNFM(value)
+	}
+}
+impl From<strafesnet_snf::bot::Error> for ReplayError{
+	fn from(value:strafesnet_snf::bot::Error)->Self{
+		Self::SNFB(value)
+	}
+}

integration-testing/src/main.rs

@@ -1,7 +1,13 @@
-use std::io::Cursor;
-use std::path::Path;
+mod error;
+mod util;
+
+#[cfg(test)]
+mod tests;
+
 use std::time::Instant;
 
+use error::ReplayError;
+use util::read_entire_file;
 use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
 
 fn main(){
@@ -13,40 +19,6 @@ fn main(){
 	}
 }
 
-#[allow(unused)]
-#[derive(Debug)]
-enum ReplayError{
-	IO(std::io::Error),
-	SNF(strafesnet_snf::Error),
-	SNFM(strafesnet_snf::map::Error),
-	SNFB(strafesnet_snf::bot::Error),
-}
-impl From<std::io::Error> for ReplayError{
-	fn from(value:std::io::Error)->Self{
-		Self::IO(value)
-	}
-}
-impl From<strafesnet_snf::Error> for ReplayError{
-	fn from(value:strafesnet_snf::Error)->Self{
-		Self::SNF(value)
-	}
-}
-impl From<strafesnet_snf::map::Error> for ReplayError{
-	fn from(value:strafesnet_snf::map::Error)->Self{
-		Self::SNFM(value)
-	}
-}
-impl From<strafesnet_snf::bot::Error> for ReplayError{
-	fn from(value:strafesnet_snf::bot::Error)->Self{
-		Self::SNFB(value)
-	}
-}
-
-fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let data=std::fs::read(path)?;
-	Ok(Cursor::new(data))
-}
-
 fn run_replay()->Result<(),ReplayError>{
 	println!("loading map file..");
 	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;

integration-testing/src/tests.rs

@@ -0,0 +1,78 @@
+use crate::error::ReplayError;
+use crate::util::read_entire_file;
+use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
+
+#[test]
+#[ignore]
+fn physics_bug_2()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("test_files/bhop_monster_jam.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	let mut physics_data=PhysicsData::default();
+	println!("generating models..");
+	physics_data.generate_models(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	// body pos = Vector { array: [Fixed { bits: 554895163352 }, Fixed { bits: 1485633089990 }, Fixed { bits: 1279601007173 }] }
+	// after the fix it's still happening, possibly for a different reason, new position to evince:
+	// body pos = Vector { array: [Fixed { bits: 555690659654 }, Fixed { bits: 1490485868773 }, Fixed { bits: 1277783839382 }] }
+	use strafesnet_common::integer::{vec3,Time};
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::raw_xyz(555690659654,1490485868773,1277783839382),
+		vec3::int(0,0,0),
+		vec3::int(0,-100,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	// wait one second to activate the bug
+	// hit=Some(ModelId(2262))
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}
+
+#[test]
+#[ignore]
+fn physics_bug_3()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("../tools/bhop_maps/5692152916.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	let mut physics_data=PhysicsData::default();
+	println!("generating models..");
+	physics_data.generate_models(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	use strafesnet_common::integer::{vec3,Time};
+	let body=strafesnet_physics::physics::Body::new(
+		// bhop_toc corner position after wall hits
+		// vec3::raw_xyz(-1401734815424,3315081280280,-2466057177493),
+		// vec3::raw_xyz(0,-96915585363,1265),
+		// vec3::raw_xyz(0,-429496729600,0),
+		// alternate room center position
+		// vec3::raw_xyz(-1129043783837,3324870327882,-2014012350212),
+		// vec3::raw_xyz(0,-96915585363,1265),
+		// vec3::raw_xyz(0,-429496729600,0),
+		// corner setup before wall hits
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
+		vec3::raw_xyz(0,-429496729600,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	// wait one second to activate the bug
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}

integration-testing/src/util.rs

@@ -0,0 +1,7 @@
+use std::io::Cursor;
+use std::path::Path;
+
+pub fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
+	let data=std::fs::read(path)?;
+	Ok(Cursor::new(data))
+}

lib/bsp_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_bsp_loader"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -11,8 +11,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 glam = "0.30.0"
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

lib/bsp_loader/src/brush.rs

@@ -187,7 +187,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 	}
 }
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum BrushToMeshError{
 	SliceBrushSides,

lib/bsp_loader/src/loader.rs

@@ -5,7 +5,6 @@ use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 
 use crate::{Bsp,Vpk};
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum TextureError{
 	Io(std::io::Error),
@@ -41,7 +40,6 @@ impl Loader for TextureLoader{
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum MeshError{
 	Io(std::io::Error),

lib/common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_common"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"

lib/common/src/gameplay_modes.rs

@@ -140,6 +140,15 @@ impl ModeId{
 	pub const MAIN:Self=Self(0);
 	pub const BONUS:Self=Self(1);
 }
+impl core::fmt::Display for ModeId{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->core::fmt::Result{
+		match self{
+			&Self::MAIN=>write!(f,"Main"),
+			&Self::BONUS=>write!(f,"Bonus"),
+			&Self(mode_id)=>write!(f,"Bonus{mode_id}"),
+		}
+	}
+}
 #[derive(Clone)]
 pub struct Mode{
 	style:gameplay_style::StyleModifiers,

lib/common/src/integer.rs

@@ -552,6 +552,12 @@ impl TryFrom<[f32;3]> for Unit32Vec3{
 }
 */
 
+// placeholder until bnum supports u8
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq,Ord,PartialOrd)]
+pub struct Planar32(i32);
+pub type Planar32Vec3=linear_ops::types::Vector3<Planar32>;
+pub type Planar32Mat3=linear_ops::types::Matrix3<Planar32>;
+
 pub type Planar64TryFromFloatError=fixed_wide::fixed::FixedFromFloatError;
 pub type Planar64=fixed_wide::types::I32F32;
 pub type Planar64Vec3=linear_ops::types::Vector3<Planar64>;

lib/common/src/model.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::integer::{Planar64Vec3,Planar64Affine3};
+use crate::integer::{Planar32Vec3,Planar32Mat3,Planar64Vec3};
 use crate::gameplay_attributes;
 
 pub type TextureCoordinate=glam::Vec2;
@@ -22,61 +22,32 @@ pub struct IndexedVertex{
 }
 #[derive(Clone,Copy,Hash,id::Id,PartialEq,Eq)]
 pub struct VertexId(u32);
-pub type IndexedVertexList=Vec<VertexId>;
-pub trait PolygonIter{
-	fn polys(&self)->impl Iterator<Item=&[VertexId]>;
-}
-pub trait MapVertexId{
-	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self;
+#[derive(Clone)]
+pub struct Triangle([VertexId;3]);
+impl Triangle{
+	pub fn new(verts:[VertexId;3])->Self{
+		Self(verts)
+	}
 }
 #[derive(Clone)]
-pub struct PolygonList(Vec<IndexedVertexList>);
-impl PolygonList{
-	pub const fn new(list:Vec<IndexedVertexList>)->Self{
+pub struct TriangleList(Vec<Triangle>);
+impl TriangleList{
+	pub const fn new(list:Vec<Triangle>)->Self{
 		Self(list)
 	}
-	pub fn extend<T:IntoIterator<Item=IndexedVertexList>>(&mut self,iter:T){
+	pub fn extend<T:IntoIterator<Item=Triangle>>(&mut self,iter:T){
 		self.0.extend(iter);
 	}
 }
-impl PolygonIter for PolygonList{
-	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
-		self.0.iter().map(|poly|poly.as_slice())
-	}
-}
-impl MapVertexId for PolygonList{
-	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self{
-		Self(self.0.into_iter().map(|ivl|ivl.into_iter().map(&f).collect()).collect())
-	}
-}
-// pub struct TriangleStrip(IndexedVertexList);
-// impl PolygonIter for TriangleStrip{
-// 	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
-// 		self.0.vertices.windows(3).enumerate().map(|(i,s)|if i&0!=0{return s.iter().rev()}else{return s.iter()})
-// 	}
-// }
+
 #[derive(Clone,Copy,Hash,id::Id,PartialEq,Eq)]
 pub struct PolygonGroupId(u32);
 #[derive(Clone)]
 pub enum PolygonGroup{
-	PolygonList(PolygonList),
+	TriangleList(TriangleList),
 	//TriangleStrip(TriangleStrip),
 }
-impl PolygonIter for PolygonGroup{
-	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
-		match self{
-			PolygonGroup::PolygonList(list)=>list.polys(),
-			//PolygonGroup::TriangleStrip(strip)=>strip.polys(),
-		}
-	}
-}
-impl MapVertexId for PolygonGroup{
-	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self{
-		match self{
-			PolygonGroup::PolygonList(polys)=>Self::PolygonList(polys.map_vertex_id(f)),
-		}
-	}
-}
+
 /// Ah yes, a group of things to render at the same time
 #[derive(Clone,Copy,Debug,Hash,id::Id,Eq,PartialEq)]
 pub struct TextureId(u32);
@@ -109,8 +80,8 @@ pub struct IndexedPhysicsGroup{
 pub struct MeshId(u32);
 #[derive(Clone)]
 pub struct Mesh{
-	pub unique_pos:Vec<Planar64Vec3>,//Unit32Vec3
-	pub unique_normal:Vec<Planar64Vec3>,//Unit32Vec3
+	pub unique_pos:Vec<Planar32Vec3>,
+	pub unique_normal:Vec<Planar32Vec3>,
 	pub unique_tex:Vec<TextureCoordinate>,
 	pub unique_color:Vec<Color4>,
 	pub unique_vertices:Vec<IndexedVertex>,
@@ -127,13 +98,13 @@ pub struct Mesh{
 
 #[derive(Default)]
 pub struct MeshBuilder{
-	unique_pos:Vec<Planar64Vec3>,//Unit32Vec3
-	unique_normal:Vec<Planar64Vec3>,//Unit32Vec3
+	unique_pos:Vec<Planar32Vec3>,
+	unique_normal:Vec<Planar32Vec3>,
 	unique_tex:Vec<TextureCoordinate>,
 	unique_color:Vec<Color4>,
 	unique_vertices:Vec<IndexedVertex>,
-	pos_id_from:HashMap<Planar64Vec3,PositionId>,//Unit32Vec3
-	normal_id_from:HashMap<Planar64Vec3,NormalId>,//Unit32Vec3
+	pos_id_from:HashMap<Planar32Vec3,PositionId>,
+	normal_id_from:HashMap<Planar32Vec3,NormalId>,
 	tex_id_from:HashMap<[u32;2],TextureCoordinateId>,
 	color_id_from:HashMap<[u32;4],ColorId>,
 	vertex_id_from:HashMap<IndexedVertex,VertexId>,
@@ -167,14 +138,14 @@ impl MeshBuilder{
 			physics_groups,
 		}
 	}
-	pub fn acquire_pos_id(&mut self,pos:Planar64Vec3)->PositionId{
+	pub fn acquire_pos_id(&mut self,pos:Planar32Vec3)->PositionId{
 		*self.pos_id_from.entry(pos).or_insert_with(||{
 			let pos_id=PositionId::new(self.unique_pos.len() as u32);
 			self.unique_pos.push(pos);
 			pos_id
 		})
 	}
-	pub fn acquire_normal_id(&mut self,normal:Planar64Vec3)->NormalId{
+	pub fn acquire_normal_id(&mut self,normal:Planar32Vec3)->NormalId{
 		*self.normal_id_from.entry(normal).or_insert_with(||{
 			let normal_id=NormalId::new(self.unique_normal.len() as u32);
 			self.unique_normal.push(normal);
@@ -212,5 +183,6 @@ pub struct Model{
 	pub mesh:MeshId,
 	pub attributes:gameplay_attributes::CollisionAttributesId,
 	pub color:Color4,//transparency is in here
-	pub transform:Planar64Affine3,
+	pub matrix3:Planar32Mat3,
+	pub translation:Planar64Vec3,
 }

lib/deferred_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_deferred_loader"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -10,4 +10,4 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"

lib/fixed_wide/src/fixed.rs

@@ -233,6 +233,11 @@ impl FixedFromFloatError{
 		}
 	}
 }
+impl core::fmt::Display for FixedFromFloatError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
 macro_rules! impl_from_float {
 	( $decode:ident, $input: ty, $mantissa_bits:expr ) => {
 		impl<const N:usize,const F:usize> TryFrom<$input> for Fixed<N,F>{

lib/rbx_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_rbx_loader"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,11 @@ glam = "0.30.0"
 lazy-regex = "3.1.0"
 rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
-rbx_mesh = "0.3.1"
+rbx_mesh = "0.5.0"
+rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"
 rbx_xml  = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
-roblox_emulator = { version = "0.5.0", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }
+roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }

lib/rbx_loader/src/error.rs

@@ -0,0 +1,245 @@
+use std::collections::HashSet;
+use std::num::ParseIntError;
+
+use strafesnet_common::gameplay_modes::{StageId,ModeId};
+use strafesnet_common::integer::{FixedFromFloatError,Planar64TryFromFloatError};
+
+/// A collection of errors which can be ignored at your peril
+#[derive(Debug,Default)]
+pub struct RecoverableErrors{
+	/// A basepart has an invalid / missing property.
+	pub basepart_property:Vec<InstancePath>,
+	/// A part has an unconvertable CFrame.
+	pub basepart_cframe:Vec<CFrameError>,
+	/// A part has an unconvertable Velocity.
+	pub basepart_velocity:Vec<Planar64ConvertError>,
+	/// A part has an invalid / missing property.
+	pub part_property:Vec<InstancePath>,
+	/// A part has an invalid shape.
+	pub part_shape:Vec<ShapeError>,
+	/// A meshpart has an invalid / missing property.
+	pub meshpart_property:Vec<InstancePath>,
+	/// A meshpart has no mesh.
+	pub meshpart_content:Vec<InstancePath>,
+	/// A basepart has an unsupported subclass.
+	pub unsupported_class:HashSet<String>,
+	/// A decal has an invalid / missing property.
+	pub decal_property:Vec<InstancePath>,
+	/// A decal has an invalid normal_id.
+	pub normal_id:Vec<NormalIdError>,
+	/// A texture has an invalid / missing property.
+	pub texture_property:Vec<InstancePath>,
+	/// A mode_id failed to parse.
+	pub mode_id_parse_int:Vec<ParseIntContext>,
+	/// There is a duplicate mode.
+	pub duplicate_mode:HashSet<ModeId>,
+	/// A mode_id failed to parse.
+	pub stage_id_parse_int:Vec<ParseIntContext>,
+	/// A Stage was duplicated leading to undefined behaviour.
+	pub duplicate_stage:HashSet<DuplicateStageError>,
+	/// A WormholeOut id failed to parse.
+	pub wormhole_out_id_parse_int:Vec<ParseIntContext>,
+	/// A WormholeOut was duplicated leading to undefined behaviour.
+	pub duplicate_wormhole_out:HashSet<u32>,
+	/// A WormholeIn id failed to parse.
+	pub wormhole_in_id_parse_int:Vec<ParseIntContext>,
+	/// A jump limit failed to parse.
+	pub jump_limit_parse_int:Vec<ParseIntContext>,
+}
+
+impl RecoverableErrors{
+	pub fn count(&self)->usize{
+		self.basepart_property.len()+
+		self.basepart_cframe.len()+
+		self.basepart_velocity.len()+
+		self.part_property.len()+
+		self.part_shape.len()+
+		self.meshpart_property.len()+
+		self.meshpart_content.len()+
+		self.unsupported_class.len()+
+		self.decal_property.len()+
+		self.normal_id.len()+
+		self.texture_property.len()+
+		self.mode_id_parse_int.len()+
+		self.duplicate_mode.len()+
+		self.stage_id_parse_int.len()+
+		self.duplicate_stage.len()+
+		self.wormhole_out_id_parse_int.len()+
+		self.duplicate_wormhole_out.len()+
+		self.wormhole_in_id_parse_int.len()+
+		self.jump_limit_parse_int.len()
+	}
+}
+
+fn write_comma_separated<T>(
+	f:&mut std::fmt::Formatter<'_>,
+	mut it:impl Iterator<Item=T>,
+	custom_write:impl Fn(&mut std::fmt::Formatter<'_>,T)->std::fmt::Result
+)->std::fmt::Result{
+	if let Some(t)=it.next(){
+		custom_write(f,t)?;
+		for t in it{
+			write!(f,", ")?;
+			custom_write(f,t)?;
+		}
+	}
+	Ok(())
+}
+
+macro_rules! write_instance_path_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal,$problem:literal)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} {}: ",$problem)?;
+			write_comma_separated($f,$self.$field.iter(),|f,InstancePath(path)|
+				write!(f,"{path}")
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+macro_rules! write_duplicate_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} duplicates: ")?;
+			write_comma_separated($f,$self.$field.iter(),|f,id|
+				write!(f,"{id}")
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+macro_rules! write_bespoke_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal,$problem:literal,$path_field:ident,$error_field:ident)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} {}: ",$problem)?;
+			write_comma_separated($f,$self.$field.iter(),|f,context|
+				write!(f,"{} ({})",context.$path_field,context.$error_field)
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+
+impl core::fmt::Display for RecoverableErrors{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write_instance_path_error!(f,self,basepart_property,"BasePart is","BaseParts are","missing a property");
+		write_bespoke_error!(f,self,basepart_cframe,"BasePart","BaseParts","CFrame float convert failed",path,error);
+		write_bespoke_error!(f,self,basepart_velocity,"BasePart","BaseParts","Velocity float convert failed",path,error);
+		write_instance_path_error!(f,self,part_property,"Part is","Parts are","missing a property");
+		write_bespoke_error!(f,self,part_shape,"Part","Parts","Shape is invalid",path,shape);
+		write_instance_path_error!(f,self,meshpart_property,"MeshPart is","MeshParts are","missing a property");
+		write_instance_path_error!(f,self,meshpart_content,"MeshPart has","MeshParts have","no mesh");
+		{
+			let len=self.unsupported_class.len();
+			if len!=0{
+				let plural=if len==1{"Class is"}else{"Classes are"};
+				write!(f,"The following {plural} not supported: ")?;
+				write_comma_separated(f,self.unsupported_class.iter(),|f,classname|write!(f,"{classname}"))?;
+				writeln!(f)?;
+			}
+		}
+		write_instance_path_error!(f,self,decal_property,"Decal is","Decals are","missing a property");
+		write_bespoke_error!(f,self,normal_id,"Decal","Decals","NormalId is invalid",path,normal_id);
+		write_instance_path_error!(f,self,texture_property,"Texture is","Textures are","missing a property");
+		write_bespoke_error!(f,self,mode_id_parse_int,"ModeId","ModeIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_mode,"ModeId has","ModeIds have");
+		write_bespoke_error!(f,self,stage_id_parse_int,"StageId","StageIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_stage,"StageId has","StageIds have");
+		write_bespoke_error!(f,self,wormhole_out_id_parse_int,"WormholeOutId","WormholeOutIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_wormhole_out,"WormholeOutId has","WormholeOutIds have");
+		write_bespoke_error!(f,self,wormhole_in_id_parse_int,"WormholeInId","WormholeInIds","failed to parse",context,error);
+		write_bespoke_error!(f,self,jump_limit_parse_int,"jump limit","jump limits","failed to parse",context,error);
+		Ok(())
+	}
+}
+
+/// A Decal was missing required properties
+#[derive(Debug)]
+pub struct InstancePath(pub String);
+
+impl core::fmt::Display for InstancePath{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		self.0.fmt(f)
+	}
+}
+
+impl InstancePath{
+	pub fn new(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->InstancePath{
+		let mut names:Vec<_>=core::iter::successors(
+			Some(instance),
+			|i|dom.get_by_ref(i.parent())
+		).map(
+			|i|i.name.as_str()
+		).collect();
+		// discard the name of the root object
+		names.pop();
+		names.reverse();
+		InstancePath(names.join("."))
+	}
+}
+
+#[derive(Debug)]
+pub struct ParseIntContext{
+	pub context:String,
+	pub error:ParseIntError,
+}
+impl ParseIntContext{
+	pub fn parse<T:core::str::FromStr<Err=ParseIntError>>(input:&str)->Result<T,Self>{
+		input.parse().map_err(|error|ParseIntContext{
+			context:input.to_owned(),
+			error,
+		})
+	}
+}
+
+#[derive(Debug)]
+pub struct NormalIdError{
+	pub path:InstancePath,
+	pub normal_id:u32,
+}
+
+#[derive(Debug)]
+pub struct ShapeError{
+	pub path:InstancePath,
+	pub shape:u32,
+}
+
+#[derive(Debug)]
+pub enum CFrameErrorType{
+	ZeroDeterminant,
+	Convert(FixedFromFloatError),
+}
+impl core::fmt::Display for CFrameErrorType{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+
+#[derive(Debug)]
+pub struct CFrameError{
+	pub path:InstancePath,
+	pub error:CFrameErrorType,
+}
+
+#[derive(Debug)]
+pub struct Planar64ConvertError{
+	pub path:InstancePath,
+	pub error:Planar64TryFromFloatError,
+}
+
+#[derive(Debug,Hash,Eq,PartialEq)]
+pub struct DuplicateStageError{
+	pub mode_id:ModeId,
+	pub stage_id:StageId,
+}
+impl core::fmt::Display for DuplicateStageError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{}-Spawn{}",self.mode_id,self.stage_id.get())
+	}
+}

lib/rbx_loader/src/lib.rs

@@ -1,10 +1,15 @@
 use std::io::Read;
 use rbx_dom_weak::WeakDom;
 use roblox_emulator::context::Context;
+use strafesnet_common::map::CompleteMap;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
+pub use error::RecoverableErrors;
+pub use roblox_emulator::runner::Error as RunnerError;
+
 mod rbx;
 mod mesh;
+mod error;
 mod union;
 pub mod loader;
 mod primitives;
@@ -28,7 +33,7 @@ impl Model{
 	fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 		to_snf(self,failure_mode)
 	}
 }
@@ -48,18 +53,20 @@ impl Place{
 			context,
 		})
 	}
-	pub fn run_scripts(&mut self){
+	pub fn run_scripts(&mut self)->Result<Vec<RunnerError>,RunnerError>{
 		let Place{context}=self;
-		let runner=roblox_emulator::runner::Runner::new().unwrap();
+		let runner=roblox_emulator::runner::Runner::new()?;
 		let scripts=context.scripts();
-		let runnable=runner.runnable_context(context).unwrap();
+		let runnable=runner.runnable_context(context)?;
+		let mut errors=Vec::new();
 		for script in scripts{
 			if let Err(e)=runnable.run_script(script){
-				println!("runner error: {e}");
+				errors.push(e);
 			}
 		}
+		Ok(errors)
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 		to_snf(self,failure_mode)
 	}
 }
@@ -123,7 +130,7 @@ impl From<loader::MeshError> for LoadError{
 	}
 }
 
-fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 	let dom=dom.as_ref();
 
 	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
@@ -143,7 +150,5 @@ fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<strafesn
 	let mut texture_loader=loader::TextureLoader::new();
 	let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
 
-	let map=map_step2.add_render_configs_and_textures(render_configs);
-
-	Ok(map)
+	Ok(map_step2.add_render_configs_and_textures(render_configs))
 }

lib/rbx_loader/src/loader.rs

@@ -18,7 +18,6 @@ fn read_entire_file(path:impl AsRef<std::path::Path>)->Result<Vec<u8>,std::io::E
 	Ok(data)
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum TextureError{
 	Io(std::io::Error),
@@ -59,7 +58,6 @@ impl Loader for TextureLoader{
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum MeshError{
 	Io(std::io::Error),
@@ -118,7 +116,7 @@ pub struct MeshIndex<'a>{
 	content:&'a str,
 }
 impl MeshIndex<'_>{
-	pub fn file_mesh(content:&str)->MeshIndex{
+	pub fn file_mesh(content:&str)->MeshIndex<'_>{
 		MeshIndex{
 			mesh_type:MeshType::FileMesh,
 			content,

lib/rbx_loader/src/mesh.rs

@@ -3,11 +3,10 @@ use std::collections::HashMap;
 use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::integer::vec3;
-use strafesnet_common::model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId};
+use strafesnet_common::model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,Triangle,TriangleList,PositionId,RenderConfigId,TextureCoordinateId,VertexId};
 
 use crate::loader::MeshWithSize;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
@@ -20,69 +19,44 @@ impl std::fmt::Display for Error{
 }
 impl std::error::Error for Error{}
 
-fn ingest_vertices2<
-	AcquirePosId,
-	AcquireTexId,
-	AcquireNormalId,
-	AcquireColorId,
-	AcquireVertexId,
->(
+fn ingest_vertices2(
 	vertices:Vec<Vertex2>,
-	acquire_pos_id:&mut AcquirePosId,
-	acquire_tex_id:&mut AcquireTexId,
-	acquire_normal_id:&mut AcquireNormalId,
-	acquire_color_id:&mut AcquireColorId,
-	acquire_vertex_id:&mut AcquireVertexId,
-)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>
-where
-	AcquirePosId:FnMut([f32;3])->Result<PositionId,Error>,
-	AcquireTexId:FnMut([f32;2])->TextureCoordinateId,
-	AcquireNormalId:FnMut([f32;3])->Result<NormalId,Error>,
-	AcquireColorId:FnMut([f32;4])->ColorId,
-	AcquireVertexId:FnMut(IndexedVertex)->VertexId,
-{
+	mb:&mut model::MeshBuilder,
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
 	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
-		acquire_vertex_id(IndexedVertex{
-			pos:acquire_pos_id(vertex.pos)?,
-			tex:acquire_tex_id(vertex.tex),
-			normal:acquire_normal_id(vertex.norm)?,
-			color:acquire_color_id(vertex.color.map(|f|f as f32/255.0f32))
-		}),
-	))).collect::<Result<_,_>>()?)
+		{
+			let vertex=IndexedVertex{
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+				color:mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)))
+			};
+			mb.acquire_vertex_id(vertex)
+		}
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
-fn ingest_vertices_truncated2<
-	AcquirePosId,
-	AcquireTexId,
-	AcquireNormalId,
-	AcquireVertexId,
->(
+fn ingest_vertices_truncated2(
 	vertices:Vec<Vertex2Truncated>,
-	acquire_pos_id:&mut AcquirePosId,
-	acquire_tex_id:&mut AcquireTexId,
-	acquire_normal_id:&mut AcquireNormalId,
+	mb:&mut model::MeshBuilder,
 	static_color_id:ColorId,//pick one color and fill everything with it
-	acquire_vertex_id:&mut AcquireVertexId,
-)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>
-where
-	AcquirePosId:FnMut([f32;3])->Result<PositionId,Error>,
-	AcquireTexId:FnMut([f32;2])->TextureCoordinateId,
-	AcquireNormalId:FnMut([f32;3])->Result<NormalId,Error>,
-	AcquireVertexId:FnMut(IndexedVertex)->VertexId,
-{
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
 	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
-		acquire_vertex_id(IndexedVertex{
-			pos:acquire_pos_id(vertex.pos)?,
-			tex:acquire_tex_id(vertex.tex),
-			normal:acquire_normal_id(vertex.norm)?,
-			color:static_color_id
-		}),
-	))).collect::<Result<_,_>>()?)
+		{
+			let vertex=IndexedVertex{
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+				color:static_color_id,
+			};
+			mb.acquire_vertex_id(vertex)
+		}
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
 
 fn ingest_faces2_lods3(
@@ -93,132 +67,80 @@ fn ingest_faces2_lods3(
 ){
 	//faces have to be split into polygon groups based on lod
 	polygon_groups.extend(lods.windows(2).map(|lod_pair|
-		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
-			vec![vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]]
+		PolygonGroup::TriangleList(TriangleList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
+			Triangle::new([vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]])
 		).collect()))
 	))
 }
 
 pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithSize,Error>{
 	//generate that mesh boi
-	let mut unique_pos=Vec::new();
-	let mut pos_id_from=HashMap::new();
-	let mut unique_tex=Vec::new();
-	let mut tex_id_from=HashMap::new();
-	let mut unique_normal=Vec::new();
-	let mut normal_id_from=HashMap::new();
-	let mut unique_color=Vec::new();
-	let mut color_id_from=HashMap::new();
-	let mut unique_vertices=Vec::new();
-	let mut vertex_id_from=HashMap::new();
 	let mut polygon_groups=Vec::new();
-	let mut aabb=Aabb::default();
-	let mut acquire_pos_id=|pos|{
-		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
-		aabb.grow(p);
-		Ok(PositionId::new(*pos_id_from.entry(p).or_insert_with(||{
-			let pos_id=unique_pos.len();
-			unique_pos.push(p);
-			pos_id
-		}) as u32))
-	};
-	let mut acquire_tex_id=|tex|{
-		let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
-		TextureCoordinateId::new(*tex_id_from.entry(h).or_insert_with(||{
-			let tex_id=unique_tex.len();
-			unique_tex.push(glam::Vec2::from_array(tex));
-			tex_id
-		}) as u32)
-	};
-	let mut acquire_normal_id=|normal|{
-		let n=vec3::try_from_f32_array(normal).map_err(Error::Planar64Vec3)?;
-		Ok(NormalId::new(*normal_id_from.entry(n).or_insert_with(||{
-			let normal_id=unique_normal.len();
-			unique_normal.push(n);
-			normal_id
-		}) as u32))
-	};
-	let mut acquire_color_id=|color|{
-		let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
-		ColorId::new(*color_id_from.entry(h).or_insert_with(||{
-			let color_id=unique_color.len();
-			unique_color.push(glam::Vec4::from_array(color));
-			color_id
-		}) as u32)
-	};
-	let mut acquire_vertex_id=|vertex:IndexedVertex|{
-		VertexId::new(*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
-			let vertex_id=unique_vertices.len();
-			unique_vertices.push(vertex);
-			vertex_id
-		}) as u32)
-	};
+	let mut mb=model::MeshBuilder::new();
 	match rbx_mesh::read_versioned(roblox_mesh_bytes.cursor()).map_err(Error::RbxMesh)?{
-		rbx_mesh::mesh::VersionedMesh::Version1(mesh)=>{
-			let color_id=acquire_color_id([1.0f32;4]);
+		rbx_mesh::mesh::Mesh::V1(mesh)=>{
+			let color_id=mb.acquire_color_id(glam::Vec4::ONE);
 			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.vertices.chunks_exact(3).map(|trip|{
-				let mut ingest_vertex1=|vertex:&rbx_mesh::mesh::Vertex1|Ok(acquire_vertex_id(IndexedVertex{
-					pos:acquire_pos_id(vertex.pos)?,
-					tex:acquire_tex_id([vertex.tex[0],vertex.tex[1]]),
-					normal:acquire_normal_id(vertex.norm)?,
-					color:color_id,
-				}));
-				Ok(vec![ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?])
-			}).collect::<Result<_,_>>()?)));
+				let mut ingest_vertex1=|vertex:&rbx_mesh::mesh::Vertex1|{
+					let vertex=IndexedVertex{
+						pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+						tex:mb.acquire_tex_id(glam::vec2(vertex.tex[0],vertex.tex[1])),
+						normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+						color:color_id,
+					};
+					Ok(mb.acquire_vertex_id(vertex))
+				};
+				Ok(Triangle::new([ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?))
+			}).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)));
 		},
-		rbx_mesh::mesh::VersionedMesh::Version2(mesh)=>{
+		rbx_mesh::mesh::Mesh::V2(mesh)=>{
 			let vertex_id_map=match mesh.header.sizeof_vertex{
 				rbx_mesh::mesh::SizeOfVertex2::Truncated=>{
 					//pick white and make all the vertices white
-					let color_id=acquire_color_id([1.0f32;4]);
-					ingest_vertices_truncated2(mesh.vertices_truncated,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,color_id,&mut acquire_vertex_id)
+					let color_id=mb.acquire_color_id(glam::Vec4::ONE);
+					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
-				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id),
+				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
 			}?;
 			//one big happy group for all the faces
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|face|
-				vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
+			polygon_groups.push(PolygonGroup::TriangleList(TriangleList::new(mesh.faces.into_iter().map(|face|
+				Triangle::new([vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]])
 			).collect())));
 		},
-		rbx_mesh::mesh::VersionedMesh::Version3(mesh)=>{
+		rbx_mesh::mesh::Mesh::V3(mesh)=>{
 			let vertex_id_map=match mesh.header.sizeof_vertex{
 				rbx_mesh::mesh::SizeOfVertex2::Truncated=>{
-					let color_id=acquire_color_id([1.0f32;4]);
-					ingest_vertices_truncated2(mesh.vertices_truncated,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,color_id,&mut acquire_vertex_id)
+					let color_id=mb.acquire_color_id(glam::Vec4::ONE);
+					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
-				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id),
+				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
 			}?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
-		rbx_mesh::mesh::VersionedMesh::Version4(mesh)=>{
-			let vertex_id_map=ingest_vertices2(
-				mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id
-			)?;
+		rbx_mesh::mesh::Mesh::V4(mesh)=>{
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
-		rbx_mesh::mesh::VersionedMesh::Version5(mesh)=>{
-			let vertex_id_map=ingest_vertices2(
-				mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id
-			)?;
+		rbx_mesh::mesh::Mesh::V5(mesh)=>{
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 	}
-	let mesh=model::Mesh{
-		unique_pos,
-		unique_normal,
-		unique_tex,
-		unique_color,
-		unique_vertices,
+	let mesh=mb.build(
 		polygon_groups,
 		//these should probably be moved to the model...
 		//but what if models want to use the same texture
-		graphics_groups:vec![model::IndexedGraphicsGroup{
+		vec![model::IndexedGraphicsGroup{
 			render:RenderConfigId::new(0),
 			//the lowest lod is highest quality
 			groups:vec![model::PolygonGroupId::new(0)]
 		}],
 		//disable physics
-		physics_groups:Vec::new(),
-	};
+		Vec::new(),
+	);
+	let mut aabb=Aabb::default();
+	for &point in &mesh.unique_pos{
+		aabb.grow(point);
+	}
 	Ok(MeshWithSize{mesh,size:aabb.size()})
 }

lib/rbx_loader/src/rbx.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use crate::error::{RecoverableErrors,CFrameError,CFrameErrorType,DuplicateStageError,InstancePath,NormalIdError,Planar64ConvertError,ParseIntContext,ShapeError};
 use crate::loader::{MeshWithSize,MeshIndex};
 use crate::primitives::{self,CubeFace,CubeFaceDescription,WedgeFaceDescription,CornerWedgeFaceDescription,FaceDescription,Primitives};
 use strafesnet_common::map;
@@ -6,7 +7,7 @@ use strafesnet_common::model;
 use strafesnet_common::gameplay_modes::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
 use strafesnet_common::gameplay_style;
 use strafesnet_common::gameplay_attributes as attr;
-use strafesnet_common::integer::{self,vec3,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
+use strafesnet_common::integer::{self,vec3,Planar64TryFromFloatError,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 use strafesnet_common::model::RenderConfigId;
 use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,MeshDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
@@ -17,40 +18,32 @@ fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
 	rbx_dom_weak::ustr(s)
 }
 
-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
-){
-	let instance=instance;
-	let db=rbx_reflection_database::get();
-	let Some(superclass)=db.classes.get(superclass)else{
-		return;
-	};
-	objects.extend(
-		dom.descendants_of(instance.referent()).filter_map(|instance|{
-			let class=db.classes.get(instance.class.as_str())?;
-			db.has_superclass(class,superclass).then(||instance.referent())
-		})
-	);
-}
-
-fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
-	Planar64Affine3::new(
+fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Result<Planar64Affine3,Planar64TryFromFloatError>{
+	Ok(Planar64Affine3::new(
 		Planar64Mat3::from_cols([
-			vec3::try_from_f32_array([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x]).unwrap()
-			*integer::try_from_f32(size.x/2.0).unwrap(),
-			vec3::try_from_f32_array([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y]).unwrap()
-			*integer::try_from_f32(size.y/2.0).unwrap(),
-			vec3::try_from_f32_array([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z]).unwrap()
-			*integer::try_from_f32(size.z/2.0).unwrap(),
-			].map(|t|t.narrow_1().unwrap())),
-		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z]).unwrap()
-	)
+			(vec3::try_from_f32_array([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x])?
+			*integer::try_from_f32(size.x/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+			(vec3::try_from_f32_array([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y])?
+			*integer::try_from_f32(size.y/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+			(vec3::try_from_f32_array([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z])?
+			*integer::try_from_f32(size.z/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+		]),
+		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z])?
+	))
 }
 
-fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
+enum GetAttributesError{
+	ModeIdParseInt(ParseIntContext),
+	DuplicateMode(ModeId),
+	StageIdParseInt(ParseIntContext),
+	DuplicateStage(DuplicateStageError),
+	WormholeOutIdParseInt(ParseIntContext),
+	DuplicateWormholeOut(u32),
+	WormholeInIdParseInt(ParseIntContext),
+	JumpLimitParseInt(ParseIntContext),
+}
+
+fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->Result<attr::CollisionAttributes,GetAttributesError>{
 	let mut general=attr::GeneralAttributes::default();
 	let mut intersecting=attr::IntersectingAttributes::default();
 	let mut contacting=attr::ContactingAttributes::default();
@@ -84,13 +77,14 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		"MapStart"=>{
 			force_can_collide=false;
 			force_intersecting=true;
+			let mode_id=ModeId::MAIN;
 			modes_builder.insert_mode(
-				ModeId::MAIN,
+				mode_id,
 				Mode::empty(
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
-			).unwrap();
+			).map_err(|_|GetAttributesError::DuplicateMode(mode_id))?;
 		},
 		"MapFinish"=>{
 			force_can_collide=false;
@@ -130,26 +124,30 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					"BonusStart"=>{
 						force_can_collide=false;
 						force_intersecting=true;
+						let mode_id=ModeId::new(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::ModeIdParseInt)?);
 						modes_builder.insert_mode(
-							ModeId::new(captures[2].parse::<u32>().unwrap()),
+							mode_id,
 							Mode::empty(
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
-						).unwrap();
+						).map_err(|_|GetAttributesError::DuplicateMode(mode_id))?;
 					},
 					"WormholeOut"=>{
 						//the PhysicsModelId has to exist for it to be teleported to!
 						force_intersecting=true;
 						//this object is not special in strafe client, but the roblox mapping needs to be converted to model id
-						assert!(wormhole_id_to_out_model.insert(captures[2].parse::<u32>().unwrap(),model_id).is_none(),"Cannot have multiple WormholeOut with same id");
+						let wormhole_id=ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::WormholeOutIdParseInt)?;
+						if wormhole_id_to_out_model.insert(wormhole_id,model_id).is_some(){
+							return Err(GetAttributesError::DuplicateWormholeOut(wormhole_id));
+						}
 					},
 					_=>(),
 				}
 			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
-				let stage_id=StageId::new(captures[3].parse::<u32>().unwrap());
+				let stage_id=StageId::new(ParseIntContext::parse(&captures[3]).map_err(GetAttributesError::StageIdParseInt)?);
 				let stage_element=StageElement::new(
 					//stage_id:
 					stage_id,
@@ -161,11 +159,12 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					//behaviour:
 					match &captures[2]{
 						"Spawn"=>{
+							let mode_id=ModeId::MAIN;
 							modes_builder.insert_stage(
-								ModeId::MAIN,
+								mode_id,
 								stage_id,
 								Stage::empty(model_id),
-							).unwrap();
+							).map_err(|_|GetAttributesError::DuplicateStage(DuplicateStageError{mode_id,stage_id}))?;
 							//TODO: let denormalize handle this
 							StageElementBehaviour::SpawnAt
 						},
@@ -175,7 +174,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						"Trigger"=>{force_can_collide=false;StageElementBehaviour::Trigger},
 						"Teleport"=>{force_can_collide=false;StageElementBehaviour::Teleport},
 						"Platform"=>StageElementBehaviour::Platform,
-						_=>panic!("regex1[2] messed up bad"),
+						_=>unreachable!("regex1[2] messed up bad"),
 					},
 					None
 				);
@@ -198,30 +197,33 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 								StageId::FIRST,
 								false,
 								StageElementBehaviour::Check,
-								Some(captures[2].parse::<u8>().unwrap())
+								Some(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::JumpLimitParseInt)?)
 							)
 						),
 					),
 					"WormholeIn"=>{
 						force_can_collide=false;
 						force_intersecting=true;
-						assert!(wormhole_in_model_to_id.insert(model_id,captures[2].parse::<u32>().unwrap()).is_none(),"Impossible");
+						let wormhole_id=ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::WormholeInIdParseInt)?;
+						// It is impossible for two different objects to have the same model id
+						assert!(wormhole_in_model_to_id.insert(model_id,wormhole_id).is_none(),"Impossible");
 					},
-					_=>panic!("regex2[1] messed up bad"),
+					_=>unreachable!("regex2[1] messed up bad"),
 				}
 			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
 			.captures(other){
 				force_can_collide=false;
 				force_intersecting=true;
+				let mode_id=ModeId::new(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::ModeIdParseInt)?);
 				modes_builder.push_mode_update(
-					ModeId::new(captures[2].parse::<u32>().unwrap()),
+					mode_id,
 					ModeUpdate::zone(
 						model_id,
 						//zone:
 						match &captures[1]{
 							"Finish"=>Zone::Finish,
 							"Anticheat"=>Zone::Anticheat,
-							_=>panic!("regex3[1] messed up bad"),
+							_=>unreachable!("regex3[1] messed up bad"),
 						},
 					),
 				);
@@ -243,7 +245,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
-	match force_can_collide{
+	Ok(match force_can_collide{
 		true=>{
 			match name{
 				"Bounce"=>contacting.contact_behaviour=Some(attr::ContactingBehaviour::Elastic(u32::MAX)),
@@ -261,7 +263,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}else{
 			attr::CollisionAttributes::Decoration
 		},
-	}
+	})
 }
 
 #[derive(Clone,Copy)]
@@ -407,21 +409,25 @@ fn get_content_url(content:&rbx_dom_weak::types::Content)->Option<&str>{
 }
 
 fn get_texture_description<'a>(
-	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
+	recoverable_errors:&mut RecoverableErrors,
+	db:&rbx_reflection::ReflectionDatabase,
 	dom:&'a rbx_dom_weak::WeakDom,
 	object:&rbx_dom_weak::Instance,
 	size:&rbx_dom_weak::types::Vector3,
 )->RobloxPartDescription{
 	//use the biggest one and cut it down later...
 	let mut part_texture_description=RobloxPartDescription::default();
-	temp_objects.clear();
-	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
-	for &mut decal_ref in temp_objects{
-		let Some(decal)=dom.get_by_ref(decal_ref) else{
-			println!("Decal get_by_ref failed");
-			continue;
-		};
+	let decal=&db.classes["Decal"];
+	let decals=object.children().iter().filter_map(|&referent|{
+		let instance=dom.get_by_ref(referent)?;
+		db.classes.get(instance.class.as_str()).is_some_and(|class|
+			db.has_superclass(class,decal)
+		).then_some(instance)
+	});
+	for decal in decals{
+		// decals should always have these properties,
+		// but it is not guaranteed by the rbx_dom_weak data structure.
 		let (
 			Some(rbx_dom_weak::types::Variant::Content(content)),
 			Some(rbx_dom_weak::types::Variant::Enum(normalid)),
@@ -433,16 +439,16 @@ fn get_texture_description<'a>(
 			decal.properties.get(&static_ustr("Color3")),
 			decal.properties.get(&static_ustr("Transparency")),
 		)else{
-			println!("Decal is missing a required property");
+			recoverable_errors.decal_property.push(InstancePath::new(dom,decal));
 			continue;
 		};
-		let texture_id=match content.value(){
-			rbx_dom_weak::types::ContentType::Uri(uri)=>Some(uri.as_str()),
-			_=>None,
-		};
+		let texture_id=get_content_url(content);
 		let render_id=render_config_deferred_loader.acquire_render_config_id(texture_id);
 		let Ok(cube_face)=normalid.to_u32().try_into()else{
-			println!("NormalId is invalid");
+			recoverable_errors.normal_id.push(NormalIdError{
+				path:InstancePath::new(dom,decal),
+				normal_id:normalid.to_u32(),
+			});
 			continue;
 		};
 		let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
@@ -479,6 +485,7 @@ fn get_texture_description<'a>(
 					}
 				)
 			}else{
+				recoverable_errors.texture_property.push(InstancePath::new(dom,decal));
 				(glam::Vec4::ONE,RobloxTextureTransform::identity())
 			}
 		}else{
@@ -532,6 +539,8 @@ pub fn convert<'a>(
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
 	mesh_deferred_loader:&mut MeshDeferredLoader<MeshIndex<'a>>,
 )->PartialMap1<'a>{
+	let mut recoverable_errors=RecoverableErrors::default();
+
 	let mut deferred_models_deferred_attributes=Vec::new();
 	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
@@ -541,63 +550,83 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let mut object_refs=Vec::new();
-	let mut temp_objects=Vec::new();
-	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
-	for object_ref in object_refs {
-		if let Some(object)=dom.get_by_ref(object_ref){
-			if let (
-					Some(rbx_dom_weak::types::Variant::CFrame(cf)),
-					Some(rbx_dom_weak::types::Variant::Vector3(size)),
-					Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
-					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
-					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
-				) = (
-					object.properties.get(&static_ustr("CFrame")),
-					object.properties.get(&static_ustr("Size")),
-					object.properties.get(&static_ustr("Velocity")),
-					object.properties.get(&static_ustr("Transparency")),
-					object.properties.get(&static_ustr("Color")),
-					object.properties.get(&static_ustr("CanCollide")),
-				)
-			{
-				let model_transform=planar64_affine3_from_roblox(cf,size);
-
+	let db=rbx_reflection_database::get();
+	let basepart=&db.classes["BasePart"];
+	let baseparts=dom.descendants().filter(|&instance|
+		db.classes.get(instance.class.as_str()).is_some_and(|class|
+			db.has_superclass(class,basepart)
+		)
+	);
+	for object in baseparts{
+		let (
+			Some(rbx_dom_weak::types::Variant::CFrame(cf)),
+			Some(rbx_dom_weak::types::Variant::Vector3(size)),
+			Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
+			Some(rbx_dom_weak::types::Variant::Float32(transparency)),
+			Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
+			Some(&rbx_dom_weak::types::Variant::Bool(can_collide)),
+		) = (
+			object.properties.get(&static_ustr("CFrame")),
+			object.properties.get(&static_ustr("Size")),
+			object.properties.get(&static_ustr("Velocity")),
+			object.properties.get(&static_ustr("Transparency")),
+			object.properties.get(&static_ustr("Color")),
+			object.properties.get(&static_ustr("CanCollide")),
+		)else{
+			recoverable_errors.basepart_property.push(InstancePath::new(dom,object));
+			continue;
+		};
+		let model_transform=match planar64_affine3_from_roblox(cf,size){
+			Ok(model_transform)=>{
 				if model_transform.matrix3.det().is_zero(){
-					let mut parent_ref=object.parent();
-					let mut full_path=object.name.clone();
-					while let Some(parent)=dom.get_by_ref(parent_ref){
-						full_path=format!("{}.{}",parent.name,full_path);
-						parent_ref=parent.parent();
-					}
-					println!("Zero determinant CFrame at location {}",full_path);
-					println!("matrix3:{}",model_transform.matrix3);
+					recoverable_errors.basepart_cframe.push(CFrameError{
+						path:InstancePath::new(dom,object),
+						error:CFrameErrorType::ZeroDeterminant,
+					});
 					continue;
 				}
+				model_transform
+			},
+			Err(e)=>{
+				recoverable_errors.basepart_cframe.push(CFrameError{
+					path:InstancePath::new(dom,object),
+					error:CFrameErrorType::Convert(e),
+				});
+				continue;
+			}
+		};
 
-				//TODO: also detect "CylinderMesh" etc here
-				let shape=match object.class.as_str(){
-					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(&static_ustr("Shape")){
-						Shape::Primitive(shape.to_u32().try_into().expect("Funky roblox PartType"))
-					}else{
-						panic!("Part has no Shape!");
-					},
-					"TrussPart"=>Shape::Primitive(Primitives::Cube),
-					"WedgePart"=>Shape::Primitive(Primitives::Wedge),
-					"CornerWedgePart"=>Shape::Primitive(Primitives::CornerWedge),
-					"MeshPart"=>Shape::MeshPart,
-					"UnionOperation"=>Shape::PhysicsData,
-					_=>{
-						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
-						Shape::Primitive(Primitives::Cube)
-					}
+		//TODO: also detect "CylinderMesh" etc here
+		let shape=match object.class.as_str(){
+			"Part"|"Seat"|"SpawnLocation"=>{
+				let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(&static_ustr("Shape"))else{
+					recoverable_errors.part_property.push(InstancePath::new(dom,object));
+					continue;
 				};
+				let Ok(shape)=shape.to_u32().try_into()else{
+					recoverable_errors.part_shape.push(ShapeError{
+						path:InstancePath::new(dom,object),
+						shape:shape.to_u32(),
+					});
+					continue;
+				};
+				Shape::Primitive(shape)
+			},
+			"TrussPart"|"VehicleSeat"=>Shape::Primitive(Primitives::Cube),
+			"WedgePart"=>Shape::Primitive(Primitives::Wedge),
+			"CornerWedgePart"=>Shape::Primitive(Primitives::CornerWedge),
+			"MeshPart"=>Shape::MeshPart,
+			"UnionOperation"=>Shape::PhysicsData,
+			"Terrain"=>continue,
+			_=>{
+				recoverable_errors.unsupported_class.insert(object.class.as_str().to_owned());
+				Shape::Primitive(Primitives::Cube)
+			}
+		};
 
-				let (availability,mesh_id)=match shape{
-					Shape::Primitive(primitive_shape)=>{
-				//TODO: TAB TAB
-				let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
+		let (availability,mesh_id)=match shape{
+			Shape::Primitive(primitive_shape)=>{
+				let part_texture_description=get_texture_description(render_config_deferred_loader,&mut recoverable_errors,db,dom,object,size);
 				//obscure rust syntax "slice pattern"
 				let RobloxPartDescription([
 					f0,//Cube::Right
@@ -646,66 +675,83 @@ pub fn convert<'a>(
 					mesh_id
 				};
 				(MeshAvailability::Immediate,mesh_id)
-					},
-					Shape::MeshPart=>if let (
-						Some(rbx_dom_weak::types::Variant::Content(mesh_content)),
-						Some(rbx_dom_weak::types::Variant::Content(texture_content)),
-					)=(
-						// mesh must exist
-						object.properties.get(&static_ustr("MeshContent")),
-						// texture is allowed to be none
-						object.properties.get(&static_ustr("TextureContent")),
-					){
-						let mesh_asset_id=get_content_url(mesh_content).unwrap_or_default();
-						let texture_asset_id=get_content_url(texture_content);
-						(
-							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
-							mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id)),
-						)
-					}else{
-						panic!("Mesh has no Mesh or Texture");
-					},
-					Shape::PhysicsData=>{
-						let mut content="";
-						let mut mesh_data:&[u8]=&[];
-						let mut physics_data:&[u8]=&[];
-						if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
-							content=asset_id.as_ref();
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("MeshData")){
-							mesh_data=data.as_ref();
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("PhysicsData")){
-							physics_data=data.as_ref();
-						}
-						let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
-						let mesh_index=MeshIndex::union(content,mesh_data,physics_data,size,part_texture_description.clone());
-						let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
-						(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
-					},
+			},
+			Shape::MeshPart=>{
+				let (
+					Some(rbx_dom_weak::types::Variant::Content(mesh_content)),
+					Some(rbx_dom_weak::types::Variant::Content(texture_content)),
+				)=(
+					// mesh must exist
+					object.properties.get(&static_ustr("MeshContent")),
+					// texture is allowed to be none
+					object.properties.get(&static_ustr("TextureContent")),
+				)else{
+					recoverable_errors.meshpart_property.push(InstancePath::new(dom,object));
+					continue;
 				};
-				let model_deferred_attributes=ModelDeferredAttributes{
-					mesh:mesh_id,
-					transform:model_transform,
-					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
-					deferred_attributes:GetAttributesArgs{
-						name:object.name.as_str(),
-						can_collide:*can_collide,
-						velocity:vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]).unwrap(),
-					},
+				let mesh_asset_id=match get_content_url(mesh_content){
+					Some(mesh_asset_id)=>mesh_asset_id,
+					None=>{
+						recoverable_errors.meshpart_content.push(InstancePath::new(dom,object));
+						// Return an empty string which will fail to parse as an asset id
+						""
+					}
 				};
-				match availability{
-					MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
-					MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
-						render,
-						model:model_deferred_attributes
-					}),
-					MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
-						render:part_texture_description,
-						model:model_deferred_attributes,
-					}),
+				let texture_asset_id=get_content_url(texture_content);
+				(
+					MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
+					mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id)),
+				)
+			},
+			Shape::PhysicsData=>{
+				let mut content="";
+				let mut mesh_data:&[u8]=&[];
+				let mut physics_data:&[u8]=&[];
+				if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
+					content=asset_id.as_ref();
 				}
+				if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("MeshData")){
+					mesh_data=data.as_ref();
+				}
+				if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("PhysicsData")){
+					physics_data=data.as_ref();
+				}
+				let part_texture_description=get_texture_description(render_config_deferred_loader,&mut recoverable_errors,db,dom,object,size);
+				let mesh_index=MeshIndex::union(content,mesh_data,physics_data,size,part_texture_description.clone());
+				let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
+				(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
+			},
+		};
+		let velocity=match vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]){
+			Ok(velocity)=>velocity,
+			Err(e)=>{
+				recoverable_errors.basepart_velocity.push(Planar64ConvertError{
+					path:InstancePath::new(dom,object),
+					error:e,
+				});
+				continue;
 			}
+		};
+		let model_deferred_attributes=ModelDeferredAttributes{
+			mesh:mesh_id,
+			transform:model_transform,
+			color:glam::vec4(color3.r as f32/255f32,color3.g as f32/255f32,color3.b as f32/255f32,1.0-*transparency),
+			deferred_attributes:GetAttributesArgs{
+				name:object.name.as_str(),
+				can_collide,
+				velocity,
+			},
+		};
+		match availability{
+			MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
+			MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
+				render,
+				model:model_deferred_attributes
+			}),
+			MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
+				render:part_texture_description,
+				model:model_deferred_attributes,
+			}),
 		}
 	}
 	PartialMap1{
@@ -713,6 +759,7 @@ pub fn convert<'a>(
 		primitive_models_deferred_attributes,
 		deferred_models_deferred_attributes,
 		deferred_unions_deferred_attributes,
+		recoverable_errors,
 	}
 }
 struct MeshIdWithSize{
@@ -772,6 +819,7 @@ pub struct PartialMap1<'a>{
 	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes<'a>>,
 	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes<'a>>,
 	deferred_unions_deferred_attributes:Vec<DeferredUnionDeferredAttributes<'a>>,
+	recoverable_errors:RecoverableErrors,
 }
 impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
@@ -795,6 +843,7 @@ impl PartialMap1<'_>{
 		// I just want to chain iterators together man
 		let aint_no_way=core::cell::UnsafeCell::new(&mut self.primitive_meshes);
 
+		let mut model_counter=0;
 		let mut mesh_id_from_render_config_id=HashMap::new();
 		let mut union_id_from_render_config_id=HashMap::new();
 		//now that the meshes are loaded, these models can be generated
@@ -847,61 +896,78 @@ impl PartialMap1<'_>{
 			})
 		}))
 		.chain(self.primitive_models_deferred_attributes.into_iter())
-		.enumerate().map(|(model_id,model_deferred_attributes)|{
-			let model_id=model::ModelId::new(model_id as u32);
-			ModelOwnedAttributes{
+		.filter_map(|model_deferred_attributes|{
+			let model_id=model::ModelId::new(model_counter);
+			let attributes=match get_attributes(
+				&model_deferred_attributes.deferred_attributes.name,
+				model_deferred_attributes.deferred_attributes.can_collide,
+				model_deferred_attributes.deferred_attributes.velocity,
+				model_id,
+				&mut modes_builder,
+				&mut wormhole_in_model_to_id,
+				&mut wormhole_id_to_out_model,
+			){
+				Ok(attributes)=>attributes,
+				Err(e)=>{
+					match e{
+						GetAttributesError::ModeIdParseInt(e)=>self.recoverable_errors.mode_id_parse_int.push(e),
+						GetAttributesError::DuplicateMode(mode_id)=>{self.recoverable_errors.duplicate_mode.insert(mode_id);},
+						GetAttributesError::StageIdParseInt(e)=>self.recoverable_errors.stage_id_parse_int.push(e),
+						GetAttributesError::DuplicateStage(duplicate_stage)=>{self.recoverable_errors.duplicate_stage.insert(duplicate_stage);},
+						GetAttributesError::WormholeOutIdParseInt(e)=>self.recoverable_errors.wormhole_out_id_parse_int.push(e),
+						GetAttributesError::DuplicateWormholeOut(wormhole_id)=>{self.recoverable_errors.duplicate_wormhole_out.insert(wormhole_id);},
+						GetAttributesError::WormholeInIdParseInt(e)=>self.recoverable_errors.wormhole_in_id_parse_int.push(e),
+						GetAttributesError::JumpLimitParseInt(e)=>self.recoverable_errors.jump_limit_parse_int.push(e),
+					}
+					return None;
+				}
+			};
+			model_counter+=1;
+			Some(ModelOwnedAttributes{
 				mesh:model_deferred_attributes.mesh,
-				attributes:get_attributes(
-					&model_deferred_attributes.deferred_attributes.name,
-					model_deferred_attributes.deferred_attributes.can_collide,
-					model_deferred_attributes.deferred_attributes.velocity,
-					model_id,
-					&mut modes_builder,
-					&mut wormhole_in_model_to_id,
-					&mut wormhole_id_to_out_model,
-				),
+				attributes,
 				color:model_deferred_attributes.color,
 				transform:model_deferred_attributes.transform,
-			}
+			})
 		}).collect();
 		let models=models_owned_attributes.into_iter().enumerate().map(|(model_id,mut model_owned_attributes)|{
-		//TODO: TAB
-		let model_id=model::ModelId::new(model_id as u32);
-		//update attributes with wormhole id
-		//TODO: errors/prints
-		if let Some(wormhole_id)=wormhole_in_model_to_id.get(&model_id){
-			if let Some(&wormhole_out_model_id)=wormhole_id_to_out_model.get(wormhole_id){
-				match &mut model_owned_attributes.attributes{
-					attr::CollisionAttributes::Contact(attr::ContactAttributes{contacting:_,general})
-					|attr::CollisionAttributes::Intersect(attr::IntersectAttributes{intersecting:_,general})
-					=>general.wormhole=Some(attr::Wormhole{destination_model:wormhole_out_model_id}),
-					attr::CollisionAttributes::Decoration=>println!("Not a wormhole"),
+			let model_id=model::ModelId::new(model_id as u32);
+			//update attributes with wormhole id
+			//TODO: errors/prints
+			if let Some(wormhole_id)=wormhole_in_model_to_id.get(&model_id){
+				if let Some(&wormhole_out_model_id)=wormhole_id_to_out_model.get(wormhole_id){
+					match &mut model_owned_attributes.attributes{
+						attr::CollisionAttributes::Contact(attr::ContactAttributes{contacting:_,general})
+						|attr::CollisionAttributes::Intersect(attr::IntersectAttributes{intersecting:_,general})
+						=>general.wormhole=Some(attr::Wormhole{destination_model:wormhole_out_model_id}),
+						attr::CollisionAttributes::Decoration=>println!("Not a wormhole"),
+					}
 				}
 			}
-		}
 
-		//index the attributes
-		let attributes_id=if let Some(&attributes_id)=attributes_id_from_attributes.get(&model_owned_attributes.attributes){
-			attributes_id
-		}else{
-			let attributes_id=attr::CollisionAttributesId::new(unique_attributes.len() as u32);
-			attributes_id_from_attributes.insert(model_owned_attributes.attributes.clone(),attributes_id);
-			unique_attributes.push(model_owned_attributes.attributes);
-			attributes_id
-		};
-		model::Model{
-			mesh:model_owned_attributes.mesh,
-			transform:model_owned_attributes.transform,
-			color:model_owned_attributes.color,
-			attributes:attributes_id,
+			//index the attributes
+			let attributes_id=if let Some(&attributes_id)=attributes_id_from_attributes.get(&model_owned_attributes.attributes){
+				attributes_id
+			}else{
+				let attributes_id=attr::CollisionAttributesId::new(unique_attributes.len() as u32);
+				attributes_id_from_attributes.insert(model_owned_attributes.attributes.clone(),attributes_id);
+				unique_attributes.push(model_owned_attributes.attributes);
+				attributes_id
+			};
+			model::Model{
+				mesh:model_owned_attributes.mesh,
+				transform:model_owned_attributes.transform,
+				color:model_owned_attributes.color,
+				attributes:attributes_id,
+			}
+		}).collect();
+		PartialMap2{
+			meshes:self.primitive_meshes,
+			models,
+			modes:modes_builder.build_normalized(),
+			attributes:unique_attributes,
+			recoverable_errors:self.recoverable_errors,
 		}
-	}).collect();
-	PartialMap2{
-		meshes:self.primitive_meshes,
-		models,
-		modes:modes_builder.build_normalized(),
-		attributes:unique_attributes,
-	}
 	}
 }
 
@@ -910,12 +976,13 @@ pub struct PartialMap2{
 	models:Vec<model::Model>,
 	modes:NormalizedModes,
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	recoverable_errors:RecoverableErrors,
 }
 impl PartialMap2{
 	pub fn add_render_configs_and_textures(
 		self,
 		render_configs:RenderConfigs,
-	)->map::CompleteMap{
+	)->(map::CompleteMap,RecoverableErrors){
 		let (textures,render_configs)=render_configs.consume();
 		let (textures,texture_id_map):(Vec<Vec<u8>>,HashMap<model::TextureId,model::TextureId>)
 		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
@@ -934,14 +1001,17 @@ impl PartialMap2{
 			);
 			render_config
 		}).collect();
-		map::CompleteMap{
-			modes:self.modes,
-			attributes:self.attributes,
-			meshes:self.meshes,
-			models:self.models,
-			//the roblox legacy texture thing always works
-			textures,
-			render_configs,
-		}
+		(
+			map::CompleteMap{
+				modes:self.modes,
+				attributes:self.attributes,
+				meshes:self.meshes,
+				models:self.models,
+				//the roblox legacy texture thing always works
+				textures,
+				render_configs,
+			},
+			self.recoverable_errors,
+		)
 	}
 }

lib/rbx_loader/src/union.rs

@@ -1,13 +1,12 @@
 use crate::loader::MeshWithSize;
 use crate::rbx::RobloxPartDescription;
-use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS};
+use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS,FaceDescription};
 
-use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId2 as MeshDataNormalId2};
+use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId as MeshDataNormalId,NormalId2 as MeshDataNormalId2,NormalId5 as MeshDataNormalId5};
 use rbx_mesh::physics_data::VertexId as PhysicsDataVertexId;
-use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
+use strafesnet_common::model::{self,IndexedVertex,MeshBuilder,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId,VertexId};
 use strafesnet_common::integer::vec3;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Block,
@@ -25,7 +24,7 @@ impl std::fmt::Display for Error{
 // wacky state machine to make sure all vertices in a face agree upon what NormalId to use.
 // Roblox duplicates this information per vertex when it should only exist per-face.
 enum MeshDataNormalStatus{
-	Agree(MeshDataNormalId2),
+	Agree(MeshDataNormalId),
 	Conflicting,
 }
 struct MeshDataNormalChecker{
@@ -35,7 +34,7 @@ impl MeshDataNormalChecker{
 	fn new()->Self{
 		Self{status:None}
 	}
-	fn check(&mut self,normal:MeshDataNormalId2){
+	fn check(&mut self,normal:MeshDataNormalId){
 		self.status=match self.status.take(){
 			None=>Some(MeshDataNormalStatus::Agree(normal)),
 			Some(MeshDataNormalStatus::Agree(old_normal))=>{
@@ -48,7 +47,7 @@ impl MeshDataNormalChecker{
 			Some(MeshDataNormalStatus::Conflicting)=>Some(MeshDataNormalStatus::Conflicting),
 		};
 	}
-	fn into_agreed_normal(self)->Option<MeshDataNormalId2>{
+	fn into_agreed_normal(self)->Option<MeshDataNormalId>{
 		self.status.and_then(|status|match status{
 			MeshDataNormalStatus::Agree(normal)=>Some(normal),
 			MeshDataNormalStatus::Conflicting=>None,
@@ -56,6 +55,116 @@ impl MeshDataNormalChecker{
 	}
 }
 
+fn build_mesh2(
+	mb:&mut MeshBuilder,
+	polygon_groups_normal_id:&mut [Vec<Vec<VertexId>>;NORMAL_FACES],
+	cube_face_description:&[Option<FaceDescription>;NORMAL_FACES],
+	mesh:rbx_mesh::mesh_data::Mesh2,
+)->Result<(),Error>{
+	//autoscale to size, idk what roblox is doing with the graphics mesh size
+	let mut pos_min=glam::Vec3::MAX;
+	let mut pos_max=glam::Vec3::MIN;
+	for vertex in &mesh.vertices{
+		let p=vertex.pos.into();
+		pos_min=pos_min.min(p);
+		pos_max=pos_max.max(p);
+	}
+	let graphics_size=pos_max-pos_min;
+	for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in mesh.faces{
+		let face=[
+			mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
+			mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
+			mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
+		];
+		let mut normal_agreement_checker=MeshDataNormalChecker::new();
+		let face=face.into_iter().map(|vertex|{
+			let MeshDataNormalId2(normal_id)=vertex.normal_id;
+			normal_agreement_checker.check(normal_id);
+			let pos=glam::Vec3::from_array(vertex.pos)/graphics_size;
+			let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array())?);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
+			let tex_coord=glam::Vec2::from_array(vertex.tex);
+			let maybe_face_description=&cube_face_description[normal_id as usize-1];
+			let (tex,color)=match maybe_face_description{
+				Some(face_description)=>{
+					// transform texture coordinates and set decal color
+					let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
+					let color=mb.acquire_color_id(face_description.color);
+					(tex,color)
+				},
+				None=>{
+					// texture coordinates don't matter and pass through mesh vertex color
+					let tex=mb.acquire_tex_id(tex_coord);
+					let color=mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)));
+					(tex,color)
+				},
+			};
+			Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+		}).collect::<Result<Vec<_>,_>>().map_err(Error::Planar64Vec3)?;
+		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
+			polygon_groups_normal_id[normal_id as usize-1].push(face);
+		}else{
+			panic!("Empty face!");
+		}
+	}
+	Ok(())
+}
+fn build_mesh5(
+	mb:&mut MeshBuilder,
+	polygon_groups_normal_id:&mut [Vec<Vec<VertexId>>;NORMAL_FACES],
+	cube_face_description:&[Option<FaceDescription>;NORMAL_FACES],
+	mesh:rbx_mesh::mesh_data::CSGMDL5,
+)->Result<(),Error>{
+	//autoscale to size, idk what roblox is doing with the graphics mesh size
+	let mut pos_min=glam::Vec3::MAX;
+	let mut pos_max=glam::Vec3::MIN;
+	for &pos in &mesh.positions{
+		let p=pos.into();
+		pos_min=pos_min.min(p);
+		pos_max=pos_max.max(p);
+	}
+	let graphics_size=pos_max-pos_min;
+	for face in mesh.faces.indices.chunks_exact(3){
+		let mut normal_agreement_checker=MeshDataNormalChecker::new();
+		let face=face.into_iter().map(|&vertex_id|{
+			let vertex_index=vertex_id as usize;
+			let &pos=mesh.positions.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &MeshDataNormalId5(normal_id)=mesh.normal_ids.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &norm=mesh.normals.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &tex=mesh.tex.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &color=mesh.colors.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			normal_agreement_checker.check(normal_id);
+			let pos=glam::Vec3::from_array(pos)/graphics_size;
+			let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array()).map_err(Error::Planar64Vec3)?);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(norm).map_err(Error::Planar64Vec3)?);
+			let tex_coord=glam::Vec2::from_array(tex);
+			let maybe_face_description=&cube_face_description[normal_id as usize-1];
+			let (tex,color)=match maybe_face_description{
+				Some(face_description)=>{
+					// transform texture coordinates and set decal color
+					let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
+					let color=mb.acquire_color_id(face_description.color);
+					(tex,color)
+				},
+				None=>{
+					// texture coordinates don't matter and pass through mesh vertex color
+					let tex=mb.acquire_tex_id(tex_coord);
+					let color=mb.acquire_color_id(glam::Vec4::from_array(color.map(|f|f as f32/255.0f32)));
+					(tex,color)
+				},
+			};
+			Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+		}).collect::<Result<Vec<_>,_>>()?;
+		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
+			polygon_groups_normal_id[normal_id as usize-1].push(face);
+		}else{
+			panic!("Empty face!");
+		}
+	}
+	Ok(())
+}
+
+const NORMAL_FACES:usize=6;
 impl std::error::Error for Error{}
 pub fn convert(
 	roblox_physics_data:&[u8],
@@ -63,11 +172,10 @@ pub fn convert(
 	size:glam::Vec3,
 	RobloxPartDescription(part_texture_description):RobloxPartDescription,
 )->Result<MeshWithSize,Error>{
-	const NORMAL_FACES:usize=6;
 	let mut polygon_groups_normal_id:[_;NORMAL_FACES]=[vec![],vec![],vec![],vec![],vec![],vec![]];
 
 	// build graphics and physics meshes
-	let mut mb=strafesnet_common::model::MeshBuilder::new();
+	let mut mb=MeshBuilder::new();
 	// graphics
 	let graphics_groups=if !roblox_mesh_data.is_empty(){
 		// create per-face texture coordinate affine transforms
@@ -79,56 +187,12 @@ pub fn convert(
 		let mesh_data=rbx_mesh::read_mesh_data_versioned(
 			std::io::Cursor::new(roblox_mesh_data)
 		).map_err(Error::RobloxMeshData)?;
-		let graphics_mesh=match mesh_data{
+		match mesh_data{
 			rbx_mesh::mesh_data::MeshData::CSGK(_)=>return Err(Error::Block),
-			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL2(mesh_data2))=>mesh_data2.mesh,
-			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL4(mesh_data4))=>mesh_data4.mesh,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V2(mesh_data2))=>build_mesh2(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data2.mesh)?,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V4(mesh_data4))=>build_mesh2(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data4.mesh)?,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V5(mesh_data4))=>build_mesh5(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data4)?,
 		};
-		//autoscale to size, idk what roblox is doing with the graphics mesh size
-		let mut pos_min=glam::Vec3::MAX;
-		let mut pos_max=glam::Vec3::MIN;
-		for vertex in &graphics_mesh.vertices{
-			let p=vertex.pos.into();
-			pos_min=pos_min.min(p);
-			pos_max=pos_max.max(p);
-		}
-		let graphics_size=pos_max-pos_min;
-		for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in graphics_mesh.faces{
-			let face=[
-				graphics_mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-				graphics_mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-				graphics_mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
-			];
-			let mut normal_agreement_checker=MeshDataNormalChecker::new();
-			let face=face.into_iter().map(|vertex|{
-				normal_agreement_checker.check(vertex.normal_id);
-				let pos=glam::Vec3::from_array(vertex.pos)/graphics_size;
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array())?);
-				let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
-				let tex_coord=glam::Vec2::from_array(vertex.tex);
-				let maybe_face_description=&cube_face_description[vertex.normal_id as usize-1];
-				let (tex,color)=match maybe_face_description{
-					Some(face_description)=>{
-						// transform texture coordinates and set decal color
-						let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
-						let color=mb.acquire_color_id(face_description.color);
-						(tex,color)
-					},
-					None=>{
-						// texture coordinates don't matter and pass through mesh vertex color
-						let tex=mb.acquire_tex_id(tex_coord);
-						let color=mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)));
-						(tex,color)
-					},
-				};
-				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
-			}).collect::<Result<Vec<_>,_>>().map_err(Error::Planar64Vec3)?;
-			if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
-				polygon_groups_normal_id[normal_id as usize-1].push(face);
-			}else{
-				panic!("Empty face!");
-			}
-		}
 		(0..NORMAL_FACES).map(|polygon_group_id|{
 			model::IndexedGraphicsGroup{
 				render:cube_face_description[polygon_group_id].as_ref().map_or(RenderConfigId::new(0),|face_description|face_description.render),
@@ -153,10 +217,13 @@ pub fn convert(
 			// have not seen this format in practice
 			|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
 			=>return Err(Error::Block),
-			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes(meshes))
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V3(meshes))
+			|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V5(meshes))
+			=>meshes.meshes,
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V6(meshes))
+			=>vec![meshes.mesh],
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V7(meshes))
 			=>meshes.meshes,
-			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
-			=>vec![pim.mesh],
 		};
 		let physics_convex_meshes_it=physics_convex_meshes.into_iter().map(|mesh|{
 			// this can be factored out of the loop but I am lazy

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -14,7 +14,7 @@ run-service=[]
 [dependencies]
 glam = "0.30.0"
 mlua = { version = "0.10.1", features = ["luau"] }
-phf = { version = "0.11.2", features = ["macros"] }
+phf = { version = "0.12.1", features = ["macros"] }
 rbx_dom_weak = { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
 rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"

lib/roblox_emulator/src/context.rs

@@ -79,7 +79,15 @@ impl Context{
 
 		//insert services
 		let game=dom.root_ref();
-		let terrain_bldr=InstanceBuilder::new("Terrain");
+		let terrain_bldr=InstanceBuilder::new("Terrain")
+		.with_properties([
+			("CFrame",rbx_dom_weak::types::Variant::CFrame(rbx_dom_weak::types::CFrame::new(rbx_dom_weak::types::Vector3::new(0.0,0.0,0.0),rbx_dom_weak::types::Matrix3::identity()))),
+			("Size",rbx_dom_weak::types::Variant::Vector3(rbx_dom_weak::types::Vector3::new(1.0,1.0,1.0))),
+			("Velocity",rbx_dom_weak::types::Variant::Vector3(rbx_dom_weak::types::Vector3::new(0.0,0.0,0.0))),
+			("Transparency",rbx_dom_weak::types::Variant::Float32(0.0)),
+			("Color",rbx_dom_weak::types::Variant::Color3uint8(rbx_dom_weak::types::Color3uint8::new(255,255,255))),
+			("CanCollide",rbx_dom_weak::types::Variant::Bool(true)),
+		]);
 		let workspace=dom.insert(game,
 			InstanceBuilder::new("Workspace")
 				//Set Workspace.Terrain property equal to Terrain

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -519,7 +519,7 @@ struct ClassMethodsStore{
 }
 impl ClassMethodsStore{
 	/// return self.classes[class] or create the ClassMethods and then return it
-	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods>{
+	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods<'_>>{
 		// Use get_entry to get the &'static str keys of the database
 		// and use it as a key for the classes hashmap
 		CLASS_FUNCTION_DATABASE.get_entry(class)

lib/roblox_emulator/src/runner/runner.rs

@@ -13,14 +13,12 @@ pub enum Error{
 		error:mlua::Error
 	},
 	RustLua(mlua::Error),
-	Services(crate::context::ServicesError),
 }
 impl std::fmt::Display for Error{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		match self{
 			Self::Lua{source,error}=>write!(f,"lua error: source:\n{source}\n{error}"),
 			Self::RustLua(error)=>write!(f,"rust-side lua error: {error}"),
-			other=>write!(f,"{other:?}"),
 		}
 	}
 }

lib/roblox_emulator/src/runner/tween.rs

@@ -1,7 +1,7 @@
 use super::instance::Instance;
 use super::tween_info::TweenInfo;
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Clone)]
 pub struct Tween{
 	instance:Instance,

lib/roblox_emulator/src/runner/tween_info.rs

@@ -1,7 +1,7 @@
 use super::number::Number;
 use super::r#enum::{CoerceEnum,Enums};
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Clone)]
 pub struct TweenInfo{
 	time:f64,

lib/snf/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "strafesnet_snf"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-binrw = "0.14.0"
+binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }

lib/snf/src/bot.rs

@@ -85,6 +85,7 @@ pub struct Segment{
 #[derive(Clone,Copy,Debug)]
 pub struct SegmentInfo{
 	/// time of the first instruction in this segment.
+	#[expect(dead_code)]
 	time:Time,
 	instruction_count:u32,
 	/// How many total instructions in segments up to and including this segment
@@ -116,6 +117,7 @@ impl<R:BinReaderExt> StreamableBot<R>{
 			segment_map,
 		})
 	}
+	#[expect(dead_code)]
 	fn get_segment_info(&self,segment_id:SegmentId)->Result<SegmentInfo,Error>{
 		Ok(*self.segment_map.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?)
 	}

lib/snf/src/file.rs

@@ -53,8 +53,6 @@ pub(crate) enum FourCC{
 	Map,
 	#[brw(magic=b"SNFB")]
 	Bot,
-	#[brw(magic=b"SNFD")]
-	Demo,
 }
 #[binrw]
 #[brw(little)]

lib/snf/src/lib.rs

@@ -5,7 +5,6 @@ mod newtypes;
 mod file;
 pub mod map;
 pub mod bot;
-pub mod demo;
 
 #[derive(Debug)]
 pub enum Error{
@@ -13,7 +12,6 @@ pub enum Error{
 	Header(file::Error),
 	Map(map::Error),
 	Bot(bot::Error),
-	Demo(demo::Error),
 }
 impl std::fmt::Display for Error{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -25,7 +23,6 @@ impl std::error::Error for Error{}
 pub enum SNF<R:BinReaderExt>{
 	Map(map::StreamableMap<R>),
 	Bot(bot::StreamableBot<R>),
-	Demo(demo::StreamableDemo<R>),
 }
 
 pub fn read_snf<R:BinReaderExt>(input:R)->Result<SNF<R>,Error>{
@@ -33,7 +30,6 @@ pub fn read_snf<R:BinReaderExt>(input:R)->Result<SNF<R>,Error>{
 	Ok(match file.fourcc(){
 		file::FourCC::Map=>SNF::Map(map::StreamableMap::new(file).map_err(Error::Map)?),
 		file::FourCC::Bot=>SNF::Bot(bot::StreamableBot::new(file).map_err(Error::Bot)?),
-		file::FourCC::Demo=>SNF::Demo(demo::StreamableDemo::new(file).map_err(Error::Demo)?),
 	})
 }
 pub fn read_map<R:BinReaderExt>(input:R)->Result<map::StreamableMap<R>,Error>{
@@ -50,13 +46,6 @@ pub fn read_bot<R:BinReaderExt>(input:R)->Result<bot::StreamableBot<R>,Error>{
 		_=>Err(Error::UnexpectedFourCC)
 	}
 }
-pub fn read_demo<R:BinReaderExt>(input:R)->Result<demo::StreamableDemo<R>,Error>{
-	let file=file::File::new(input).map_err(Error::Header)?;
-	match file.fourcc(){
-		file::FourCC::Demo=>Ok(demo::StreamableDemo::new(file).map_err(Error::Demo)?),
-		_=>Err(Error::UnexpectedFourCC)
-	}
-}
 
 #[cfg(test)]
 mod tests {

lib/snf/src/newtypes/gameplay_style.rs

@@ -104,6 +104,7 @@ impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
+#[expect(dead_code)]
 pub enum JumpCalculation{
 	Max,
 	BoostThenJump,
@@ -128,6 +129,7 @@ impl From<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculatio
 	}
 }
 
+#[expect(dead_code)]
 pub enum JumpImpulse{
 	Time(Time),
 	Height(Planar64),

map-tool/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "map-tool"
-version = "1.7.0"
+version = "1.7.2"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -19,10 +19,10 @@ rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet" }
 rbx_reflection_database = "1.0.0"
 rbx_xml = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_bsp_loader = { version = "0.3.0", path = "../lib/bsp_loader", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../lib/deferred_loader", registry = "strafesnet" }
-strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registry = "strafesnet" }
-strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
+strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
+strafesnet_rbx_loader = { version = "0.7.0", path = "../lib/rbx_loader", registry = "strafesnet" }
+strafesnet_snf = { version = "0.3.1", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
 vbsp = "0.9.1"

map-tool/src/roblox.rs

@@ -32,8 +32,12 @@ pub struct RobloxToSNFSubcommand {
 pub struct DownloadAssetsSubcommand{
 	#[arg(required=true)]
 	roblox_files:Vec<PathBuf>,
-	// #[arg(long)]
-	// cookie_file:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
 }
 
 impl Commands{
@@ -42,13 +46,27 @@ impl Commands{
 			Commands::RobloxToSNF(subcommand)=>roblox_to_snf(subcommand.input_files,subcommand.output_folder).await,
 			Commands::DownloadAssets(subcommand)=>download_assets(
 				subcommand.roblox_files,
-				rbx_asset::cookie::Cookie::new("".to_string()),
+				cookie_from_args(
+					subcommand.cookie_literal,
+					subcommand.cookie_envvar,
+					subcommand.cookie_file,
+				).await?,
 			).await,
 		}
 	}
 }
 
-#[allow(unused)]
+async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<rbx_asset::cookie::Cookie>{
+	let cookie=match (literal,environment,file){
+		(Some(cookie_literal),None,None)=>cookie_literal,
+		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
+		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
+		_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?,
+	};
+	Ok(rbx_asset::cookie::Cookie::new(cookie))
+}
+
+#[expect(dead_code)]
 #[derive(Debug)]
 enum LoadDomError{
 	IO(std::io::Error),
@@ -174,7 +192,7 @@ impl UniqueAssets{
 	}
 }
 
-#[allow(unused)]
+#[expect(dead_code)]
 #[derive(Debug)]
 enum UniqueAssetError{
 	IO(std::io::Error),
@@ -249,8 +267,8 @@ async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,dow
 				tokio::fs::write(path,&data).await?;
 				break Ok(DownloadResult::Data(data));
 			},
-			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::StatusCodeWithUrlAndBody(scwuab)))=>{
-				if scwuab.status_code.as_u16()==429{
+			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body}))=>{
+				if status_code.as_u16()==429{
 					if retry==12{
 						println!("Giving up asset download {asset_id}");
 						stats.timed_out_downloads+=1;
@@ -262,7 +280,7 @@ async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,dow
 					retry+=1;
 				}else{
 					stats.failed_downloads+=1;
-					println!("weird scuwab error: {scwuab:?}");
+					println!("weird status_code error: status_code={status_code} url={} body={}",url_and_body.url,url_and_body.body);
 					break Ok(DownloadResult::Failed);
 				}
 			},
@@ -403,7 +421,7 @@ async fn download_assets(paths:Vec<PathBuf>,cookie:rbx_asset::cookie::Cookie)->A
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum ConvertError{
 	IO(std::io::Error),
 	SNFMap(strafesnet_snf::map::Error),
@@ -416,17 +434,23 @@ impl std::fmt::Display for ConvertError{
 	}
 }
 impl std::error::Error for ConvertError{}
-async fn convert_to_snf(path:&Path,output_folder:PathBuf)->AResult<()>{
-	let entire_file=tokio::fs::read(path).await?;
+
+struct Errors{
+	script_errors:Vec<strafesnet_rbx_loader::RunnerError>,
+	convert_errors:strafesnet_rbx_loader::RecoverableErrors,
+}
+
+fn convert_to_snf(path:&Path,output_folder:PathBuf)->Result<Errors,ConvertError>{
+	let entire_file=std::fs::read(path).map_err(ConvertError::IO)?;
 
 	let model=strafesnet_rbx_loader::read(
-		std::io::Cursor::new(entire_file)
+		entire_file.as_slice()
 	).map_err(ConvertError::RobloxRead)?;
 
 	let mut place=strafesnet_rbx_loader::Place::from(model);
-	place.run_scripts();
+	let script_errors=place.run_scripts().unwrap_or_else(|e|vec![e]);
 
-	let map=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
+	let (map,convert_errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
 
 	let mut dest=output_folder;
 	dest.push(path.file_stem().unwrap());
@@ -435,7 +459,10 @@ async fn convert_to_snf(path:&Path,output_folder:PathBuf)->AResult<()>{
 
 	strafesnet_snf::map::write_map(file,map).map_err(ConvertError::SNFMap)?;
 
-	Ok(())
+	Ok(Errors{
+		script_errors,
+		convert_errors,
+	})
 }
 
 async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->AResult<()>{
@@ -444,15 +471,25 @@ async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->ARe
 	let thread_limit=std::thread::available_parallelism()?.get();
 	let mut it=paths.into_iter();
 	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	// This is wrong! Calling roblox_to_snf multiple times keeps adding permits
 	SEM.add_permits(thread_limit);
 
 	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
 		let output_folder=output_folder.clone();
-		tokio::spawn(async move{
-			let result=convert_to_snf(path.as_path(),output_folder).await;
+		tokio::task::spawn_blocking(move||{
+			let result=convert_to_snf(path.as_path(),output_folder);
 			drop(permit);
 			match result{
-				Ok(())=>(),
+				Ok(errors)=>{
+					for error in errors.script_errors{
+						println!("Script error: {error}");
+					}
+					let error_count=errors.convert_errors.count();
+					if error_count!=0{
+						println!("Error count: {error_count}");
+						println!("Errors: {}",errors.convert_errors);
+					}
+				},
 				Err(e)=>println!("Convert error: {e:?}"),
 			}
 		});

map-tool/src/source.rs

@@ -452,7 +452,7 @@ fn bsp_contents(path:PathBuf)->AResult<()>{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum ConvertError{
 	IO(std::io::Error),
 	SNFMap(strafesnet_snf::map::Error),

strafe-client/Cargo.toml

@@ -28,5 +28,9 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "25.0.0"
+wgpu = "26.0.1"
 winit = "0.30.7"
+
+[profile.dev]
+strip = false
+opt-level = 3

strafe-client/src/file.rs

@@ -3,7 +3,7 @@ use std::io::Read;
 #[cfg(any(feature="roblox",feature="source"))]
 use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum ReadError{
 	#[cfg(feature="roblox")]
@@ -63,7 +63,7 @@ pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
 	}
 }
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum LoadError{
 	ReadError(ReadError),
@@ -98,10 +98,15 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 		#[cfg(feature="roblox")]
 		ReadFormat::Roblox(model)=>{
 			let mut place=strafesnet_rbx_loader::Place::from(model);
-			place.run_scripts();
-			Ok(LoadFormat::Map(
-				place.to_snf(LoadFailureMode::DefaultToNone).map_err(LoadError::LoadRoblox)?
-			))
+			let script_errors=place.run_scripts().unwrap();
+			for error in script_errors{
+				println!("Script error: {error}");
+			}
+			let (map,errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(LoadError::LoadRoblox)?;
+			if errors.count()!=0{
+				print!("Errors encountered while loading the map:\n{}",errors);
+			}
+			Ok(LoadFormat::Map(map))
 		},
 		#[cfg(feature="source")]
 		ReadFormat::Source(bsp)=>Ok(LoadFormat::Map(

strafe-client/src/graphics_worker.rs

@@ -21,7 +21,7 @@ WorkerDescription{
 pub fn new(
 	mut graphics:graphics::GraphicsState,
 	mut config:wgpu::SurfaceConfiguration,
-	surface:wgpu::Surface,
+	surface:wgpu::Surface<'_>,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 )->crate::compat_worker::INWorker<'_,Instruction>{

tools/clarion

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client bhop_maps/5692098704.snfm "$@"