comment infinite loop avoidance

.cargo/config.toml

@@ -1,2 +1,6 @@
 [registries.strafesnet]
-index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=/usr/bin/mold"]

lib/common/src/instruction.rs

@@ -6,16 +6,32 @@ pub struct TimedInstruction<I,T>{
 	pub instruction:I,
 }
 
-pub trait InstructionEmitter{
-	type Instruction;
+/// Ensure all emitted instructions are processed before consuming external instructions
+pub trait InstructionEmitter<I>{
 	type TimeInner;
-	fn next_instruction(&self,time_limit:Time<Self::TimeInner>)->Option<TimedInstruction<Self::Instruction,Self::TimeInner>>;
+	fn next_instruction(&self,time_limit:Time<Self::TimeInner>)->Option<TimedInstruction<I,Self::TimeInner>>;
 }
-pub trait InstructionConsumer{
-	type Instruction;
+/// Apply an atomic state update
+pub trait InstructionConsumer<I>{
 	type TimeInner;
-	fn process_instruction(&mut self, instruction:TimedInstruction<Self::Instruction,Self::TimeInner>);
+	fn process_instruction(&mut self,instruction:TimedInstruction<I,Self::TimeInner>);
 }
+/// If the object produces its own instructions, allow exhaustively feeding them back in
+pub trait InstructionFeedback<I,T>:InstructionEmitter<I,TimeInner=T>+InstructionConsumer<I,TimeInner=T>
+	where
+		Time<T>:Copy,
+{
+	fn process_exhaustive(&mut self,time_limit:Time<T>){
+		while let Some(instruction)=self.next_instruction(time_limit){
+			self.process_instruction(instruction);
+		}
+	}
+}
+impl<I,T,X> InstructionFeedback<I,T> for X
+	where
+		Time<T>:Copy,
+		X:InstructionEmitter<I,TimeInner=T>+InstructionConsumer<I,TimeInner=T>,
+{}
 
 //PROPER PRIVATE FIELDS!!!
 pub struct InstructionCollector<I,T>{

lib/fixed_wide/src/fixed.rs

@@ -1,6 +1,6 @@
 use bnum::{BInt,cast::As};
 
-#[derive(Clone,Copy,Debug,Default,Hash)]
+#[derive(Clone,Copy,Debug,Default,Hash,PartialEq,PartialOrd,Ord)]
 /// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
@@ -87,12 +87,6 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
-impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
-	#[inline]
-	fn eq(&self,other:&Self)->bool{
-		self.bits.eq(&other.bits)
-	}
-}
 impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
 where
 		T:Copy,
@@ -105,12 +99,6 @@ where
 }
 impl<const N:usize,const F:usize> Eq for Fixed<N,F>{}
 
-impl<const N:usize,const F:usize> PartialOrd for Fixed<N,F>{
-	#[inline]
-	fn partial_cmp(&self,other:&Self)->Option<std::cmp::Ordering>{
-		self.bits.partial_cmp(&other.bits)
-	}
-}
 impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 	where
 		T:Copy,
@@ -121,12 +109,6 @@ impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 		self.bits.partial_cmp(&other.into())
 	}
 }
-impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
-	#[inline]
-	fn cmp(&self,other:&Self)->std::cmp::Ordering{
-		self.bits.cmp(&other.bits)
-	}
-}
 
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;

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

@@ -33,7 +33,7 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 // LMAO look at this function!
 pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
 	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
-	f(&mut *dom)
+	f(*dom)
 }
 
 fn coerce_float32(value:&mlua::Value)->Option<f32>{

strafe-client/src/graphics_worker.rs

@@ -21,7 +21,6 @@ pub fn new<'a>(
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 )->crate::compat_worker::INWorker<'a,Instruction>{
-	let mut resize=None;
 	crate::compat_worker::INWorker::new(move |ins:Instruction|{
 		match ins{
 			Instruction::ChangeMap(map)=>{
@@ -29,18 +28,15 @@ pub fn new<'a>(
 				graphics.generate_models(&device,&queue,&map);
 			},
 			Instruction::Resize(size,user_settings)=>{
-				resize=Some((size,user_settings));
+				println!("Resizing to {:?}",size);
+				let t0=std::time::Instant::now();
+				config.width=size.width.max(1);
+				config.height=size.height.max(1);
+				surface.configure(&device,&config);
+				graphics.resize(&device,&config,&user_settings);
+				println!("Resize took {:?}",t0.elapsed());
 			}
 			Instruction::Render(frame_state)=>{
-				if let Some((size,user_settings))=resize.take(){
-					println!("Resizing to {:?}",size);
-					let t0=std::time::Instant::now();
-					config.width=size.width.max(1);
-					config.height=size.height.max(1);
-					surface.configure(&device,&config);
-					graphics.resize(&device,&config,&user_settings);
-					println!("Resize took {:?}",t0.elapsed());
-				}
 				//this has to go deeper somehow
 				let frame=match surface.get_current_texture(){
 					Ok(frame)=>frame,

strafe-client/src/physics.rs

@@ -9,7 +9,7 @@ use strafesnet_common::gameplay_attributes::{self,CollisionAttributesId};
 use strafesnet_common::gameplay_modes::{self,StageId};
 use strafesnet_common::gameplay_style::{self,StyleModifiers};
 use strafesnet_common::controls_bitflag::Controls;
-use strafesnet_common::instruction::{self,InstructionEmitter,InstructionConsumer,TimedInstruction};
+use strafesnet_common::instruction::{self,InstructionEmitter,InstructionConsumer,InstructionFeedback,TimedInstruction};
 use strafesnet_common::integer::{self,vec3,mat3,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64Vec2};
 pub use strafesnet_common::physics::{Time,TimeInner};
 use gameplay::ModeState;
@@ -773,10 +773,7 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		match crate::push_solve::push_solve(&contacts,*velocity){
-			Some(new_velocity)=>*velocity=new_velocity,
-			None=>println!("Algorithm silently failing :)"),
-		}
+		*velocity=crate::push_solve::push_solve(&contacts,*velocity);
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:&mut Planar64Vec3){
 		let contacts=self.contacts.iter().map(|contact|{
@@ -787,10 +784,7 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		match crate::push_solve::push_solve(&contacts,*acceleration){
-			Some(new_acceleration)=>*acceleration=new_acceleration,
-			None=>println!("Algorithm silently failing :)"),
-		}
+		*acceleration=crate::push_solve::push_solve(&contacts,*acceleration);
 	}
 	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<PhysicsInternalInstruction,TimeInner>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,time:Time){
 		let relative_body=crate::body::VirtualBody::relative(&Body::ZERO,body).body(time);
@@ -941,16 +935,21 @@ pub struct PhysicsContext{
 	state:PhysicsState,//this captures the entire state of the physics.
 	data:PhysicsData,//data currently loaded into memory which is needded for physics to run, but is not part of the state.
 }
-//the physics consumes the generic PhysicsInstruction, but can only emit the more narrow PhysicsInternalInstruction
-impl instruction::InstructionConsumer for PhysicsContext{
-	type Instruction=PhysicsInstruction;
+// the physics consumes both PhysicsInputInstruction and PhysicsInternalInstruction,
+// but can only emit PhysicsInternalInstruction
+impl InstructionConsumer<PhysicsInternalInstruction> for PhysicsContext{
 	type TimeInner=TimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<PhysicsInstruction,TimeInner>){
-		atomic_state_update(&mut self.state,&self.data,ins)
+	fn process_instruction(&mut self,ins:TimedInstruction<PhysicsInternalInstruction,TimeInner>){
+		atomic_internal_instruction(&mut self.state,&self.data,ins)
 	}
 }
-impl instruction::InstructionEmitter for PhysicsContext{
-	type Instruction=PhysicsInternalInstruction;
+impl InstructionConsumer<PhysicsInputInstruction> for PhysicsContext{
+	type TimeInner=TimeInner;
+	fn process_instruction(&mut self,ins:TimedInstruction<PhysicsInputInstruction,TimeInner>){
+		atomic_input_instruction(&mut self.state,&self.data,ins)
+	}
+}
+impl InstructionEmitter<PhysicsInternalInstruction> for PhysicsContext{
 	type TimeInner=TimeInner;
 	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
 	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<PhysicsInternalInstruction,TimeInner>>{
@@ -1110,24 +1109,9 @@ impl PhysicsContext{
 		println!("Physics Objects: {}",model_count);
 	}
 
-	//tickless gaming
-	fn run_internal_exhaustive(&mut self,time_limit:Time){
-		//prepare is ommitted - everything is done via instructions.
-		while let Some(instruction)=self.next_instruction(time_limit){//collect
-			//process
-			self.process_instruction(TimedInstruction{
-				time:instruction.time,
-				instruction:PhysicsInstruction::Internal(instruction.instruction),
-			});
-			//write hash lol
-		}
-	}
 	pub fn run_input_instruction(&mut self,instruction:TimedInstruction<PhysicsInputInstruction,TimeInner>){
-		self.run_internal_exhaustive(instruction.time);
-		self.process_instruction(TimedInstruction{
-			time:instruction.time,
-			instruction:PhysicsInstruction::Input(instruction.instruction),
-		});
+		self.process_exhaustive(instruction.time);
+		self.process_instruction(instruction);
 	}
 }
 
@@ -1154,6 +1138,7 @@ impl PhysicsContext{
 			collector.collect(minkowski.predict_collision_in(relative_body,collector.time())
 				//temp (?) code to avoid collision loops
 				.map_or(None,|(face,dt)|{
+					// this must be rounded to avoid the infinite loop when hitting the start zone
 					let time=relative_body.time+dt.into();
 					if time<=state.time{None}else{Some((time,face,dt))}})
 				.map(|(time,face,dt)|
@@ -1887,26 +1872,6 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 				}
 }
 
-	fn atomic_state_update(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<PhysicsInstruction,TimeInner>){
-		match &ins.instruction{
-			PhysicsInstruction::Input(PhysicsInputInstruction::Idle)
-			|PhysicsInstruction::Input(PhysicsInputInstruction::SetNextMouse(_))
-			|PhysicsInstruction::Input(PhysicsInputInstruction::ReplaceMouse(_,_))
-			|PhysicsInstruction::Internal(PhysicsInternalInstruction::StrafeTick)
-			|PhysicsInstruction::Internal(PhysicsInternalInstruction::ReachWalkTargetVelocity)=>(),
-			_=>println!("{}|{:?}",ins.time,ins.instruction),
-		}
-		if ins.time<state.time{
-			println!("@@@@ Time travel warning! state.time={} ins.time={}\nInstruction={:?}",state.time,ins.time,ins.instruction);
-		}
-		//idle is special, it is specifically a no-op to get Internal events to catch up to real time
-		match ins.instruction{
-			PhysicsInstruction::Input(PhysicsInputInstruction::Idle)=>(),
-			PhysicsInstruction::Internal(instruction)=>atomic_internal_instruction(state,data,TimedInstruction{time:ins.time,instruction}),
-			PhysicsInstruction::Input(instruction)=>atomic_input_instruction(state,data,TimedInstruction{time:ins.time,instruction}),
-		}
-	}
-
 #[cfg(test)]
 mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};

strafe-client/src/push_solve.rs

@@ -164,8 +164,8 @@ fn is_space_enclosed_4(
 		||is_space_enclosed_3(b,c,d)
 }
 
-const fn get_push_ray_0(point:Planar64Vec3)->Option<Ray>{
-	Some(Ray{origin:point,direction:vec3::ZERO})
+const fn get_push_ray_0(point:Planar64Vec3)->Ray{
+	Ray{origin:point,direction:vec3::ZERO}
 }
 fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
 	let direction=solve1(c0)?.divide().fix_1();
@@ -204,11 +204,8 @@ fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Optio
 	Some(Ray{origin,direction})
 }
 
-const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->Option<(Ray,Conts<'a>)>{
-	match get_push_ray_0(point){
-		Some(ray)=>Some((ray,Conts::new_const())),
-		None=>None,
-	}
+const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->(Ray,Conts<'a>){
+	(get_push_ray_0(point),Conts::new_const())
 }
 fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
 	get_push_ray_1(point,c0)
@@ -280,14 +277,14 @@ fn get_best_push_ray_and_conts_4<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Co
 
 fn get_best_push_ray_and_conts<'a>(
 	point:Planar64Vec3,
-	conts:Conts<'a>,
+	conts:&[&'a Contact],
 )->Option<(Ray,Conts<'a>)>{
-	match conts.as_slice(){
+	match conts{
 		&[c0,c1,c2,c3]=>get_best_push_ray_and_conts_4(point,c0,c1,c2,c3),
 		&[c0,c1,c2]=>get_best_push_ray_and_conts_3(point,c0,c1,c2),
 		&[c0,c1]=>get_best_push_ray_and_conts_2(point,c0,c1),
 		&[c0]=>get_best_push_ray_and_conts_1(point,c0),
-		&[]=>get_best_push_ray_and_conts_0(point),
+		&[]=>Some(get_best_push_ray_and_conts_0(point)),
 		_=>unreachable!(),
 	}
 }
@@ -302,17 +299,16 @@ fn get_first_touch<'a>(contacts:&'a Vec<Contact>,ray:&Ray,conts:&Conts)->Option<
 		.min_by_key(|&(t,_)|t)
 }
 
-pub fn push_solve(contacts:&Vec<Contact>,point:Planar64Vec3)->Option<Planar64Vec3>{
-	const ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
-	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point)?;
+pub fn push_solve(contacts:&Vec<Contact>,point:Planar64Vec3)->Planar64Vec3{
+	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
 	loop{
 		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
-			Some((t,conts))=>(t,conts),
-			None=>return Some(ray.origin),
+			Some((t,cont))=>(t,cont),
+			None=>return ray.origin,
 		};
 
-		if ZERO.le_ratio(next_t){
-			return Some(ray.origin);
+		if RATIO_ZERO.le_ratio(next_t){
+			return ray.origin;
 		}
 
 		//push_front
@@ -326,9 +322,9 @@ pub fn push_solve(contacts:&Vec<Contact>,point:Planar64Vec3)->Option<Planar64Vec
 		}
 
 		let meet_point=ray.extrapolate(next_t);
-		match get_best_push_ray_and_conts(meet_point,conts){
+		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
 			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return Some(meet_point),
+			None=>return meet_point,
 		}
 	}
 }
@@ -346,7 +342,7 @@ mod tests{
 			}
 		];
 		assert_eq!(
-			Some(vec3::ZERO),
+			vec3::ZERO,
 			push_solve(&contacts,vec3::NEG_Y)
 		);
 	}