diff --git a/src/face_crawler.rs b/src/face_crawler.rs
index 663384c..63915bb 100644
--- a/src/face_crawler.rs
+++ b/src/face_crawler.rs
@@ -3,24 +3,18 @@ use crate::model_physics::{FEV,MeshQuery};
 use crate::integer::{Time,Planar64};
 use crate::zeroes::zeroes2;
 
-struct State<FEV>{
-	fev:FEV,
-	time:Time,
-}
-
 enum Transition<F,E,V>{
 	Miss,
 	Next(FEV<F,E,V>,Time),
 	Hit(F,Time),
 }
 
-impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
-	fn next_transition(&self,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
+	pub fn next_transition_body<F:Copy,E:Copy,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_time=time_limit;
 		let mut best_transtition=Transition::Miss;
-		match &self.fev{
+		match fev{
 			&FEV::<F,E,V>::Face(face_id)=>{
 				//test own face collision time, ignoring roots with zero or conflicting derivative
 				//n=face.normal d=face.dot
@@ -28,7 +22,7 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 				let (n,d)=mesh.face_nd(face_id);
 				for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 					let t=body.time+Time::from(t);
-					if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+					if time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 						best_time=t;
 						best_transtition=Transition::Hit(face_id,t);
 					}
@@ -41,7 +35,7 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 					let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
 					for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
 							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
 							break;
@@ -59,7 +53,7 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 					let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
 					for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
 							best_transtition=Transition::Next(FEV::<F,E,V>::Face(test_face_id),t);
 							break;
@@ -72,7 +66,7 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 					let d=n.dot(mesh.vert(vert_id));
 					for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
 							best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
 							break;
@@ -88,7 +82,7 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 					let d=n.dot(mesh.vert(vert_id));
 					for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
 							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
 							break;
@@ -100,27 +94,13 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
 		}
 		best_transtition
 	}
-}
-
-pub fn predict_collision<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time)->Option<(F,Time)>{
-	let mut state=State{
-		fev:mesh.closest_fev(relative_body.position),
-		time:relative_body.time,
-	};
-	//it would be possible to write down the point of closest approach...
+pub fn crawl_fev_body<F:Copy,E:Copy,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time)->Option<(F,Time)>{	
+	let mut time=relative_body.time;
 	loop{
-		match state.next_transition(mesh,relative_body,time_limit){
+		match next_transition_body(&fev,time,mesh,relative_body,time_limit){
 			Transition::Miss=>return None,
-			Transition::Next(fev,time)=>(state.fev,state.time)=(fev,time),
+			Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
 			Transition::Hit(face,time)=>return Some((face,time)),
 		}
 	}
 }
-
-pub fn predict_collision_end<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time,ignore_face_id:F)->Option<(F,Time)>{
-	//imagine the mesh without the collision face
-	//no algorithm needed, there is only one state and three cases (Face,Edge,None)
-	//determine when it passes an edge ("sliding off" case) or if it leaves the surface directly
-	//the state can be constructed from the ContactCollision directly
-	None
-}
diff --git a/src/model_physics.rs b/src/model_physics.rs
index a3cc277..8b16801 100644
--- a/src/model_physics.rs
+++ b/src/model_physics.rs
@@ -325,6 +325,31 @@ impl MinkowskiMesh<'_>{
 		//put some genius code right here
 		todo!()
 	}
+	pub fn predict_collision(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
+		crate::face_crawler::crawl_fev_body(self.closest_fev(relative_body.position),self,relative_body,time_limit)
+	}
+	pub fn predict_collision_end(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,crate::integer::Time)>{
+		//no algorithm needed, there is only one state and two cases (Edge,None)
+		//determine when it passes an edge ("sliding off" case)
+		let mut best_time=time_limit;
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		for &edge_id in self.face_edges(contact_face_id).iter(){
+			let edge_n=self.edge_n(edge_id);
+			let n=face_n.cross(edge_n);
+			//picking a vert randomly is terrible
+			let d=n.dot(self.vert(self.edge_verts(edge_id)[0]));
+			for t in crate::zeroes::zeroes2((n.dot(relative_body.position)-d)*2,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
+				let t=relative_body.time+crate::integer::Time::from(t);
+				if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
+					best_time=t;
+					best_edge=Some(edge_id);
+					break;
+				}
+			}
+		}
+		best_edge.map(|e|(e,best_time))
+	}
 }
 impl MeshQuery<MinkowskiFace,MinkowskiEdge,MinkowskiVert> for MinkowskiMesh<'_>{
 	fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){