add StrafeTickState to allow 0 time strafe events

expect dead code
use allow instead of expect
2025-12-10 18:19:22 -08:00 · 2025-12-10 18:05:16 -08:00 · 2025-12-09 14:39:42 -08:00 · 2025-11-27 16:42:01 -08:00 · 2025-11-27 15:50:19 -08:00 · 2025-11-27 15:48:17 -08:00
15 changed files with 633 additions and 1241 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/engine/physics/src/face_crawler.rs
+++ b/engine/physics/src/face_crawler.rs
@@ -21,6 +21,12 @@ impl<M:MeshQuery> CrawlResult<M>{
 			CrawlResult::Hit(face,time)=>Some((face,time)),
 		}
 	}
 	pub fn miss(self)->Option<FEV<M>>{
 		match self{
 			CrawlResult::Miss(fev)=>Some(fev),
 			CrawlResult::Hit(_,_)=>None,
 		}
 	}
 }
 // TODO: move predict_collision_face_out algorithm in here or something
--- a/engine/physics/src/lib.rs
+++ b/engine/physics/src/lib.rs
@@ -1,8 +1,7 @@
 mod body;
 mod push_solve;
 mod face_crawler;
 mod model;
 mod push_solve;
 mod minimum_difference;
 pub mod physics;
--- a/engine/physics/src/minimum_difference.rs
+++ b/engine/physics/src/minimum_difference.rs
@@ -1,844 +0,0 @@
 use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 use crate::model::{DirectedEdge,FEV,MeshQuery};
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
 type Simplex<const N:usize,Vert>=[Vert;N];
 #[derive(Clone,Copy)]
 enum Simplex1_3<Vert>{
 	Simplex1(Simplex<1,Vert>),
 	Simplex2(Simplex<2,Vert>),
 	Simplex3(Simplex<3,Vert>),
 }
 impl<Vert> Simplex1_3<Vert>{
 	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
 		match self{
 			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
 			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
 			Simplex1_3::Simplex3([v0,v1,v2])=>Simplex2_4::Simplex4([v,v0,v1,v2]),
 		}
 	}
 }
 #[derive(Clone,Copy)]
 enum Simplex2_4<Vert>{
 	Simplex2(Simplex<2,Vert>),
 	Simplex3(Simplex<3,Vert>),
 	Simplex4(Simplex<4,Vert>),
 }
 /*
 local function absDet(r, u, v, w)
 	if w then
 		return math.abs((u - r):Cross(v - r):Dot(w - r))
 	elseif v then
 		return (u - r):Cross(v - r).magnitude
 	elseif u then
 		return (u - r).magnitude
 	else
 		return 1
 	end
 end
 */
 impl<Vert> Simplex2_4<Vert>{
 	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
 		match self{
 			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				let p3=mesh.vert(p3);
 				(p1-p0).cross(p2-p0).dot(p3-p0)==Fixed::ZERO
 			},
 			Self::Simplex3([p0,p1,p2])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				(p1-p0).cross(p2-p0)==vec3::zero()
 			},
 			Self::Simplex2([p0,p1])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				p1-p0==vec3::zero()
 			}
 		}
 	}
 }
 /*
 local function choosePerpendicularDirection(d)
 	local x, y, z = d.x, d.y, d.z
 	local best = math.min(x*x, y*y, z*z)
 	if x*x == best then
 		return Vector3.new(y*y + z*z, -x*y, -x*z)
 	elseif y*y == best then
 		return Vector3.new(-x*y, x*x + z*z, -y*z)
 	else
 		return Vector3.new(-x*z, -y*z, x*x + y*y)
 	end
 end
 */
 fn choose_perpendicular_direction(d:Planar64Vec3)->Planar64Vec3{
 	let x=d.x.abs();
 	let y=d.y.abs();
 	let z=d.z.abs();
 	if x<y&&x<z{
 		Vector3::new([Fixed::ZERO,-d.z,d.y])
 	}else if y<z{
 		Vector3::new([d.z,Fixed::ZERO,-d.x])
 	}else{
 		Vector3::new([-d.y,d.x,Fixed::ZERO])
 	}
 }
 const fn choose_any_direction()->Planar64Vec3{
 	vec3::X
 }
 fn reduce1<M:MeshQuery>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
 	// local p = -a
 	let p=-(p0+point);
 	// local direction = p
 	let mut dir=p;
 	// if direction.magnitude == 0 then
 	// 	direction = chooseAnyDirection()
 	if dir==vec3::zero(){
 		dir=choose_any_direction();
 	}
 	// return direction, a0, a1
 	Reduced{
 		dir,
 		simplex:Simplex1_3::Simplex1([v0]),
 	}
 }
 // local function reduceSimplex1(a0, a1, b0, b1)
 fn reduce2<M:MeshQuery>(
 	[v0,v1]:Simplex<2,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	let p0=mesh.vert(v0);
 	let p1=mesh.vert(v1);
 	// local p = -a
 	// local u = b - a
 	let p=-(p0+point);
 	let u=p1-p0;
 	// -- modify to take into account the radiuses
 	// local p_u = p:Dot(u)
 	let p_u=p.dot(u);
 	// if p_u >= 0 then
 	if !p_u.is_negative(){
 		// local direction = u:Cross(p):Cross(u)
 		let direction=u.cross(p).cross(u);
 		// if direction.magnitude == 0 then
 		if direction==vec3::zero(){
 			return Reduced{
 				dir:choose_perpendicular_direction(u),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
 			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
 	// local direction = p
 	let mut dir=p;
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		dir=choose_perpendicular_direction(u);
 	}
 	// return direction, a0, a1
 	Reduced{
 		dir,
 		simplex:Simplex1_3::Simplex1([v0]),
 	}
 }
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
 fn reduce3<M:MeshQuery>(
 	[v0,mut v1,v2]:Simplex<3,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
 	let p0=mesh.vert(v0);
 	let p1=mesh.vert(v1);
 	let p2=mesh.vert(v2);
 	// local p = -a
 	// local u = b - a
 	// local v = c - a
 	let p=-(p0+point);
 	let mut u=p1-p0;
 	let v=p2-p0;
 	// local uv = u:Cross(v)
 	// local up = u:Cross(p)
 	// local pv = p:Cross(v)
 	// local uv_up = uv:Dot(up)
 	// local uv_pv = uv:Dot(pv)
 	let mut uv=u.cross(v);
 	let mut up=u.cross(p);
 	let pv=p.cross(v);
 	let uv_up=uv.dot(up);
 	let uv_pv=uv.dot(pv);
 	// if uv_up >= 0 and uv_pv >= 0 then
 	if !uv_up.is_negative()&&!uv_pv.is_negative(){
 		// local uvp = uv:Dot(p)
 		let uvp=uv.dot(p);
 		// local direction = uvp < 0 and -uv or uv
 		let direction=if uvp.is_negative(){
 			-uv
 		}else{
 			uv
 		};
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
 			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
 	// local u_u = u:Dot(u)
 	// local v_v = v:Dot(v)
 	// local uDist = uv_up/(u_u*v.magnitude)
 	// local vDist = uv_pv/(v_v*u.magnitude)
 	// local minDist2 = math.min(uDist, vDist)
 	let u_dist=uv_up*v.length();
 	let v_dist=uv_pv*u.length();
 	// if vDist == minDist2 then
 	if v_dist<u_dist{
 		u=v;
 		up=-pv;
 		uv=-uv;
 		// b0 = c0
 		// b1 = c1
 		v1=v2;
 	}
 	// local p_u = p:Dot(u)
 	let p_u=p.dot(u);
 	// if p_u >= 0 then
 	if !p_u.is_negative(){
 		// local direction = up:Cross(u)
 		let direction=up.cross(u);
 		// if direction.magnitude == 0 then
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
 				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 		// return direction, a0, a1, b0, b1
 		return Reduced{
 			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
 	// local direction = p
 	let dir=p;
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
 			dir:uv.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
 	// return direction, a0, a0
 	Reduced{
 		dir,
 		simplex:Simplex1_3::Simplex1([v0]),
 	}
 }
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
 fn reduce4<M:MeshQuery>(
 	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduce<M::Vert>{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
 	// local d = d1 - d0
 	let p0=mesh.vert(v0);
 	let p1=mesh.vert(v1);
 	let p2=mesh.vert(v2);
 	let p3=mesh.vert(v3);
 	// local p = -a
 	// local u = b - a
 	// local v = c - a
 	// local w = d - a
 	let p=-(p0+point);
 	let mut u=p1-p0;
 	let mut v=p2-p0;
 	let w=p3-p0;
 	// local uv = u:Cross(v)
 	// local vw = v:Cross(w)
 	// local wu = w:Cross(u)
 	// local uvw = uv:Dot(w)
 	// local pvw = vw:Dot(p)
 	// local upw = wu:Dot(p)
 	// local uvp = uv:Dot(p)
 	let mut uv=u.cross(v);
 	let vw=v.cross(w);
 	let wu=w.cross(u);
 	let uv_w=uv.dot(w);
 	let pv_w=vw.dot(p);
 	let up_w=wu.dot(p);
 	let uv_p=uv.dot(p);
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
 	if !pv_w.div_sign(uv_w).is_negative()
 	 ||!up_w.div_sign(uv_w).is_negative()
 	 ||!uv_p.div_sign(uv_w).is_negative(){
 		// origin is contained, this is a positive detection
 		// local direction = Vector3.new(0, 0, 0)
 		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
 		return Reduce::Escape([v0,v1,v2,v3]);
 	}
 	// local uvwSign = uvw < 0 and -1 or uvw > 0 and 1 or 0
 	// local uvDist = uvp*uvwSign/uv.magnitude
 	// local vwDist = pvw*uvwSign/vw.magnitude
 	// local wuDist = upw*uvwSign/wu.magnitude
 	// local minDist3 = math.min(uvDist, vwDist, wuDist)
 	let uv_dist=uv_p.mul_sign(uv_w);
 	let vw_dist=pv_w.mul_sign(uv_w);
 	let wu_dist=up_w.mul_sign(uv_w);
 	let wu_len=wu.length();
 	let uv_len=uv.length();
 	let vw_len=vw.length();
 	if vw_dist*wu_len<wu_dist*vw_len{
 		// if vwDist == minDist3 then
 		if vw_dist*uv_len<uv_dist*vw_len{
 			(u,v)=(v,w);
 			uv=vw;
 			// uv_p=pv_w; // unused
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
 		}else{
 			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
 		if wu_dist*uv_len<uv_dist*wu_len{
 			(u,v)=(w,u);
 			uv=wu;
 			// uv_p=up_w; // unused
 			// b0, c0 = d0, b0
 			// b1, c1 = d1, b1
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
 		}else{
 			v2=v3;
 		}
 	}
 	// local up = u:Cross(p)
 	// local pv = p:Cross(v)
 	// local uv_up = uv:Dot(up)
 	// local uv_pv = uv:Dot(pv)
 	let mut up=u.cross(p);
 	let pv=p.cross(v);
 	let uv_up=uv.dot(up);
 	let uv_pv=uv.dot(pv);
 	// if uv_up >= 0 and uv_pv >= 0 then
 	if !uv_up.is_negative()&&!uv_pv.is_negative(){
 		// local direction = uvw < 0 and uv or -uv
 		// return direction, a0, a1, b0, b1, c0, c1
 		if uv_w.is_negative(){
 			return Reduce::Reduced(Reduced{
 				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}else{
 			return Reduce::Reduced(Reduced{
 				dir:-uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}
 	}
 	// local u_u = u:Dot(u)
 	// local v_v = v:Dot(v)
 	// local uDist = uv_up/(u_u*v.magnitude)
 	// local vDist = uv_pv/(v_v*u.magnitude)
 	// local minDist2 = math.min(uDist, vDist)
 	let u_dist=uv_up*v.length();
 	let v_dist=uv_pv*u.length();
 	// if vDist == minDist2 then
 	if v_dist<u_dist{
 		u=v;
 		up=-pv;
 		uv=-uv;
 		// b0 = c0
 		// b1 = c1
 		v1=v2;
 	}
 	// local p_u = p:Dot(u)
 	let p_u=p.dot(u);
 	// if p_u >= 0 then
 	if !p_u.is_negative(){
 		// local direction = up:Cross(u)
 		let direction=up.cross(u);
 		// if direction.magnitude == 0 then
 		if direction==vec3::zero(){
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
 			if uv_w.is_negative(){
 				return Reduce::Reduced(Reduced{
 					dir:uv.narrow_1().unwrap(),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}else{
 				return Reduce::Reduced(Reduced{
 					dir:-uv.narrow_1().unwrap(),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}
 		}
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
 			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
 	// local direction = p
 	let dir=p;
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
 		if uv_w.is_negative(){
 			return Reduce::Reduced(Reduced{
 				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}else{
 			return Reduce::Reduced(Reduced{
 				dir:-uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}
 	}
 	// return direction, a0, a1
 	Reduce::Reduced(Reduced{
 		dir,
 		simplex:Simplex1_3::Simplex1([v0]),
 	})
 }
 struct Reduced<Vert>{
 	dir:Planar64Vec3,
 	simplex:Simplex1_3<Vert>,
 }
 enum Reduce<Vert>{
 	Escape(Simplex<4,Vert>),
 	Reduced(Reduced<Vert>),
 }
 impl<Vert> Simplex2_4<Vert>{
 	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
 			Self::Simplex4(simplex)=>reduce4(simplex,mesh,point),
 		}
 	}
 }
 pub fn contains_point<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->bool{
 	const ENABLE_FAST_FAIL:bool=true;
 	// TODO: remove mesh negation
 	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
 		// on_exact
 		|is_intersecting,_simplex|{
 			is_intersecting
 		},
 		// on_escape
 		|_simplex|{
 			// intersection is guaranteed at this point
 			true
 		},
 		// fast_fail value
 		||false
 	)
 }
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
 	Done,//found closest vert, no edges are better
 	Vert(Vert),//transition to vert
 }
 enum EV<M:MeshQuery>{
 	Vert(M::Vert),
 	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
 }
 impl<M:MeshQuery> From<EV<M>> for FEV<M>{
 	fn from(value:EV<M>)->Self{
 		match value{
 			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
 			EV::Edge(minkowski_edge)=>FEV::Edge(minkowski_edge),
 		}
 	}
 }
 trait Contains{
 	fn contains(&self,point:Planar64Vec3)->bool;
 }
 // convenience type to check if a point is within some threshold of a plane.
 struct ThickPlane{
 	point:Planar64Vec3,
 	normal:Vector3<Fixed<2,64>>,
 	epsilon:Fixed<3,96>,
 }
 impl ThickPlane{
 	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let p2=mesh.vert(v2);
 		let point=p0;
 		let normal=(p1-p0).cross(p2-p0);
 		// Allow ~ 2*sqrt(3) units of thickness on the plane
 		// This is to account for the variance of two voxels across the longest diagonal
 		let epsilon=(normal.length()*(Planar64::EPSILON*3)).wrap_3();
 		Self{point,normal,epsilon}
 	}
 }
 impl Contains for ThickPlane{
 	fn contains(&self,point:Planar64Vec3)->bool{
 		(point-self.point).dot(self.normal).abs()<=self.epsilon
 	}
 }
 struct ThickLine{
 	point:Planar64Vec3,
 	dir:Planar64Vec3,
 	epsilon:Fixed<4,128>,
 }
 impl ThickLine{
 	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let point=p0;
 		let dir=p1-p0;
 		// Allow ~ 2*sqrt(3) units of thickness on the plane
 		// This is to account for the variance of two voxels across the longest diagonal
 		let epsilon=(dir.length_squared()*(Planar64::EPSILON*3)).widen_4();
 		Self{point,dir,epsilon}
 	}
 }
 impl Contains for ThickLine{
 	fn contains(&self,point:Planar64Vec3)->bool{
 		(point-self.point).cross(self.dir).length_squared()<=self.epsilon
 	}
 }
 struct EVFinder<'a,M,C>{
 	mesh:&'a M,
 	constraint:C,
 	best_distance_squared:Fixed<2,64>,
 }
 impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
 		let mut best_transition=Transition::Done;
 		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
 			//test if this edge's opposite vertex closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
 			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
 			let test_pos=self.mesh.vert(test_vert_id);
 			let diff=point-test_pos;
 			let distance_squared=diff.dot(diff);
 			// ensure test_vert_id is coplanar to simplex
 			if distance_squared<self.best_distance_squared&&self.constraint.contains(test_pos){
 				best_transition=Transition::Vert(test_vert_id);
 				self.best_distance_squared=distance_squared;
 			}
 		}
 		best_transition
 	}
 	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
 		let mut best_transition=EV::Vert(vert_id);
 		let vert_pos=self.mesh.vert(vert_id);
 		let diff=point-vert_pos;
 		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
 			//test if this edge is closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
 			let test_pos=self.mesh.vert(test_vert_id);
 			let edge_n=test_pos-vert_pos;
 			let d=edge_n.dot(diff);
 			//test the edge
 			let edge_nn=edge_n.dot(edge_n);
 			// ensure edge contains closest point and directed_edge_id is coplanar to simplex
 			if !d.is_negative()&&d<=edge_nn&&self.constraint.contains(test_pos){
 				let distance_squared={
 					let c=diff.cross(edge_n);
 					//wrap for speed
 					(c.dot(c)/edge_nn).divide().wrap_2()
 				};
 				if distance_squared<=self.best_distance_squared{
 					best_transition=EV::Edge(directed_edge_id.as_undirected());
 					self.best_distance_squared=distance_squared;
 				}
 			}
 		}
 		best_transition
 	}
 	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
 		loop{
 			match self.next_transition_vert(vert_id,point){
 				Transition::Done=>return self.final_ev(vert_id,point),
 				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
 			}
 		}
 	}
 }
 /// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
 fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
 	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
 		let diff=point-mesh.vert(vert_id);
 		(vert_id,diff.dot(diff))
 	}).min_by_key(|&(_,d)|d).unwrap();
 	let constraint=ThickLine::new(mesh,simplex);
 	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
 	//start on any vertex
 	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 	//cross edge-face boundary if it's uncrossable
 	finder.crawl_boundaries(vert_id,point)
 }
 /// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
 fn crawl_to_closest_fev<M:MeshQuery>(mesh:&M,simplex:Simplex<3,M::Vert>,point:Planar64Vec3)->FEV::<M>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
 	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
 		let diff=point-mesh.vert(vert_id);
 		(vert_id,diff.dot(diff))
 	}).min_by_key(|&(_,d)|d).unwrap();
 	let constraint=ThickPlane::new(mesh,simplex);
 	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
 	//start on any vertex
 	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 	//cross edge-face boundary if it's uncrossable
 	match finder.crawl_boundaries(vert_id,point){
 		//if a vert is returned, it is the closest point to the infinity point
 		EV::Vert(vert_id)=>FEV::Vert(vert_id),
 		EV::Edge(edge_id)=>{
 			//cross to face if we are on the wrong side
 			let edge_n=mesh.edge_n(edge_id);
 			// point is multiplied by two because vert_sum sums two vertices.
 			let delta_pos=point*2-{
 				let &[v0,v1]=mesh.edge_verts(edge_id).as_ref();
 				mesh.vert(v0)+mesh.vert(v1)
 			};
 			for (i,&face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 				//test if this face is closer
 				let (face_n,d)=mesh.face_nd(face_id);
 				//if test point is behind face, the face is invalid
 				// TODO: find out why I thought of this backwards
 				if !(face_n.dot(point)-d).is_positive(){
 					continue;
 				}
 				//edge-face boundary nd, n facing out of the face towards the edge
 				let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
 				let boundary_d=boundary_n.dot(delta_pos);
 				//is test point behind edge, i.e. contained in the face
 				if !boundary_d.is_positive(){
 					//both faces cannot pass this condition, return early if one does.
 					return FEV::Face(face_id);
 				}
 			}
 			FEV::Edge(edge_id)
 		},
 	}
 }
 pub fn closest_fev_not_inside<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->Option<FEV<M>>{
 	const ENABLE_FAST_FAIL:bool=false;
 	// TODO: remove mesh negation
 	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
 			if is_intersecting{
 				return None;
 			}
 			// Convert simplex to FEV
 			// Vertices must be inverted since the mesh is inverted
 			Some(match simplex{
 				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
 					let (v0,v1)=(-v0,-v1);
 					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
 					if !matches!(ev,EV::Edge(_)){
 						println!("I can't believe it's not an edge!");
 					}
 					ev.into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
 					let (v0,v1,v2)=(-v0,-v1,-v2);
 					// Shimmy to the side until you find a face that contains the closest point
 					// it's ALWAYS representable as a face, but this algorithm may
 					// return E or V in edge cases but I don't think that will break the face crawler
 					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
 					if !matches!(fev,FEV::Face(_)){
 						println!("I can't believe it's not a face!");
 					}
 					fev
 				},
 			})
 		},
 		// on_escape
 		|_simplex|{
 			// intersection is guaranteed at this point
 			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
 			// let simplex=refine_to_exact(mesh,simplex);
 			None
 		},
 		// fast_fail value is irrelevant and will never be returned!
 		||unreachable!()
 	)
 }
 // local function minimumDifference(
 // 	queryP, radiusP,
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
 fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
 	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
 	on_fast_fail:impl FnOnce()->T,
 )->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)
 	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
 	let mut initial_axis=mesh.hint_point()+point;
 	// degenerate case
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
 	let last_point=mesh.farthest_vert(-initial_axis);
 	// this represents the 'a' value in the commented code
 	let mut last_pos=mesh.vert(last_point);
 	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
 	loop{
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
 		let next_point=mesh.farthest_vert(direction);
 		let next_pos=mesh.vert(next_point);
 		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
 		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
 			return on_fast_fail();
 		}
 		let simplex_big=simplex_small.push_front(next_point);
 		// if
 		// 	direction:Dot(next_point - a) <= 0 or
 		// 	absDet(next_point, a, b, c) < 1e-6
 		if !direction.dot(next_pos-last_pos).is_positive()
 		||simplex_big.det_is_zero(mesh){
 			// Found enough information to compute the exact closest point.
 			// local norm = direction.unit
 			// local dist = a:Dot(norm)
 			// local hits = -dist < radiusP + radiusQ
 			let is_intersecting=(last_pos+point).dot(direction).is_positive();
 			return on_exact(is_intersecting,simplex_small);
 		}
 		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
 		match simplex_big.reduce(mesh,point){
 			// if a and b and c and d then
 			Reduce::Escape(simplex)=>{
 				// Enough information to conclude that the meshes are intersecting.
 				// Topology information is computed if needed.
 				return on_escape(simplex);
 			},
 			Reduce::Reduced(reduced)=>{
 				direction=reduced.dir;
 				simplex_small=reduced.simplex;
 			},
 		}
 		// next loop this will be a
 		last_pos=next_pos;
 	}
 }
 // TODO: unit tests
--- a/engine/physics/src/model.rs
+++ b/engine/physics/src/model.rs
@@ -91,8 +91,8 @@ pub trait MeshQuery{
 		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
 	}
 	/// This must return a point inside the mesh.
 	#[expect(dead_code)]
 	fn hint_point(&self)->Planar64Vec3;
 	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
 	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
 	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
@@ -435,7 +435,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -454,18 +454,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		// invariant: meshes always encompass the origin
 		vec3::zero()
 	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.topology.verts.iter()
 			.enumerate()
 			.max_by_key(|&(_,&vert_id)|
 				dir.dot(self.data.verts[vert_id.get() as usize].0)
 			)
 			//assume there is more than zero vertices.
 			.unwrap().0 as u32
 		)
 	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -504,7 +492,7 @@ impl PhysicsMeshTransform{
 	}
 }
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -522,6 +510,18 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.view.topology.verts.iter()
 			.enumerate()
 			.max_by_key(|&(_,&vert_id)|
 				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
 			)
 			//assume there is more than zero vertices.
 			.unwrap().0 as u32
 		)
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -542,18 +542,6 @@ impl MeshQuery for TransformedMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.transform.vertex.translation
 	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.view.topology.verts.iter()
 			.enumerate()
 			.max_by_key(|&(_,&vert_id)|
 				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
 			)
 			//assume there is more than zero vertices.
 			.unwrap().0 as u32
 		)
 	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -580,20 +568,11 @@ impl MeshQuery for TransformedMesh<'_>{
 //(face,vertex)
 //(edge,edge)
 //(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-// TODO: remove this
+#[derive(Clone,Copy,Debug)]
 impl core::ops::Neg for MinkowskiVert{
 	type Output=Self;
 	fn neg(self)->Self::Output{
 		match self{
 			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
 		}
 	}
 }
 #[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -608,7 +587,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -629,7 +608,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash)]
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 pub enum MinkowskiFace{
 	VertFace(SubmeshVertId,SubmeshFaceId),
 	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
@@ -645,20 +624,23 @@ pub struct MinkowskiMesh<'a>{
 	mesh1:TransformedMesh<'a>,
 }
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition{
 	Done,//found closest vert, no edges are better
 	Vert(MinkowskiVert),//transition to vert
 }
 enum EV{
 	Vert(MinkowskiVert),
 	Edge(MinkowskiEdge),
 }
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
 // TODO: remove this
 impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
 	type Output=MinkowskiMesh<'a>;
 	fn neg(self)->Self::Output{
 		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
 	}
 }
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
 		MinkowskiMesh{
@@ -666,21 +648,140 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
 		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
 	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
 		let mut best_transition=Transition::Done;
 		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//is boundary uncrossable by a crawl from infinity
 			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
 			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
 			//test if it's closer
 			let diff=point-self.vert(test_vert_id);
 			if edge_n.dot(infinity_dir).is_zero(){
 				let distance_squared=diff.dot(diff);
 				if distance_squared<*best_distance_squared{
 					best_transition=Transition::Vert(test_vert_id);
 					*best_distance_squared=distance_squared;
 				}
 			}
 		}
 		best_transition
 	}
 	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
 		let mut best_transition=EV::Vert(vert_id);
 		let diff=point-self.vert(vert_id);
 		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//is boundary uncrossable by a crawl from infinity
 			//check if time of collision is outside Time::MIN..Time::MAX
 			if edge_n.dot(infinity_dir).is_zero(){
 				let d=edge_n.dot(diff);
 				//test the edge
 				let edge_nn=edge_n.dot(edge_n);
 				if !d.is_negative()&&d<=edge_nn{
 					let distance_squared={
 						let c=diff.cross(edge_n);
 						//wrap for speed
 						(c.dot(c)/edge_nn).divide().wrap_2()
 					};
 					if distance_squared<=*best_distance_squared{
 						best_transition=EV::Edge(directed_edge_id.as_undirected());
 						*best_distance_squared=distance_squared;
 					}
 				}
 			}
 		}
 		best_transition
 	}
 	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
 		let mut best_distance_squared={
 			let diff=point-self.vert(vert_id);
 			diff.dot(diff)
 		};
 		loop{
 			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
 				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
 				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
 			}
 		}
 	}
 	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
 	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh<'_>>{
 		//start on any vertex
 		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 		//cross edge-face boundary if it's uncrossable
 		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
 			//if a vert is returned, it is the closest point to the infinity point
 			EV::Vert(vert_id)=>FEV::Vert(vert_id),
 			EV::Edge(edge_id)=>{
 				//cross to face if the boundary is not crossable and we are on the wrong side
 				let edge_n=self.edge_n(edge_id);
 				// point is multiplied by two because vert_sum sums two vertices.
 				let delta_pos=point*2-{
 					let &[v0,v1]=self.edge_verts(edge_id).as_ref();
 					self.vert(v0)+self.vert(v1)
 				};
 				for (i,&face_id) in self.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=self.face_nd(face_id).0;
 					//edge-face boundary nd, n facing out of the face towards the edge
 					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
 					let boundary_d=boundary_n.dot(delta_pos);
 					//check if time of collision is outside Time::MIN..Time::MAX
 					//infinity_dir can always be treated as a velocity
 					if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
 						//both faces cannot pass this condition, return early if one does.
 						return FEV::Face(face_id);
 					}
 				}
 				FEV::Edge(edge_id)
 			},
 		}
 	}
 	// TODO: fundamentally improve this algorithm.
 	// All it needs to do is find the closest point on the mesh
 	// and return the FEV which the point resides on.
 	//
 	// What it actually does is use the above functions to trace a ray in from infinity,
 	// crawling the closest point along the mesh surface until the ray reaches
 	// the starting point to discover the final FEV.
 	//
 	// The actual collision prediction probably does a single test
 	// and then immediately returns with 0 FEV transitions on average,
 	// because of the strict time_limit constraint.
 	//
 	// Most of the calculation time is just calculating the starting point
 	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
 	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
 		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::zero();
 			//crawl in from negative infinity along a tangent line to get the closest fev
 			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
-		//continue forwards along the body parabola
+			//continue forwards along the body parabola
-		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 		})
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body;
-		//continue backwards along the body parabola
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
-		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//continue backwards along the body parabola
-			//no need to test -time<time_limit because of the first step
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			.map(|(face,time)|(face,-time))
+				//no need to test -time<time_limit because of the first step
 				.map(|(face,time)|(face,-time))
 		})
 	}
 	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
@@ -710,8 +811,20 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge
 	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
-		crate::minimum_difference::contains_point(self,point)
+		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
 		// Bound::Included means that the surface of the mesh is included in the mesh
 		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
 		let infinity_body=Body::new(point,vec3::Y,vec3::zero(),Time::ZERO);
 		//movement must escape the mesh forwards and backwards in time,
 		//otherwise the point is not inside the mesh
 		self.infinity_in(infinity_body)
    	.is_some_and(|_|
 			self.infinity_in(-infinity_body)
    		.is_some()
     	)
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -751,10 +864,8 @@ impl MeshQuery for MinkowskiMesh<'_>{
 		}
 	}
 	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
+		self.mesh1.transform.vertex.translation-
-	}
+		self.mesh0.transform.vertex.translation
 	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
 		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
--- a/engine/physics/src/physics.rs
+++ b/engine/physics/src/physics.rs
@@ -488,8 +488,21 @@ impl StyleHelper for StyleModifiers{
 	}
 }
 #[derive(Clone,Debug)]
 struct StrafeTickState{
 	tick_number:u64,
 }
 impl StrafeTickState{
 	fn next_tick(&self,settings:&gameplay_style::StrafeSettings)->Time{
 		let n=self.tick_number as i128;
 		let ticks=settings.tick_rate.num() as i128;
 		let seconds=settings.tick_rate.den() as i128;
 		let time=n*seconds/ticks;
 		Time::from_nanos(time as i64)
 	}
 }
 #[derive(Clone,Debug)]
 enum MoveState{
-	Air,
+	Air(StrafeTickState),
 	Walk(ContactMoveState),
 	Ladder(ContactMoveState),
 	#[expect(dead_code)]
@@ -497,11 +510,21 @@ enum MoveState{
 	Fly,
 }
 impl MoveState{
 	fn air(time:Time,settings:Option<&gameplay_style::StrafeSettings>)->Self{
 		let tick_number=if let Some(settings)=settings{
 			// let time=n*seconds/ticks;
 			let time=time.nanos() as i128;
 			let ticks=settings.tick_rate.num() as i128;
 			let seconds=settings.tick_rate.den() as i128;
 			(time*ticks/seconds) as u64
 		}else{0};
 		MoveState::Air(StrafeTickState{tick_number})
 	}
 	//call this after state.move_state is changed
 	fn apply_enum(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly=>body.acceleration=vec3::zero(),
-			MoveState::Air=>{
+			MoveState::Air(_)=>{
 				//calculate base acceleration
 				let a=touching.base_acceleration(models,style,camera,input_state);
 				//set_acceleration clips according to contacts
@@ -513,7 +536,7 @@ impl MoveState{
 	//function to coerce &mut self into &self
 	fn apply_to_body(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
-			MoveState::Air=>(),
+			MoveState::Air(_)=>(),
 			MoveState::Water=>(),
 			MoveState::Fly=>{
 				//set velocity according to current control state
@@ -534,7 +557,7 @@ impl MoveState{
 	fn apply_input(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly
-			|MoveState::Air
+			|MoveState::Air(_)
 			|MoveState::Water=>(),
 			MoveState::Walk(ContactMoveState{target,contact,jump_direction:_})=>{
 				if let Some(walk_settings)=&style.walk{
@@ -559,13 +582,13 @@ impl MoveState{
 			MoveState::Walk(walk_state)
 			|MoveState::Ladder(walk_state)
 			=>Some(walk_state),
-			MoveState::Air
+			MoveState::Air(_)
 			|MoveState::Water
 			|MoveState::Fly
 			=>None,
 		}
 	}
-	fn next_move_instruction(&self,strafe:&Option<gameplay_style::StrafeSettings>,time:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+	fn next_move_instruction(&self,strafe:Option<&gameplay_style::StrafeSettings>)->Option<TimedInstruction<InternalInstruction,Time>>{
 		//check if you have a valid walk state and create an instruction
 		match self{
 			MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>match &walk_state.target{
@@ -577,9 +600,9 @@ impl MoveState{
 				|TransientAcceleration::Reached
 				=>None,
 			}
-			MoveState::Air=>strafe.as_ref().map(|strafe|{
+			MoveState::Air(strafe_tick_state)=>strafe.as_ref().map(|strafe|{
 				TimedInstruction{
-					time:strafe.next_tick(time),
+					time:strafe_tick_state.next_tick(strafe),
 					//only poll the physics if there is a before and after mouse event
 					instruction:InternalInstruction::StrafeTick
 				}
@@ -607,7 +630,7 @@ impl MoveState{
 		//this function call reads the above state that was just set
 		self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
-	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState,time:Time){
 		//TODO: be more precise about contacts
 		if set_velocity_cull(body,touching,models,hitbox_mesh,velocity){
 			// TODO do better
@@ -615,7 +638,7 @@ impl MoveState{
 			match self.get_walk_state(){
 				// did you stop touching the thing you were walking on?
 				Some(walk_state)=>if !touching.contains_contact(&walk_state.contact.convex_mesh_id){
-					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
+					self.set_move_state(MoveState::air(time,style.strafe.as_ref()),body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
 					self.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
@@ -729,7 +752,7 @@ struct IntersectModel{
 	transform:PhysicsMeshTransform,
 }
-#[derive(Debug,Clone,Copy,Hash)]
+#[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
@@ -738,7 +761,7 @@ pub struct ContactCollision{
 pub struct IntersectCollision{
 	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
-#[derive(Debug,Clone,Hash)]
+#[derive(Debug,Clone,Eq,Hash,PartialEq)]
 pub enum Collision{
 	Contact(ContactCollision),
 	Intersect(IntersectCollision),
@@ -890,7 +913,7 @@ impl Default for PhysicsState{
 			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
-			move_state:MoveState::Air,
+			move_state:MoveState::air(Time::ZERO,None),
 			camera:PhysicsCamera::default(),
 			input_state:InputState::default(),
 			_world:WorldState{},
@@ -935,10 +958,10 @@ impl PhysicsState{
 		*self=Self::default();
 	}
 	fn next_move_instruction(&self)->Option<TimedInstruction<InternalInstruction,Time>>{
-		self.move_state.next_move_instruction(&self.style.strafe,self.time)
+		self.move_state.next_move_instruction(self.style.strafe.as_ref())
 	}
-	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3){
+	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3,time:Time){
-		self.move_state.cull_velocity(velocity,&mut self.body,&mut self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
+		self.move_state.cull_velocity(velocity,&mut self.body,&mut self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state,time);
 	}
 	fn set_move_state(&mut self,data:&PhysicsData,move_state:MoveState){
 		self.move_state.set_move_state(move_state,&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
@@ -1262,7 +1285,7 @@ fn recalculate_touching(
 	//I would have preferred while let Some(contact)=contacts.pop()
 	//but there is no such method
 	while let Some((&convex_mesh_id,_face_id))=touching.contacts.iter().next(){
-		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id)
+		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id,time)
 	}
 	while let Some(&convex_mesh_id)=touching.intersects.iter().next(){
 		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(convex_mesh_id.model_id),&convex_mesh_id,time);
@@ -1277,7 +1300,7 @@ fn recalculate_touching(
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-		if minkowski.contains_point(body.position){
+		if minkowski.is_point_in_mesh(body.position){
 			match convex_mesh_id.model_id{
 				//being inside of contact objects is an invalid physics state
 				//but the physics isn't advanced enough to do anything about it yet
@@ -1598,7 +1621,7 @@ fn collision_start_contact(
 				gameplay_attributes::SetTrajectory::TargetPointTime{..}=>todo!(),
 				gameplay_attributes::SetTrajectory::TargetPointSpeed{..}=>todo!(),
 				&gameplay_attributes::SetTrajectory::Velocity(velocity)=>{
-					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
+					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state,time);
 				},
 				gameplay_attributes::SetTrajectory::DotVelocity{..}=>todo!(),
 			}
@@ -1628,7 +1651,7 @@ fn collision_start_contact(
 			}else{
 				let jump_dir=walk_state.jump_direction.direction(models,hitbox_mesh,&walk_state.contact);
 				let jumped_velocity=jump_settings.jumped_velocity(style,jump_dir,body.velocity,attr.general.booster.as_ref());
-				move_state.cull_velocity(jumped_velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
+				move_state.cull_velocity(jumped_velocity,body,touching,models,hitbox_mesh,style,camera,input_state,time);
 			}
 		}
 	}
@@ -1658,7 +1681,7 @@ fn collision_start_intersect(
 	touching.insert_intersect(intersect);
 	//insta booster!
 	if let Some(booster)=&attr.general.booster{
-		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state);
+		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state,time);
 	}
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(intersect.convex_mesh_id.model_id.into());
@@ -1692,6 +1715,7 @@ fn collision_end_contact(
 	input_state:&InputState,
 	_attr:&gameplay_attributes::ContactAttributes,
 	convex_mesh_id:&ConvexMeshId<ContactModelId>,
 	time:Time,
 ){
 	touching.remove_contact(convex_mesh_id);//remove contact before calling contact_constrain_acceleration
 	//check ground
@@ -1702,7 +1726,7 @@ fn collision_end_contact(
 		// This does not check the face! Is that a bad thing? It should be
 		// impossible to stop touching a different face than you started touching...
 		Some(walk_state)=>if &walk_state.contact.convex_mesh_id==convex_mesh_id{
-			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
+			move_state.set_move_state(MoveState::air(time,style.strafe.as_ref()),body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
 			move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1781,7 +1805,8 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 				Collision::Contact(contact)=>collision_end_contact(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.models.contact_attr(contact.convex_mesh_id.model_id),
-					&contact.convex_mesh_id
+					&contact.convex_mesh_id,
 					state.time,
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
@@ -1793,6 +1818,11 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 				),
 			},
 			InternalInstruction::StrafeTick=>{
 				let strafe_tick_state=match &mut state.move_state{
 					MoveState::Air(strafe_tick_state)=>strafe_tick_state,
 					_=>panic!("StrafeTick fired for non-air MoveState"),
 				};
 				strafe_tick_state.tick_number+=1;
 				//TODO make this less huge
 				if let Some(strafe_settings)=&state.style.strafe{
 					let controls=state.input_state.controls;
@@ -1804,7 +1834,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 							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);
+								state.cull_velocity(data,ticked_velocity,state.time);
 							}
 						}
 					}
@@ -1812,7 +1842,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 			}
 			InternalInstruction::ReachWalkTargetVelocity=>{
 				match &mut state.move_state{
-					MoveState::Air
+					MoveState::Air(_)
 					|MoveState::Water
 					|MoveState::Fly
 					=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
@@ -1854,7 +1884,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 				|MoveState::Water
 				|MoveState::Walk(_)
 				|MoveState::Ladder(_)=>true,
-				MoveState::Air=>false,
+				MoveState::Air(_)=>false,
 			}
 		},
 		//the body must be updated unconditionally
@@ -1888,7 +1918,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 					let jump_dir=walk_state.jump_direction.direction(&data.models,&data.hitbox_mesh,&walk_state.contact);
 					let booster_option=data.models.contact_attr(walk_state.contact.convex_mesh_id.model_id).general.booster.as_ref();
 					let jumped_velocity=jump_settings.jumped_velocity(&state.style,jump_dir,state.body.velocity,booster_option);
-					state.cull_velocity(data,jumped_velocity);
+					state.cull_velocity(data,jumped_velocity,state.time);
 				}
 			}
 			b_refresh_walk_target=false;
@@ -1918,7 +1948,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			}
 			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);
+			state.set_move_state(data,MoveState::air(state.time,state.style.strafe.as_ref()));
 			b_refresh_walk_target=false;
 		}
 		// Spawn does not necessarily imply reset
@@ -1942,7 +1972,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Misc(MiscInstruction::PracticeFly)=>{
 			match &state.move_state{
 				MoveState::Fly=>{
-					state.set_move_state(data,MoveState::Air);
+					state.set_move_state(data,MoveState::air(state.time,state.style.strafe.as_ref()));
 				},
 				_=>{
 					state.set_move_state(data,MoveState::Fly);
@@ -1957,7 +1987,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 	}
 	if b_refresh_walk_target{
 		state.apply_input_and_body(data);
-		state.cull_velocity(data,state.body.velocity);
+		state.cull_velocity(data,state.body.velocity,state.time);
 		//also check if accelerating away from surface
 	}
 }
--- a/lib/common/src/gameplay_style.rs
+++ b/lib/common/src/gameplay_style.rs
@@ -2,7 +2,6 @@ const VALVE_SCALE:Planar64=Planar64::raw(1<<28);// 1/16
 use crate::integer::{int,vec3::int as int3,AbsoluteTime,Ratio64,Planar64,Planar64Vec3};
 use crate::controls_bitflag::Controls;
 use crate::physics::Time as PhysicsTime;
 #[derive(Clone,Debug)]
 pub struct StyleModifiers{
@@ -273,9 +272,6 @@ impl StrafeSettings{
 			false=>None,
 		}
 	}
 	pub fn next_tick(&self,time:PhysicsTime)->PhysicsTime{
 		PhysicsTime::from_nanos(self.tick_rate.rhs_div_int(self.tick_rate.mul_int(time.nanos())+1))
 	}
 	pub const fn activates(&self,controls:Controls)->bool{
 		self.enable.activates(controls)
 	}
--- a/lib/fixed_wide/src/fixed.rs
+++ b/lib/fixed_wide/src/fixed.rs
@@ -366,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 // This macro is not used in the default configuration.
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
--- a/lib/rbx_loader/Cargo.toml
+++ b/lib/rbx_loader/Cargo.toml
@@ -13,16 +13,16 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 bytemuck = "1.14.3"
 glam = "0.30.0"
 regex = { version = "1.11.3", default-features = false }
 rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
 rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"
 rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 rbx_binary = "2.0.1"
 rbx_dom_weak = "4.1.0"
 rbx_reflection = "6.1.0"
 rbx_reflection_database = "2.0.2"
 rbx_xml = "2.0.1"
 [lints]
 workspace = true
--- a/lib/rbx_loader/src/rbx.rs
+++ b/lib/rbx_loader/src/rbx.rs
@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|
--- a/lib/roblox_emulator/Cargo.toml
+++ b/lib/roblox_emulator/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,10 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection = "5.0.0"
+rbx_reflection = "6.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_types = "2.0.0"
+rbx_types = "3.1.0"
 [lints]
 workspace = true
--- a/lib/roblox_emulator/src/context.rs
+++ b/lib/roblox_emulator/src/context.rs
@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};
--- a/lib/roblox_emulator/src/runner/enum.rs
+++ b/lib/roblox_emulator/src/runner/enum.rs
@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }
--- a/lib/roblox_emulator/src/runner/instance/instance.rs
+++ b/lib/roblox_emulator/src/runner/instance/instance.rs
@@ -37,7 +37,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }
 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
@@ -80,14 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak
 }
 pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
 pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +282,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +344,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)
--- a/map-tool/Cargo.toml
+++ b/map-tool/Cargo.toml
@@ -13,10 +13,10 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_binary = "2.0.1"
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_xml = "2.0.1"
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
Author	SHA1	Message	Date
Rhys Lloyd	eb40c1a0d0	add StrafeTickState to allow 0 time strafe events	2025-12-10 18:19:22 -08:00
Rhys Lloyd	6ca6d5e484	expect dead code	2025-12-10 18:05:16 -08:00
Rhys Lloyd	0668ac2def	use allow instead of expect	2025-12-09 14:39:42 -08:00
Rhys Lloyd	73e3181d0c	roblox_emulator: v0.5.2	2025-11-27 16:42:01 -08:00
Rhys Lloyd	19ba8f2445	update deps	2025-11-27 15:50:19 -08:00
Rhys Lloyd	0495d07e26	update rbx-dom	2025-11-27 15:48:17 -08:00