lib/common/src/physics.rs

@@ -4,6 +4,7 @@ pub type Time=crate::integer::Time<TimeInner>;
 
 #[derive(Clone,Debug)]
 pub enum Instruction{
+	ReplaceMouse(crate::mouse::MouseState<TimeInner>,crate::mouse::MouseState<TimeInner>),
 	SetNextMouse(crate::mouse::MouseState<TimeInner>),
 	SetMoveRight(bool),
 	SetMoveUp(bool),

strafe-client/src/main.rs

@@ -4,7 +4,6 @@ mod setup;
 mod window;
 mod worker;
 mod physics;
-mod session;
 mod graphics;
 mod settings;
 mod push_solve;
@@ -14,7 +13,6 @@ mod model_physics;
 mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
-mod mouse_interpolator;
 
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 

strafe-client/src/mouse_interpolator.rs

@@ -1,109 +0,0 @@
-use strafesnet_common::mouse::MouseState;
-use strafesnet_common::physics::{Instruction as PhysicsInputInstruction,Time as PhysicsTime,TimeInner as PhysicsTimeInner};
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,TimedInstruction};
-
-type TimedPhysicsInstruction=TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>;
-type PhysicsTimedUnbufferedInstruction=TimedInstruction<UnbufferedInputInstruction,PhysicsTimeInner>;
-type DoubleTimedUnbufferedInstruction=TimedInstruction<PhysicsTimedUnbufferedInstruction,SessionTimeInner>;
-
-const MOUSE_TIMEOUT:SessionTime=SessionTime::from_millis(10);
-
-#[derive(Debug)]
-pub enum UnbufferedInputInstruction{
-	MoveMouse(glam::IVec2),
-	MoveRight(bool),
-	MoveUp(bool),
-	MoveBack(bool),
-	MoveLeft(bool),
-	MoveDown(bool),
-	MoveForward(bool),
-	Jump(bool),
-	Zoom(bool),
-	ResetAndRestart,
-	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
-	PracticeFly,
-	Idle,
-}
-
-pub enum StepInstruction{
-	Other,
-	ReplaceMouse,
-}
-
-pub struct MouseInterpolator{
-	last_mouse_state:MouseState<SessionTimeInner>,
-	// double timestamped timeline?
-	physics_timeline:std::collections::VecDeque<TimedPhysicsInstruction>,
-}
-// Maybe MouseInterpolator manipulation is better expressed using impls
-// and called from Instruction trait impls in session
-impl InstructionConsumer<PhysicsTimedUnbufferedInstruction> for MouseInterpolator{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:DoubleTimedUnbufferedInstruction){
-		self.push_unbuffered_input(ins)
-	}
-}
-impl InstructionEmitter<StepInstruction> for MouseInterpolator{
-	type TimeInner=SessionTimeInner;
-	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
-		self.buffered_instruction_with_timeout(time_limit)
-	}
-}
-impl MouseInterpolator{
-	pub fn new()->MouseInterpolator{
-		MouseInterpolator{
-			last_mouse_state:MouseState::default(),
-			physics_timeline:std::collections::VecDeque::new(),
-		}
-	}
-	pub fn push_unbuffered_input(&mut self,ins:DoubleTimedUnbufferedInstruction){
-		// new input
-		// if there is zero instruction buffered, it means the mouse is not moving
-	}
-	fn is_first_ready(&self)->bool{
-		// if the last instruction is a mouse instruction
-		// and there is 2 or more instructions
-		1<self.physics_timeline.len()&&matches!(self.physics_timeline.back(),Some(TimedInstruction{
-			instruction:PhysicsInputInstruction::SetNextMouse(_),
-			..
-		}))
-	}
-	pub fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTimeInner>>{
-		let timeout=self.last_mouse_state.time+MOUSE_TIMEOUT;
-		if timeout<time_limit{
-			// if the mouse has stopped moving for over 10ms, emit DoStepReplaceMouse at that exact timestamp
-			Some(TimedInstruction{
-				time:timeout,
-				instruction:StepInstruction::ReplaceMouse,
-			})
-		}else if self.is_first_ready(){
-			// emit Step
-			Some(TimedInstruction{
-				// this timestamp should not matter
-				// verify this and potentially emit a different type using the enum only
-				time:time_limit,
-				instruction:StepInstruction::Other,
-			})
-		}else{
-			None
-		}
-	}
-	pub fn pop_buffered_instruction(&mut self,ins:StepInstruction)->Option<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>{
-		match ins{
-			StepInstruction::Other=>{
-				// if the last instruction is a mouse instruction,
-				// then the buffer is in the process of flushing.
-				// pop and return the first event.
-				// if the first instruction is a mouse instruction,
-				// then events are being buffered to wait for another
-				// mouse instruction as an interpolation target
-			},
-			StepInstruction::ReplaceMouse=>{
-				// use the first instruction which should be a mouse instruction
-				// to push a ReplaceMouse instruction
-			},
-		}
-		None
-	}
-}

strafe-client/src/physics.rs

@@ -1759,6 +1759,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		|PhysicsInputInstruction::Idle=>false,
 		//these controls only update the body if you are on the ground
 		PhysicsInputInstruction::SetNextMouse(..)
+		|PhysicsInputInstruction::ReplaceMouse(..)
 		|PhysicsInputInstruction::SetMoveForward(..)
 		|PhysicsInputInstruction::SetMoveLeft(..)
 		|PhysicsInputInstruction::SetMoveBack(..)
@@ -1788,6 +1789,10 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 						state.camera.move_mouse(state.input_state.mouse_delta());
 						state.input_state.set_next_mouse(m);
 					},
+					PhysicsInputInstruction::ReplaceMouse(m0,m1)=>{
+						state.camera.move_mouse(m0.pos-state.input_state.mouse.pos);
+						state.input_state.replace_mouse(m0,m1);
+					},
 					PhysicsInputInstruction::SetMoveForward(s)=>state.input_state.set_control(Controls::MoveForward,s),
 					PhysicsInputInstruction::SetMoveLeft(s)=>state.input_state.set_control(Controls::MoveLeft,s),
 					PhysicsInputInstruction::SetMoveBack(s)=>state.input_state.set_control(Controls::MoveBackward,s),

strafe-client/src/physics_worker.rs

@@ -1,39 +1,249 @@
-use crate::graphics_worker::Instruction as GraphicsInstruction;
-use crate::session::{Instruction as SessionInstruction,Session, Simulation};
-use strafesnet_common::physics::Time as PhysicsTime;
+use strafesnet_common::mouse::MouseState;
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::timer::Timer;
+use strafesnet_common::physics::{Time as PhysicsTime,TimeInner as PhysicsTimeInner,Instruction as PhysicsInputInstruction};
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::timer::{Scaled,Timer,TimerState};
+use mouse_interpolator::MouseInterpolator;
 
-type TimedSessionInstruction=strafesnet_common::instruction::TimedInstruction<SessionInstruction,SessionTimeInner>;
+
+pub struct FrameState{
+	pub body:crate::physics::Body,
+	pub camera:crate::physics::PhysicsCamera,
+	pub time:PhysicsTime,
+}
+
+#[derive(Debug)]
+pub enum InputInstruction{
+	MoveMouse(glam::IVec2),
+	MoveRight(bool),
+	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
+	MoveDown(bool),
+	MoveForward(bool),
+	Jump(bool),
+	Zoom(bool),
+	ResetAndRestart,
+	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
+	PracticeFly,
+}
+pub enum Instruction{
+	Input(InputInstruction),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>),
+	ChangeMap(strafesnet_common::map::CompleteMap),
+	//SetPaused is not an InputInstruction: the physics doesn't know that it's paused.
+	SetPaused(bool),
+	//Graphics(crate::graphics_worker::Instruction),
+}
+mod mouse_interpolator{
+	use super::*;
+	//TODO: move this or tab
+pub struct MouseInterpolator{
+	//"PlayerController"
+	user_settings:crate::settings::UserSettings,
+	//"MouseInterpolator"
+	timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
+	last_mouse_time:PhysicsTime,
+	mouse_blocking:bool,
+	//"Simulation"
+	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
+	physics:crate::physics::PhysicsContext,
+
+}
+impl MouseInterpolator{
+	pub fn new(
+		physics:crate::physics::PhysicsContext,
+		user_settings:crate::settings::UserSettings,
+	)->MouseInterpolator{
+		MouseInterpolator{
+			mouse_blocking:true,
+			last_mouse_time:physics.get_next_mouse().time,
+			timeline:std::collections::VecDeque::new(),
+			timer:Timer::from_state(Scaled::identity(),false),
+			physics,
+			user_settings,
+		}
+	}
+	fn push_mouse_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>,m:glam::IVec2){
+		if self.mouse_blocking{
+			//tell the game state which is living in the past about its future
+			self.timeline.push_front(TimedInstruction{
+				time:self.last_mouse_time,
+				instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(ins.time),pos:m}),
+			});
+		}else{
+			//mouse has just started moving again after being still for longer than 10ms.
+			//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
+			self.timeline.push_front(TimedInstruction{
+				time:self.last_mouse_time,
+				instruction:PhysicsInputInstruction::ReplaceMouse(
+					MouseState{time:self.last_mouse_time,pos:self.physics.get_next_mouse().pos},
+					MouseState{time:self.timer.time(ins.time),pos:m}
+				),
+			});
+			//delay physics execution until we have an interpolation target
+			self.mouse_blocking=true;
+		}
+		self.last_mouse_time=self.timer.time(ins.time);
+	}
+	fn push(&mut self,time:SessionTime,phys_input:PhysicsInputInstruction){
+		//This is always a non-mouse event
+		self.timeline.push_back(TimedInstruction{
+			time:self.timer.time(time),
+			instruction:phys_input,
+		});
+	}
+	/// returns should_empty_queue
+	/// may or may not mutate internal state XD!
+	fn map_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>)->bool{
+		let mut update_mouse_blocking=true;
+		match &ins.instruction{
+			Instruction::Input(input_instruction)=>match input_instruction{
+				&InputInstruction::MoveMouse(m)=>{
+					if !self.timer.is_paused(){
+						self.push_mouse_instruction(ins,m);
+					}
+					update_mouse_blocking=false;
+				},
+				&InputInstruction::MoveForward(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveForward(s)),
+				&InputInstruction::MoveLeft(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveLeft(s)),
+				&InputInstruction::MoveBack(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveBack(s)),
+				&InputInstruction::MoveRight(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveRight(s)),
+				&InputInstruction::MoveUp(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveUp(s)),
+				&InputInstruction::MoveDown(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveDown(s)),
+				&InputInstruction::Jump(s)=>self.push(ins.time,PhysicsInputInstruction::SetJump(s)),
+				&InputInstruction::Zoom(s)=>self.push(ins.time,PhysicsInputInstruction::SetZoom(s)),
+				&InputInstruction::ResetAndSpawn(mode_id,stage_id)=>{
+					self.push(ins.time,PhysicsInputInstruction::Reset);
+					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
+					self.push(ins.time,PhysicsInputInstruction::Spawn(mode_id,stage_id));
+				},
+				InputInstruction::ResetAndRestart=>{
+					self.push(ins.time,PhysicsInputInstruction::Reset);
+					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
+					self.push(ins.time,PhysicsInputInstruction::Restart);
+				},
+				InputInstruction::PracticeFly=>self.push(ins.time,PhysicsInputInstruction::PracticeFly),
+			},
+			//do these really need to idle the physics?
+			//sending None dumps the instruction queue
+			Instruction::ChangeMap(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			Instruction::Resize(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			Instruction::Render=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			&Instruction::SetPaused(paused)=>{
+				if let Err(e)=self.timer.set_paused(ins.time,paused){
+					println!("Cannot SetPaused: {e}");
+				}
+				self.push(ins.time,PhysicsInputInstruction::Idle);
+			},
+		}
+		if update_mouse_blocking{
+			//this returns the bool for us
+			self.update_mouse_blocking(ins.time)
+		}else{
+			//do flush that queue
+			true
+		}
+	}
+	/// must check if self.mouse_blocking==true before calling!
+	fn unblock_mouse(&mut self,time:SessionTime){
+		//push an event to extrapolate no movement from
+		self.timeline.push_front(TimedInstruction{
+			time:self.last_mouse_time,
+			instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(time),pos:self.physics.get_next_mouse().pos}),
+		});
+		self.last_mouse_time=self.timer.time(time);
+		//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
+		self.mouse_blocking=false;
+	}
+	fn update_mouse_blocking(&mut self,time:SessionTime)->bool{
+		if self.mouse_blocking{
+			//assume the mouse has stopped moving after 10ms.
+			//shitty mice are 125Hz which is 8ms so this should cover that.
+			//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
+			//so mouse events are probably not handled separately from drawing and fire right before it :(
+			if PhysicsTime::from_millis(10)<self.timer.time(time)-self.physics.get_next_mouse().time{
+				self.unblock_mouse(time);
+				true
+			}else{
+				false
+			}
+		}else{
+			//keep this up to date so that it can be used as a known-timestamp
+			//that the mouse was not moving when the mouse starts moving again
+			self.last_mouse_time=self.timer.time(time);
+			true
+		}
+	}
+	fn empty_queue(&mut self){
+		while let Some(instruction)=self.timeline.pop_front(){
+			self.physics.run_input_instruction(instruction);
+		}
+	}
+	pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>){
+		let should_empty_queue=self.map_instruction(ins);
+		if should_empty_queue{
+			self.empty_queue();
+		}
+	}
+	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
+		FrameState{
+			body:self.physics.camera_body(),
+			camera:self.physics.camera(),
+			time:self.timer.time(time),
+		}
+	}
+	pub fn change_map(&mut self,time:SessionTime,map:&strafesnet_common::map::CompleteMap){
+		//dump any pending interpolation state
+		if self.mouse_blocking{
+			self.unblock_mouse(time);
+		}
+		self.empty_queue();
+
+		//doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>)
+		self.physics.generate_models(&map);
+
+		//use the standard input interface so the instructions are written out to bots
+		self.handle_instruction(&TimedInstruction{
+			time,
+			instruction:Instruction::Input(InputInstruction::ResetAndSpawn(
+				strafesnet_common::gameplay_modes::ModeId::MAIN,
+				strafesnet_common::gameplay_modes::StageId::FIRST,
+			)),
+		});
+	}
+	pub const fn user_settings(&self)->&crate::settings::UserSettings{
+		&self.user_settings
+	}
+}
+}
 
 pub fn new<'a>(
 	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
 	user_settings:crate::settings::UserSettings,
-)->crate::compat_worker::QNWorker<'a,TimedSessionInstruction>{
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
 	let physics=crate::physics::PhysicsContext::default();
-	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
-	let simulation=Simulation::new(timer,physics);
-	let mouse_interpolator=crate::mouse_interpolator::MouseInterpolator::new();
-	let mut session=Session::new(
-		user_settings,
-		simulation,
+	let mut interpolator=MouseInterpolator::new(
+		physics,
+		user_settings
 	);
-	crate::compat_worker::QNWorker::new(move |ins:TimedSessionInstruction|{
-		session.handle_instruction(&ins);
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
+		interpolator.handle_instruction(&ins);
 		match ins.instruction{
-			SessionInstruction::Render=>{
-				let frame_state=session.get_frame_state(ins.time);
-				graphics_worker.send(GraphicsInstruction::Render(frame_state)).unwrap();
+			Instruction::Render=>{
+				let frame_state=interpolator.get_frame_state(ins.time);
+				graphics_worker.send(crate::graphics_worker::Instruction::Render(frame_state)).unwrap();
 			},
-			SessionInstruction::Resize(size)=>{
-				graphics_worker.send(GraphicsInstruction::Resize(size,session.user_settings().clone())).unwrap();
+			Instruction::Resize(size)=>{
+				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
 			},
-			SessionInstruction::ChangeMap(map)=>{
-				session.change_map(ins.time,&map);
-				graphics_worker.send(GraphicsInstruction::ChangeMap(map)).unwrap();
+			Instruction::ChangeMap(map)=>{
+				interpolator.change_map(ins.time,&map);
+				graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).unwrap();
 			},
-			SessionInstruction::Input(_)=>(),
-			SessionInstruction::SetPaused(_)=>(),
+			Instruction::Input(_)=>(),
+			Instruction::SetPaused(_)=>(),
 		}
 	})
 }

strafe-client/src/session.rs

@@ -1,127 +0,0 @@
-use strafesnet_common::instruction::{InstructionConsumer, InstructionEmitter, InstructionFeedback, TimedInstruction};
-// session represents the non-hardware state of the client.
-// Ideally it is a deterministic state which is atomically updated by instructions, same as the simulation state.
-use strafesnet_common::physics::{Instruction as PhysicsInputInstruction,TimeInner as PhysicsTimeInner,Time as PhysicsTime};
-use strafesnet_common::timer::{Scaled,Timer};
-use strafesnet_common::session::{TimeInner as SessionTimeInner,Time as SessionTime};
-
-use crate::mouse_interpolator::{MouseInterpolator,UnbufferedInputInstruction,StepInstruction};
-
-pub enum ExternalInstruction{
-	ToBuffer(UnbufferedInputInstruction),
-	SetPaused(bool),
-	Render,
-	Resize(winit::dpi::PhysicalSize<u32>),
-	ChangeMap(strafesnet_common::map::CompleteMap),
-	//Graphics(crate::graphics_worker::Instruction),
-}
-
-pub struct FrameState{
-	pub body:crate::physics::Body,
-	pub camera:crate::physics::PhysicsCamera,
-	pub time:PhysicsTime,
-}
-
-pub struct Simulation{
-	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-	physics:crate::physics::PhysicsContext,
-}
-impl Simulation{
-	pub const fn new(
-		timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-		physics:crate::physics::PhysicsContext,
-	)->Self{
-		Self{
-			timer,
-			physics,
-		}
-	}
-}
-
-pub struct Replay{
-	last_instruction_id:usize,
-	instructions:Vec<PhysicsInputInstruction>,
-	simulation:Simulation,
-}
-impl Replay{
-	pub const fn new(
-		instructions:Vec<PhysicsInputInstruction>,
-		simulation:Simulation,
-	)->Self{
-		Self{
-			last_instruction_id:0,
-			instructions,
-			simulation,
-		}
-	}
-}
-
-pub struct Session{
-	user_settings:crate::settings::UserSettings,
-	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
-	//gui:GuiState
-	simulation:Simulation,
-	replays:Vec<Replay>,
-}
-impl Session{
-	pub fn new(
-		user_settings:crate::settings::UserSettings,
-		simulation:Simulation,
-	)->Self{
-		Self{
-			user_settings,
-			mouse_interpolator:MouseInterpolator::new(),
-			simulation,
-			replays:Vec::new(),
-		}
-	}
-}
-
-// mouseinterpolator consumes RawInputInstruction
-// mouseinterpolator emits PhysicsInputInstruction
-// mouseinterpolator consumes DoStep to move on to the next emitted instruction
-// Session comsumes SessionInstruction -> forwards RawInputInstruction to mouseinterpolator
-// Session consumes DoStep -> forwards DoStep to mouseinterpolator
-// Session emits DoStep
-
-impl InstructionConsumer<ExternalInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<ExternalInstruction,Self::TimeInner>){
-		match ins.instruction{
-			// send it down to MouseInterpolator with two timestamps, SessionTime and PhysicsTime
-			ExternalInstruction::ToBuffer(instruction)=>self.mouse_interpolator.process_instruction(TimedInstruction{
-				time:ins.time,
-				instruction:TimedInstruction{
-					time:self.simulation.timer.time(ins.time),
-					instruction,
-				},
-			}),
-			ExternalInstruction::SetPaused(paused)=>{
-				// don't flush the buffered instructions in the mouse interpolator
-				// until the mouse is confirmed to be not moving at a later time
-				// what if they pause for 5ms lmao
-				_=self.simulation.timer.set_paused(ins.time,paused);
-			}
-			ExternalInstruction::Render=>(),
-			ExternalInstruction::Resize(physical_size)=>(),
-			ExternalInstruction::ChangeMap(complete_map)=>(),
-		};
-		// run all buffered instruction produced
-		self.process_exhaustive(ins.time);
-	}
-}
-impl InstructionConsumer<StepInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::TimeInner>){
-		// ins.time ignored???
-		if let Some(instruction)=self.mouse_interpolator.pop_buffered_instruction(ins.instruction){
-			self.simulation.physics.run_input_instruction(instruction);
-		}
-	}
-}
-impl InstructionEmitter<StepInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
-		self.mouse_interpolator.next_instruction(time_limit)
-	}
-}

strafe-client/src/window.rs

@@ -1,4 +1,5 @@
 use crate::physics_worker::InputInstruction;
+use strafesnet_common::integer;
 use strafesnet_common::instruction::TimedInstruction;
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};