the bug

these were supposed to be 3 voxels but were on the order of 3 units

engine/physics/src/minimum_difference.rs

@@ -355,6 +355,10 @@ fn reduce4<M:MeshQuery>(
 	let mut u=p1-p0;
 	let mut v=p2-p0;
 	let w=p3-p0;
+	println!("p={p}");
+	println!("u={u}");
+	println!("v={v}");
+	println!("w={w}");
 
 	// local uv = u:Cross(v)
 	// local vw = v:Cross(w)
@@ -425,20 +429,28 @@ fn reduce4<M:MeshQuery>(
 	let pv=p.cross(v);
 	let uv_up=uv.dot(up);
 	let uv_pv=uv.dot(pv);
+	println!("up={up}");
+	println!("pv={pv}");
+	println!("uv_up={uv_up}");
+	println!("uv_pv={uv_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
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			println!("a");
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		});
+			println!("b");
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}
 
 	// local u_u = u:Dot(u)
@@ -470,17 +482,22 @@ fn reduce4<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
-			let dir=if uv_w.is_negative(){
-				narrow_dir2(uv)
+			if uv_w.is_negative(){
+				println!("c");
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
 			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
+				println!("d");
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(-uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}
 
+		println!("e");
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
 			dir:narrow_dir3(direction),
@@ -493,17 +510,22 @@ fn reduce4<M:MeshQuery>(
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			println!("f");
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			println!("g");
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}
 
+	println!("h");
 	// return direction, a0, a1
 	Reduce::Reduced(Reduced{
 		dir,
@@ -730,28 +752,30 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 	}
 }
 
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+#[derive(Debug)]
+pub struct InfiniteLoop;
+pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
 	println!("=== LUA ===");
 	let (hits,_details)=crate::minimum_difference_lua::minimum_difference_details(mesh,point).unwrap();
 	println!("=== RUST ===");
-	let closest_fev_not_inside=closest_fev_not_inside_inner(mesh,point);
+	let closest_fev_not_inside=closest_fev_not_inside_inner(mesh,point).unwrap();
 	assert_eq!(hits,closest_fev_not_inside.is_none(),"algorithms disagree");
-	closest_fev_not_inside
+	Ok(closest_fev_not_inside)
 }
 
-fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+pub fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
 	const ENABLE_FAST_FAIL:bool=false;
 	// TODO: remove mesh negation
 	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
-			println!("on_exact is_intersecting={is_intersecting} simplex={simplex:?}");
+			println!("on_exact simplex={simplex:?}");
 			if is_intersecting{
-				return None;
+				return Ok(None);
 			}
 			// Convert simplex to FEV
 			// Vertices must be inverted since the mesh is inverted
-			Some(match simplex{
+			Ok(Some(match simplex{
 				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
@@ -766,17 +790,18 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 					// return E or V in edge cases but I don't think that will break the face crawler
 					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
 				},
-			})
+			}))
 		},
 		// 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
+			Ok(None)
 		},
 		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!()
+		||unreachable!(),
+		||Err(InfiniteLoop),
 	)
 }
 
@@ -794,7 +819,9 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 			true
 		},
 		// fast_fail value
-		||false
+		||false,
+		// infinite loop
+		||false,
 	)
 }
 
@@ -809,6 +836,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	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,
+	on_infinite_loop:impl FnOnce()->T,
 )->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
@@ -827,7 +855,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
-	loop{
+	for _ in 0..100{
 		println!("direction={direction}");
 
 		// new_point_p = queryP(-direction)
@@ -881,6 +909,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// next loop this will be a
 		last_pos=next_pos;
 	}
+	on_infinite_loop()
 }
 
 #[cfg(test)]
@@ -902,7 +931,8 @@ mod test{
 				true
 			},
 			// fast_fail value
-			||false
+			||false,
+			||false,
 		)
 	}
 

engine/physics/src/minimum_difference_lua.rs

@@ -163,7 +163,7 @@ struct Ctx{
 	f:Function,
 }
 fn init_lua()->LuaResult<Ctx>{
-	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("/home/quat/strafesnet/strafe-project/Trey-MinimumDifference.lua").unwrap());
+	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("Trey-MinimumDifference.lua").unwrap());
 	let lua=Lua::new();
 	lua.sandbox(true)?;
 	let lib_f=lua.load(SOURCE.as_str()).set_name("Trey-MinimumDifference").into_function()?;

engine/physics/src/model.rs

@@ -597,7 +597,7 @@ impl core::ops::Neg for MinkowskiVert{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -612,7 +612,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -670,12 +670,14 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	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)?;
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
+		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?else{
+			return Ok(None);
+		};
 		//continue forwards along the body parabola
-		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		Ok(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)>{
+	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
 		// TODO: handle unbounded collision using infinity fev
 		let time=match upper_bound{
@@ -683,14 +685,16 @@ impl MinkowskiMesh<'_>{
 			Bound::Excluded(&time)=>time,
 			Bound::Unbounded=>unimplemented!("unbounded collision out"),
 		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?;
+		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?else{
+			return Ok(None);
+		};
 		// 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
-		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+		Ok(fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
 			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time))
+			.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

engine/physics/src/physics.rs

@@ -828,7 +828,7 @@ impl TouchingState{
 		}).collect();
 		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time)->Result<(),crate::minimum_difference::InfiniteLoop>{
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
 		for (convex_mesh_id,face_id) in &self.contacts{
@@ -849,7 +849,7 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time())?.map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -859,6 +859,7 @@ impl TouchingState{
 				}
 			}));
 		}
+		Ok(())
 	}
 }
 
@@ -1199,7 +1200,7 @@ impl<'a> PhysicsContext<'a>{
 		collector.collect(state.next_move_instruction());
 
 		//check for collision ends
-		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
+		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time).unwrap();
 		//check for collision starts
 		let mut aabb=aabb::Aabb::default();
 		state.body.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1214,17 +1215,17 @@ impl<'a> PhysicsContext<'a>{
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(*convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
-				.map(|(face,dt)|
-					TimedInstruction{
-						time:relative_body.time+dt.into(),
-						instruction:InternalInstruction::CollisionStart(
-							Collision::new(*convex_mesh_id,face),
-							dt
-						)
-					}
+			let Ok(collision)=minkowski.predict_collision_in(relative_body,state.time..collector.time())else{
+				println!("Infinite loop! body={relative_body}");
+				return;
+			};
+			collector.collect(collision.map(|(face,dt)|TimedInstruction{
+				time:relative_body.time+dt.into(),
+				instruction:InternalInstruction::CollisionStart(
+					Collision::new(*convex_mesh_id,face),
+					dt
 				)
-			);
+			}));
 		});
 		collector.take()
 	}
@@ -1972,7 +1973,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10)).unwrap();
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1990,7 +1991,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10)).unwrap();
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){

engine/session/src/session.rs

@@ -52,6 +52,7 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
+	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -252,14 +253,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				match &self.view_state{
-					ViewState::Play=>{
-						_=self.simulation.timer.set_paused(ins.time,paused);
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,paused);
-					},
-				}
+				_=self.simulation.timer.set_paused(ins.time,paused);
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -380,6 +374,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);

integration-testing/src/test_scenes.rs

@@ -115,3 +115,40 @@ fn bug_3(){
 	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }
+
+fn test_scene_cylinder()->PhysicsData{
+	let mut builder=TestSceneBuilder::new();
+	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
+	let mesh=builder.push_mesh(strafesnet_rbx_loader::primitives::unit_cylinder(cube_face_description));
+	// place one 5x5x5 cylinder.
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::from_diagonal(vec3::int(5,5,5)>>1),
+		vec3::int(0,-5,0)
+	));
+	builder.build()
+}
+
+#[test]
+fn test_minimum_difference(){
+	let physics_data=test_scene_cylinder();
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::int(4,1,4)>>1,
+		vec3::int(-1,-1,-2),
+		vec3::int(0,-100,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	physics.style_mut().gravity=vec3::zero();
+	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(3))
+		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
+	// touch side of part at 0,0,0
+	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
+	// touch top of part at 5,-5,0
+	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
+	assert!(phys_iter.next().is_none());
+	let body=physics.body();
+	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
+	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
+	assert_eq!(body.time,Time::from_secs(2));
+}

integration-testing/src/tests.rs

@@ -74,3 +74,39 @@ fn physics_bug_3()->Result<(),ReplayError>{
 
 	Ok(())
 }
+
+// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
+// Infinite loop! body=p(-2382.440, 160.150, -379.151) v(53.632, 35.779, 44.904) a(0.000, -100.000, 0.000) t(306s+675758543ns)
+// Infinite loop! body=p(-1798.724, 731.459, 68.784) v(-17.389, 0.000, -78.087) a(0.000, 0.000, 0.000) t(284s+006980061ns)
+// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
+// Infinite loop! body=p(-1797.504, 738.529, 74.864) v(-3.653, 0.000, -79.917) a(0.000, 0.000, 0.000) t(282s+709871336ns)
+// Infinite loop! body=p(-1797.569, 735.449, 71.859) v(23.726, -76.309, -3.747) a(0.000, 0.000, 0.000) t(283s+325193187ns)
+
+#[test]
+fn physics_md_infinite_loop()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	println!("generating models..");
+	let physics_data=PhysicsData::new(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	use strafesnet_common::integer::{vec3,Time};
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::try_from_f32_array([-1796.657, 677.618, 36.959]).unwrap(),
+		vec3::try_from_f32_array([3.158, -53.650, -34.435]).unwrap(),
+		vec3::int(0,-100,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	// wait one second to activate the bug
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}

lib/rbx_loader/Cargo.toml

@@ -12,7 +12,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
+regex = { version = "1.11.3", default-features = false }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }

strafe-client/models/teslacyberv3.0.mtl

@@ -0,0 +1,62 @@
+# Blender MTL File: 'teslacyberv3.0.blend'
+# Material Count: 6
+
+newmtl Material
+Ns 65.476285
+Ka 1.000000 1.000000 1.000000
+Kd 0.411568 0.411568 0.411568
+Ks 0.614679 0.614679 0.614679
+Ke 0.000000 0.000000 0.000000
+Ni 36.750000
+d 1.000000
+illum 3
+
+newmtl Материал
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2
+
+newmtl Материал.001
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.026240 0.026240 0.026240
+Ks 0.000000 0.000000 0.000000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 1
+
+newmtl Материал.002
+Ns 0.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.031837 0.032429 0.029425
+Ks 0.169725 0.169725 0.169725
+Ke 0.000000 0.000000 0.000000
+Ni 0.000000
+d 1.000000
+illum 2
+
+newmtl Материал.003
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.023585 0.083235 0.095923
+Ks 1.000000 1.000000 1.000000
+Ke 0.000000 0.000000 0.000000
+Ni 45.049999
+d 1.000000
+illum 3
+
+newmtl Материал.004
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2

strafe-client/src/window.rs

@@ -15,7 +15,6 @@ pub enum Instruction{
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
 	mouse_pos:glam::DVec2,
-	simulation_paused:bool,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
@@ -25,35 +24,6 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
-	fn free_mouse(&mut self){
-		self.manual_mouse_lock=false;
-		match self.window.set_cursor_position(self.get_middle_of_screen()){
-			Ok(())=>(),
-			Err(e)=>println!("Could not set cursor position: {:?}",e),
-		}
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
-			Ok(())=>(),
-			Err(e)=>println!("Could not release cursor: {:?}",e),
-		}
-		self.window.set_cursor_visible(true);
-	}
-	fn lock_mouse(&mut self){
-		//if cursor is outside window don't lock but apparently there's no get pos function
-		//let pos=window.get_cursor_pos();
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
-			Ok(())=>(),
-			Err(_)=>{
-				match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
-					Ok(())=>(),
-					Err(e)=>{
-						self.manual_mouse_lock=true;
-						println!("Could not confine cursor: {:?}",e)
-					},
-				}
-			}
-		}
-		self.window.set_cursor_visible(false);
-	}
 	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
@@ -64,10 +34,6 @@ impl WindowContext<'_>{
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
-				// don't unpause if manually paused
-				if self.simulation_paused{
-					return;
-				}
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
@@ -80,8 +46,35 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>self.free_mouse(),
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>self.lock_mouse(),
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>{
+						self.manual_mouse_lock=false;
+						match self.window.set_cursor_position(self.get_middle_of_screen()){
+							Ok(())=>(),
+							Err(e)=>println!("Could not set cursor position: {:?}",e),
+						}
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+							Ok(())=>(),
+							Err(e)=>println!("Could not release cursor: {:?}",e),
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>{
+						//if cursor is outside window don't lock but apparently there's no get pos function
+						//let pos=window.get_cursor_pos();
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+							Ok(())=>(),
+							Err(_)=>{
+								match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+									Ok(())=>(),
+									Err(e)=>{
+										self.manual_mouse_lock=true;
+										println!("Could not confine cursor: {:?}",e)
+									},
+								}
+							}
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
 					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -139,16 +132,7 @@ impl WindowContext<'_>{
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
 							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
-								let paused=!self.simulation_paused;
-								self.simulation_paused=paused;
-								if paused{
-									self.free_mouse();
-								}else{
-									self.lock_mouse();
-								}
-								Some(SessionInstructionSubset::Control(SessionControlInstruction::SetPaused(paused)))
-							}else{None},
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
@@ -257,7 +241,6 @@ pub fn worker<'a>(
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,
-		simulation_paused:false,
 		//make sure to update this!!!!!
 		screen_size,
 		window,