print edge -> face

engine/physics/src/face_crawler.rs

@@ -74,13 +74,13 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
-		M::Edge:Copy,
-		M::Vert:Copy,
+		M::Edge:Copy+core::fmt::Debug,
+		M::Vert:Copy+core::fmt::Debug,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition<const ENABLE_DEBUG:bool>(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -132,6 +132,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
 						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							if ENABLE_DEBUG{
+								println!("Face Crawler FEV::Edge({edge_id:?}) -> FEV::Face");
+							}
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
@@ -160,6 +163,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							if ENABLE_DEBUG{
+								println!("Face Crawler FEV::Vert({vert_id:?}) -> FEV::Edge");
+							}
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
@@ -172,11 +178,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+	pub fn crawl<const ENABLE_DEBUG:bool>(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
 		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
 		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
 		for _ in 0..20{
-			match self.next_transition(mesh,relative_body,lower_bound,upper_bound){
+			match self.next_transition::<ENABLE_DEBUG>(mesh,relative_body,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/model.rs

@@ -103,17 +103,21 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
+	// I didn't write it down, but I assume the edges are directed
+	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
+	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//bottom, top
+	verts:[SubmeshVertId;2],//start, end
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
+	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -762,13 +766,13 @@ impl MinkowskiMesh<'_>{
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::zero();
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+			infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,start_time).miss()
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+			fev.crawl::<true>(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)>{
@@ -778,7 +782,7 @@ impl MinkowskiMesh<'_>{
 		let infinity_body=-relative_body;
 		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			fev.crawl::<true>(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))
 		})
@@ -814,7 +818,7 @@ impl MinkowskiMesh<'_>{
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
 		// Bound::Included means that the surface of the mesh is included in the mesh
-		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
+		infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
 		let infinity_body=Body::new(point,vec3::Y,vec3::zero(),Time::ZERO);

engine/physics/src/physics.rs

@@ -488,21 +488,8 @@ impl StyleHelper for StyleModifiers{
 	}
 }
 #[derive(Clone,Debug)]
-struct StrafeTickState{
-	tick_number:u64,
-}
-impl StrafeTickState{
-	fn next_tick(&self,settings:&gameplay_style::StrafeSettings)->Time{
-		let n=self.tick_number as i128;
-		let ticks=settings.tick_rate.num() as i128;
-		let seconds=settings.tick_rate.den() as i128;
-		let time=n*seconds/ticks;
-		Time::from_nanos(time as i64)
-	}
-}
-#[derive(Clone,Debug)]
 enum MoveState{
-	Air(StrafeTickState),
+	Air,
 	Walk(ContactMoveState),
 	Ladder(ContactMoveState),
 	#[expect(dead_code)]
@@ -510,21 +497,11 @@ enum MoveState{
 	Fly,
 }
 impl MoveState{
-	fn air(time:Time,settings:Option<&gameplay_style::StrafeSettings>)->Self{
-		let tick_number=if let Some(settings)=settings{
-			// let time=n*seconds/ticks;
-			let time=time.nanos() as i128;
-			let ticks=settings.tick_rate.num() as i128;
-			let seconds=settings.tick_rate.den() as i128;
-			(time*ticks/seconds) as u64
-		}else{0};
-		MoveState::Air(StrafeTickState{tick_number})
-	}
 	//call this after state.move_state is changed
 	fn apply_enum(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly=>body.acceleration=vec3::zero(),
-			MoveState::Air(_)=>{
+			MoveState::Air=>{
 				//calculate base acceleration
 				let a=touching.base_acceleration(models,style,camera,input_state);
 				//set_acceleration clips according to contacts
@@ -536,7 +513,7 @@ impl MoveState{
 	//function to coerce &mut self into &self
 	fn apply_to_body(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
-			MoveState::Air(_)=>(),
+			MoveState::Air=>(),
 			MoveState::Water=>(),
 			MoveState::Fly=>{
 				//set velocity according to current control state
@@ -557,7 +534,7 @@ impl MoveState{
 	fn apply_input(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly
-			|MoveState::Air(_)
+			|MoveState::Air
 			|MoveState::Water=>(),
 			MoveState::Walk(ContactMoveState{target,contact,jump_direction:_})=>{
 				if let Some(walk_settings)=&style.walk{
@@ -582,13 +559,13 @@ impl MoveState{
 			MoveState::Walk(walk_state)
 			|MoveState::Ladder(walk_state)
 			=>Some(walk_state),
-			MoveState::Air(_)
+			MoveState::Air
 			|MoveState::Water
 			|MoveState::Fly
 			=>None,
 		}
 	}
-	fn next_move_instruction(&self,strafe:Option<&gameplay_style::StrafeSettings>)->Option<TimedInstruction<InternalInstruction,Time>>{
+	fn next_move_instruction(&self,strafe:&Option<gameplay_style::StrafeSettings>,time:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
 		//check if you have a valid walk state and create an instruction
 		match self{
 			MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>match &walk_state.target{
@@ -600,9 +577,9 @@ impl MoveState{
 				|TransientAcceleration::Reached
 				=>None,
 			}
-			MoveState::Air(strafe_tick_state)=>strafe.as_ref().map(|strafe|{
+			MoveState::Air=>strafe.as_ref().map(|strafe|{
 				TimedInstruction{
-					time:strafe_tick_state.next_tick(strafe),
+					time:strafe.next_tick(time),
 					//only poll the physics if there is a before and after mouse event
 					instruction:InternalInstruction::StrafeTick
 				}
@@ -630,7 +607,7 @@ impl MoveState{
 		//this function call reads the above state that was just set
 		self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
-	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState,time:Time){
+	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		//TODO: be more precise about contacts
 		if set_velocity_cull(body,touching,models,hitbox_mesh,velocity){
 			// TODO do better
@@ -638,7 +615,7 @@ impl MoveState{
 			match self.get_walk_state(){
 				// did you stop touching the thing you were walking on?
 				Some(walk_state)=>if !touching.contains_contact(&walk_state.contact.convex_mesh_id){
-					self.set_move_state(MoveState::air(time,style.strafe.as_ref()),body,touching,models,hitbox_mesh,style,camera,input_state);
+					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
 					self.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
@@ -913,7 +890,7 @@ impl Default for PhysicsState{
 			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
-			move_state:MoveState::air(Time::ZERO,None),
+			move_state:MoveState::Air,
 			camera:PhysicsCamera::default(),
 			input_state:InputState::default(),
 			_world:WorldState{},
@@ -958,10 +935,10 @@ impl PhysicsState{
 		*self=Self::default();
 	}
 	fn next_move_instruction(&self)->Option<TimedInstruction<InternalInstruction,Time>>{
-		self.move_state.next_move_instruction(self.style.strafe.as_ref())
+		self.move_state.next_move_instruction(&self.style.strafe,self.time)
 	}
-	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3,time:Time){
-		self.move_state.cull_velocity(velocity,&mut self.body,&mut self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state,time);
+	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3){
+		self.move_state.cull_velocity(velocity,&mut self.body,&mut self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
 	}
 	fn set_move_state(&mut self,data:&PhysicsData,move_state:MoveState){
 		self.move_state.set_move_state(move_state,&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
@@ -1285,7 +1262,7 @@ fn recalculate_touching(
 	//I would have preferred while let Some(contact)=contacts.pop()
 	//but there is no such method
 	while let Some((&convex_mesh_id,_face_id))=touching.contacts.iter().next(){
-		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id,time)
+		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id)
 	}
 	while let Some(&convex_mesh_id)=touching.intersects.iter().next(){
 		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(convex_mesh_id.model_id),&convex_mesh_id,time);
@@ -1621,7 +1598,7 @@ fn collision_start_contact(
 				gameplay_attributes::SetTrajectory::TargetPointTime{..}=>todo!(),
 				gameplay_attributes::SetTrajectory::TargetPointSpeed{..}=>todo!(),
 				&gameplay_attributes::SetTrajectory::Velocity(velocity)=>{
-					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state,time);
+					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
 				},
 				gameplay_attributes::SetTrajectory::DotVelocity{..}=>todo!(),
 			}
@@ -1651,7 +1628,7 @@ fn collision_start_contact(
 			}else{
 				let jump_dir=walk_state.jump_direction.direction(models,hitbox_mesh,&walk_state.contact);
 				let jumped_velocity=jump_settings.jumped_velocity(style,jump_dir,body.velocity,attr.general.booster.as_ref());
-				move_state.cull_velocity(jumped_velocity,body,touching,models,hitbox_mesh,style,camera,input_state,time);
+				move_state.cull_velocity(jumped_velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
 			}
 		}
 	}
@@ -1681,7 +1658,7 @@ fn collision_start_intersect(
 	touching.insert_intersect(intersect);
 	//insta booster!
 	if let Some(booster)=&attr.general.booster{
-		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state,time);
+		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(intersect.convex_mesh_id.model_id.into());
@@ -1715,7 +1692,6 @@ fn collision_end_contact(
 	input_state:&InputState,
 	_attr:&gameplay_attributes::ContactAttributes,
 	convex_mesh_id:&ConvexMeshId<ContactModelId>,
-	time:Time,
 ){
 	touching.remove_contact(convex_mesh_id);//remove contact before calling contact_constrain_acceleration
 	//check ground
@@ -1726,7 +1702,7 @@ fn collision_end_contact(
 		// This does not check the face! Is that a bad thing? It should be
 		// impossible to stop touching a different face than you started touching...
 		Some(walk_state)=>if &walk_state.contact.convex_mesh_id==convex_mesh_id{
-			move_state.set_move_state(MoveState::air(time,style.strafe.as_ref()),body,touching,models,hitbox_mesh,style,camera,input_state);
+			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
 			move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1805,8 +1781,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 				Collision::Contact(contact)=>collision_end_contact(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.models.contact_attr(contact.convex_mesh_id.model_id),
-					&contact.convex_mesh_id,
-					state.time,
+					&contact.convex_mesh_id
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
@@ -1818,11 +1793,6 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 				),
 			},
 			InternalInstruction::StrafeTick=>{
-				let strafe_tick_state=match &mut state.move_state{
-					MoveState::Air(strafe_tick_state)=>strafe_tick_state,
-					_=>panic!("StrafeTick fired for non-air MoveState"),
-				};
-				strafe_tick_state.tick_number+=1;
 				//TODO make this less huge
 				if let Some(strafe_settings)=&state.style.strafe{
 					let controls=state.input_state.controls;
@@ -1834,7 +1804,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
 								//need to note which push planes activate in push solve and keep those
-								state.cull_velocity(data,ticked_velocity,state.time);
+								state.cull_velocity(data,ticked_velocity);
 							}
 						}
 					}
@@ -1842,7 +1812,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 			}
 			InternalInstruction::ReachWalkTargetVelocity=>{
 				match &mut state.move_state{
-					MoveState::Air(_)
+					MoveState::Air
 					|MoveState::Water
 					|MoveState::Fly
 					=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
@@ -1884,7 +1854,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 				|MoveState::Water
 				|MoveState::Walk(_)
 				|MoveState::Ladder(_)=>true,
-				MoveState::Air(_)=>false,
+				MoveState::Air=>false,
 			}
 		},
 		//the body must be updated unconditionally
@@ -1918,7 +1888,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 					let jump_dir=walk_state.jump_direction.direction(&data.models,&data.hitbox_mesh,&walk_state.contact);
 					let booster_option=data.models.contact_attr(walk_state.contact.convex_mesh_id.model_id).general.booster.as_ref();
 					let jumped_velocity=jump_settings.jumped_velocity(&state.style,jump_dir,state.body.velocity,booster_option);
-					state.cull_velocity(data,jumped_velocity,state.time);
+					state.cull_velocity(data,jumped_velocity);
 				}
 			}
 			b_refresh_walk_target=false;
@@ -1948,7 +1918,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			}
 			set_position(spawn_point,&mut state.move_state,&mut state.body,&mut state.touching,&mut state.run,&mut state.mode_state,mode,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,state.time);
 			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
-			state.set_move_state(data,MoveState::air(state.time,state.style.strafe.as_ref()));
+			state.set_move_state(data,MoveState::Air);
 			b_refresh_walk_target=false;
 		}
 		// Spawn does not necessarily imply reset
@@ -1972,7 +1942,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Misc(MiscInstruction::PracticeFly)=>{
 			match &state.move_state{
 				MoveState::Fly=>{
-					state.set_move_state(data,MoveState::air(state.time,state.style.strafe.as_ref()));
+					state.set_move_state(data,MoveState::Air);
 				},
 				_=>{
 					state.set_move_state(data,MoveState::Fly);
@@ -1987,7 +1957,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 	}
 	if b_refresh_walk_target{
 		state.apply_input_and_body(data);
-		state.cull_velocity(data,state.body.velocity,state.time);
+		state.cull_velocity(data,state.body.velocity);
 		//also check if accelerating away from surface
 	}
 }

lib/common/src/gameplay_style.rs

@@ -2,6 +2,7 @@ const VALVE_SCALE:Planar64=Planar64::raw(1<<28);// 1/16
 
 use crate::integer::{int,vec3::int as int3,AbsoluteTime,Ratio64,Planar64,Planar64Vec3};
 use crate::controls_bitflag::Controls;
+use crate::physics::Time as PhysicsTime;
 
 #[derive(Clone,Debug)]
 pub struct StyleModifiers{
@@ -272,6 +273,9 @@ impl StrafeSettings{
 			false=>None,
 		}
 	}
+	pub fn next_tick(&self,time:PhysicsTime)->PhysicsTime{
+		PhysicsTime::from_nanos(self.tick_rate.rhs_div_int(self.tick_rate.mul_int(time.nanos())+1))
+	}
 	pub const fn activates(&self,controls:Controls)->bool{
 		self.enable.activates(controls)
 	}