From f16bc043c48455d749b7bb45339952b6387692b2 Mon Sep 17 00:00:00 2001
From: Quaternions <krakow20@gmail.com>
Date: Wed, 11 Oct 2023 19:17:56 -0700
Subject: [PATCH] replace TIME with Time

---
 src/integer.rs | 31 +++++++++++++++++
 src/physics.rs | 90 ++++++++++++++++++++++++--------------------------
 2 files changed, 74 insertions(+), 47 deletions(-)

diff --git a/src/integer.rs b/src/integer.rs
index d5c6879..fb973ab 100644
--- a/src/integer.rs
+++ b/src/integer.rs
@@ -1,6 +1,8 @@
 //integer units
+#[derive(Clone,Copy,Hash,Debug)]
 pub struct Time(i64);
 impl Time{
+	pub const ZERO:Self=Self(0);
 	pub const ONE_SECOND:Self=Self(1_000_000_000);
 	pub const ONE_MILLISECOND:Self=Self(1_000_000);
 	pub const ONE_MICROSECOND:Self=Self(1_000);
@@ -18,6 +20,35 @@ impl Time{
 		Self(Self::ONE_NANOSECOND.0*num)
 	}
 	//should I have checked subtraction? force all time variables to be positive?
+	pub fn nanos(&self)->i64{
+		self.0
+	}
+}
+impl std::fmt::Display for Time{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{}s+{}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
+	}
+}
+impl std::ops::Neg for Time{
+	type Output=Time;
+	#[inline]
+	fn neg(self)->Self::Output {
+		Time(-self.0)
+	}
+}
+impl std::ops::Add<Time> for Time{
+	type Output=Time;
+	#[inline]
+	fn add(self,rhs:Self)->Self::Output {
+		Time(self.0+rhs.0)
+	}
+}
+impl std::ops::Sub<Time> for Time{
+	type Output=Time;
+	#[inline]
+	fn sub(self,rhs:Self)->Self::Output {
+		Time(self.0-rhs.0)
+	}
 }
 
 #[derive(Clone,Copy,Hash)]
diff --git a/src/physics.rs b/src/physics.rs
index dd63374..5fd7b5f 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -1,6 +1,6 @@
 use crate::{instruction::{InstructionEmitter, InstructionConsumer, TimedInstruction}, zeroes::zeroes2};
 
-use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Angle32,Angle32Vec2,Ratio64Vec2};
+use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
 
 #[derive(Debug)]
 pub enum PhysicsInstruction {
@@ -54,7 +54,7 @@ pub struct Body {
 	position: Planar64Vec3,//I64 where 2^32 = 1 u
 	velocity: Planar64Vec3,//I64 where 2^32 = 1 u/s
 	acceleration: Planar64Vec3,//I64 where 2^32 = 1 u/s/s
-	time: TIME,//nanoseconds x xxxxD!
+	time:Time,//nanoseconds x xxxxD!
 }
 
 pub enum MoveRestriction {
@@ -75,7 +75,7 @@ impl InputState {
 	}
 }
 impl crate::instruction::InstructionEmitter<InputInstruction> for InputState{
-	fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<InputInstruction>> {
+	fn next_instruction(&self, time_limit:crate::body::Time) -> Option<TimedInstruction<InputInstruction>> {
 		//this is polled by PhysicsState for actions like Jump
 		//no, it has to be the other way around. physics is run up until the jump instruction, and then the jump instruction is pushed.
 		self.queue.get(0)
@@ -93,24 +93,24 @@ impl crate::instruction::InstructionConsumer<InputInstruction> for InputState{
 #[derive(Clone,Debug)]
 pub struct MouseState {
 	pub pos: glam::IVec2,
-	pub time: TIME,
+	pub time:Time,
 }
 impl Default for MouseState{
 	fn default() -> Self {
 		Self {
-			time:0,
+			time:Time::ZERO,
 			pos:glam::IVec2::ZERO,
 		}
 	}
 }
 impl MouseState {
-	pub fn lerp(&self,target:&MouseState,time:TIME)->glam::IVec2 {
+	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) as i64;
-		let tt0=(time-self.time) as i64;
-		let dt=(target.time-self.time) as i64;
+		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()
 	}
 }
@@ -121,14 +121,14 @@ pub enum WalkEnum{
 }
 pub struct WalkState {
 	pub target_velocity: Planar64Vec3,
-	pub target_time: TIME,
+	pub target_time: Time,
 	pub state: WalkEnum,
 }
 impl WalkState {
 	pub fn new() -> Self {
 		Self{
 			target_velocity:Planar64Vec3::ZERO,
-			target_time:0,
+			target_time:Time::ZERO,
 			state:WalkEnum::Reached,
 		}
 	}
@@ -160,7 +160,7 @@ impl PhysicsCamera {
 		Self{
 			offset,
 			sensitivity:Ratio64Vec2::ONE.mul_ratio(200_000),
-			mouse:MouseState{pos:glam::IVec2::ZERO,time:-1},//escape initialization hell divide by zero
+			mouse:MouseState{pos:glam::IVec2::ZERO,time:-Time::ONE_NANOSECOND},//escape initialization hell divide by zero
 			clamped_mouse_pos:glam::IVec2::ZERO,
 			angle_pitch_lower_limit:-Angle32::FRAC_PI_2,
 			angle_pitch_upper_limit:Angle32::FRAC_PI_2,
@@ -210,8 +210,7 @@ pub struct StyleModifiers{
 	pub friction:Planar64,
 	pub walk_accel:Planar64,
 	pub gravity:Planar64Vec3,
-	pub strafe_tick_num:TIME,
-	pub strafe_tick_den:TIME,
+	pub strafe_tick_rate:Ratio64,
 	pub hitbox_halfsize:Planar64Vec3,
 }
 impl std::default::Default for StyleModifiers{
@@ -219,8 +218,7 @@ impl std::default::Default for StyleModifiers{
 		Self{
 			controls_mask: !0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held: 0,
-			strafe_tick_num: 100,//100t
-			strafe_tick_den: 1_000_000_000,
+			strafe_tick_rate:Ratio64::ONE.div_ratio(100),
 			gravity: Planar64Vec3::new(0,100,0),
 			friction: Planar64::new(12)/10,
 			walk_accel: Planar64::new(90),
@@ -280,7 +278,7 @@ impl StyleModifiers{
 }
 
 pub struct PhysicsState{
-	pub time:TIME,
+	pub time:Time,
 	pub body:Body,
 	pub world:WorldState,//currently there is only one state the world can be in
 	pub game:GameMechanicsState,
@@ -391,26 +389,24 @@ impl RelativeCollision {
 	}
 }
 
-pub type TIME = i64;
-
 impl Body {
 	pub fn with_pva(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3) -> Self {
 		Self{
 			position,
 			velocity,
 			acceleration,
-			time: 0,
+			time:Time::ZERO,
 		}
 	}
-	pub fn extrapolated_position(&self,time: TIME)->Planar64Vec3{
-		let dt=(time-self.time) as f64/1_000_000_000f64;
-		self.position+self.velocity*(dt as f32)+self.acceleration*((0.5*dt*dt) as f32)
+	pub fn extrapolated_position(&self,time:Time)->Planar64Vec3{
+		let dt=time-self.time;
+		self.position+self.velocity*dt+self.acceleration*(dt*dt*0.5)
 	}
-	pub fn extrapolated_velocity(&self,time: TIME)->Planar64Vec3{
-		let dt=(time-self.time) as f64/1_000_000_000f64;
-		self.velocity+self.acceleration*(dt as f32)
+	pub fn extrapolated_velocity(&self,time:Time)->Planar64Vec3{
+		let dt=time-self.time;
+		self.velocity+self.acceleration*dt
 	}
-	pub fn advance_time(&mut self, time: TIME){
+	pub fn advance_time(&mut self,time:Time){
 		self.position=self.extrapolated_position(time);
 		self.velocity=self.extrapolated_velocity(time);
 		self.time=time;
@@ -420,9 +416,9 @@ impl Body {
 impl Default for PhysicsState{
 	fn default() -> Self {
  		Self{
-			time: 0,
 			spawn_point:Planar64Vec3::new(0,50,0),
 			body: Body::with_pva(Planar64Vec3::new(0,50,0),Planar64Vec3::new(0,0,0),Planar64Vec3::new(0,-100,0)),
+			time: Time::ZERO,
 			style:StyleModifiers::default(),
 			grounded: false,
 			contacts: std::collections::HashMap::new(),
@@ -628,7 +624,7 @@ impl PhysicsState {
 		}
 	}
 	//tickless gaming
-	pub fn run(&mut self, time_limit:TIME){
+	pub fn run(&mut self, time_limit:Time){
 		//prepare is ommitted - everything is done via instructions.
 		while let Some(instruction) = self.next_instruction(time_limit) {//collect
 			//process
@@ -637,7 +633,7 @@ impl PhysicsState {
 		}
 	}
 
-	pub fn advance_time(&mut self, time: TIME){
+	pub fn advance_time(&mut self, time: Time){
 		self.body.advance_time(time);
 		self.time=time;
 	}
@@ -672,7 +668,7 @@ impl PhysicsState {
 	}
 	fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
 		return Some(TimedInstruction{
-			time:(self.time*self.style.strafe_tick_num/self.style.strafe_tick_den+1)*self.style.strafe_tick_den/self.style.strafe_tick_num,
+			time:self.style.strafe_tick_rate.div_int(self.style.strafe_tick_rate.mul_int(self.time)+1),
 			//only poll the physics if there is a before and after mouse event
 			instruction:PhysicsInstruction::StrafeTick
 		});
@@ -727,7 +723,7 @@ impl PhysicsState {
 				let mut a=target_diff/time_delta;
 				self.contact_constrain_acceleration(&mut a);
 				self.body.acceleration=a;
-				self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME;
+				self.walk.target_time=self.body.time+Time::from(time_delta);
 				self.walk.state=WalkEnum::Transient;
 			}
 		}else{
@@ -755,7 +751,7 @@ impl PhysicsState {
 		}
 		aabb
 	}
-	fn predict_collision_end(&self,time:TIME,time_limit:TIME,collision_data:&RelativeCollision) -> Option<TimedInstruction<PhysicsInstruction>> {
+	fn predict_collision_end(&self,time:Time,time_limit:Time,collision_data:&RelativeCollision) -> Option<TimedInstruction<PhysicsInstruction>> {
 		//must treat cancollide false objects differently: you may not exit through the same face you entered.
 		//RelativeCollsion must reference the full model instead of a particular face
 		//this is Ctrl+C Ctrl+V of predict_collision_start but with v=-v before the calc and t=-t after the calc
@@ -773,7 +769,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*-t{
 						//collect valid t
 						best_time=t_time;
@@ -786,7 +782,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&v.x+a.x*-t<0f32{
 						//collect valid t
 						best_time=t_time;
@@ -818,7 +814,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*-t{
 						//collect valid t
 						best_time=t_time;
@@ -831,7 +827,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&v.y+a.y*-t<0f32{
 						//collect valid t
 						best_time=t_time;
@@ -863,7 +859,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*-t{
 						//collect valid t
 						best_time=t_time;
@@ -876,7 +872,7 @@ impl PhysicsState {
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
 					//must be moving towards surface
-					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME;
+					let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
 					if time<=t_time&&t_time<best_time&&v.z+a.z*-t<0f32{
 						//collect valid t
 						best_time=t_time;
@@ -909,7 +905,7 @@ impl PhysicsState {
 		}
 		None
 	}
-	fn predict_collision_start(&self,time:TIME,time_limit:TIME,model_id:u32) -> Option<TimedInstruction<PhysicsInstruction>> {
+	fn predict_collision_start(&self,time:Time,time_limit:Time,model_id:u32) -> Option<TimedInstruction<PhysicsInstruction>> {
 		let mesh0=self.mesh();
 		let mesh1=self.models.get(model_id as usize).unwrap().mesh();
 		let (p,v,a,body_time)=(self.body.position,self.body.velocity,self.body.acceleration,self.body.time);
@@ -921,7 +917,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*t{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -937,7 +933,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&v.x+a.x*t<0f32{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -954,7 +950,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*t{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -970,7 +966,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&v.y+a.y*t<0f32{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -987,7 +983,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*t{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -1003,7 +999,7 @@ impl PhysicsState {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
-			let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME;
+			let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
 			if time<=t_time&&t_time<best_time&&v.z+a.z*t<0f32{
 				let dp=self.body.extrapolated_position(t_time)-p;
 				//faces must be overlapping
@@ -1031,7 +1027,7 @@ impl PhysicsState {
 
 impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState {
 	//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
-	fn next_instruction(&self,time_limit:TIME) -> Option<TimedInstruction<PhysicsInstruction>> {
+	fn next_instruction(&self,time_limit:Time) -> Option<TimedInstruction<PhysicsInstruction>> {
 		//JUST POLLING!!! NO MUTATION
 		let mut collector = crate::instruction::InstructionCollector::new(time_limit);
 		//check for collision stop instructions with curent contacts