Fix movement inputs when holding shift

Cargo.lock

@@ -324,9 +324,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.1.24"
+version = "1.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812acba72f0a070b003d3697490d2b55b837230ae7c6c6497f05cc2ddbb8d938"
+checksum = "e8d9e0b4957f635b8d3da819d0db5603620467ecf1f692d22a8c2717ce27e6d8"
 dependencies = [
  "jobserver",
  "libc",
@@ -1933,9 +1933,9 @@ dependencies = [
 
 [[package]]
 name = "roblox_emulator"
-version = "0.2.3"
+version = "0.4.1"
 source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "2fa2c785a17f607aad6bdd19eef6d19f9476f308ce38de139df931a99132bd46"
+checksum = "6935943e8d473c8d19b52623877bee18421743072e2675730886d13592008266"
 dependencies = [
  "glam",
  "mlua",
@@ -2107,7 +2107,6 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 name = "strafe-client"
 version = "0.10.5"
 dependencies = [
- "arrayvec",
  "bytemuck",
  "configparser",
  "ddsfile",
@@ -2153,9 +2152,9 @@ dependencies = [
 
 [[package]]
 name = "strafesnet_deferred_loader"
-version = "0.4.0"
+version = "0.4.1"
 source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "9985192a282473ddd40d03114e67afe057cba031bea665e9020b139a621afb07"
+checksum = "cb47034893e945c640063a6c0fb09c6186dcc9f0b221b8c41f5a22070fe430f4"
 dependencies = [
  "strafesnet_common",
  "url",
@@ -2164,9 +2163,9 @@ dependencies = [
 
 [[package]]
 name = "strafesnet_rbx_loader"
-version = "0.4.1"
+version = "0.5.2"
 source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "a1540fa66518857886cf4094dc597b3228341046d8973ccc70196fb52a47105b"
+checksum = "bb852ee329d26410daee50f1e583ea8286caf6a81a42ff887b78f21477c48731"
 dependencies = [
  "bytemuck",
  "glam",
@@ -2367,9 +2366,9 @@ checksum = "5be21190ff5d38e8b4a2d3b6a3ae57f612cc39c96e83cedeaf7abc338a8bac4a"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.15"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893"
 
 [[package]]
 name = "unicode-ident"

Cargo.toml

@@ -15,7 +15,6 @@ source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
-arrayvec = "0.7.6"
 bytemuck = { version = "1.13.1", features = ["derive"] }
 configparser = "3.0.2"
 ddsfile = "0.5.1"
@@ -26,7 +25,7 @@ pollster = "0.3.0"
 strafesnet_bsp_loader = { version = "0.2.1", registry = "strafesnet", optional = true }
 strafesnet_common = { version = "0.5.2", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.4.0", features = ["legacy"], registry = "strafesnet", optional = true }
-strafesnet_rbx_loader = { version = "0.4.1", registry = "strafesnet", optional = true }
+strafesnet_rbx_loader = { version = "0.5.1", registry = "strafesnet", optional = true }
 strafesnet_snf = { version = "0.2.0", registry = "strafesnet", optional = true }
 wgpu = "22.1.0"
 winit = "0.30.5"

src/file.rs

@@ -22,7 +22,7 @@ impl std::error::Error for ReadError{}
 
 pub enum DataStructure{
 	#[cfg(feature="roblox")]
-	Roblox(strafesnet_rbx_loader::Dom),
+	Roblox(strafesnet_rbx_loader::Model),
 	#[cfg(feature="source")]
 	Source(strafesnet_bsp_loader::Bsp),
 	#[cfg(feature="snf")]
@@ -66,15 +66,16 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
 		#[cfg(feature="snf")]
 		DataStructure::StrafesNET(map)=>Ok(map),
 		#[cfg(feature="roblox")]
-		DataStructure::Roblox(mut dom)=>{
-			dom.run_scripts();
+		DataStructure::Roblox(model)=>{
+			let mut place=model.into_place();
+			place.run_scripts();
 
 			let mut loader=strafesnet_deferred_loader::roblox_legacy();
 
 			let (texture_loader,mesh_loader)=loader.get_inner_mut();
 
 			let map_step1=strafesnet_rbx_loader::convert(
-				&dom,
+				&place,
 				|name|texture_loader.acquire_render_config_id(name),
 				|name|mesh_loader.acquire_mesh_id(name),
 			);

src/main.rs

@@ -5,7 +5,6 @@ mod worker;
 mod physics;
 mod graphics;
 mod settings;
-mod push_solve;
 mod face_crawler;
 mod compat_worker;
 mod model_physics;

src/physics.rs

@@ -766,31 +766,23 @@ impl TouchingState{
 		a
 	}
 	fn constrain_velocity(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,velocity:&mut Planar64Vec3){
-		let contacts=self.contacts.iter().map(|contact|{
+		//TODO: trey push solve
+		for contact in &self.contacts{
 			let n=contact_normal(models,hitbox_mesh,contact);
-			crate::push_solve::Contact{
-				position:Planar64Vec3::ZERO,
-				velocity:n,
-				normal:n,
+			let d=n.dot(*velocity);
+			if d.is_negative(){
+				*velocity-=(n*d/n.length_squared()).divide().fix_1();
 			}
-		}).collect();
-		match crate::push_solve::push_solve(&contacts,*velocity){
-			Some(new_velocity)=>*velocity=new_velocity,
-			None=>println!("Algorithm silently failing :)"),
 		}
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:&mut Planar64Vec3){
-		let contacts=self.contacts.iter().map(|contact|{
+		//TODO: trey push solve
+		for contact in &self.contacts{
 			let n=contact_normal(models,hitbox_mesh,contact);
-			crate::push_solve::Contact{
-				position:Planar64Vec3::ZERO,
-				velocity:n,
-				normal:n,
+			let d=n.dot(*acceleration);
+			if d.is_negative(){
+				*acceleration-=(n*d/n.length_squared()).divide().fix_1();
 			}
-		}).collect();
-		match crate::push_solve::push_solve(&contacts,*acceleration){
-			Some(new_acceleration)=>*acceleration=new_acceleration,
-			None=>println!("Algorithm silently failing :)"),
 		}
 	}
 	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<PhysicsInternalInstruction>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,time:Time){
@@ -885,8 +877,7 @@ impl Body{
 			T1:integer::Fix<Planar64>,
 	{
 		// a*dt + v
-		self.acceleration.map(|elem|dt*elem)
-		.map(|elem|elem.divide().fix())+self.velocity
+		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
 	}
 	pub fn advance_time_ratio_dt(&mut self,dt:model_physics::GigaTime){
 		self.position=self.extrapolated_position_ratio_dt(dt);

src/push_solve.rs

@@ -1,321 +0,0 @@
-use strafesnet_common::integer::{vec3::{self, Vector3}, Fixed, Planar64, Planar64Vec3, Ratio};
-
-// This algorithm is based on Lua code
-// written by Trey Reynolds in 2021
-
-// 1/2^10
-const EPSILON:Planar64=Planar64::raw(1<<(32-10));
-
-// A stack-allocated variable-size list that holds up to 4 elements
-// Direct references are used instead of indices i0, i1, i2, i3
-type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
-
-struct Ray{
-	origin:Planar64Vec3,
-	direction:Planar64Vec3,
-}
-impl Ray{
-	fn extrapolate(&self,t:Planar64)->Planar64Vec3{
-		self.origin+self.direction*t
-	}
-}
-
-/// Information about a contact restriction
-pub struct Contact{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub normal:Planar64Vec3,
-}
-impl Contact{
-	fn relative_to(&self,point:Planar64Vec3)->Self{
-		Self{
-			position:self.position-point,
-			velocity:self.velocity,
-			normal:self.normal,
-		}
-	}
-	fn relative_dot(&self,direction:Planar64Vec3)->Fixed<2,64>{
-		(direction-self.velocity).dot(self.normal)
-	}
-	/// Calculate the time of intersection. (previously get_touch_time)
-	fn solve(&self,ray:&Ray)->Ratio<Fixed<2,64>,Fixed<2,64>>{
-		(self.position-ray.origin).dot(self.normal)/(ray.direction-self.velocity).dot(self.normal)
-	}
-}
-
-//note that this is horrible with fixed point arithmetic
-fn solve1(c0:&Contact)->Ratio<Vector3<Fixed<3,96>>,Fixed<2,64>>{
-	let det=c0.normal.dot(c0.velocity);
-	let d0=c0.normal.dot(c0.position);
-	c0.normal*d0/det
-}
-fn solve2(c0:&Contact,c1:&Contact)->Ratio<Vector3<Fixed<5,160>>,Fixed<4,128>>{
-	let u0_u1=c0.velocity.cross(c1.velocity);
-	let n0_n1=c0.normal.cross(c1.normal);
-	let det=u0_u1.dot(n0_n1);
-	let d0=c0.normal.dot(c0.position);
-	let d1=c1.normal.dot(c1.position);
-	(c1.normal.cross(u0_u1)*d0+u0_u1.cross(c0.normal)*d1)/det
-}
-fn solve3(c0:&Contact,c1:&Contact,c2:&Contact)->Ratio<Vector3<Fixed<4,128>>,Fixed<3,96>>{
-	let n0_n1=c0.normal.cross(c1.normal);
-	let det=c2.normal.dot(n0_n1);
-	let d0=c0.normal.dot(c0.position);
-	let d1=c1.normal.dot(c1.position);
-	let d2=c2.normal.dot(c2.position);
-	(c1.normal.cross(c2.normal)*d0+c2.normal.cross(c0.normal)*d1+c0.normal.cross(c1.normal)*d2)/det
-}
-
-fn decompose1(point:Planar64Vec3,u0:Planar64Vec3)->[Ratio<Fixed<2,64>,Fixed<2,64>>;1]{
-	let det=u0.dot(u0);
-	let s0=u0.dot(point)/det;
-	[s0]
-}
-fn decompose2(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3)->[Ratio<Fixed<4,128>,Fixed<4,128>>;2]{
-	let u0_u1=u0.cross(u1);
-	let det=u0_u1.dot(u0_u1);
-	let s0=u0_u1.dot(point.cross(u1))/det;
-	let s1=u0_u1.dot(u0.cross(point))/det;
-	[s0,s1]
-}
-fn decompose3(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3,u2:Planar64Vec3)->[Ratio<Fixed<3,96>,Fixed<3,96>>;3]{
-	let det=u0.cross(u1).dot(u2);
-	let s0=point.cross(u1).dot(u2)/det;
-	let s1=u0.cross(point).dot(u2)/det;
-	let s2=u0.cross(u1).dot(point)/det;
-	[s0,s1,s2]
-}
-
-fn is_space_enclosed_2(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-)->bool{
-	a.cross(b)==Vector3::new([Fixed::ZERO;3])
-	&&a.dot(b).is_negative()
-}
-fn is_space_enclosed_3(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-	c:Planar64Vec3
-)->bool{
-	a.cross(b).dot(c)==Fixed::ZERO
-	&&{
-		let det_abac=a.cross(b).dot(a.cross(c));
-		let det_abbc=a.cross(b).dot(b.cross(c));
-		let det_acbc=a.cross(c).dot(b.cross(c));
-		return!( det_abac*det_abbc).is_positive()
-			&&!( det_abbc*det_acbc).is_positive()
-			&&!(-det_acbc*det_abac).is_positive()
-			||is_space_enclosed_2(a,b)
-			||is_space_enclosed_2(a,c)
-			||is_space_enclosed_2(b,c)
-	}
-}
-fn is_space_enclosed_4(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-	c:Planar64Vec3,
-	d:Planar64Vec3,
-)->bool{
-	let det_abc=a.cross(b).dot(c);
-	let det_abd=a.cross(b).dot(d);
-	let det_acd=a.cross(c).dot(d);
-	let det_bcd=b.cross(c).dot(d);
-	return( det_abc*det_abd).is_negative()
-		&&(-det_abc*det_acd).is_negative()
-		&&( det_abd*det_acd).is_negative()
-		&&( det_abc*det_bcd).is_negative()
-		&&(-det_abd*det_bcd).is_negative()
-		&&( det_acd*det_bcd).is_negative()
-		||is_space_enclosed_3(a,b,c)
-		||is_space_enclosed_3(a,b,d)
-		||is_space_enclosed_3(a,c,d)
-		||is_space_enclosed_3(b,c,d)
-}
-
-const fn get_push_ray_0(point:Planar64Vec3)->Option<Ray>{
-	Some(Ray{origin:point,direction:vec3::ZERO})
-}
-fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
-	let direction=solve1(c0);
-	let s0=decompose1(direction,c0.velocity);
-	if s0<Planar64::ZERO{
-		return None;
-	}
-	let origin=point+solve1(
-		&c0.relative_to(point),
-	).divide().fix_1();
-	Some(Ray{origin,direction})
-}
-fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
-	let direction=solve2(c0,c1)?;
-	let (s0,s1)=decompose2(direction,c0.velocity,c1.velocity)?;
-	if s0<Planar64::ZERO||s1<Planar64::ZERO{
-		return None;
-	}
-	let origin=point+solve2(
-		&c0.relative_to(point),
-		&c1.relative_to(point),
-	)?;
-	Some(Ray{origin,direction})
-}
-fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ray>{
-	let direction=solve3(c0,c1,c2)?;
-	let (s0,s1,s2)=decompose3(direction,c0.velocity,c1.velocity,c2.velocity)?;
-	if s0<Planar64::ZERO||s1<Planar64::ZERO||s2<Planar64::ZERO{
-		return None;
-	}
-	let origin=point+solve3(
-		&c0.relative_to(point),
-		&c1.relative_to(point),
-		&c2.relative_to(point),
-	)?;
-	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,
-	}
-}
-fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
-	get_push_ray_1(point,c0)
-		.map(|ray|(ray,Conts::from_iter([c0])))
-}
-fn get_best_push_ray_and_conts_2<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_2(c0.normal,c1.normal){
-		return None;
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c1){
-		return Some((ray,Conts::from_iter([c0,c1])));
-	}
-	if let Some(ray)=get_push_ray_1(point,c0){
-		if !c1.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0])));
-		}
-	}
-	return None;
-}
-fn get_best_push_ray_and_conts_3<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_3(c0.normal,c1.normal,c2.normal){
-		return None;
-	}
-	if let Some(ray)=get_push_ray_3(point,c0,c1,c2){
-		return Some((ray,Conts::from_iter([c0,c1,c2])));
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c1){
-		if !c2.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0,c1])));
-		}
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c2){
-		if !c1.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0,c2])));
-		}
-	}
-	if let Some(ray)=get_push_ray_1(point,c0){
-		if !c1.relative_dot(ray.direction).is_negative()
-		 &&!c2.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0])));
-		}
-	}
-	return None;
-}
-fn get_best_push_ray_and_conts_4<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact,c3:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_4(c0.normal,c1.normal,c2.normal,c3.normal){
-		return None;
-	}
-
-	let (ray012,conts012)=get_best_push_ray_and_conts_3(point,c0,c1,c2)?;
-	let (ray013,conts013)=get_best_push_ray_and_conts_3(point,c0,c1,c3)?;
-	let (ray023,conts023)=get_best_push_ray_and_conts_3(point,c0,c2,c3)?;
-
-	let err012=c3.relative_dot(ray012.direction);
-	let err013=c2.relative_dot(ray013.direction);
-	let err023=c1.relative_dot(ray023.direction);
-
-	let best_err=err012.max(err013).max(err023);
-
-	if best_err==err012{
-		return Some((ray012,conts012))
-	}else if best_err==err013{
-		return Some((ray013,conts013))
-	}else if best_err==err023{
-		return Some((ray023,conts023))
-	}
-	unreachable!()
-}
-
-fn get_best_push_ray_and_conts<'a>(
-	point:Planar64Vec3,
-	conts:Conts<'a>,
-)->Option<(Ray,Conts<'a>)>{
-	match conts.as_slice(){
-		&[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),
-		_=>unreachable!(),
-	}
-}
-
-fn get_first_touch<'a>(contacts:&'a Vec<Contact>,ray:&Ray,conts:&Conts)->Option<(Ratio<Fixed<2,64>,Fixed<2,64>>,&'a Contact)>{
-	contacts.iter()
-		.filter(|&contact|
-			!conts.iter().any(|&c|std::ptr::eq(c,contact))
-			&&contact.relative_dot(ray.direction).is_negative()
-		)
-		.map(|contact|(contact.solve(ray),contact))
-		.min_by_key(|&(t,_)|t)
-}
-
-pub fn push_solve(contacts:&Vec<Contact>,point:Planar64Vec3)->Option<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),
-		};
-
-		if Planar64::ZERO<=next_t{
-			return Some(ray.origin);
-		}
-
-		//push_front
-		if conts.len()==conts.capacity(){
-			//this is a dead case, new_conts never has more than 3 elements
-			conts.rotate_right(1);
-			conts[0]=next_cont;
-		}else{
-			conts.push(next_cont);
-			conts.rotate_right(1);
-		}
-
-		let meet_point=ray.extrapolate(next_t);
-		match get_best_push_ray_and_conts(meet_point,conts){
-			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return Some(meet_point),
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests{
-	use super::*;
-	#[test]
-	fn test_push_solve(){
-		let contacts=vec![
-			Contact{
-				position:vec3::ZERO,
-				velocity:vec3::Y,
-				normal:vec3::Y,
-			}
-		];
-		assert_eq!(
-			Some(vec3::ZERO),
-			push_solve(&contacts,vec3::NEG_Y)
-		);
-	}
-}

src/window.rs

@@ -100,19 +100,19 @@ impl WindowContext<'_>{
 						if let Some(input_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
 							winit::keyboard::Key::Character(key)=>match key.as_str(){
-								"w"=>Some(InputInstruction::MoveForward(s)),
-								"a"=>Some(InputInstruction::MoveLeft(s)),
-								"s"=>Some(InputInstruction::MoveBack(s)),
-								"d"=>Some(InputInstruction::MoveRight(s)),
-								"e"=>Some(InputInstruction::MoveUp(s)),
-								"q"=>Some(InputInstruction::MoveDown(s)),
-								"z"=>Some(InputInstruction::Zoom(s)),
-								"r"=>if s{
+								"w"|"W"=>Some(InputInstruction::MoveForward(s)),
+								"a"|"A"=>Some(InputInstruction::MoveLeft(s)),
+								"s"|"S"=>Some(InputInstruction::MoveBack(s)),
+								"d"|"D"=>Some(InputInstruction::MoveRight(s)),
+								"e"|"E"=>Some(InputInstruction::MoveUp(s)),
+								"q"|"Q"=>Some(InputInstruction::MoveDown(s)),
+								"z"|"Z"=>Some(InputInstruction::Zoom(s)),
+								"r"|"R"=>if s{
 									//mouse needs to be reset since the position is absolute
 									self.mouse=strafesnet_common::mouse::MouseState::default();
 									Some(InputInstruction::ResetAndRestart)
 								}else{None},
-								"f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
+								"f"|"F"=>if s{Some(InputInstruction::PracticeFly)}else{None},
 								_=>None,
 							},
 							_=>None,