tweak

Cargo.lock

@@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "arrayvec"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
-
 [[package]]
 name = "bitflags"
 version = "2.6.0"
@@ -33,27 +27,26 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "strafesnet_common"
-version = "0.4.1"
+version = "0.2.0"
 dependencies = [
- "arrayvec",
  "bitflags",
  "glam",
  "id",
@@ -61,9 +54,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.72"
+version = "2.0.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc4b9b9bf2add8093d3f2c0204471e951b2285580335de42f9d2534f3ae7a8af"
+checksum = "b699d15b36d1f02c3e7c69f8ffef53de37aefae075d8488d4ba1a7788d574a07"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_common"
-version = "0.4.1"
+version = "0.2.0"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/common"
 license = "MIT OR Apache-2.0"
@@ -10,7 +10,6 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-arrayvec = "0.7.4"
 bitflags = "2.6.0"
 glam = "0.28.0"
 id = { version = "0.1.0", registry = "strafesnet" }

src/bvh.rs

@@ -19,18 +19,11 @@ impl<R,T> Default for RecursiveContent<R,T>{
 		Self::Branch(Vec::new())
 	}
 }
+#[derive(Default)]
 pub struct BvhNode<T>{
 	content:RecursiveContent<BvhNode<T>,T>,
 	aabb:Aabb,
 }
-impl<T> Default for BvhNode<T>{
-	fn default()->Self{
-		Self{
-			content:Default::default(),
-			aabb:Aabb::default(),
-		}
-	}
-}
 pub struct BvhWeightNode<W,T>{
 	content:RecursiveContent<BvhWeightNode<W,T>,T>,
 	weight:W,
@@ -121,11 +114,13 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 			aabb,
 		}
 	}else{
+		let mut octant=std::collections::HashMap::with_capacity(n);//this ids which octant the boxen is put in
 		let mut sort_x=Vec::with_capacity(n);
 		let mut sort_y=Vec::with_capacity(n);
 		let mut sort_z=Vec::with_capacity(n);
 		for (i,(_,aabb)) in boxen.iter().enumerate(){
 			let center=aabb.center();
+			octant.insert(i,0);
 			sort_x.push((i,center.x()));
 			sort_y.push((i,center.y()));
 			sort_z.push((i,center.z()));
@@ -137,34 +132,26 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 		let median_x=sort_x[h].1;
 		let median_y=sort_y[h].1;
 		let median_z=sort_z[h].1;
-		//locate a run of values equal to the median
-		//partition point gives the first index for which the predicate evaluates to false
-		let first_index_eq_median_x=sort_x.partition_point(|&(_,x)|x<median_x);
-		let first_index_eq_median_y=sort_y.partition_point(|&(_,y)|y<median_y);
-		let first_index_eq_median_z=sort_z.partition_point(|&(_,z)|z<median_z);
-		let first_index_gt_median_x=sort_x.partition_point(|&(_,x)|x<=median_x);
-		let first_index_gt_median_y=sort_y.partition_point(|&(_,y)|y<=median_y);
-		let first_index_gt_median_z=sort_z.partition_point(|&(_,z)|z<=median_z);
-		//pick which side median value copies go into such that both sides are as balanced as possible based on distance from n/2
-		let partition_point_x=if n.abs_diff(2*first_index_eq_median_x)<n.abs_diff(2*first_index_gt_median_x){first_index_eq_median_x}else{first_index_gt_median_x};
-		let partition_point_y=if n.abs_diff(2*first_index_eq_median_y)<n.abs_diff(2*first_index_gt_median_y){first_index_eq_median_y}else{first_index_gt_median_y};
-		let partition_point_z=if n.abs_diff(2*first_index_eq_median_z)<n.abs_diff(2*first_index_gt_median_z){first_index_eq_median_z}else{first_index_gt_median_z};
-		//this ids which octant the boxen is put in
-		let mut octant=vec![0;n];
-		for &(i,_) in &sort_x[partition_point_x..]{
-			octant[i]+=1<<0;
+		for (i,c) in sort_x{
+			if median_x<c{
+				octant.insert(i,octant[&i]+1<<0);
+			}
 		}
-		for &(i,_) in &sort_y[partition_point_y..]{
-			octant[i]+=1<<1;
+		for (i,c) in sort_y{
+			if median_y<c{
+				octant.insert(i,octant[&i]+1<<1);
+			}
 		}
-		for &(i,_) in &sort_z[partition_point_z..]{
-			octant[i]+=1<<2;
+		for (i,c) in sort_z{
+			if median_z<c{
+				octant.insert(i,octant[&i]+1<<2);
+			}
 		}
 		//generate lists for unique octant values
 		let mut list_list=Vec::with_capacity(8);
 		let mut octant_list=Vec::with_capacity(8);
 		for (i,(data,aabb)) in boxen.into_iter().enumerate(){
-			let octant_id=octant[i];
+			let octant_id=octant[&i];
 			let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
 				list_id
 			}else{

src/gameplay_attributes.rs

@@ -31,22 +31,6 @@ pub enum Booster{
 	//Affine(crate::integer::Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
 	Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
 	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
-	AirTime(Time),//increase airtime, invariant across mass and gravity changes
-	Height(Planar64),//increase height, invariant across mass and gravity changes
-}
-impl Booster{
-	pub fn boost(&self,velocity:Planar64Vec3)->Planar64Vec3{
-		match self{
-			&Booster::Velocity(boost_velocity)=>velocity+boost_velocity,
-			&Booster::Energy{direction,energy}=>{
-				let d=direction.dot(velocity);
-				//TODO: think about negative
-				velocity+direction.with_length((d*d+energy).sqrt()-d)
-			},
-			Booster::AirTime(_)=>todo!(),
-			Booster::Height(_)=>todo!(),
-		}
-	}
 }
 #[derive(Clone,Hash,Eq,PartialEq)]
 pub enum TrajectoryChoice{
@@ -150,24 +134,23 @@ impl IntersectingAttributes{
 }
 #[derive(Clone,Copy,id::Id,Hash,Eq,PartialEq)]
 pub struct CollisionAttributesId(u32);
-#[derive(Clone,Default,Hash,Eq,PartialEq)]
-pub struct ContactAttributes{
-	pub contacting:ContactingAttributes,
-	pub general:GeneralAttributes,
-}
-#[derive(Clone,Default,Hash,Eq,PartialEq)]
-pub struct IntersectAttributes{
-	pub intersecting:IntersectingAttributes,
-	pub general:GeneralAttributes,
-}
 #[derive(Clone,Hash,Eq,PartialEq)]
 pub enum CollisionAttributes{
 	Decoration,//visual only
-	Contact(ContactAttributes),//track whether you are contacting the object
-	Intersect(IntersectAttributes),//track whether you are intersecting the object
+	Contact{//track whether you are contacting the object
+		contacting:ContactingAttributes,
+		general:GeneralAttributes,
+	},
+	Intersect{//track whether you are intersecting the object
+		intersecting:IntersectingAttributes,
+		general:GeneralAttributes,
+	},
 }
 impl CollisionAttributes{
 	pub fn contact_default()->Self{
-		Self::Contact(ContactAttributes::default())
+		Self::Contact{
+			contacting:ContactingAttributes::default(),
+			general:GeneralAttributes::default()
+		}
 	}
 }

src/gameplay_style.rs

@@ -41,135 +41,33 @@ impl std::default::Default for StyleModifiers{
 
 #[derive(Clone,Debug)]
 pub enum JumpCalculation{
-	Max,//Roblox: jumped_speed=max(velocity.boost(),velocity.jump())
-	BoostThenJump,//jumped_speed=velocity.boost().jump()
-	JumpThenBoost,//jumped_speed=velocity.jump().boost()
+	Capped,//roblox
+	Energy,//new
+	Linear,//source
 }
 
 #[derive(Clone,Debug)]
 pub enum JumpImpulse{
-	Time(Time),//jump time is invariant across mass and gravity changes
-	Height(Planar64),//jump height is invariant across mass and gravity changes
-	Linear(Planar64),//jump velocity is invariant across mass and gravity changes
-	Energy(Planar64),// :)
+	FromTime(Time),//jump time is invariant across mass and gravity changes
+	FromHeight(Planar64),//jump height is invariant across mass and gravity changes
+	FromDeltaV(Planar64),//jump velocity is invariant across mass and gravity changes
+	FromEnergy(Planar64),// :)
 }
 //Jumping acts on dot(walks_state.normal,body.velocity)
+//Capped means it increases the dot to the cap
 //Energy means it adds energy
 //Linear means it linearly adds on
 impl JumpImpulse{
-	pub fn jump(
-		&self,
-		velocity:Planar64Vec3,
-		jump_dir:Planar64Vec3,
-		gravity:&Planar64Vec3,
-		mass:Planar64,
-	)->Planar64Vec3{
-		match self{
-			&JumpImpulse::Time(time)=>velocity-*gravity*time,
-			&JumpImpulse::Height(height)=>{
-				//height==-v.y*v.y/(2*g.y);
-				//use energy to determine max height
-				let g=gravity.length();
-				let v_g=gravity.dot(velocity)/g;
-				//do it backwards
-				velocity-gravity.with_length((v_g*v_g+height*g*2).sqrt()+v_g)
-			},
-			&JumpImpulse::Linear(jump_speed)=>velocity+jump_dir.with_length(jump_speed),
-			&JumpImpulse::Energy(energy)=>{
-				//calculate energy
-				let e=gravity.dot(velocity);
-				//add
-				//you get the idea
-				todo!()
-			},
-		}
-	}
-	//TODO: remove this and implement JumpCalculation properly
+	//fn get_jump_time(&self)->Planar64
+	//fn get_jump_height(&self)->Planar64
+	//fn get_jump_energy(&self)->Planar64
 	pub fn get_jump_deltav(&self,gravity:&Planar64Vec3,mass:Planar64)->Planar64{
 		//gravity.length() is actually the proper calculation because the jump is always opposite the gravity direction
 		match self{
-			&JumpImpulse::Time(time)=>gravity.length()*(time/2),
-			&JumpImpulse::Height(height)=>(gravity.length()*height*2).sqrt(),
-			&JumpImpulse::Linear(deltav)=>deltav,
-			&JumpImpulse::Energy(energy)=>(energy*2/mass).sqrt(),
-		}
-	}
-}
-
-#[derive(Clone,Debug)]
-pub struct JumpSettings{
-	//information used to calculate jump power
-	pub impulse:JumpImpulse,
-	//information used to calculate jump behaviour
-	pub calculation:JumpCalculation,
-	//limit the minimum jump power when combined with downwards momentum
-	//This is true in both roblox and source
-	pub limit_minimum:bool,
-}
-impl JumpSettings{
-	pub fn jumped_velocity(
-		&self,
-		style:&StyleModifiers,
-		jump_dir:Planar64Vec3,
-		rel_velocity:Planar64Vec3,
-		booster:Option<&crate::gameplay_attributes::Booster>,
-	)->Planar64Vec3{
-		let jump_speed=self.impulse.get_jump_deltav(&style.gravity,style.mass);
-		match (self.limit_minimum,&self.calculation){
-			(true,JumpCalculation::Max)=>{
-				//the roblox calculation
-				let boost_vel=match booster{
-					Some(booster)=>booster.boost(rel_velocity),
-					None=>rel_velocity,
-				};
-				let j=boost_vel.dot(jump_dir);
-				if j<jump_speed{
-					//weak booster: just do a regular jump
-					boost_vel+jump_dir.with_length(jump_speed-j)
-				}else{
-					//activate booster normally, jump does nothing
-					boost_vel
-				}
-			},
-			(true,_)=>{
-				//the source calculation (?)
-				let boost_vel=match booster{
-					Some(booster)=>booster.boost(rel_velocity),
-					None=>rel_velocity,
-				};
-				let j=boost_vel.dot(jump_dir);
-				if j<jump_speed{
-					//speed in direction of jump cannot be lower than amount
-					boost_vel+jump_dir.with_length(jump_speed-j)
-				}else{
-					//boost and jump add together
-					boost_vel+jump_dir.with_length(jump_speed)
-				}
-			}
-			(false,JumpCalculation::Max)=>{
-				//??? calculation
-				//max(boost_vel,jump_vel)
-				let boost_vel=match booster{
-					Some(booster)=>booster.boost(rel_velocity),
-					None=>rel_velocity,
-				};
-				let boost_dot=boost_vel.dot(jump_dir);
-				if boost_dot<jump_speed{
-					//weak boost is extended to jump speed
-					boost_vel+jump_dir.with_length(jump_speed-boost_dot)
-				}else{
-					//activate booster normally, jump does nothing
-					boost_vel
-				}
-			},
-			//the strafe client calculation
-			(false,_)=>{
-				let boost_vel=match booster{
-					Some(booster)=>booster.boost(rel_velocity),
-					None=>rel_velocity,
-				};
-				boost_vel+jump_dir.with_length(jump_speed)
-			},
+			&JumpImpulse::FromTime(time)=>gravity.length()*(time/2),
+			&JumpImpulse::FromHeight(height)=>(gravity.length()*height*2).sqrt(),
+			&JumpImpulse::FromDeltaV(deltav)=>deltav,
+			&JumpImpulse::FromEnergy(energy)=>(energy*2/mass).sqrt(),
 		}
 	}
 }
@@ -177,14 +75,34 @@ impl JumpSettings{
 #[derive(Clone,Debug)]
 pub struct ControlsActivation{
 	//allowed keys
-	pub controls_mask:Controls,
+	controls_mask:Controls,
 	//allow strafing only if any of the masked controls are held, eg W|S for shsw
-	pub controls_intersects:Controls,
+	controls_intersects:Controls,
 	//allow strafing only if all of the masked controls are held, eg W for hsw, w-only
-	pub controls_contains:Controls,
+	controls_contains:Controls,
 	//Function(Box<dyn Fn(u32)->bool>),
 }
 impl ControlsActivation{
+	pub const fn new(
+		controls_mask:Controls,
+		controls_intersects:Controls,
+		controls_contains:Controls,
+	)->Self{
+		Self{
+			controls_mask,
+			controls_intersects,
+			controls_contains,
+		}
+	}
+	pub const fn controls_mask(&self)->Controls{
+		self.controls_mask
+	}
+	pub const fn controls_intersects(&self)->Controls{
+		self.controls_intersects
+	}
+	pub const fn controls_contains(&self)->Controls{
+		self.controls_contains
+	}
 	pub const fn mask(&self,controls:Controls)->Controls{
 		controls.intersection(self.controls_mask)
 	}
@@ -253,12 +171,23 @@ impl ControlsActivation{
 
 #[derive(Clone,Debug)]
 pub struct StrafeSettings{
-	pub enable:ControlsActivation,
-	pub mv:Planar64,
-	pub air_accel_limit:Option<Planar64>,
-	pub tick_rate:Ratio64,
+	enable:ControlsActivation,
+	mv:Planar64,
+	air_accel_limit:Option<Planar64>,
+	tick_rate:Ratio64,
 }
 impl StrafeSettings{
+	pub const fn new(
+		enable:ControlsActivation,
+		mv:Planar64,
+		air_accel_limit:Option<Planar64>,
+		tick_rate:Ratio64,
+	)->Self{
+		Self{enable,mv,air_accel_limit,tick_rate}
+	}
+	pub fn into_inner(self)->(ControlsActivation,Planar64,Option<Planar64>,Ratio64){
+		(self.enable,self.mv,self.air_accel_limit,self.tick_rate)
+	}
 	pub fn tick_velocity(&self,velocity:Planar64Vec3,control_dir:Planar64Vec3)->Option<Planar64Vec3>{
 		let d=velocity.dot(control_dir);
 		match d<self.mv{
@@ -279,28 +208,88 @@ impl StrafeSettings{
 
 #[derive(Clone,Debug)]
 pub struct PropulsionSettings{
-	pub magnitude:Planar64,
+	magnitude:Planar64,
 }
 impl PropulsionSettings{
+	pub const fn new(magnitude:Planar64)->Self{
+		Self{magnitude}
+	}
+	pub fn magnitude(&self)->Planar64{
+		self.magnitude
+	}
 	pub fn acceleration(&self,control_dir:Planar64Vec3)->Planar64Vec3{
 		control_dir*self.magnitude
 	}
 }
 
+#[derive(Clone,Debug)]
+pub struct JumpSettings{
+	//information used to calculate jump power
+	impulse:JumpImpulse,
+	//information used to calculate jump behaviour
+	calculation:JumpCalculation,
+}
+impl JumpSettings{
+	pub const fn new(
+		impulse:JumpImpulse,
+		calculation:JumpCalculation,
+	)->Self{
+		Self{impulse,calculation}
+	}
+	pub fn into_inner(self)->(JumpImpulse,JumpCalculation){
+		(self.impulse,self.calculation)
+	}
+	pub fn jumped_velocity(&self,style:&StyleModifiers,jump_dir:Planar64Vec3,velocity:Planar64Vec3)->Planar64Vec3{
+		match self.calculation{
+			//roblox style
+			JumpCalculation::Capped=>todo!(),
+			//something different
+			JumpCalculation::Energy=>todo!(),
+			//source style
+			JumpCalculation::Linear=>velocity+jump_dir*(self.impulse.get_jump_deltav(&style.gravity,style.mass)/jump_dir.length()),
+		}
+	}
+}
+
 #[derive(Clone,Debug)]
 pub struct AccelerateSettings{
-	pub accel:Planar64,
-	pub topspeed:Planar64,
+	accel:Planar64,
+	topspeed:Planar64,
+}
+impl AccelerateSettings{
+	pub const fn new(
+		accel:Planar64,
+		topspeed:Planar64,
+	)->Self{
+		Self{accel,topspeed}
+	}
+	pub const fn accel(&self)->Planar64{
+		self.accel
+	}
+	pub const fn topspeed(&self)->Planar64{
+		self.topspeed
+	}
 }
 #[derive(Clone,Debug)]
 pub struct WalkSettings{
-	pub accelerate:AccelerateSettings,
-	pub static_friction:Planar64,
-	pub kinetic_friction:Planar64,
+	accelerate:AccelerateSettings,
+	static_friction:Planar64,
+	kinetic_friction:Planar64,
 	//if a surf slope angle does not exist, then everything is slippery and walking is impossible
-	pub surf_dot:Planar64,//surf_dot<n.dot(up)/n.length()
+	surf_dot:Planar64,//surf_dot<n.dot(up)/n.length()
 }
 impl WalkSettings{
+	pub const fn new(
+		accelerate:AccelerateSettings,
+		static_friction:Planar64,
+		kinetic_friction:Planar64,
+		surf_dot:Planar64,
+	)->Self{
+		Self{accelerate,static_friction,kinetic_friction,surf_dot}
+	}
+	pub fn into_inner(self)->(AccelerateSettings,Planar64,Planar64,Planar64){
+		(self.accelerate,self.static_friction,self.kinetic_friction,self.surf_dot)
+	}
 	pub fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible walk accel
 		let diff_len=target_diff.length();
@@ -340,12 +329,21 @@ impl WalkSettings{
 
 #[derive(Clone,Debug)]
 pub struct LadderSettings{
-	pub accelerate:AccelerateSettings,
+	accelerate:AccelerateSettings,
 	//how close to pushing directly into/out of the ladder normal
 	//does your input need to be to redirect straight up/down the ladder
-	pub dot:Planar64,
+	dot:Planar64,
 }
 impl LadderSettings{
+	pub const fn new(
+		accelerate:AccelerateSettings,
+		dot:Planar64,
+	)->Self{
+		Self{accelerate,dot}
+	}
+	pub fn into_inner(self)->(AccelerateSettings,Planar64){
+		(self.accelerate,self.dot)
+	}
 	pub const fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible ladder accel
 		self.accelerate.accel
@@ -427,9 +425,8 @@ impl StyleModifiers{
 				tick_rate:Ratio64::new(64,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Energy(Planar64::int(512)),
-				calculation:JumpCalculation::JumpThenBoost,
-				limit_minimum:false,
+				impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
+				calculation:JumpCalculation::Energy,
 			}),
 			gravity:Planar64Vec3::int(0,-80,0),
 			mass:Planar64::int(1),
@@ -469,9 +466,8 @@ impl StyleModifiers{
 				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Time(Time::from_micros(715_588)),
-				calculation:JumpCalculation::Max,
-				limit_minimum:true,
+				impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
+				calculation:JumpCalculation::Linear,//Should be capped
 			}),
 			gravity:Planar64Vec3::int(0,-100,0),
 			mass:Planar64::int(1),
@@ -526,9 +522,8 @@ impl StyleModifiers{
 				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height(Planar64::int(52)*VALVE_SCALE),
-				calculation:JumpCalculation::JumpThenBoost,
-				limit_minimum:true,
+				impulse:JumpImpulse::FromHeight(Planar64::int(52)*VALVE_SCALE),
+				calculation:JumpCalculation::Linear,
 			}),
 			gravity:Planar64Vec3::int(0,-800,0)*VALVE_SCALE,
 			mass:Planar64::int(1),
@@ -567,9 +562,8 @@ impl StyleModifiers{
 				tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height(Planar64::int(52)*VALVE_SCALE),
-				calculation:JumpCalculation::JumpThenBoost,
-				limit_minimum:true,
+				impulse:JumpImpulse::FromHeight(Planar64::int(52)*VALVE_SCALE),
+				calculation:JumpCalculation::Linear,
 			}),
 			gravity:Planar64Vec3::int(0,-800,0)*VALVE_SCALE,
 			mass:Planar64::int(1),

src/instruction.rs

@@ -19,14 +19,14 @@ pub struct InstructionCollector<I>{
 	instruction:Option<I>,
 }
 impl<I> InstructionCollector<I>{
-	pub const fn new(time:Time)->Self{
+	pub fn new(time:Time)->Self{
 		Self{
 			time,
 			instruction:None
 		}
 	}
 	#[inline]
-	pub const fn time(&self)->Time{
+	pub fn time(&self)->Time{
 		self.time
 	}
 	pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
@@ -50,4 +50,4 @@ impl<I> InstructionCollector<I>{
 			None=>None,
 		}
 	}
-}
+}

src/integer.rs

@@ -448,25 +448,8 @@ impl Planar64{
 		self.0
 	}
 	#[inline]
-	pub const fn abs(self)->Self{
-		Self(self.0.abs())
-	}
-	#[inline]
 	pub fn sqrt(&self)->Self{
-		const BITS:i32=64;
-		const FRAC:i32=32;
-		let pow=(((BITS-FRAC-(self.0.leading_zeros() as i32)+1)>>1)+FRAC)-1;
-		let mut result=Self::ZERO;
-		let wide_self=(self.0 as i128)<<FRAC;
-		for i in (0..=pow).rev(){
-			let new_result=Self::raw(result.0|1<<i);
-			match wide_self.cmp(&((new_result.0 as i128)*(new_result.0 as i128))){
-				core::cmp::Ordering::Less=>(),
-				core::cmp::Ordering::Equal=>return new_result,
-				core::cmp::Ordering::Greater=>result=new_result,
-			}
-		}
-		result
+		Planar64(unsafe{(((self.0 as i128)<<32) as f64).sqrt().to_int_unchecked()})
 	}
 	#[inline]
 	pub const fn signum_i64(&self)->i64{

src/lib.rs

@@ -3,11 +3,9 @@ pub mod map;
 pub mod run;
 pub mod aabb;
 pub mod model;
-pub mod mouse;
 pub mod timer;
 pub mod zeroes;
 pub mod integer;
-pub mod physics;
 pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;

src/mouse.rs

@@ -1,26 +0,0 @@
-use crate::integer::Time;
-
-#[derive(Clone,Debug)]
-pub struct MouseState{
-	pub pos:glam::IVec2,
-	pub time:Time,
-}
-impl Default for MouseState{
-	fn default()->Self{
-		Self{
-			time:Time::ZERO,
-			pos:glam::IVec2::ZERO,
-		}
-	}
-}
-impl MouseState{
-	pub fn lerp(&self,target:&MouseState,time:Time)->glam::IVec2{
-		let m0=self.pos.as_i64vec2();
-		let m1=target.pos.as_i64vec2();
-		//these are deltas
-		let t1t=(target.time-time).nanos();
-		let tt0=(time-self.time).nanos();
-		let dt=(target.time-self.time).nanos();
-		((m0*t1t+m1*tt0)/dt).as_ivec2()
-	}
-}

src/physics.rs

@@ -1,27 +0,0 @@
-#[derive(Clone,Debug)]
-pub enum Instruction{
-	ReplaceMouse(crate::mouse::MouseState,crate::mouse::MouseState),
-	SetNextMouse(crate::mouse::MouseState),
-	SetMoveRight(bool),
-	SetMoveUp(bool),
-	SetMoveBack(bool),
-	SetMoveLeft(bool),
-	SetMoveDown(bool),
-	SetMoveForward(bool),
-	SetJump(bool),
-	SetZoom(bool),
-	/// Reset: fully replace the physics state.
-	/// This forgets all inputs and settings which need to be reapplied.
-	Reset,
-	/// Restart: Teleport to the start zone.
-	Restart,
-	/// Spawn: Teleport to a specific mode's spawn
-	/// Sets current mode & spawn
-	Spawn(crate::gameplay_modes::ModeId,crate::gameplay_modes::StageId),
-	Idle,
-		//Idle: there were no input events, but the simulation is safe to advance to this timestep
-		//for interpolation / networking / playback reasons, most playback heads will always want
-		//to be 1 instruction ahead to generate the next state for interpolation.
-	PracticeFly,
-	SetSensitivity(crate::integer::Ratio64Vec2),
-}

src/run.rs

@@ -1,7 +1,7 @@
 use crate::timer::{TimerFixed,Realtime,Paused,Unpaused};
 use crate::integer::Time;
 
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Debug)]
 pub enum FlagReason{
 	Anticheat,
 	StyleChange,
@@ -42,14 +42,14 @@ impl std::fmt::Display for Error{
 }
 impl std::error::Error for Error{}
 
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Debug)]
 enum RunState{
 	Created,
 	Started{timer:TimerFixed<Realtime,Unpaused>},
 	Finished{timer:TimerFixed<Realtime,Paused>},
 }
 
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Debug)]
 pub struct Run{
 	state:RunState,
 	flagged:Option<FlagReason>,

src/timer.rs

@@ -27,7 +27,7 @@ pub struct Realtime{
 	offset:Time,
 }
 impl Realtime{
-	pub const fn new(offset:Time)->Self{
+	const fn new(offset:Time)->Self{
 		Self{offset}
 	}
 }
@@ -38,7 +38,7 @@ pub struct Scaled{
 	offset:Time,
 }
 impl Scaled{
-	pub const fn new(scale:Ratio64,offset:Time)->Self{
+	const fn new(scale:Ratio64,offset:Time)->Self{
 		Self{scale,offset}
 	}
 	const fn with_scale(scale:Ratio64)->Self{
@@ -243,38 +243,11 @@ impl<T:TimerState> Timer<T>{
 		};
 		Ok(())
 	}
-	pub fn is_paused(&self)->bool{
-		match self{
-			Self::Paused(_)=>true,
-			Self::Unpaused(_)=>false,
-		}
-	}
-	pub fn set_paused(&mut self,time:Time,paused:bool)->Result<(),Error>{
-		match paused{
-			true=>self.pause(time),
-			false=>self.unpause(time),
-		}
-	}
-}
-//scaled timer methods are generic across PauseState
-impl Timer<Scaled>{
-	pub const fn get_scale(&self)->Ratio64{
-		match self{
-			Self::Paused(timer)=>timer.get_scale(),
-			Self::Unpaused(timer)=>timer.get_scale(),
-		}
-	}
-	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
-		match self{
-			Self::Paused(timer)=>timer.set_scale(time,new_scale),
-			Self::Unpaused(timer)=>timer.set_scale(time,new_scale),
-		}
-	}
 }
 
 #[cfg(test)]
 mod test{
-	use super::*;
+	use super::{Time,Timer,TimerFixed,Error,Realtime,Scaled,Paused};
 	macro_rules! sec {
 		($s: expr) => {
 			Time::from_secs($s)

src/zeroes.rs

@@ -1,41 +1,40 @@
 //find roots of polynomials
-use arrayvec::ArrayVec;
 use crate::integer::Planar64;
 
 #[inline]
-pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64)->ArrayVec<Planar64,2>{
+pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
 	if a2==Planar64::ZERO{
-		return zeroes1(a0,a1);
+		return zeroes1(a0, a1);
 	}
 	let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
-	if 0<radicand{
+	if 0<radicand {
 		//start with f64 sqrt
 		//failure case: 2^63 < sqrt(2^127)
 		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
 		//TODO: one or two newtons
 		//sort roots ascending and avoid taking the difference of large numbers
 		match (Planar64::ZERO<a2,Planar64::ZERO<a1){
-			(true, true )=>[(-a1-planar_radicand)/(a2*2),(a0*2)/(-a1-planar_radicand)].into(),
-			(true, false)=>[(a0*2)/(-a1+planar_radicand),(-a1+planar_radicand)/(a2*2)].into(),
-			(false,true )=>[(a0*2)/(-a1-planar_radicand),(-a1-planar_radicand)/(a2*2)].into(),
-			(false,false)=>[(-a1+planar_radicand)/(a2*2),(a0*2)/(-a1+planar_radicand)].into(),
+			(true, true )=>vec![(-a1-planar_radicand)/(a2*2),(a0*2)/(-a1-planar_radicand)],
+			(true, false)=>vec![(a0*2)/(-a1+planar_radicand),(-a1+planar_radicand)/(a2*2)],
+			(false,true )=>vec![(a0*2)/(-a1-planar_radicand),(-a1-planar_radicand)/(a2*2)],
+			(false,false)=>vec![(-a1+planar_radicand)/(a2*2),(a0*2)/(-a1+planar_radicand)],
 		}
-	}else if radicand==0{
-		return ArrayVec::from_iter([a1/(a2*-2)]);
-	}else{
-		return ArrayVec::new_const();
+	} else if radicand==0 {
+		return vec![a1/(a2*-2)];
+	} else {
+		return vec![];
 	}
 }
 #[inline]
-pub fn zeroes1(a0:Planar64,a1:Planar64)->ArrayVec<Planar64,2>{
+pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
 	if a1==Planar64::ZERO{
-		return ArrayVec::new_const();
+		return vec![];
 	}else{
 		let q=((-a0.get() as i128)<<32)/(a1.get() as i128);
 		if i64::MIN as i128<=q&&q<=i64::MAX as i128{
-			return ArrayVec::from_iter([Planar64::raw(q as i64)]);
+			return vec![Planar64::raw(q as i64)];
 		}else{
-			return ArrayVec::new_const();
+			return vec![];
 		}
 	}
-}
+}