physics: hardcoded cylinder

Cargo.toml

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

engine/graphics/src/graphics.rs

@@ -103,6 +103,26 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
+const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
+const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
+fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
+	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
+	for mi in instances{
+		//model transform
+		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
+		//normal transform
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
+		raw.extend_from_slice(&[0.0]);
+		//color
+		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
+	}
+	raw
+}
+
 pub struct GraphicsState{
 	pipelines:GraphicsPipelines,
 	bind_groups:GraphicsBindGroups,
@@ -967,22 +987,3 @@ impl GraphicsState{
 		self.staging_belt.recall();
 	}
 }
-const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
-const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
-	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
-	for mi in instances{
-		//model transform
-		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
-		//normal transform
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
-		raw.extend_from_slice(&[0.0]);
-		//color
-		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
-	}
-	raw
-}

engine/physics/src/body.rs

@@ -42,12 +42,12 @@ impl<T> Body<T>
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
 		self.position
-		+(self.velocity*dt).map(|elem|elem.divide().fix_1())
-		+self.acceleration.map(|elem|(dt*dt*elem/2).divide().fix_1())
+		+(self.velocity*dt).map(|elem|elem.divide().clamp_1())
+		+self.acceleration.map(|elem|(dt*dt*elem/2).divide().clamp_1())
 	}
 	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
-		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().fix_1())
+		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().clamp_1())
 	}
 	pub fn advance_time(&mut self,time:Time<T>){
 		self.position=self.extrapolated_position(time);
@@ -71,12 +71,12 @@ impl<T> Body<T>
 			D2:Copy,
 			Planar64:core::ops::Mul<D2,Output=N4>,
 			N4:integer::Divide<D2,Output=T1>,
-			T1:integer::Fix<Planar64>,
+			T1:integer::Clamp<Planar64>,
 	{
 		// a*dt^2/2 + v*dt + p
 		// (a*dt/2+v)*dt+p
 		(self.acceleration.map(|elem|dt*elem/2)+self.velocity).map(|elem|dt.mul_ratio(elem))
-		.map(|elem|elem.divide().fix())+self.position
+		.map(|elem|elem.divide().clamp())+self.position
 	}
 	pub fn extrapolated_velocity_ratio_dt<Num,Den,N1,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
 		where
@@ -85,10 +85,10 @@ impl<T> Body<T>
 			Num:core::ops::Mul<Planar64,Output=N1>,
 			Planar64:core::ops::Mul<Den,Output=N1>,
 			N1:integer::Divide<Den,Output=T1>,
-			T1:integer::Fix<Planar64>,
+			T1:integer::Clamp<Planar64>,
 	{
 		// a*dt + v
-		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
+		self.acceleration.map(|elem|(dt*elem).divide().clamp())+self.velocity
 	}
 	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
 		self.position=self.extrapolated_position_ratio_dt(dt);

engine/physics/src/face_crawler.rs

@@ -57,13 +57,14 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).iter(){
+				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
-					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
+					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
 					//WARNING: precision is swept under the rug!
-					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+					//wrap for speed
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
@@ -77,13 +78,15 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//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 delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
-				for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
+				let &[ev0,ev1]=edge_verts.as_ref();
+				let delta_pos=body.position*2-(mesh.vert(ev0)+mesh.vert(ev1));
+				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
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
 					//WARNING yada yada d *2
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+					//wrap for speed
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
@@ -92,12 +95,12 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each vertex collision time, ignoring roots with zero or conflicting derivative
-				for (i,&vert_id) in edge_verts.iter().enumerate(){
+				for (i,&vert_id) in edge_verts.as_ref().iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
@@ -108,12 +111,12 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
+				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
@@ -128,11 +131,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	pub fn crawl(mut self,mesh:&M,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<M>{
 		let mut body_time={
 			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		let time_limit={
 			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		for _ in 0..20{
 			match self.next_transition(body_time,mesh,relative_body,time_limit){

engine/physics/src/physics.rs

@@ -117,8 +117,8 @@ impl TransientAcceleration{
 		}else{
 			//normal friction acceleration is clippedAcceleration.dot(normal)*friction
 			TransientAcceleration::Reachable{
-				acceleration:target_diff.with_length(accel).divide().fix_1(),
-				time:time+Time::from((target_diff.length()/accel).divide().fix_1())
+				acceleration:target_diff.with_length(accel).divide().wrap_1(),
+				time:time+Time::from((target_diff.length()/accel).divide().clamp_1())
 			}
 		}
 	}
@@ -407,7 +407,7 @@ impl HitboxMesh{
 		let transform=PhysicsMeshTransform::new(transform);
 		let transformed_mesh=TransformedMesh::new(mesh.complete_mesh_view(),&transform);
 		for vert in transformed_mesh.verts(){
-			aabb.grow(vert.fix_1());
+			aabb.grow(vert.narrow_1().unwrap());
 		}
 		Self{
 			halfsize:aabb.size()>>1,
@@ -460,12 +460,12 @@ impl StyleHelper for StyleModifiers{
 	}
 
 	fn get_y_control_dir(&self,camera:&PhysicsCamera,controls:Controls)->Planar64Vec3{
-		(camera.rotation_y()*self.get_control_dir(controls)).fix_1()
+		(camera.rotation_y()*self.get_control_dir(controls)).wrap_1()
 	}
 
 	fn get_propulsion_control_dir(&self,camera:&PhysicsCamera,controls:Controls)->Planar64Vec3{
 		//don't interpolate this! discrete mouse movement, constant acceleration
-		(camera.rotation()*self.get_control_dir(controls)).fix_1()
+		(camera.rotation()*self.get_control_dir(controls)).wrap_1()
 	}
 	fn calculate_mesh(&self)->HitboxMesh{
 		let mesh=match self.hitbox.mesh{
@@ -982,10 +982,7 @@ impl PhysicsContext<'_>{
 impl PhysicsData{
 	/// use with caution, this is the only non-instruction way to mess with physics
 	pub fn generate_models(&mut self,map:&map::CompleteMap){
-		let mut modes=map.modes.clone();
-		for mode in &mut modes.modes{
-			mode.denormalize_data();
-		}
+		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
 
@@ -1087,7 +1084,7 @@ impl PhysicsData{
 				let mut aabb=aabb::Aabb::default();
 				let transformed_mesh=TransformedMesh::new(view,transform);
 				for v in transformed_mesh.verts(){
-					aabb.grow(v.fix_1());
+					aabb.grow(v.narrow_1().unwrap());
 				}
 				(ConvexMeshId{
 					model_id,
@@ -1165,7 +1162,8 @@ fn contact_normal(models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&Contact
 	let model_mesh=models.contact_mesh(contact);
 	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
-	minkowski.face_nd(contact.face_id).0.fix_1()
+	// wrap for speed
+	minkowski.face_nd(contact.face_id).0.wrap_1()
 }
 
 fn recalculate_touching(
@@ -1324,7 +1322,7 @@ fn teleport_to_spawn(
 	const EPSILON:Planar64=Planar64::raw((1<<32)/16);
 	let transform=models.get_model_transform(spawn_model_id).ok_or(TeleportToSpawnError::NoModel)?;
 	//TODO: transform.vertex.matrix3.col(1)+transform.vertex.translation
-	let point=transform.vertex.transform_point3(vec3::Y).fix_1()+Planar64Vec3::new([Planar64::ZERO,style.hitbox.halfsize.y+EPSILON,Planar64::ZERO]);
+	let point=transform.vertex.transform_point3(vec3::Y).clamp_1()+Planar64Vec3::new([Planar64::ZERO,style.hitbox.halfsize.y+EPSILON,Planar64::ZERO]);
 	teleport(point,move_state,body,touching,run,mode_state,Some(mode),models,hitbox_mesh,bvh,style,camera,input_state,time);
 	Ok(())
 }
@@ -1488,7 +1486,7 @@ fn collision_start_contact(
 		Some(gameplay_attributes::ContactingBehaviour::Surf)=>(),
 		Some(gameplay_attributes::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
 		&Some(gameplay_attributes::ContactingBehaviour::Elastic(elasticity))=>{
-			let reflected_velocity=body.velocity+((body.velocity-incident_velocity)*Planar64::raw(elasticity as i64+1)).fix_1();
+			let reflected_velocity=body.velocity+((body.velocity-incident_velocity)*Planar64::raw(elasticity as i64+1)).wrap_1();
 			set_velocity(body,touching,models,hitbox_mesh,reflected_velocity);
 		},
 		Some(gameplay_attributes::ContactingBehaviour::Ladder(contacting_ladder))=>
@@ -1711,7 +1709,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						let control_dir=state.style.get_control_dir(masked_controls);
 						if control_dir!=vec3::ZERO{
 							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
-							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().fix_1()){
+							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
 								//need to note which push planes activate in push solve and keep those
 								state.cull_velocity(data,ticked_velocity);
@@ -1814,14 +1812,18 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 		Instruction::Mode(ModeInstruction::Restart(mode_id))=>{
 			//teleport to mode start zone
+			let mut spawn_point=vec3::ZERO;
 			let mode=data.modes.get_mode(mode_id);
-			let spawn_point=mode.and_then(|mode|
+			if let Some(mode)=mode{
+				// set style
+				state.style=mode.get_style().clone();
 				//TODO: spawn at the bottom of the start zone plus the hitbox size
-				//TODO: set camera andles to face the same way as the start zone
-				data.models.get_model_transform(mode.get_start().into()).map(|transform|
-					transform.vertex.translation
-				)
-			).unwrap_or(vec3::ZERO);
+				//TODO: set camera angles to face the same way as the start zone
+				if let Some(transform)=data.models.get_model_transform(mode.get_start()){
+					// NOTE: this value may be 0,0,0 on source maps
+					spawn_point=transform.vertex.translation;
+				}
+			}
 			set_position(spawn_point,&mut state.move_state,&mut state.body,&mut state.touching,&mut state.run,&mut state.mode_state,mode,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,state.time);
 			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
 			state.set_move_state(data,MoveState::Air);
@@ -1831,6 +1833,9 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Mode(ModeInstruction::Spawn(mode_id,stage_id))=>{
 			//spawn at a particular stage
 			if let Some(mode)=data.modes.get_mode(mode_id){
+				// set style
+				state.style=mode.get_style().clone();
+				// teleport to stage in mode
 				if let Some(stage)=mode.get_stage(stage_id){
 					let _=teleport_to_spawn(
 						stage.spawn(),

engine/physics/src/push_solve.rs

@@ -152,18 +152,19 @@ const fn get_push_ray_0(point:Planar64Vec3)->Ray{
 	Ray{origin:point,direction:vec3::ZERO}
 }
 fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
-	let direction=solve1(c0)?.divide().fix_1();
+	//wrap for speed
+	let direction=solve1(c0)?.divide().wrap_1();
 	let [s0]=decompose1(direction,c0.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO){
 		return None;
 	}
 	let origin=point+solve1(
 		&c0.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
-	let direction=solve2(c0,c1)?.divide().fix_1();
+	let direction=solve2(c0,c1)?.divide().wrap_1();
 	let [s0,s1]=decompose2(direction,c0.velocity,c1.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO){
 		return None;
@@ -171,11 +172,11 @@ fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
 	let origin=point+solve2(
 		&c0.relative_to(point),
 		&c1.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ray>{
-	let direction=solve3(c0,c1,c2)?.divide().fix_1();
+	let direction=solve3(c0,c1,c2)?.divide().wrap_1();
 	let [s0,s1,s2]=decompose3(direction,c0.velocity,c1.velocity,c2.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO)||s2.lt_ratio(RATIO_ZERO){
 		return None;
@@ -184,7 +185,7 @@ fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Optio
 		&c0.relative_to(point),
 		&c1.relative_to(point),
 		&c2.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 

integration-testing/src/main.rs

@@ -1,10 +1,16 @@
-
-use std::{io::{Cursor,Read},path::Path};
+use std::io::Cursor;
+use std::path::Path;
+use std::time::Instant;
 
 use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
 
 fn main(){
-	test_determinism().unwrap();
+	let arg=std::env::args().skip(1).next();
+	match arg.as_deref(){
+		Some("determinism")|None=>test_determinism().unwrap(),
+		Some("replay")=>run_replay().unwrap(),
+		_=>println!("invalid argument"),
+	}
 }
 
 #[allow(unused)]
@@ -37,9 +43,7 @@ impl From<strafesnet_snf::bot::Error> for ReplayError{
 }
 
 fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=std::fs::File::open(path)?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data)?;
+	let data=std::fs::read(path)?;
 	Ok(Cursor::new(data))
 }
 
@@ -72,7 +76,12 @@ enum DeterminismResult{
 	Deterministic,
 	NonDeterministic,
 }
-fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->DeterminismResult{
+struct SegmentResult{
+	determinism:DeterminismResult,
+	ticks:u64,
+	nanoseconds:u64,
+}
+fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->SegmentResult{
 	// create default physics state
 	let mut physics_deterministic=PhysicsState::default();
 	// create a second physics state
@@ -82,6 +91,9 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	println!("simulating...");
 
 	let mut non_idle_count=0;
+	let instruction_count=bot.instructions.len();
+
+	let start=Instant::now();
 
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
@@ -97,6 +109,7 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 				let b0=physics_deterministic.camera_body();
 				let b1=physics_filtered.camera_body();
 				if b0.position!=b1.position{
+					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);
 					println!("non idle instructions completed={non_idle_count}");
 					println!("instruction #{i}={:?}",other);
@@ -104,11 +117,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 					println!("filtered state0:\n{state_filtered:?}");
 					println!("deterministic state1:\n{:?}",physics_deterministic);
 					println!("filtered state1:\n{:?}",physics_filtered);
-					return DeterminismResult::NonDeterministic;
+					return SegmentResult{
+						determinism:DeterminismResult::NonDeterministic,
+						ticks:1+i as u64+non_idle_count,
+						nanoseconds,
+					};
 				}
 			},
 		}
 	}
+	let nanoseconds=start.elapsed().as_nanos() as u64;
 	match physics_deterministic.get_finish_time(){
 		Some(time)=>println!("[with idle] finish time:{}",time),
 		None=>println!("[with idle] simulation did not end in finished state"),
@@ -117,9 +135,14 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 		Some(time)=>println!("[filtered] finish time:{}",time),
 		None=>println!("[filtered] simulation did not end in finished state"),
 	}
-	DeterminismResult::Deterministic
+	SegmentResult{
+		determinism:DeterminismResult::Deterministic,
+		ticks:instruction_count as u64+non_idle_count,
+		nanoseconds,
+	}
+
 }
-type ThreadResult=Result<Option<DeterminismResult>,ReplayError>;
+type ThreadResult=Result<Option<SegmentResult>,ReplayError>;
 fn read_and_run(file_path:std::path::PathBuf,physics_data:&PhysicsData)->ThreadResult{
 	let data=read_entire_file(file_path.as_path())?;
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
@@ -198,10 +221,18 @@ fn test_determinism()->Result<(),ReplayError>{
 		invalid:u32,
 		error:u32,
 	}
+	let mut nanoseconds=0;
+	let mut ticks=0;
 	let Totals{deterministic,nondeterministic,invalid,error}=thread_results.into_iter().fold(Totals::default(),|mut totals,result|{
 		match result{
-			Ok(Some(DeterminismResult::Deterministic))=>totals.deterministic+=1,
-			Ok(Some(DeterminismResult::NonDeterministic))=>totals.nondeterministic+=1,
+			Ok(Some(segment_result))=>{
+				ticks+=segment_result.ticks;
+				nanoseconds+=segment_result.nanoseconds;
+				match segment_result.determinism{
+					DeterminismResult::Deterministic=>totals.deterministic+=1,
+					DeterminismResult::NonDeterministic=>totals.nondeterministic+=1,
+				}
+			},
 			Ok(None)=>totals.invalid+=1,
 			Err(_)=>totals.error+=1,
 		}
@@ -212,6 +243,7 @@ fn test_determinism()->Result<(),ReplayError>{
 	println!("nondeterministic={nondeterministic}");
 	println!("invalid={invalid}");
 	println!("error={error}");
+	println!("average ticks/s per core: {}",ticks*1_000_000_000/nanoseconds);
 
 	assert!(nondeterministic==0);
 	assert!(invalid==0);

lib/bsp_loader/Cargo.toml

@@ -13,7 +13,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 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" }
-vbsp = { version = "0.7.0-codegen5", registry = "strafesnet", default-features = false }
-vbsp-entities = { version = "0.1.0", registry = "strafesnet", default-features = false, features = ["css"]}
+vbsp = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
-vpk = "0.2.0"
+vpk = "0.3.0"

lib/bsp_loader/src/brush.rs

@@ -34,6 +34,7 @@ pub enum PlanesToFacesError{
 	InitFace2,
 	InitIntersection,
 	FindNewIntersection,
+	// Narrow(strafesnet_common::integer::NarrowError),
 	EmptyFaces,
 	InfiniteLoop1,
 	InfiniteLoop2,
@@ -81,12 +82,12 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 			// test if any *other* faces occlude the intersection
 			for new_face in &face_list{
 				// new face occludes intersection point
-				if (new_face.dot.fix_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
+				if (new_face.dot.widen_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
 					// replace one of the faces with the new face
 					// dont' try to replace face0 because we are exploring that face in particular
 					if let Some(new_intersection)=solve3(face0,new_face,face2){
 						// face1 does not occlude (or intersect) the new intersection
-						if (face1.dot.fix_2()/Planar64::ONE).gt_ratio(face1.normal.dot(new_intersection.num)/new_intersection.den){
+						if (face1.dot.widen_2()/Planar64::ONE).gt_ratio(face1.normal.dot(new_intersection.num)/new_intersection.den){
 							face1=new_face;
 							intersection=new_intersection;
 							continue 'find;
@@ -94,7 +95,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 					}
 					if let Some(new_intersection)=solve3(face0,face1,new_face){
 						// face2 does not occlude (or intersect) the new intersection
-						if (face2.dot.fix_2()/Planar64::ONE).gt_ratio(face2.normal.dot(new_intersection.num)/new_intersection.den){
+						if (face2.dot.widen_2()/Planar64::ONE).gt_ratio(face2.normal.dot(new_intersection.num)/new_intersection.den){
 							face2=new_face;
 							intersection=new_intersection;
 							continue 'find;
@@ -119,7 +120,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 				continue;
 			}
 			// new_face occludes intersection meaning intersection is not on convex solid and face0 is degenrate
-			if (new_face.dot.fix_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
+			if (new_face.dot.widen_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
 				// abort! reject face0 entirely
 				continue 'face;
 			}
@@ -137,7 +138,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 		loop{
 			// push point onto vertices
 			// problem: this may push a vertex that does not fit in the fixed point range and is thus meaningless
-			face.push(intersection.divide().fix_1());
+			face.push(intersection.divide().narrow_1().unwrap());
 
 			// we looped back around to face1, we're done!
 			if core::ptr::eq(face1,face2){
@@ -240,7 +241,7 @@ pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,Brus
 		// The so-called tumor brushes have TRIGGER bit set
 		// but also ignore visleaf hint and skip sides
 		const TUMOR:vbsp::TextureFlags=vbsp::TextureFlags::HINT.union(vbsp::TextureFlags::SKIP).union(vbsp::TextureFlags::TRIGGER);
-		if let Some(texture_info)=bsp.textures_info.get(side.texture_info as usize){
+		if let Some(texture_info)=bsp.texture_info(side.texture_info as usize){
 			if texture_info.flags.intersects(TUMOR){
 				return None;
 			}

lib/bsp_loader/src/bsp.rs

@@ -1,11 +1,12 @@
 use std::borrow::Cow;
 
-use vbsp_entities::css::Entity;
+use vbsp_entities_css::Entity;
 
-use strafesnet_common::{map,model,integer,gameplay_attributes};
+use strafesnet_common::{map,model,integer,gameplay_attributes as attr};
 use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
+use strafesnet_common::gameplay_modes::{NormalizedMode,NormalizedModes,Mode,Stage};
 
 use crate::valve_transform;
 
@@ -41,7 +42,7 @@ fn add_brush<'a>(
 	model:&'a str,
 	origin:vbsp::Vector,
 	rendercolor:vbsp::Color,
-	attributes:gameplay_attributes::CollisionAttributesId,
+	attributes:attr::CollisionAttributesId,
 ){
 	let transform=integer::Planar64Affine3::from_translation(
 		valve_transform(origin.into())
@@ -52,9 +53,9 @@ fn add_brush<'a>(
 		rendercolor.b as f32
 	])/255.0).extend(1.0);
 
-	match model.split_at(1){
+	match model.chars().next(){
 		// The first character of brush.model is '*'
-		("*",id_str)=>match id_str.parse(){
+		Some('*')=>match model[1..].parse(){
 			Ok(mesh_id)=>{
 				let mesh=model::MeshId::new(mesh_id);
 				world_models.push(
@@ -82,29 +83,60 @@ pub fn convert<'a>(
 )->PartialMap1{
 	let bsp=bsp.as_ref();
 	//figure out real attributes later
-	let mut unique_attributes=Vec::new();
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::Decoration);
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::contact_default());
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::intersect_default());
-	const ATTRIBUTE_DECORATION:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
-	const ATTRIBUTE_CONTACT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(1);
-	const ATTRIBUTE_INTERSECT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(2);
+	let unique_attributes=vec![
+		attr::CollisionAttributes::Decoration,
+		attr::CollisionAttributes::contact_default(),
+		attr::CollisionAttributes::intersect_default(),
+		// ladder
+		attr::CollisionAttributes::Contact(
+			attr::ContactAttributes{
+				contacting:attr::ContactingAttributes{
+					contact_behaviour:Some(attr::ContactingBehaviour::Ladder(
+						attr::ContactingLadder{sticky:true}
+					))
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+		// water
+		attr::CollisionAttributes::Intersect(
+			attr::IntersectAttributes{
+				intersecting:attr::IntersectingAttributes{
+					water:Some(attr::IntersectingWater{
+						viscosity:integer::Planar64::ONE,
+						density:integer::Planar64::ONE,
+						velocity:integer::vec3::ZERO,
+					}),
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+	];
+	const ATTRIBUTE_DECORATION:attr::CollisionAttributesId=attr::CollisionAttributesId::new(0);
+	const ATTRIBUTE_CONTACT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(1);
+	const ATTRIBUTE_INTERSECT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(2);
+	const ATTRIBUTE_LADDER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(3);
+	const ATTRIBUTE_WATER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(4);
 
 	//declare all prop models to Loader
 	let mut prop_models=bsp.static_props().map(|prop|{
+		const DEG_TO_RAD:f32=std::f32::consts::TAU/360.0;
 		//get or create mesh_id
 		let mesh_id=mesh_deferred_loader.acquire_mesh_id(prop.model());
-		let placement=prop.as_prop_placement();
 		model::Model{
 			mesh:mesh_id,
 			attributes:ATTRIBUTE_DECORATION,
 			transform:integer::Planar64Affine3::new(
-				integer::mat3::try_from_f32_array_2d((
-					glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
+				integer::mat3::try_from_f32_array_2d(
 					//TODO: figure this out
-					*glam::Mat3A::from_quat(glam::Quat::from_array(placement.rotation.into()))
-				).to_cols_array_2d()).unwrap(),
-				valve_transform(placement.origin.into()),
+					glam::Mat3A::from_euler(
+						glam::EulerRot::XYZ,
+						prop.angles.pitch*DEG_TO_RAD,
+						prop.angles.yaw*DEG_TO_RAD,
+						prop.angles.roll*DEG_TO_RAD
+					).to_cols_array_2d()
+				).unwrap(),
+				valve_transform(prop.origin.into()),
 			),
 			color:glam::Vec4::ONE,
 		}
@@ -181,7 +213,7 @@ pub fn convert<'a>(
 	for raw_ent in &bsp.entities{
 		match raw_ent.parse(){
 			Ok(Entity::Cycler(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.parse().unwrap_or(WHITE),ATTRIBUTE_DECORATION),
+			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncBreakable(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncBrush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
@@ -232,9 +264,27 @@ pub fn convert<'a>(
 
 	// physics models
 	for brush in &bsp.brushes{
-		if !brush.flags.contains(vbsp::BrushFlags::SOLID){
+		const RELEVANT:vbsp::BrushFlags=
+			vbsp::BrushFlags::SOLID
+			.union(vbsp::BrushFlags::PLAYERCLIP)
+			.union(vbsp::BrushFlags::WATER)
+			.union(vbsp::BrushFlags::MOVEABLE)
+			.union(vbsp::BrushFlags::LADDER);
+		if !brush.flags.intersects(RELEVANT){
 			continue;
 		}
+		let is_ladder=brush.flags.contains(vbsp::BrushFlags::LADDER);
+		let is_water=brush.flags.contains(vbsp::BrushFlags::WATER);
+		let attributes=match (is_ladder,is_water){
+			(true,false)=>ATTRIBUTE_LADDER_DEFAULT,
+			(false,true)=>ATTRIBUTE_WATER_DEFAULT,
+			(false,false)=>ATTRIBUTE_CONTACT_DEFAULT,
+			(true,true)=>{
+				// water ladder? wtf
+				println!("brush is a water ladder o_o defaulting to ladder");
+				ATTRIBUTE_LADDER_DEFAULT
+			}
+		};
 		let mesh_result=crate::brush::brush_to_mesh(bsp,brush);
 		match mesh_result{
 			Ok(mesh)=>{
@@ -242,7 +292,7 @@ pub fn convert<'a>(
 				world_meshes.push(mesh);
 				world_models.push(model::Model{
 					mesh:mesh_id,
-					attributes:ATTRIBUTE_CONTACT_DEFAULT,
+					attributes,
 					transform:integer::Planar64Affine3::new(
 						integer::mat3::identity(),
 						integer::vec3::ZERO,
@@ -268,15 +318,15 @@ pub fn convert<'a>(
 			color:glam::Vec4::W,
 		});
 
-		let first_stage=strafesnet_common::gameplay_modes::Stage::empty(model_id);
-		let main_mode=strafesnet_common::gameplay_modes::Mode::new(
+		let first_stage=Stage::empty(model_id);
+		let main_mode=Mode::new(
 			strafesnet_common::gameplay_style::StyleModifiers::source_bhop(),
 			model_id,
 			std::collections::HashMap::new(),
 			vec![first_stage],
 			std::collections::HashMap::new(),
 		);
-		modes_list.push(main_mode);
+		modes_list.push(NormalizedMode::new(main_mode));
 	}
 
 	PartialMap1{
@@ -284,17 +334,17 @@ pub fn convert<'a>(
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:strafesnet_common::gameplay_modes::Modes::new(modes_list),
+		modes:NormalizedModes::new(modes_list),
 	}
 }
 
 //partially constructed map types
 pub struct PartialMap1{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	modes:NormalizedModes,
 }
 impl PartialMap1{
 	pub fn add_prop_meshes<'a>(
@@ -312,12 +362,12 @@ impl PartialMap1{
 	}
 }
 pub struct PartialMap2{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_meshes:Vec<(model::MeshId,model::Mesh)>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	modes:NormalizedModes,
 }
 impl PartialMap2{
 	pub fn add_render_configs_and_textures(

lib/common/Cargo.toml

@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 arrayvec = "0.7.4"
 bitflags = "2.6.0"
-fixed_wide = { version = "0.1.2", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { version = "0.1.0", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
+linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }

lib/common/src/aabb.rs

@@ -7,46 +7,57 @@ pub struct Aabb{
 }
 
 impl Default for Aabb{
+	#[inline]
 	fn default()->Self{
 		Self{min:vec3::MAX,max:vec3::MIN}
 	}
 }
 
 impl Aabb{
+	#[inline]
 	pub const fn new(min:Planar64Vec3,max:Planar64Vec3)->Self{
 		Self{min,max}
 	}
+	#[inline]
 	pub const fn max(&self)->Planar64Vec3{
 		self.max
 	}
+	#[inline]
 	pub const fn min(&self)->Planar64Vec3{
 		self.min
 	}
+	#[inline]
 	pub fn grow(&mut self,point:Planar64Vec3){
 		self.min=self.min.min(point);
 		self.max=self.max.max(point);
 	}
+	#[inline]
 	pub fn join(&mut self,aabb:&Aabb){
 		self.min=self.min.min(aabb.min);
 		self.max=self.max.max(aabb.max);
 	}
+	#[inline]
 	pub fn inflate(&mut self,hs:Planar64Vec3){
 		self.min-=hs;
 		self.max+=hs;
 	}
+	#[inline]
 	pub fn contains(&self,point:Planar64Vec3)->bool{
 		let bvec=self.min.lt(point)&point.lt(self.max);
 		bvec.all()
 	}
+	#[inline]
 	pub fn intersects(&self,aabb:&Aabb)->bool{
 		let bvec=self.min.lt(aabb.max)&aabb.min.lt(self.max);
 		bvec.all()
 	}
+	#[inline]
 	pub fn size(&self)->Planar64Vec3{
 		self.max-self.min
 	}
+	#[inline]
 	pub fn center(&self)->Planar64Vec3{
-		self.min+(self.max-self.min)>>1
+		self.min.map_zip(self.max,|(min,max)|min.midpoint(max))
 	}
 	//probably use floats for area & volume because we don't care about precision
 	// pub fn area_weight(&self)->f32{

lib/common/src/gameplay_modes.rs

@@ -1,7 +1,6 @@
 use std::collections::{HashSet,HashMap};
 use crate::model::ModelId;
 use crate::gameplay_style;
-use crate::updatable::Updatable;
 
 #[derive(Clone)]
 pub struct StageElement{
@@ -128,18 +127,6 @@ impl Stage{
 		self.unordered_checkpoints.contains(&model_id)
 	}
 }
-#[derive(Default)]
-pub struct StageUpdate{
-	//other behaviour models of this stage can have
-	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
-	unordered_checkpoints:HashSet<ModelId>,
-}
-impl Updatable<StageUpdate> for Stage{
-	fn update(&mut self,update:StageUpdate){
-		self.ordered_checkpoints.extend(update.ordered_checkpoints);
-		self.unordered_checkpoints.extend(update.unordered_checkpoints);
-	}
-}
 
 #[derive(Clone,Copy,Hash,Eq,PartialEq)]
 pub enum Zone{
@@ -211,34 +198,47 @@ impl Mode{
 	pub fn push_stage(&mut self,stage:Stage){
 		self.stages.push(stage)
 	}
-	pub fn get_stage_mut(&mut self,stage:StageId)->Option<&mut Stage>{
-		self.stages.get_mut(stage.0 as usize)
+	pub fn get_stage_mut(&mut self,StageId(stage_id):StageId)->Option<&mut Stage>{
+		self.stages.get_mut(stage_id as usize)
 	}
-	pub fn get_spawn_model_id(&self,stage:StageId)->Option<ModelId>{
-		self.stages.get(stage.0 as usize).map(|s|s.spawn)
+	pub fn get_spawn_model_id(&self,StageId(stage_id):StageId)->Option<ModelId>{
+		self.stages.get(stage_id as usize).map(|s|s.spawn)
 	}
 	pub fn get_zone(&self,model_id:ModelId)->Option<&Zone>{
 		self.zones.get(&model_id)
 	}
-	pub fn get_stage(&self,stage_id:StageId)->Option<&Stage>{
-		self.stages.get(stage_id.0 as usize)
+	pub fn get_stage(&self,StageId(stage_id):StageId)->Option<&Stage>{
+		self.stages.get(stage_id as usize)
 	}
 	pub fn get_element(&self,model_id:ModelId)->Option<&StageElement>{
 		self.elements.get(&model_id)
 	}
+}
+
+#[derive(Clone)]
+pub struct NormalizedMode(Mode);
+impl NormalizedMode{
+	pub fn new(mode:Mode)->Self{
+		Self(mode)
+	}
+	pub fn into_inner(self)->Mode{
+		let Self(mode)=self;
+		mode
+	}
 	//TODO: put this in the SNF
-	pub fn denormalize_data(&mut self){
+	pub fn denormalize(self)->Mode{
+		let NormalizedMode(mut mode)=self;
 		//expand and index normalized data
-		self.zones.insert(self.start,Zone::Start);
-		for (stage_id,stage) in self.stages.iter().enumerate(){
-			self.elements.insert(stage.spawn,StageElement{
+		mode.zones.insert(mode.start,Zone::Start);
+		for (stage_id,stage) in mode.stages.iter().enumerate(){
+			mode.elements.insert(stage.spawn,StageElement{
 				stage_id:StageId(stage_id as u32),
 				force:false,
 				behaviour:StageElementBehaviour::SpawnAt,
 				jump_limit:None,
 			});
 			for (_,&model) in &stage.ordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -246,7 +246,7 @@ impl Mode{
 				});
 			}
 			for &model in &stage.unordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -254,53 +254,13 @@ impl Mode{
 				});
 			}
 		}
-	}
-}
-//this would be nice as a macro
-#[derive(Default)]
-pub struct ModeUpdate{
-	zones:HashMap<ModelId,Zone>,
-	stages:HashMap<StageId,StageUpdate>,
-	//mutually exlusive stage element behaviour
-	elements:HashMap<ModelId,StageElement>,
-}
-impl Updatable<ModeUpdate> for Mode{
-	fn update(&mut self,update:ModeUpdate){
-		self.zones.extend(update.zones);
-		for (stage,stage_update) in update.stages{
-			if let Some(stage)=self.stages.get_mut(stage.0 as usize){
-				stage.update(stage_update);
-			}
-		}
-		self.elements.extend(update.elements);
-	}
-}
-impl ModeUpdate{
-	pub fn zone(model_id:ModelId,zone:Zone)->Self{
-		let mut mu=Self::default();
-		mu.zones.insert(model_id,zone);
-		mu
-	}
-	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
-		let mut mu=Self::default();
-		mu.stages.insert(stage_id,stage_update);
-		mu
-	}
-	pub fn element(model_id:ModelId,element:StageElement)->Self{
-		let mut mu=Self::default();
-		mu.elements.insert(model_id,element);
-		mu
-	}
-	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
-		for (_,stage_element) in self.elements.iter_mut(){
-			stage_element.stage_id=f(stage_element.stage_id);
-		}
+		mode
 	}
 }
 
 #[derive(Default,Clone)]
 pub struct Modes{
-	pub modes:Vec<Mode>,
+	modes:Vec<Mode>,
 }
 impl Modes{
 	pub const fn new(modes:Vec<Mode>)->Self{
@@ -314,19 +274,182 @@ impl Modes{
 	pub fn push_mode(&mut self,mode:Mode){
 		self.modes.push(mode)
 	}
-	pub fn get_mode(&self,mode:ModeId)->Option<&Mode>{
-		self.modes.get(mode.0 as usize)
+	pub fn get_mode(&self,ModeId(mode_id):ModeId)->Option<&Mode>{
+		self.modes.get(mode_id as usize)
 	}
 }
-pub struct ModesUpdate{
-	modes:HashMap<ModeId,ModeUpdate>,
+
+#[derive(Clone)]
+pub struct NormalizedModes{
+	modes:Vec<NormalizedMode>,
 }
-impl Updatable<ModesUpdate> for Modes{
-	fn update(&mut self,update:ModesUpdate){
-		for (mode,mode_update) in update.modes{
-			if let Some(mode)=self.modes.get_mut(mode.0 as usize){
-				mode.update(mode_update);
-			}
+impl NormalizedModes{
+	pub fn new(modes:Vec<NormalizedMode>)->Self{
+		Self{modes}
+	}
+	pub fn len(&self)->usize{
+		self.modes.len()
+	}
+	pub fn denormalize(self)->Modes{
+		Modes{
+			modes:self.modes.into_iter().map(NormalizedMode::denormalize).collect(),
 		}
 	}
 }
+impl IntoIterator for NormalizedModes{
+	type Item=<Vec<NormalizedMode> as IntoIterator>::Item;
+	type IntoIter=<Vec<NormalizedMode> as IntoIterator>::IntoIter;
+	fn into_iter(self)->Self::IntoIter{
+		self.modes.into_iter()
+	}
+}
+
+
+#[derive(Default)]
+pub struct StageUpdate{
+	//other behaviour models of this stage can have
+	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
+	unordered_checkpoints:HashSet<ModelId>,
+}
+impl StageUpdate{
+	fn apply_to(self,stage:&mut Stage){
+		stage.ordered_checkpoints.extend(self.ordered_checkpoints);
+		stage.unordered_checkpoints.extend(self.unordered_checkpoints);
+	}
+}
+
+//this would be nice as a macro
+#[derive(Default)]
+pub struct ModeUpdate{
+	zones:Option<(ModelId,Zone)>,
+	stages:Option<(StageId,StageUpdate)>,
+	//mutually exlusive stage element behaviour
+	elements:Option<(ModelId,StageElement)>,
+}
+impl ModeUpdate{
+	fn apply_to(self,mode:&mut Mode){
+		mode.zones.extend(self.zones);
+		if let Some((StageId(stage_id),stage_update))=self.stages{
+			if let Some(stage)=mode.stages.get_mut(stage_id as usize){
+				stage_update.apply_to(stage);
+			}
+		}
+		mode.elements.extend(self.elements);
+	}
+}
+impl ModeUpdate{
+	pub fn zone(model_id:ModelId,zone:Zone)->Self{
+		Self{
+			zones:Some((model_id,zone)),
+			stages:None,
+			elements:None,
+		}
+	}
+	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
+		Self{
+			zones:None,
+			stages:Some((stage_id,stage_update)),
+			elements:None,
+		}
+	}
+	pub fn element(model_id:ModelId,element:StageElement)->Self{
+		Self{
+			zones:None,
+			stages:None,
+			elements:Some((model_id,element)),
+		}
+	}
+	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
+		for (_,stage_element) in self.elements.iter_mut(){
+			stage_element.stage_id=f(stage_element.stage_id);
+		}
+	}
+}
+
+struct ModeBuilder{
+	mode:Mode,
+	stage_id_map:HashMap<StageId,StageId>,
+}
+#[derive(Default)]
+pub struct ModesBuilder{
+	modes:HashMap<ModeId,Mode>,
+	stages:HashMap<ModeId,HashMap<StageId,Stage>>,
+	mode_updates:Vec<(ModeId,ModeUpdate)>,
+	stage_updates:Vec<(ModeId,StageId,StageUpdate)>,
+}
+impl ModesBuilder{
+	pub fn build_normalized(mut self)->NormalizedModes{
+		//collect modes and stages into contiguous arrays
+		let mut unique_modes:Vec<(ModeId,Mode)>
+		=self.modes.into_iter().collect();
+		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
+		let (mut modes,mode_id_map):(Vec<ModeBuilder>,HashMap<ModeId,ModeId>)
+		=unique_modes.into_iter().enumerate()
+		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
+			(
+				ModeBuilder{
+					stage_id_map:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
+						let mut unique_stages:Vec<(StageId,Stage)>
+						=stages.into_iter().collect();
+						unique_stages.sort_by_key(|&(StageId(stage_id),_)|stage_id);
+						unique_stages.into_iter().enumerate()
+						.map(|(final_stage_id,(builder_stage_id,stage))|{
+							mode.push_stage(stage);
+							(builder_stage_id,StageId::new(final_stage_id as u32))
+						}).collect()
+					}),
+					mode,
+				},
+				(
+					builder_mode_id,
+					ModeId::new(final_mode_id as u32)
+				)
+			)
+		}).unzip();
+		//TODO: failure messages or errors or something
+		//push stage updates
+		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					if let Some(&final_stage_id)=mode.stage_id_map.get(&builder_stage_id){
+						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
+							stage_update.apply_to(stage);
+						}
+					}
+				}
+			}
+		}
+		//push mode updates
+		for (builder_mode_id,mut mode_update) in self.mode_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					//map stage id on stage elements
+					mode_update.map_stage_element_ids(|stage_id|
+						//walk down one stage id at a time until a stage is found
+						//TODO use better logic like BTreeMap::upper_bound instead of walking
+						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
+						// .value().copied().unwrap_or(StageId::FIRST)
+						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
+							//map the stage element to that stage
+							mode.stage_id_map.get(&StageId::new(builder_stage_id)).copied()
+						).unwrap_or(StageId::FIRST)
+					);
+					mode_update.apply_to(&mut mode.mode);
+				}
+			}
+		}
+		NormalizedModes::new(modes.into_iter().map(|mode_builder|NormalizedMode(mode_builder.mode)).collect())
+	}
+	pub fn insert_mode(&mut self,mode_id:ModeId,mode:Mode){
+		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
+	}
+	pub fn insert_stage(&mut self,mode_id:ModeId,stage_id:StageId,stage:Stage){
+		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
+	}
+	pub fn push_mode_update(&mut self,mode_id:ModeId,mode_update:ModeUpdate){
+		self.mode_updates.push((mode_id,mode_update));
+	}
+	// fn push_stage_update(&mut self,mode_id:ModeId,stage_id:StageId,stage_update:StageUpdate){
+	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
+	// }
+}

lib/common/src/gameplay_style.rs

@@ -63,22 +63,22 @@ impl JumpImpulse{
 		velocity:Planar64Vec3,
 		jump_dir:Planar64Vec3,
 		gravity:&Planar64Vec3,
-		mass:Planar64,
+		_mass:Planar64,
 	)->Planar64Vec3{
 		match self{
-			&JumpImpulse::Time(time)=>velocity-(*gravity*time).map(|t|t.divide().fix_1()),
+			&JumpImpulse::Time(time)=>velocity-(*gravity*time).map(|t|t.divide().clamp_1()),
 			&JumpImpulse::Height(height)=>{
 				//height==-v.y*v.y/(2*g.y);
 				//use energy to determine max height
 				let gg=gravity.length_squared();
-				let g=gg.sqrt().fix_1();
+				let g=gg.sqrt();
 				let v_g=gravity.dot(velocity);
 				//do it backwards
-				let radicand=v_g*v_g+(g*height*2).fix_4();
-				velocity-(*gravity*(radicand.sqrt().fix_2()+v_g)/gg).divide().fix_1()
+				let radicand=v_g*v_g+(g*height*2).widen_4();
+				velocity-(*gravity*(radicand.sqrt().wrap_2()+v_g)/gg).divide().clamp_1()
 			},
-			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().fix_1(),
-			&JumpImpulse::Energy(energy)=>{
+			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().clamp_1(),
+			&JumpImpulse::Energy(_energy)=>{
 				//calculate energy
 				//let e=gravity.dot(velocity);
 				//add
@@ -91,10 +91,10 @@ impl JumpImpulse{
 	pub fn get_jump_deltav(&self,gravity:&Planar64Vec3,mass:Planar64)->Planar64{
 		//gravity.length() is actually the proper calculation because the jump is always opposite the gravity direction
 		match self{
-			&JumpImpulse::Time(time)=>(gravity.length().fix_1()*time/2).divide().fix_1(),
-			&JumpImpulse::Height(height)=>(gravity.length()*height*2).sqrt().fix_1(),
+			&JumpImpulse::Time(time)=>(gravity.length().wrap_1()*time/2).divide().clamp_1(),
+			&JumpImpulse::Height(height)=>(gravity.length()*height*2).sqrt().wrap_1(),
 			&JumpImpulse::Linear(deltav)=>deltav,
-			&JumpImpulse::Energy(energy)=>(energy.sqrt()*2/mass.sqrt()).divide().fix_1(),
+			&JumpImpulse::Energy(energy)=>(energy.sqrt()*2/mass.sqrt()).divide().clamp_1(),
 		}
 	}
 }
@@ -126,10 +126,10 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let j=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if j<js{
 					//weak booster: just do a regular jump
-					boost_vel+jump_dir.with_length(js-j).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-j).divide().wrap_1()
 				}else{
 					//activate booster normally, jump does nothing
 					boost_vel
@@ -142,13 +142,13 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let j=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if j<js{
 					//speed in direction of jump cannot be lower than amount
-					boost_vel+jump_dir.with_length(js-j).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-j).divide().wrap_1()
 				}else{
 					//boost and jump add together
-					boost_vel+jump_dir.with_length(js).divide().fix_1()
+					boost_vel+jump_dir.with_length(js).divide().wrap_1()
 				}
 			}
 			(false,JumpCalculation::Max)=>{
@@ -159,10 +159,10 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let boost_dot=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if boost_dot<js{
 					//weak boost is extended to jump speed
-					boost_vel+jump_dir.with_length(js-boost_dot).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-boost_dot).divide().wrap_1()
 				}else{
 					//activate booster normally, jump does nothing
 					boost_vel
@@ -174,7 +174,7 @@ impl JumpSettings{
 					Some(booster)=>booster.boost(rel_velocity),
 					None=>rel_velocity,
 				};
-				boost_vel+jump_dir.with_length(jump_speed).divide().fix_1()
+				boost_vel+jump_dir.with_length(jump_speed).divide().wrap_1()
 			},
 		}
 	}
@@ -267,9 +267,9 @@ pub struct StrafeSettings{
 impl StrafeSettings{
 	pub fn tick_velocity(&self,velocity:Planar64Vec3,control_dir:Planar64Vec3)->Option<Planar64Vec3>{
 		let d=velocity.dot(control_dir);
-		let mv=self.mv.fix_2();
+		let mv=self.mv.widen_2();
 		match d<mv{
-			true=>Some(velocity+(control_dir*self.air_accel_limit.map_or(mv-d,|limit|limit.fix_2().min(mv-d))).fix_1()),
+			true=>Some(velocity+(control_dir*self.air_accel_limit.map_or(mv-d,|limit|limit.widen_2().min(mv-d))).wrap_1()),
 			false=>None,
 		}
 	}
@@ -290,7 +290,7 @@ pub struct PropulsionSettings{
 }
 impl PropulsionSettings{
 	pub fn acceleration(&self,control_dir:Planar64Vec3)->Planar64Vec3{
-		(control_dir*self.magnitude).fix_1()
+		(control_dir*self.magnitude).clamp_1()
 	}
 }
 
@@ -310,13 +310,13 @@ pub struct WalkSettings{
 impl WalkSettings{
 	pub fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible walk accel
-		let diff_len=target_diff.length().fix_1();
+		let diff_len=target_diff.length().wrap_1();
 		let friction=if diff_len<self.accelerate.topspeed{
 			self.static_friction
 		}else{
 			self.kinetic_friction
 		};
-		self.accelerate.accel.min((-gravity.y*friction).fix_1())
+		self.accelerate.accel.min((-gravity.y*friction).clamp_1())
 	}
 	pub fn get_walk_target_velocity(&self,control_dir:Planar64Vec3,normal:Planar64Vec3)->Planar64Vec3{
 		if control_dir==crate::integer::vec3::ZERO{
@@ -332,7 +332,7 @@ impl WalkSettings{
 			if cr==crate::integer::vec3::ZERO_2{
 				crate::integer::vec3::ZERO
 			}else{
-				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().fix_1()
+				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
 			crate::integer::vec3::ZERO
@@ -341,7 +341,7 @@ impl WalkSettings{
 	pub fn is_slope_walkable(&self,normal:Planar64Vec3,up:Planar64Vec3)->bool{
 		//normal is not guaranteed to be unit length
 		let ny=normal.dot(up);
-		let h=normal.length().fix_1();
+		let h=normal.length().wrap_1();
 		//remember this is a normal vector
 		ny.is_positive()&&h*self.surf_dot<ny
 	}
@@ -355,7 +355,7 @@ pub struct LadderSettings{
 	pub dot:Planar64,
 }
 impl LadderSettings{
-	pub const fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
+	pub const fn accel(&self,_target_diff:Planar64Vec3,_gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible ladder accel
 		self.accelerate.accel
 	}
@@ -368,13 +368,13 @@ impl LadderSettings{
 		let nnmm=nn*mm;
 		let d=normal.dot(control_dir);
 		let mut dd=d*d;
-		if (self.dot*self.dot*nnmm).fix_4()<dd{
+		if (self.dot*self.dot*nnmm).clamp_4()<dd{
 			if d.is_negative(){
-				control_dir=Planar64Vec3::new([Planar64::ZERO,mm.fix_1(),Planar64::ZERO]);
+				control_dir=Planar64Vec3::new([Planar64::ZERO,mm.clamp_1(),Planar64::ZERO]);
 			}else{
-				control_dir=Planar64Vec3::new([Planar64::ZERO,-mm.fix_1(),Planar64::ZERO]);
+				control_dir=Planar64Vec3::new([Planar64::ZERO,-mm.clamp_1(),Planar64::ZERO]);
 			}
-			dd=(normal.y*normal.y).fix_4();
+			dd=(normal.y*normal.y).widen_4();
 		}
 		//n=d if you are standing on top of a ladder and press E.
 		//two fixes:
@@ -385,7 +385,7 @@ impl LadderSettings{
 			if cr==crate::integer::vec3::ZERO_2{
 				crate::integer::vec3::ZERO
 			}else{
-				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().fix_1()
+				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
 			crate::integer::vec3::ZERO
@@ -417,7 +417,7 @@ impl Hitbox{
 	}
 	pub fn source()->Self{
 		Self{
-			halfsize:((int3(33,73,33)>>1)*VALVE_SCALE).fix_1(),
+			halfsize:((int3(33,73,33)>>1)*VALVE_SCALE).narrow_1().unwrap(),
 			mesh:HitboxMesh::Box,
 		}
 	}
@@ -529,20 +529,20 @@ impl StyleModifiers{
 
 	pub fn source_bhop()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
-				air_accel_limit:Some(Planar64::raw(150<<28)*100),
-				mv:(Planar64::raw(30)*VALVE_SCALE).fix_1(),
+				air_accel_limit:Some(Planar64::raw((150<<28)*100)),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),
+				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).narrow_1().unwrap()),
 				calculation:JumpCalculation::JumpThenBoost,
 				limit_minimum:true,
 			}),
-			gravity:(int3(0,-800,0)*VALVE_SCALE).fix_1(),
+			gravity:(int3(0,-800,0)*VALVE_SCALE).narrow_1().unwrap(),
 			mass:int(1),
 			rocket:None,
 			walk:Some(WalkSettings{
@@ -565,25 +565,25 @@ impl StyleModifiers{
 				magnitude:int(12),//?
 			}),
 			hitbox:Hitbox::source(),
-			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).fix_1(),
+			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).narrow_1().unwrap(),
 		}
 	}
 	pub fn source_surf()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
-				air_accel_limit:Some((int(150)*66*VALVE_SCALE).fix_1()),
-				mv:(int(30)*VALVE_SCALE).fix_1(),
+				air_accel_limit:Some((int(150)*66*VALVE_SCALE).narrow_1().unwrap()),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(66,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),
+				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).narrow_1().unwrap()),
 				calculation:JumpCalculation::JumpThenBoost,
 				limit_minimum:true,
 			}),
-			gravity:(int3(0,-800,0)*VALVE_SCALE).fix_1(),
+			gravity:(int3(0,-800,0)*VALVE_SCALE).narrow_1().unwrap(),
 			mass:int(1),
 			rocket:None,
 			walk:Some(WalkSettings{
@@ -606,7 +606,7 @@ impl StyleModifiers{
 				magnitude:int(12),//?
 			}),
 			hitbox:Hitbox::source(),
-			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).fix_1(),
+			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).narrow_1().unwrap(),
 		}
 	}
 }

lib/common/src/integer.rs

@@ -1,4 +1,4 @@
-pub use fixed_wide::fixed::{Fixed,Fix};
+pub use fixed_wide::fixed::*;
 pub use ratio_ops::ratio::{Ratio,Divide};
 
 //integer units
@@ -60,7 +60,7 @@ impl<T> Time<T>{
 impl<T> From<Planar64> for Time<T>{
 	#[inline]
 	fn from(value:Planar64)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+		Self::raw((value*Planar64::raw(1_000_000_000)).clamp_1().to_raw())
 	}
 }
 impl<T> From<Time<T>> for Ratio<Planar64,Planar64>{
@@ -73,11 +73,11 @@ impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
 	where
 		Num:core::ops::Mul<Planar64,Output=N1>,
 		N1:Divide<Den,Output=T1>,
-		T1:Fix<Planar64>,
+		T1:Clamp<Planar64>,
 {
 	#[inline]
 	fn from(value:Ratio<Num,Den>)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
+		Self::raw((value*Planar64::raw(1_000_000_000)).divide().clamp().to_raw())
 	}
 }
 impl<T> std::fmt::Display for Time<T>{
@@ -401,6 +401,10 @@ impl Angle32{
 	pub const NEG_FRAC_PI_2:Self=Self(-1<<30);
 	pub const PI:Self=Self(-1<<31);
 	#[inline]
+	pub const fn raw(num:i32)->Self{
+		Self(num)
+	}
+	#[inline]
 	pub const fn wrap_from_i64(theta:i64)->Self{
 		//take lower bits
 		//note: this was checked on compiler explorer and compiles to 1 instruction!
@@ -515,8 +519,8 @@ fn angle_sin_cos(){
 		println!("cordic s={} c={}",(s/h).divide(),(c/h).divide());
 		let (fs,fc)=f.sin_cos();
 		println!("float s={} c={}",fs,fc);
-		assert!(close_enough((c/h).divide().fix_1(),Planar64::raw((fc*((1u64<<32) as f64)) as i64)));
-		assert!(close_enough((s/h).divide().fix_1(),Planar64::raw((fs*((1u64<<32) as f64)) as i64)));
+		assert!(close_enough((c/h).divide().wrap_1(),Planar64::raw((fc*((1u64<<32) as f64)) as i64)));
+		assert!(close_enough((s/h).divide().wrap_1(),Planar64::raw((fs*((1u64<<32) as f64)) as i64)));
 	}
 	test_angle(1.0);
 	test_angle(std::f64::consts::PI/4.0);
@@ -558,6 +562,10 @@ pub mod vec3{
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
 	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
 	pub const ZERO_2:linear_ops::types::Vector3<Fixed::<2,64>>=linear_ops::types::Vector3::new([Fixed::<2,64>::ZERO;3]);
+	pub const ZERO_3:linear_ops::types::Vector3<Fixed::<3,96>>=linear_ops::types::Vector3::new([Fixed::<3,96>::ZERO;3]);
+	pub const ZERO_4:linear_ops::types::Vector3<Fixed::<4,128>>=linear_ops::types::Vector3::new([Fixed::<4,128>::ZERO;3]);
+	pub const ZERO_5:linear_ops::types::Vector3<Fixed::<5,160>>=linear_ops::types::Vector3::new([Fixed::<5,160>::ZERO;3]);
+	pub const ZERO_6:linear_ops::types::Vector3<Fixed::<6,192>>=linear_ops::types::Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);
@@ -625,8 +633,8 @@ pub mod mat3{
 		let (yc,ys)=y.cos_sin();
 		Planar64Mat3::from_cols([
 			Planar64Vec3::new([xc,Planar64::ZERO,-xs]),
-			Planar64Vec3::new([(xs*ys).fix_1(),yc,(xc*ys).fix_1()]),
-			Planar64Vec3::new([(xs*yc).fix_1(),-ys,(xc*yc).fix_1()]),
+			Planar64Vec3::new([(xs*ys).wrap_1(),yc,(xc*ys).wrap_1()]),
+			Planar64Vec3::new([(xs*yc).wrap_1(),-ys,(xc*yc).wrap_1()]),
 		])
 	}
 	#[inline]
@@ -668,7 +676,7 @@ impl Planar64Affine3{
 	}
 	#[inline]
 	pub fn transform_point3(&self,point:Planar64Vec3)->vec3::Vector3<Fixed<2,64>>{
-		self.translation.fix_2()+self.matrix3*point
+		self.translation.widen_2()+self.matrix3*point
 	}
 }
 impl Into<glam::Mat4> for Planar64Affine3{

lib/common/src/lib.rs

@@ -9,7 +9,6 @@ pub mod timer;
 pub mod integer;
 pub mod physics;
 pub mod session;
-pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;
 pub mod gameplay_modes;

lib/common/src/map.rs

@@ -4,7 +4,7 @@ use crate::gameplay_attributes;
 //this is a temporary struct to try to get the code running again
 //TODO: use snf::map::Region to update the data in physics and graphics instead of this
 pub struct CompleteMap{
-	pub modes:gameplay_modes::Modes,
+	pub modes:gameplay_modes::NormalizedModes,
 	pub attributes:Vec<gameplay_attributes::CollisionAttributes>,
 	pub meshes:Vec<model::Mesh>,
 	pub models:Vec<model::Model>,

lib/common/src/ray.rs

@@ -13,8 +13,8 @@ impl Ray{
 		Num:core::ops::Mul<Planar64,Output=N1>,
 		Planar64:core::ops::Mul<Den,Output=N1>,
 		N1:integer::Divide<Den,Output=T1>,
-		T1:integer::Fix<Planar64>,
+		T1:integer::Clamp<Planar64>,
 	{
-		self.origin+self.direction.map(|elem|(t*elem).divide().fix())
+		self.origin+self.direction.map(|elem|(t*elem).divide().clamp())
 	}
 }

lib/common/src/updatable.rs

@@ -1,57 +0,0 @@
-// This whole thing should be a drive macro
-
-pub trait Updatable<Updater>{
-	fn update(&mut self,update:Updater);
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct InnerId(u32);
-#[derive(Clone)]
-struct Inner{
-	id:InnerId,
-	enabled:bool,
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct OuterId(u32);
-struct Outer{
-	id:OuterId,
-	inners:std::collections::HashMap<InnerId,Inner>,
-}
-
-enum Update<I,U>{
-	Insert(I),
-	Update(U),
-	Remove
-}
-
-struct InnerUpdate{
-	//#[updatable(Update)]
-	enabled:Option<bool>,
-}
-struct OuterUpdate{
-	//#[updatable(Insert,Update,Remove)]
-	inners:std::collections::HashMap<InnerId,Update<Inner,InnerUpdate>>,
-	//#[updatable(Update)]
-	//inners:std::collections::HashMap<InnerId,InnerUpdate>,
-}
-impl Updatable<InnerUpdate> for Inner{
-	fn update(&mut self,update:InnerUpdate){
-		if let Some(enabled)=update.enabled{
-			self.enabled=enabled;
-		}
-	}
-}
-impl Updatable<OuterUpdate> for Outer{
-	fn update(&mut self,update:OuterUpdate){
-		for (id,up) in update.inners{
-			match up{
-				Update::Insert(new_inner)=>self.inners.insert(id,new_inner),
-				Update::Update(inner_update)=>self.inners.get_mut(&id).map(|inner|{
-					let old=inner.clone();
-					inner.update(inner_update);
-					old
-				}),
-				Update::Remove=>self.inners.remove(&id),
-			};
-		}
-	}
-}

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -14,7 +14,7 @@ wide-mul=[]
 zeroes=["dep:arrayvec"]
 
 [dependencies]
-bnum = "0.12.0"
+bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }

lib/fixed_wide/src/fixed.rs

@@ -33,6 +33,14 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 		self.bits
 	}
 	#[inline]
+	pub const fn as_bits(&self)->&BInt<N>{
+		&self.bits
+	}
+	#[inline]
+	pub const fn as_bits_mut(&mut self)->&mut BInt<N>{
+		&mut self.bits
+	}
+	#[inline]
 	pub const fn raw_digit(value:i64)->Self{
 		let mut digits=[0u64;N];
 		digits[0]=value.abs() as u64;
@@ -56,6 +64,10 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn abs(self)->Self{
 		Self::from_bits(self.bits.abs())
 	}
+	#[inline]
+	pub const fn midpoint(self,other:Self)->Self{
+		Self::from_bits(self.bits.midpoint(other.bits))
+	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -651,74 +663,94 @@ macro_repeated!(
 	1,2,3,4,5,6,7,8
 );
 
-pub trait Fix<Out>{
-	fn fix(self)->Out;
+#[derive(Debug,Eq,PartialEq)]
+pub enum NarrowError{
+	Overflow,
+	Underflow,
 }
 
-macro_rules! impl_fix_rhs_lt_lhs_not_const_generic{
+pub trait Wrap<Output>{
+	fn wrap(self)->Output;
+}
+pub trait Clamp<Output>{
+	fn clamp(self)->Output;
+}
+impl<const N:usize,const F:usize> Clamp<Fixed<N,F>> for Result<Fixed<N,F>,NarrowError>{
+	fn clamp(self)->Fixed<N,F>{
+		match self{
+			Ok(fixed)=>fixed,
+			Err(NarrowError::Overflow)=>Fixed::MAX,
+			Err(NarrowError::Underflow)=>Fixed::MIN,
+		}
+	}
+}
+
+macro_rules! impl_narrow_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+		paste::item!{
+			impl Fixed<$lhs,{$lhs*32}>
+			{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+				pub fn [<wrap_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
 					Fixed::from_bits(bnum::cast::As::as_::<BInt::<$rhs>>(self.bits.shr(($lhs-$rhs)*32)))
 				}
+				#[inline]
+				pub fn [<narrow_ $rhs>](self)->Result<Fixed<$rhs,{$rhs*32}>,NarrowError>{
+					if Fixed::<$rhs,{$rhs*32}>::MAX.[<widen_ $lhs>]().bits<self.bits{
+						return Err(NarrowError::Overflow);
+					}
+					if self.bits<Fixed::<$rhs,{$rhs*32}>::MIN.[<widen_ $lhs>]().bits{
+						return Err(NarrowError::Underflow);
+					}
+					Ok(self.[<wrap_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<clamp_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<narrow_ $rhs>]().clamp()
+				}
 			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
+			impl Wrap<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				#[inline]
+				fn wrap(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<wrap_ $rhs>]()
+				}
+			}
+			impl TryInto<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				type Error=NarrowError;
+				#[inline]
+				fn try_into(self)->Result<Fixed<$rhs,{$rhs*32}>,Self::Error>{
+					self.[<narrow_ $rhs>]()
+				}
+			}
+			impl Clamp<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				#[inline]
+				fn clamp(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<clamp_ $rhs>]()
 				}
 			}
 		}
 	}
 }
-macro_rules! impl_fix_lhs_lt_rhs_not_const_generic{
+macro_rules! impl_widen_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+		paste::item!{
+			impl Fixed<$lhs,{$lhs*32}>
+			{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+				pub fn [<widen_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
 					Fixed::from_bits(bnum::cast::As::as_::<BInt::<$rhs>>(self.bits).shl(($rhs-$lhs)*32))
 				}
 			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
-				}
-			}
-		}
-	}
-}
-macro_rules! impl_fix_lhs_eq_rhs_not_const_generic{
-	(
-		(),
-		($lhs:expr,$rhs:expr)
-	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+			impl Into<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
-					self
-				}
-			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
+				fn into(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<widen_ $rhs>]()
 				}
 			}
 		}
@@ -728,7 +760,7 @@ macro_rules! impl_fix_lhs_eq_rhs_not_const_generic{
 // I LOVE NOT BEING ABLE TO USE CONST GENERICS
 
 macro_repeated!(
-	impl_fix_rhs_lt_lhs_not_const_generic,(),
+	impl_narrow_not_const_generic,(),
 	(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),(17,1),
 	(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
 	(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
@@ -746,7 +778,7 @@ macro_repeated!(
 	(16,15)
 );
 macro_repeated!(
-	impl_fix_lhs_lt_rhs_not_const_generic,(),
+	impl_widen_not_const_generic,(),
 	(1,2),
 	(1,3),(2,3),
 	(1,4),(2,4),(3,4),
@@ -761,11 +793,8 @@ macro_repeated!(
 	(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),
 	(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),
 	(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),
-	(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16)
-);
-macro_repeated!(
-	impl_fix_lhs_eq_rhs_not_const_generic,(),
-	(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10),(11,11),(12,12),(13,13),(14,14),(15,15),(16,16)
+	(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),
+	(1,17)
 );
 
 macro_rules! impl_not_const_generic{
@@ -785,16 +814,13 @@ macro_rules! impl_not_const_generic{
 				let mut result=Self::ZERO;
 
 				//resize self to match the wide mul output
-				let wide_self=self.[<fix_ $_2n>]();
+				let wide_self=self.[<widen_ $_2n>]();
 				//descend down the bits and check if flipping each bit would push the square over the input value
 				for shift in (0..=max_shift).rev(){
-					let new_result={
-						let mut bits=result.to_bits().to_bits();
-						bits.set_bit(shift,true);
-						Self::from_bits(BInt::from_bits(bits))
-					};
-					if new_result.[<wide_mul_ $n _ $n>](new_result)<=wide_self{
-						result=new_result;
+					result.as_bits_mut().as_bits_mut().set_bit(shift,true);
+					if wide_self<result.[<wide_mul_ $n _ $n>](result){
+						// put it back lol
+						result.as_bits_mut().as_bits_mut().set_bit(shift,false);
 					}
 				}
 				result

lib/fixed_wide/src/tests.rs

@@ -61,7 +61,7 @@ fn from_f32(){
 	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	//16 is within the 24 bits of float precision
-	let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.fix_2()).try_into();
+	let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.widen_2()).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	let b:Result<I32F32,_>=f32::MIN_POSITIVE.try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Underflow));
@@ -136,11 +136,24 @@ fn test_bint(){
 }
 
 #[test]
-fn test_fix(){
-	assert_eq!(I32F32::ONE.fix_8(),I256F256::ONE);
-	assert_eq!(I32F32::ONE,I256F256::ONE.fix_1());
-	assert_eq!(I32F32::NEG_ONE.fix_8(),I256F256::NEG_ONE);
-	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.fix_1());
+fn test_wrap(){
+	assert_eq!(I32F32::ONE,I256F256::ONE.wrap_1());
+	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.wrap_1());
+}
+#[test]
+fn test_narrow(){
+	assert_eq!(Ok(I32F32::ONE),I256F256::ONE.narrow_1());
+	assert_eq!(Ok(I32F32::NEG_ONE),I256F256::NEG_ONE.narrow_1());
+}
+#[test]
+fn test_widen(){
+	assert_eq!(I32F32::ONE.widen_8(),I256F256::ONE);
+	assert_eq!(I32F32::NEG_ONE.widen_8(),I256F256::NEG_ONE);
+}
+#[test]
+fn test_clamp(){
+	assert_eq!(I32F32::ONE,I256F256::ONE.clamp_1());
+	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.clamp_1());
 }
 #[test]
 fn test_sqrt(){

lib/fixed_wide/src/zeroes.rs

@@ -15,8 +15,10 @@ macro_rules! impl_zeroes{
 				let radicand=a1*a1-a2*a0*4;
 				match radicand.cmp(&<Self as core::ops::Mul>::Output::ZERO){
 					Ordering::Greater=>{
+						// using wrap because sqrt always halves the number of leading digits.
+						// clamp would be more defensive, but is slower.
 						paste::item!{
-						let planar_radicand=radicand.sqrt().[<fix_ $n>]();
+						let planar_radicand=radicand.sqrt().[<wrap_ $n>]();
 						}
 						//sort roots ascending and avoid taking the difference of large numbers
 						let zeroes=match (a2pos,Self::ZERO<a1){

lib/linear_ops/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "linear_ops"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,7 @@ deferred-division=["dep:ratio_ops"]
 
 [dependencies]
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-fixed_wide = { version = "0.1.2", path = "../fixed_wide", registry = "strafesnet", optional = true }
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", optional = true }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]

lib/linear_ops/src/macros/fixed_wide.rs

@@ -38,40 +38,95 @@ macro_rules! impl_fixed_wide_vector {
 		$crate::macro_4!(impl_fixed_wide_vector_not_const_generic,());
 		// I LOVE NOT BEING ABLE TO USE CONST GENERICS
 		$crate::macro_repeated!(
-			impl_fix_not_const_generic,(),
-			(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),
-			(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
-			(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
-			(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(8,4),(9,4),(10,4),(11,4),(12,4),(13,4),(14,4),(15,4),(16,4),
-			(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5),(8,5),(9,5),(10,5),(11,5),(12,5),(13,5),(14,5),(15,5),(16,5),
-			(1,6),(2,6),(3,6),(4,6),(5,6),(6,6),(7,6),(8,6),(9,6),(10,6),(11,6),(12,6),(13,6),(14,6),(15,6),(16,6),
-			(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),(7,7),(8,7),(9,7),(10,7),(11,7),(12,7),(13,7),(14,7),(15,7),(16,7),
-			(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),(8,8),(9,8),(10,8),(11,8),(12,8),(13,8),(14,8),(15,8),(16,8),
-			(1,9),(2,9),(3,9),(4,9),(5,9),(6,9),(7,9),(8,9),(9,9),(10,9),(11,9),(12,9),(13,9),(14,9),(15,9),(16,9),
-			(1,10),(2,10),(3,10),(4,10),(5,10),(6,10),(7,10),(8,10),(9,10),(10,10),(11,10),(12,10),(13,10),(14,10),(15,10),(16,10),
-			(1,11),(2,11),(3,11),(4,11),(5,11),(6,11),(7,11),(8,11),(9,11),(10,11),(11,11),(12,11),(13,11),(14,11),(15,11),(16,11),
-			(1,12),(2,12),(3,12),(4,12),(5,12),(6,12),(7,12),(8,12),(9,12),(10,12),(11,12),(12,12),(13,12),(14,12),(15,12),(16,12),
-			(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),(13,13),(14,13),(15,13),(16,13),
-			(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),(14,14),(15,14),(16,14),
-			(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),(15,15),(16,15),
-			(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),(16,16)
+			impl_narrow_not_const_generic,(),
+			(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),(17,1),
+			(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
+			(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
+			(5,4),(6,4),(7,4),(8,4),(9,4),(10,4),(11,4),(12,4),(13,4),(14,4),(15,4),(16,4),
+			(6,5),(7,5),(8,5),(9,5),(10,5),(11,5),(12,5),(13,5),(14,5),(15,5),(16,5),
+			(7,6),(8,6),(9,6),(10,6),(11,6),(12,6),(13,6),(14,6),(15,6),(16,6),
+			(8,7),(9,7),(10,7),(11,7),(12,7),(13,7),(14,7),(15,7),(16,7),
+			(9,8),(10,8),(11,8),(12,8),(13,8),(14,8),(15,8),(16,8),
+			(10,9),(11,9),(12,9),(13,9),(14,9),(15,9),(16,9),
+			(11,10),(12,10),(13,10),(14,10),(15,10),(16,10),
+			(12,11),(13,11),(14,11),(15,11),(16,11),
+			(13,12),(14,12),(15,12),(16,12),
+			(14,13),(15,13),(16,13),
+			(15,14),(16,14),
+			(16,15)
 		);
+		$crate::macro_repeated!(
+			impl_widen_not_const_generic,(),
+			(1,2),
+			(1,3),(2,3),
+			(1,4),(2,4),(3,4),
+			(1,5),(2,5),(3,5),(4,5),
+			(1,6),(2,6),(3,6),(4,6),(5,6),
+			(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),
+			(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),
+			(1,9),(2,9),(3,9),(4,9),(5,9),(6,9),(7,9),(8,9),
+			(1,10),(2,10),(3,10),(4,10),(5,10),(6,10),(7,10),(8,10),(9,10),
+			(1,11),(2,11),(3,11),(4,11),(5,11),(6,11),(7,11),(8,11),(9,11),(10,11),
+			(1,12),(2,12),(3,12),(4,12),(5,12),(6,12),(7,12),(8,12),(9,12),(10,12),(11,12),
+			(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),
+			(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),
+			(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),
+			(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),
+			(1,17)
+		);
+		impl<const N:usize,T:fixed_wide::fixed::Wrap<U>,U> fixed_wide::fixed::Wrap<Vector<N,U>> for Vector<N,T>
+		{
+			#[inline]
+			fn wrap(self)->Vector<N,U>{
+				self.map(|t|t.wrap())
+			}
+		}
+		impl<const N:usize,T:fixed_wide::fixed::Clamp<U>,U> fixed_wide::fixed::Clamp<Vector<N,U>> for Vector<N,T>
+		{
+			#[inline]
+			fn clamp(self)->Vector<N,U>{
+				self.map(|t|t.clamp())
+			}
+		}
 	};
 }
-
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_fix_not_const_generic{
+macro_rules! impl_narrow_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>
-		{
-			paste::item!{
+		paste::item!{
+			impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
-					self.map(|t|t.[<fix_ $rhs>]())
+				pub fn [<wrap_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<wrap_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<narrow_ $rhs>](self)->Vector<N,Result<fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>,fixed_wide::fixed::NarrowError>>{
+					self.map(|t|t.[<narrow_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<clamp_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<clamp_ $rhs>]())
+				}
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_widen_not_const_generic{
+	(
+		(),
+		($lhs:expr,$rhs:expr)
+	)=>{
+		paste::item!{
+			impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>{
+				#[inline]
+				pub fn [<widen_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<widen_ $rhs>]())
 				}
 			}
 		}

lib/linear_ops/src/macros/vector.rs

@@ -58,6 +58,15 @@ macro_rules! impl_vector {
 			}
 		}
 
+		impl<const N:usize,T,E:std::fmt::Debug> Vector<N,Result<T,E>>{
+			#[inline]
+			pub fn unwrap(self)->Vector<N,T>{
+				Vector{
+					array:self.array.map(Result::unwrap)
+				}
+			}
+		}
+
 		impl<const N:usize,T:Ord> Vector<N,T>{
 			#[inline]
 			pub fn min(self,rhs:Self)->Self{

lib/rbx_loader/src/mesh.rs

@@ -84,13 +84,13 @@ where
 fn ingest_faces2_lods3(
 	polygon_groups:&mut Vec<PolygonGroup>,
 	vertex_id_map:&HashMap<rbx_mesh::mesh::VertexId2,VertexId>,
-	faces:&Vec<rbx_mesh::mesh::Face2>,
-	lods:&Vec<rbx_mesh::mesh::Lod3>
+	faces:&[rbx_mesh::mesh::Face2],
+	lods:&[rbx_mesh::mesh::Lod3],
 ){
 	//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(|face|
-			vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
+		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]]
 		).collect()))
 	))
 }

lib/rbx_loader/src/rbx.rs

@@ -4,12 +4,11 @@ use crate::primitives;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
-use strafesnet_common::gameplay_modes;
+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::model::RenderConfigId;
-use strafesnet_common::updatable::Updatable;
 use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,MeshDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
@@ -48,97 +47,11 @@ fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_we
 			*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.fix_1())),
+			].map(|t|t.narrow_1().unwrap())),
 		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z]).unwrap()
 	)
 }
-struct ModeBuilder{
-	mode:gameplay_modes::Mode,
-	final_stage_id_from_builder_stage_id:HashMap<gameplay_modes::StageId,gameplay_modes::StageId>,
-}
-#[derive(Default)]
-struct ModesBuilder{
-	modes:HashMap<gameplay_modes::ModeId,gameplay_modes::Mode>,
-	stages:HashMap<gameplay_modes::ModeId,HashMap<gameplay_modes::StageId,gameplay_modes::Stage>>,
-	mode_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::ModeUpdate)>,
-	stage_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::StageId,gameplay_modes::StageUpdate)>,
-}
-impl ModesBuilder{
-	fn build(mut self)->gameplay_modes::Modes{
-		//collect modes and stages into contiguous arrays
-		let mut unique_modes:Vec<(gameplay_modes::ModeId,gameplay_modes::Mode)>
-		=self.modes.into_iter().collect();
-		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
-		let (mut modes,final_mode_id_from_builder_mode_id):(Vec<ModeBuilder>,HashMap<gameplay_modes::ModeId,gameplay_modes::ModeId>)
-		=unique_modes.into_iter().enumerate()
-		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
-			(
-				ModeBuilder{
-					final_stage_id_from_builder_stage_id:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
-						let mut unique_stages:Vec<(gameplay_modes::StageId,gameplay_modes::Stage)>
-						=stages.into_iter().collect();
-						unique_stages.sort_by(|a,b|a.0.cmp(&b.0));
-						unique_stages.into_iter().enumerate()
-						.map(|(final_stage_id,(builder_stage_id,stage))|{
-							mode.push_stage(stage);
-							(builder_stage_id,gameplay_modes::StageId::new(final_stage_id as u32))
-						}).collect()
-					}),
-					mode,
-				},
-				(
-					builder_mode_id,
-					gameplay_modes::ModeId::new(final_mode_id as u32)
-				)
-			)
-		}).unzip();
-		//TODO: failure messages or errors or something
-		//push stage updates
-		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					if let Some(&final_stage_id)=mode.final_stage_id_from_builder_stage_id.get(&builder_stage_id){
-						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
-							stage.update(stage_update);
-						}
-					}
-				}
-			}
-		}
-		//push mode updates
-		for (builder_mode_id,mut mode_update) in self.mode_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					//map stage id on stage elements
-					mode_update.map_stage_element_ids(|stage_id|
-						//walk down one stage id at a time until a stage is found
-						//TODO use better logic like BTreeMap::upper_bound instead of walking
-						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
-						// .value().copied().unwrap_or(gameplay_modes::StageId::FIRST)
-						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
-							//map the stage element to that stage
-							mode.final_stage_id_from_builder_stage_id.get(&gameplay_modes::StageId::new(builder_stage_id)).copied()
-						).unwrap_or(gameplay_modes::StageId::FIRST)
-					);
-					mode.mode.update(mode_update);
-				}
-			}
-		}
-		gameplay_modes::Modes::new(modes.into_iter().map(|mode_builder|mode_builder.mode).collect())
-	}
-	fn insert_mode(&mut self,mode_id:gameplay_modes::ModeId,mode:gameplay_modes::Mode){
-		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
-	}
-	fn insert_stage(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage:gameplay_modes::Stage){
-		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
-	}
-	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
-		self.mode_updates.push((mode_id,mode_update));
-	}
-	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
-	// }
-}
+
 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{
 	let mut general=attr::GeneralAttributes::default();
 	let mut intersecting=attr::IntersectingAttributes::default();
@@ -167,8 +80,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.insert_mode(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::Mode::empty(
+				ModeId::MAIN,
+				Mode::empty(
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
@@ -178,10 +91,10 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Finish,
+					Zone::Finish,
 				),
 			);
 		},
@@ -189,19 +102,19 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Anticheat,
+					Zone::Anticheat,
 				),
 			);
 		},
 		"Platform"=>{
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::element(
+				ModeId::MAIN,
+				ModeUpdate::element(
 					model_id,
-					gameplay_modes::StageElement::new(gameplay_modes::StageId::FIRST,false,gameplay_modes::StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
+					StageElement::new(StageId::FIRST,false,StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
 				),
 			);
 		},
@@ -213,8 +126,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						force_can_collide=false;
 						force_intersecting=true;
 						modes_builder.insert_mode(
-							gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-							gameplay_modes::Mode::empty(
+							ModeId::new(captures[2].parse::<u32>().unwrap()),
+							Mode::empty(
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
@@ -231,8 +144,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
-				let stage_id=gameplay_modes::StageId::new(captures[3].parse::<u32>().unwrap());
-				let stage_element=gameplay_modes::StageElement::new(
+				let stage_id=StageId::new(captures[3].parse::<u32>().unwrap());
+				let stage_element=StageElement::new(
 					//stage_id:
 					stage_id,
 					//force:
@@ -244,26 +157,26 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					match &captures[2]{
 						"Spawn"=>{
 							modes_builder.insert_stage(
-								gameplay_modes::ModeId::MAIN,
+								ModeId::MAIN,
 								stage_id,
-								gameplay_modes::Stage::empty(model_id),
+								Stage::empty(model_id),
 							);
 							//TODO: let denormalize handle this
-							gameplay_modes::StageElementBehaviour::SpawnAt
+							StageElementBehaviour::SpawnAt
 						},
-						"SpawnAt"=>gameplay_modes::StageElementBehaviour::SpawnAt,
+						"SpawnAt"=>StageElementBehaviour::SpawnAt,
 						//cancollide false so you don't hit the side
 						//NOT a decoration
-						"Trigger"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Trigger},
-						"Teleport"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Teleport},
-						"Platform"=>gameplay_modes::StageElementBehaviour::Platform,
+						"Trigger"=>{force_can_collide=false;StageElementBehaviour::Trigger},
+						"Teleport"=>{force_can_collide=false;StageElementBehaviour::Teleport},
+						"Platform"=>StageElementBehaviour::Platform,
 						_=>panic!("regex1[2] messed up bad"),
 					},
 					None
 				);
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::MAIN,
-					gameplay_modes::ModeUpdate::element(
+					ModeId::MAIN,
+					ModeUpdate::element(
 						model_id,
 						stage_element,
 					),
@@ -272,14 +185,14 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			.captures(other){
 				match &captures[1]{
 					"Jump"=>modes_builder.push_mode_update(
-						gameplay_modes::ModeId::MAIN,
-						gameplay_modes::ModeUpdate::element(
+						ModeId::MAIN,
+						ModeUpdate::element(
 							model_id,
 							//jump_limit:
-							gameplay_modes::StageElement::new(
-								gameplay_modes::StageId::FIRST,
+							StageElement::new(
+								StageId::FIRST,
 								false,
-								gameplay_modes::StageElementBehaviour::Check,
+								StageElementBehaviour::Check,
 								Some(captures[2].parse::<u8>().unwrap())
 							)
 						),
@@ -296,13 +209,13 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 				force_can_collide=false;
 				force_intersecting=true;
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-					gameplay_modes::ModeUpdate::zone(
+					ModeId::new(captures[2].parse::<u32>().unwrap()),
+					ModeUpdate::zone(
 						model_id,
 						//zone:
 						match &captures[1]{
-							"Finish"=>gameplay_modes::Zone::Finish,
-							"Anticheat"=>gameplay_modes::Zone::Anticheat,
+							"Finish"=>Zone::Finish,
+							"Anticheat"=>Zone::Anticheat,
 							_=>panic!("regex3[1] messed up bad"),
 						},
 					),
@@ -312,9 +225,9 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			// .captures(other){
 			// 	match &captures[1]{
 			// 		"OrderedCheckpoint"=>modes_builder.push_stage_update(
-			// 			gameplay_modes::ModeId::MAIN,
-			// 			gameplay_modes::StageId::new(0),
-			// 			gameplay_modes::StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
+			// 			ModeId::MAIN,
+			// 			StageId::new(0),
+			// 			StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
 			// 		),
 			// 		_=>panic!("regex3[1] messed up bad"),
 			// 	}
@@ -924,9 +837,9 @@ impl PartialMap1<'_>{
 				color:deferred_model_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().fix_1(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().fix_1(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().fix_1()
+						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_model_deferred_attributes.model.transform.translation
 				),
@@ -948,9 +861,9 @@ impl PartialMap1<'_>{
 				color:deferred_union_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_union_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().fix_1(),
-						(deferred_union_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().fix_1(),
-						(deferred_union_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().fix_1()
+						(deferred_union_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
+						(deferred_union_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
+						(deferred_union_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_union_deferred_attributes.model.transform.translation
 				),
@@ -1009,7 +922,7 @@ impl PartialMap1<'_>{
 	PartialMap2{
 		meshes:self.primitive_meshes,
 		models,
-		modes:modes_builder.build(),
+		modes:modes_builder.build_normalized(),
 		attributes:unique_attributes,
 	}
 	}
@@ -1018,7 +931,7 @@ impl PartialMap1<'_>{
 pub struct PartialMap2{
 	meshes:Vec<model::Mesh>,
 	models:Vec<model::Model>,
-	modes:gameplay_modes::Modes,
+	modes:NormalizedModes,
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 }
 impl PartialMap2{

lib/snf/src/map.rs

@@ -138,7 +138,7 @@ struct MapHeader{
 	//#[br(count=num_resources_external)]
 	//external_resources:Vec<ResourceExternalHeader>,
 	#[br(count=num_modes)]
-	modes:Vec<newtypes::gameplay_modes::Mode>,
+	modes:Vec<newtypes::gameplay_modes::NormalizedMode>,
 	#[br(count=num_attributes)]
 	attributes:Vec<newtypes::gameplay_attributes::CollisionAttributes>,
 	#[br(count=num_render_configs)]
@@ -181,7 +181,7 @@ fn read_texture<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)
 pub struct StreamableMap<R:BinReaderExt>{
 	file:crate::file::File<R>,
 	//this includes every platform... move the unconstrained datas to their appropriate data block?
-	modes:gameplay_modes::Modes,
+	modes:gameplay_modes::NormalizedModes,
 	//this is every possible attribute... need some sort of streaming system
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 	//this is every possible render configuration... shaders and such... need streaming
@@ -223,7 +223,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		}
 		Ok(Self{
 			file,
-			modes:strafesnet_common::gameplay_modes::Modes::new(modes),
+			modes:strafesnet_common::gameplay_modes::NormalizedModes::new(modes),
 			attributes,
 			render_configs,
 			bvh:strafesnet_common::bvh::generate_bvh(bvh),
@@ -386,7 +386,7 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
 		let mut aabb=strafesnet_common::aabb::Aabb::default();
 		for &pos in &mesh.unique_pos{
-			aabb.grow(model.transform.transform_point3(pos).fix_1());
+			aabb.grow(model.transform.transform_point3(pos).narrow_1().unwrap());
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
@@ -430,13 +430,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		num_spacial_blocks:spacial_blocks.len() as u32,
 		num_resource_blocks:resource_blocks.len() as u32,
 		//num_resources_external:0,
-		num_modes:map.modes.modes.len() as u32,
+		num_modes:map.modes.len() as u32,
 		num_attributes:map.attributes.len() as u32,
 		num_render_configs:map.render_configs.len() as u32,
 		spacial_blocks,
 		resource_blocks,
 		//external_resources:Vec::new(),
-		modes:map.modes.modes.into_iter().map(Into::into).collect(),
+		modes:map.modes.into_iter().map(Into::into).collect(),
 		attributes:map.attributes.into_iter().map(Into::into).collect(),
 		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
 	};

lib/snf/src/newtypes/gameplay_modes.rs

@@ -157,7 +157,7 @@ pub struct ModeHeader{
 }
 #[binrw::binrw]
 #[brw(little)]
-pub struct Mode{
+pub struct NormalizedMode{
 	pub header:ModeHeader,
 	pub style:super::gameplay_style::StyleModifiers,
 	pub start:u32,
@@ -179,10 +179,10 @@ impl std::fmt::Display for ModeError{
 	}
 }
 impl std::error::Error for ModeError{}
-impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
+impl TryInto<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
 	type Error=ModeError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_modes::Mode,Self::Error>{
-		Ok(strafesnet_common::gameplay_modes::Mode::new(
+	fn try_into(self)->Result<strafesnet_common::gameplay_modes::NormalizedMode,Self::Error>{
+		Ok(strafesnet_common::gameplay_modes::NormalizedMode::new(strafesnet_common::gameplay_modes::Mode::new(
 			self.style.try_into().map_err(ModeError::StyleModifier)?,
 			strafesnet_common::model::ModelId::new(self.start),
 			self.zones.into_iter().map(|(model_id,zone)|
@@ -192,12 +192,12 @@ impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
 			self.elements.into_iter().map(|(model_id,stage_element)|
 				Ok((strafesnet_common::model::ModelId::new(model_id),stage_element.try_into()?))
 			).collect::<Result<_,_>>().map_err(ModeError::StageElement)?,
-		))
+		)))
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
-	fn from(value:strafesnet_common::gameplay_modes::Mode)->Self{
-		let (style,start,zones,stages,elements)=value.into_inner();
+impl From<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
+	fn from(value:strafesnet_common::gameplay_modes::NormalizedMode)->Self{
+		let (style,start,zones,stages,elements)=value.into_inner().into_inner();
 		Self{
 			header:ModeHeader{
 				zones:zones.len() as u32,

map-tool/Cargo.toml

@@ -25,11 +25,11 @@ strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registr
 strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
-vbsp = { version = "0.7.0-codegen5", registry = "strafesnet", default-features = false }
-vbsp-entities = { version = "0.1.0", registry = "strafesnet", default-features = false, features = ["css"]}
+vbsp = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vmt-parser = "0.2.0"
-vpk = "0.2.0"
+vpk = "0.3.0"
 vtf = "0.3.0"
 
 #[profile.release]

map-tool/src/source.rs

@@ -6,7 +6,7 @@ use futures::StreamExt;
 use strafesnet_bsp_loader::loader::BspFinder;
 use strafesnet_deferred_loader::loader::Loader;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
-use vbsp_entities::css::Entity;
+use vbsp_entities_css::Entity;
 
 #[derive(Subcommand)]
 pub enum Commands{

tools/dev

@@ -0,0 +1 @@
+RUST_BACKTRACE=1 mangohud ../target/debug/strafe-client "$@"