aidan9382/strafe-client
1
Fork 0
forked from StrafesNET/strafe-client
Code Pull Requests Activity

yeah

Browse Source
This commit is contained in:
Quaternions 2024-08-05 16:53:21 -07:00
parent 26b286af31
commit 78cf5e155e
2 changed files with 47 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
src/physics_worker.rs
View File

@ -16,12 +16,8 @@ pub enum InputInstruction{
MoveForward(bool), MoveForward(bool),
Jump(bool), Jump(bool),
Zoom(bool), Zoom(bool),
/// Reset: fully replace the physics state. ResetAndRestart,
/// This forgets all inputs and settings which need to be reapplied. ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
Reset,
/// Restart: Teleport to the start zone.
Restart,
Spawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
PracticeFly, PracticeFly,
} }
pub enum Instruction{ pub enum Instruction{
@ -87,41 +83,62 @@ impl MouseInterpolator<'_>{
} }
self.last_mouse_time=self.timer.time(ins.time); self.last_mouse_time=self.timer.time(ins.time);
} }
/// returns the mapped physics input instruction fn push(&mut self,time:Time,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! /// may or may not mutate internal state XD!
fn map_instruction(&mut self,ins:&TimedInstruction<Instruction>)->Option<PhysicsInputInstruction>{ fn map_instruction(&mut self,ins:&TimedInstruction<Instruction>)->bool{
let mut update_mouse_blocking=false;
match &ins.instruction{ match &ins.instruction{
Instruction::Input(input_instruction)=>match input_instruction{ Instruction::Input(input_instruction)=>match input_instruction{
&InputInstruction::MoveMouse(m)=>{ &InputInstruction::MoveMouse(m)=>{
if !self.timer.is_paused(){ if !self.timer.is_paused(){
self.push_mouse_instruction(ins,m); self.push_mouse_instruction(ins,m);
} }
None update_mouse_blocking=true;
}, },
&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)), &InputInstruction::MoveForward(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveForward(s)),
&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)), &InputInstruction::MoveLeft(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveLeft(s)),
&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)), &InputInstruction::MoveBack(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveBack(s)),
&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)), &InputInstruction::MoveRight(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveRight(s)),
&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)), &InputInstruction::MoveUp(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveUp(s)),
&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)), &InputInstruction::MoveDown(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveDown(s)),
&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)), &InputInstruction::Jump(s)=>self.push(ins.time,PhysicsInputInstruction::SetJump(s)),
&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)), &InputInstruction::Zoom(s)=>self.push(ins.time,PhysicsInputInstruction::SetZoom(s)),
&InputInstruction::Spawn(mode_id,stage_id)=>Some(PhysicsInputInstruction::Spawn(mode_id,stage_id)), &InputInstruction::ResetAndSpawn(mode_id,stage_id)=>{
InputInstruction::Restart=>Some(PhysicsInputInstruction::Restart), self.push(ins.time,PhysicsInputInstruction::Reset);
InputInstruction::PracticeFly=>Some(PhysicsInputInstruction::PracticeFly), self.push(ins.time,PhysicsInputInstruction::Spawn(mode_id,stage_id));
},
InputInstruction::ResetAndRestart=>{
self.push(ins.time,PhysicsInputInstruction::Reset);
self.push(ins.time,PhysicsInputInstruction::Restart);
},
InputInstruction::PracticeFly=>self.push(ins.time,PhysicsInputInstruction::PracticeFly),
}, },
//do these really need to idle the physics? //do these really need to idle the physics?
//sending None dumps the instruction queue //sending None dumps the instruction queue
Instruction::ChangeMap(_)=>Some(PhysicsInputInstruction::Idle), Instruction::ChangeMap(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
Instruction::Resize(_)=>Some(PhysicsInputInstruction::Idle), Instruction::Resize(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
Instruction::Render=>Some(PhysicsInputInstruction::Idle), Instruction::Render=>self.push(ins.time,PhysicsInputInstruction::Idle),
&Instruction::SetPaused(paused)=>{ &Instruction::SetPaused(paused)=>{
if let Err(e)=self.timer.set_paused(ins.time,paused){ if let Err(e)=self.timer.set_paused(ins.time,paused){
println!("Cannot pause: {e}"); println!("Cannot pause: {e}");
} }
Some(PhysicsInputInstruction::Idle) 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! /// must check if self.mouse_blocking==true before calling!
fn unblock_mouse(&mut self,time:Time){ fn unblock_mouse(&mut self,time:Time){
@ -153,17 +170,6 @@ impl MouseInterpolator<'_>{
true true
} }
} }
/// returns whether or not to empty the instruction queue
fn handle_physics_input(&mut self,time:Time,phys_input:PhysicsInputInstruction)->bool{
//non-mouse event
self.timeline.push_back(TimedInstruction{
time:self.timer.time(time),
instruction:phys_input,
});
//this returns the bool for us
self.update_mouse_blocking(time)
}
fn empty_queue(&mut self){ fn empty_queue(&mut self){
while let Some(instruction)=self.timeline.pop_front(){ while let Some(instruction)=self.timeline.pop_front(){
//makeshift clone because requiring all TimedInstructions to be Clone is troublesome //makeshift clone because requiring all TimedInstructions to be Clone is troublesome
@ -177,12 +183,7 @@ impl MouseInterpolator<'_>{
} }
} }
pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction>){ pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction>){
let should_empty_queue=self.map_instruction(ins) let should_empty_queue=self.map_instruction(ins);
//should empty queue defaults to true
.map_or(true,|physics_input|
//this returns whether to empty the queue based on the input
self.handle_physics_input(ins.time,physics_input)
);
if should_empty_queue{ if should_empty_queue{
self.empty_queue(); self.empty_queue();
} }
@ -196,22 +197,14 @@ impl MouseInterpolator<'_>{
self.unblock_mouse(time); self.unblock_mouse(time);
} }
self.empty_queue(); self.empty_queue();
//doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>) //doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>)
self.physics.generate_models(&map); self.physics.generate_models(&map);
let simulation_time=self.timer.time(time); //use the standard input interface so the instructions are written out to bots
//important!
//bots will not work properly without this exact restart + spawn setup
//reset the physics state to start a new run on the new map
self.handle_instruction(&TimedInstruction{ self.handle_instruction(&TimedInstruction{
time:simulation_time, time:self.timer.time(time),
instruction:Instruction::Input(InputInstruction::Reset), instruction:Instruction::Input(InputInstruction::ResetAndSpawn(
});
//generate a spawn event so bots work properly on the first run
//no run started so does not invalidate the run
self.handle_instruction(&TimedInstruction{
time:simulation_time,
instruction:Instruction::Input(InputInstruction::Spawn(
strafesnet_common::gameplay_modes::ModeId::MAIN, strafesnet_common::gameplay_modes::ModeId::MAIN,
strafesnet_common::gameplay_modes::StageId::FIRST, strafesnet_common::gameplay_modes::StageId::FIRST,
)), )),

2
src/window.rs
View File

@ -110,7 +110,7 @@ impl WindowContext<'_>{
"r"=>if s{ "r"=>if s{
//mouse needs to be reset since the position is absolute //mouse needs to be reset since the position is absolute
self.mouse=strafesnet_common::mouse::MouseState::default(); self.mouse=strafesnet_common::mouse::MouseState::default();
Some(InputInstruction::Restart) Some(InputInstruction::ResetAndRestart)
}else{None}, }else{None},
"f"=>if s{Some(InputInstruction::PracticeFly)}else{None}, "f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
_=>None, _=>None,