basic wormholes (no velocity or camera transformation)

Cargo.toml

@@ -22,7 +22,7 @@ rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
 wgpu = "0.17.0"
-winit = { version = "0.29.2", features = ["rwh_05"] }
+winit = "0.28.6"
 
 #[profile.release]
 #lto = true

src/framework.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
 use winit::{
 	event::{self, WindowEvent, DeviceEvent},
-	event_loop::EventLoop,
+	event_loop::{ControlFlow, EventLoop},
 };
 
 #[allow(dead_code)]
@@ -88,7 +88,7 @@ async fn setup<E: Example>(title: &str) -> Setup {
 		env_logger::init();
 	};
 
-	let event_loop = EventLoop::new().unwrap();
+	let event_loop = EventLoop::new();
 	let mut builder = winit::window::WindowBuilder::new();
 	builder = builder.with_title(title);
 	#[cfg(windows_OFF)] // TODO
@@ -302,15 +302,15 @@ fn start<E: Example>(
 	let mut example = E::init(&config, &adapter, &device, &queue);
 
 	log::info!("Entering render loop...");
-	event_loop.run(move |event, elwt| {
+	event_loop.run(move |event, _, control_flow| {
 		let _ = (&instance, &adapter); // force ownership by the closure
-		// *control_flow = if cfg!(feature = "metal-auto-capture") {
-		// 	ControlFlow::Exit
-		// } else {
-		// 	ControlFlow::Poll
-		// };
+		*control_flow = if cfg!(feature = "metal-auto-capture") {
+			ControlFlow::Exit
+		} else {
+			ControlFlow::Poll
+		};
 		match event {
-			event::Event::AboutToWait => {
+			event::Event::RedrawEventsCleared => {
 				#[cfg(not(target_arch = "wasm32"))]
 				spawner.run_until_stalled();
 
@@ -318,44 +318,48 @@ fn start<E: Example>(
 			}
 			event::Event::WindowEvent {
 				event:
-					// WindowEvent::Resized(size)
-					// | WindowEvent::ScaleFactorChanged {
-					// 	new_inner_size: &mut size,
-					// 	..
-					// },
-					WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
+					WindowEvent::Resized(size)
+					| WindowEvent::ScaleFactorChanged {
+						new_inner_size: &mut size,
+						..
+					},
 				..
 			} => {
-				log::info!("Resizing to {:?}", size);
-				config.width = size.width.max(1);
-				config.height = size.height.max(1);
-				example.resize(&config, &device, &queue);
-				surface.configure(&device, &config);
+				// Once winit is fixed, the detection conditions here can be removed.
+				// https://github.com/rust-windowing/winit/issues/2876
+				let max_dimension = adapter.limits().max_texture_dimension_2d;
+				if size.width > max_dimension || size.height > max_dimension {
+					log::warn!(
+						"The resizing size {:?} exceeds the limit of {}.",
+						size,
+						max_dimension
+					);
+				} else {
+					log::info!("Resizing to {:?}", size);
+					config.width = size.width.max(1);
+					config.height = size.height.max(1);
+					example.resize(&config, &device, &queue);
+					surface.configure(&device, &config);
+				}
 			}
-			event::Event::DeviceEvent {
-				event,
-				..
-			} => {
-				example.device_event(&window,event);
-			},
 			event::Event::WindowEvent { event, .. } => match event {
 				WindowEvent::KeyboardInput {
-					event:
-						event::KeyEvent {
-							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+					input:
+						event::KeyboardInput {
+							virtual_keycode: Some(event::VirtualKeyCode::Escape),
 							state: event::ElementState::Pressed,
 							..
 						},
 					..
 				}
 				| WindowEvent::CloseRequested => {
-					elwt.exit();
+					*control_flow = ControlFlow::Exit;
 				}
 				#[cfg(not(target_arch = "wasm32"))]
 				WindowEvent::KeyboardInput {
-					event:
-						event::KeyEvent {
-							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::ScrollLock),
+					input:
+						event::KeyboardInput {
+							virtual_keycode: Some(event::VirtualKeyCode::Scroll),
 							state: event::ElementState::Pressed,
 							..
 						},
@@ -363,47 +367,54 @@ fn start<E: Example>(
 				} => {
 					println!("{:#?}", instance.generate_report());
 				}
-				WindowEvent::RedrawRequested => {
-					let frame = match surface.get_current_texture() {
-						Ok(frame) => frame,
-						Err(_) => {
-							surface.configure(&device, &config);
-							surface
-								.get_current_texture()
-								.expect("Failed to acquire next surface texture!")
-						}
-					};
-					let view = frame.texture.create_view(&wgpu::TextureViewDescriptor {
-						format: Some(surface_view_format),
-						..wgpu::TextureViewDescriptor::default()
-					});
-
-					example.render(&view, &device, &queue, &spawner);
-
-					frame.present();
-
-					#[cfg(target_arch = "wasm32")]
-					{
-						if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
-							let image_bitmap = offscreen_canvas_setup
-								.offscreen_canvas
-								.transfer_to_image_bitmap()
-								.expect("couldn't transfer offscreen canvas to image bitmap.");
-							offscreen_canvas_setup
-								.bitmap_renderer
-								.transfer_from_image_bitmap(&image_bitmap);
-
-							log::info!("Transferring OffscreenCanvas to ImageBitmapRenderer");
-						}
-					}
-				}
 				_ => {
 					example.update(&window,&device,&queue,event);
 				}
 			},
+			event::Event::DeviceEvent {
+				event,
+				..
+			} => {
+				example.device_event(&window,event);
+			},
+			event::Event::RedrawRequested(_) => {
+
+				let frame = match surface.get_current_texture() {
+					Ok(frame) => frame,
+					Err(_) => {
+						surface.configure(&device, &config);
+						surface
+							.get_current_texture()
+							.expect("Failed to acquire next surface texture!")
+					}
+				};
+				let view = frame.texture.create_view(&wgpu::TextureViewDescriptor {
+					format: Some(surface_view_format),
+					..wgpu::TextureViewDescriptor::default()
+				});
+
+				example.render(&view, &device, &queue, &spawner);
+
+				frame.present();
+
+				#[cfg(target_arch = "wasm32")]
+				{
+					if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
+						let image_bitmap = offscreen_canvas_setup
+							.offscreen_canvas
+							.transfer_to_image_bitmap()
+							.expect("couldn't transfer offscreen canvas to image bitmap.");
+						offscreen_canvas_setup
+							.bitmap_renderer
+							.transfer_from_image_bitmap(&image_bitmap);
+
+						log::info!("Transferring OffscreenCanvas to ImageBitmapRenderer");
+					}
+				}
+			}
 			_ => {}
 		}
-	}).unwrap();
+	});
 }
 
 #[cfg(not(target_arch = "wasm32"))]

src/main.rs

@@ -1093,20 +1093,20 @@ impl framework::Example for GlobalState {
 		let time=integer::Time::from_nanos(self.start_time.elapsed().as_nanos() as i64);
 		match event {
 			winit::event::WindowEvent::DroppedFile(path) => self.load_file(path,device,queue),
-			winit::event::WindowEvent::Focused(_state)=>{
+			winit::event::WindowEvent::Focused(state)=>{
 				//pause unpause
 				//recalculate pressed keys on focus
 			},
-			winit::event::WindowEvent::KeyboardInput{
-				event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
+			winit::event::WindowEvent::KeyboardInput {
+				input:winit::event::KeyboardInput{state, virtual_keycode,..},
 				..
 			}=>{
 				let s=match state {
 					winit::event::ElementState::Pressed => true,
 					winit::event::ElementState::Released => false,
 				};
-				match logical_key{
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab)=>{
+				match virtual_keycode{
+					Some(winit::event::VirtualKeyCode::Tab)=>{
 						if s{
 							self.manual_mouse_lock=false;
 							match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.graphics.camera.screen_size.x as f32/2.0, self.graphics.camera.screen_size.y as f32/2.0)){
@@ -1135,7 +1135,7 @@ impl framework::Example for GlobalState {
 						}
 						window.set_cursor_visible(s);
 					},
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11)=>{
+					Some(winit::event::VirtualKeyCode::F11)=>{
 						if s{
 							if window.fullscreen().is_some(){
 								window.set_fullscreen(None);
@@ -1144,7 +1144,7 @@ impl framework::Example for GlobalState {
 							}
 						}
 					},
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape)=>{
+					Some(winit::event::VirtualKeyCode::Escape)=>{
 						if s{
 							self.manual_mouse_lock=false;
 							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
@@ -1154,21 +1154,18 @@ impl framework::Example for GlobalState {
 							window.set_cursor_visible(true);
 						}
 					},
-					keycode=>{
+					Some(keycode)=>{
 						if let Some(input_instruction)=match keycode {
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
-							winit::keyboard::Key::Character(c)=>match c.as_str(){
-								"w"=>Some(InputInstruction::MoveForward(s)),
-								"a"=>Some(InputInstruction::MoveLeft(s)),
-								"s"=>Some(InputInstruction::MoveBack(s)),
-								"d"=>Some(InputInstruction::MoveRight(s)),
-								"e"=>Some(InputInstruction::MoveUp(s)),
-								"q"=>Some(InputInstruction::MoveDown(s)),
-								"z"=>Some(InputInstruction::Zoom(s)),
-								"r"=>if s{Some(InputInstruction::Reset)}else{None},
-								_=>None,
-							}
-							_=>None,
+							winit::event::VirtualKeyCode::W => Some(InputInstruction::MoveForward(s)),
+							winit::event::VirtualKeyCode::A => Some(InputInstruction::MoveLeft(s)),
+							winit::event::VirtualKeyCode::S => Some(InputInstruction::MoveBack(s)),
+							winit::event::VirtualKeyCode::D => Some(InputInstruction::MoveRight(s)),
+							winit::event::VirtualKeyCode::E => Some(InputInstruction::MoveUp(s)),
+							winit::event::VirtualKeyCode::Q => Some(InputInstruction::MoveDown(s)),
+							winit::event::VirtualKeyCode::Space => Some(InputInstruction::Jump(s)),
+							winit::event::VirtualKeyCode::Z => Some(InputInstruction::Zoom(s)),
+							winit::event::VirtualKeyCode::R => if s{Some(InputInstruction::Reset)}else{None},
+							_ => None,
 						}{
 							self.physics_thread.send(TimedInstruction{
 								time,
@@ -1176,6 +1173,7 @@ impl framework::Example for GlobalState {
 							}).unwrap();
 						}
 					},
+					_=>(),
 				}
 			},
 			_=>(),

src/physics.rs

@@ -57,6 +57,38 @@ pub struct Body {
 	time:Time,//nanoseconds x xxxxD!
 }
 
+pub enum MoveRestriction {
+	Air,
+	Water,
+	Ground,
+	Ladder,//multiple ladders how
+}
+
+/*
+enum InputInstruction {
+}
+struct InputState {
+}
+impl InputState {
+	pub fn get_control(&self,control:u32) -> bool {
+		self.controls&control!=0
+	}
+}
+impl crate::instruction::InstructionEmitter<InputInstruction> for InputState{
+	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)
+	}
+}
+impl crate::instruction::InstructionConsumer<InputInstruction> for InputState{
+	fn process_instruction(&mut self,ins:TimedInstruction<InputInstruction>){
+		//add to queue
+		self.queue.push(ins);
+	}
+}
+*/
+
 //hey dumbass just use a delta
 #[derive(Clone,Debug)]
 pub struct MouseState {
@@ -291,7 +323,7 @@ enum JumpImpulse{
 struct StyleModifiers{
 	controls_mask:u32,//controls which are unable to be activated
 	controls_held:u32,//controls which must be active to be able to strafe
-	strafe_tick_rate:Option<Ratio64>,
+	strafe_tick_rate:Ratio64,
 	jump_impulse:JumpImpulse,
 	jump_calculation:JumpCalculation,
 	static_friction:Planar64,
@@ -305,7 +337,6 @@ struct StyleModifiers{
 	mass:Planar64,
 	mv:Planar64,
 	air_accel_limit:Option<Planar64>,
-	rocket_force:Option<Planar64>,
 	gravity:Planar64Vec3,
 	hitbox_halfsize:Planar64Vec3,
 }
@@ -332,7 +363,7 @@ impl StyleModifiers{
 		Self{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe_tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
 			jump_calculation:JumpCalculation::Energy,
 			gravity:Planar64Vec3::int(0,-80,0),
@@ -341,7 +372,6 @@ impl StyleModifiers{
 			mass:Planar64::int(1),
 			mv:Planar64::int(2),
 			air_accel_limit:None,
-			rocket_force:None,
 			walk_speed:Planar64::int(16),
 			walk_accel:Planar64::int(80),
 			ladder_speed:Planar64::int(16),
@@ -356,7 +386,7 @@ impl StyleModifiers{
 		Self{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-100,0),
@@ -365,7 +395,6 @@ impl StyleModifiers{
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
 			air_accel_limit:None,
-			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
 			ladder_speed:Planar64::int(18),
@@ -379,7 +408,7 @@ impl StyleModifiers{
 		Self{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-50,0),
@@ -388,7 +417,6 @@ impl StyleModifiers{
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
 			air_accel_limit:None,
-			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
 			ladder_speed:Planar64::int(18),
@@ -404,7 +432,7 @@ impl StyleModifiers{
 		Self{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -413,7 +441,6 @@ impl StyleModifiers{
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
 			air_accel_limit:Some(Planar64::raw(150<<28)*66),
-			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
 			ladder_speed:Planar64::int(18),//?
@@ -428,7 +455,7 @@ impl StyleModifiers{
 		Self{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe_tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -437,7 +464,6 @@ impl StyleModifiers{
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
 			air_accel_limit:Some(Planar64::raw(150<<28)*66),
-			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
 			ladder_speed:Planar64::int(18),//?
@@ -447,29 +473,6 @@ impl StyleModifiers{
 			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
 		}
 	}
-	fn roblox_rocket()->Self{
-		Self{
-			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:None,
-			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
-			jump_calculation:JumpCalculation::Capped,
-			gravity:Planar64Vec3::int(0,-100,0),
-			static_friction:Planar64::int(2),
-			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
-			mass:Planar64::int(1),
-			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
-			rocket_force:Some(Planar64::int(200)),
-			walk_speed:Planar64::int(18),
-			walk_accel:Planar64::int(90),
-			ladder_speed:Planar64::int(18),
-			ladder_accel:Planar64::int(180),
-			ladder_dot:(Planar64::int(1)/2).sqrt(),
-			swim_speed:Planar64::int(12),
-			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
-		}
-	}
 
 	fn get_control(&self,control:u32,controls:u32)->bool{
 		controls&self.controls_mask&control==control
@@ -537,9 +540,10 @@ impl StyleModifiers{
 		// return cross(cross(Normal,ControlDir),Normal)/sqrt(1-d*d)
 		control_dir*self.walk_speed
 	}
-	fn get_propulsion_control_dir(&self,camera:&PhysicsCamera,controls:u32,next_mouse:&MouseState,time:Time)->Planar64Vec3{
+	fn get_propulsion_target_velocity(&self,camera:&PhysicsCamera,controls:u32,next_mouse:&MouseState,time:Time)->Planar64Vec3{
 		let camera_mat=camera.simulate_move_rotation(camera.mouse.lerp(&next_mouse,time));
-		camera_mat*self.get_control_dir(controls)
+		let control_dir=camera_mat*self.get_control_dir(controls);
+		control_dir*self.walk_speed
 	}
 }
 
@@ -961,13 +965,11 @@ impl PhysicsState {
 	}
 
 	fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		self.style.strafe_tick_rate.as_ref().map(|strafe_tick_rate|{
-			TimedInstruction{
-				time:Time::from_nanos(strafe_tick_rate.rhs_div_int(strafe_tick_rate.mul_int(self.time.nanos())+1)),
-				//only poll the physics if there is a before and after mouse event
-				instruction:PhysicsInstruction::StrafeTick
-			}
-		})
+		return Some(TimedInstruction{
+			time:Time::from_nanos(self.style.strafe_tick_rate.rhs_div_int(self.style.strafe_tick_rate.mul_int(self.time.nanos())+1)),
+			//only poll the physics if there is a before and after mouse event
+			instruction:PhysicsInstruction::StrafeTick
+		});
 	}
 
 	//state mutated on collision:
@@ -1001,20 +1003,16 @@ impl PhysicsState {
 	// 	});
 	// }
 
-	fn refresh_walk_target(&mut self)->Option<Planar64Vec3>{
+	fn refresh_walk_target(&mut self){
 		match &mut self.move_state{
-			MoveState::Air|MoveState::Water=>None,
+			MoveState::Air|MoveState::Water=>(),
 			MoveState::Walk(WalkState{normal,state})=>{
 				let n=normal;
-				let a;
-				(*state,a)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
-				Some(a)
+				(*state,self.body.acceleration)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
 			},
 			MoveState::Ladder(WalkState{normal,state})=>{
 				let n=normal;
-				let a;
-				(*state,a)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
-				Some(a)
+				(*state,self.body.acceleration)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
 			},
 		}
 	}
@@ -1185,7 +1183,7 @@ impl PhysicsState {
 			},
 		}
 		//generate instruction
-		if let Some(_face) = exit_face{
+		if let Some(face) = exit_face{
 			return Some(TimedInstruction {
 				time: best_time,
 				instruction: PhysicsInstruction::CollisionEnd(collision_data.clone())
@@ -1319,7 +1317,6 @@ impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState
 		//JUST POLLING!!! NO MUTATION
 		let mut collector = crate::instruction::InstructionCollector::new(time_limit);
 		//check for collision stop instructions with curent contacts
-		//TODO: make this into a touching.next_instruction(&mut collector) member function
 		for (_,collision_data) in &self.touching.contacts {
 			collector.collect(self.predict_collision_end(self.time,time_limit,collision_data));
 		}
@@ -1371,6 +1368,7 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
 			}
 		},
 		Some(crate::model::TeleportBehaviour::Wormhole(wormhole))=>{
+			//telefart
 			let origin_model=model;
 			let destination_model=models.get_wormhole_model(wormhole.destination_model_id)?;
 			//ignore the transform for now
@@ -1442,7 +1440,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								match booster{
 									&crate::model::GameMechanicBooster::Affine(transform)=>v=transform.transform_point3(v),
 									&crate::model::GameMechanicBooster::Velocity(velocity)=>v+=velocity,
-									&crate::model::GameMechanicBooster::Energy{direction: _,energy: _}=>todo!(),
+									&crate::model::GameMechanicBooster::Energy{direction,energy}=>todo!(),
 								}
 								self.touching.constrain_velocity(&self.models,&mut v);
 							},
@@ -1453,10 +1451,10 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								match trajectory{
 									crate::model::GameMechanicSetTrajectory::AirTime(_) => todo!(),
 									crate::model::GameMechanicSetTrajectory::Height(_) => todo!(),
-									crate::model::GameMechanicSetTrajectory::TargetPointTime { target_point: _, time: _ } => todo!(),
-									crate::model::GameMechanicSetTrajectory::TrajectoryTargetPoint { target_point: _, speed: _, trajectory_choice: _ } => todo!(),
+									crate::model::GameMechanicSetTrajectory::TargetPointTime { target_point, time } => todo!(),
+									crate::model::GameMechanicSetTrajectory::TrajectoryTargetPoint { target_point, speed, trajectory_choice } => todo!(),
 									&crate::model::GameMechanicSetTrajectory::Velocity(velocity)=>v=velocity,
-									crate::model::GameMechanicSetTrajectory::DotVelocity { direction: _, dot: _ } => todo!(),
+									crate::model::GameMechanicSetTrajectory::DotVelocity { direction, dot } => todo!(),
 								}
 								self.touching.constrain_velocity(&self.models,&mut v);
 							},
@@ -1466,11 +1464,9 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 						if self.style.get_control(StyleModifiers::CONTROL_JUMP,self.controls){
 							self.jump();
 						}
-						if let Some(a)=self.refresh_walk_target(){
-							self.body.acceleration=a;
-						}
+						self.refresh_walk_target();
 					},
-					PhysicsCollisionAttributes::Intersect{intersecting: _,general}=>{
+					PhysicsCollisionAttributes::Intersect{intersecting,general}=>{
 						//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
 						self.touching.insert_intersect(c.model,c);
 						run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model);
@@ -1480,12 +1476,9 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 			PhysicsInstruction::CollisionEnd(c) => {
 				let model=c.model(&self.models).unwrap();
 				match &model.attributes{
-					PhysicsCollisionAttributes::Contact{contacting: _,general: _}=>{
+					PhysicsCollisionAttributes::Contact{contacting,general}=>{
 						self.touching.remove_contact(c.model);//remove contact before calling contact_constrain_acceleration
 						let mut a=self.style.gravity;
-						if let Some(rocket_force)=self.style.rocket_force{
-							a+=self.style.get_propulsion_control_dir(&self.camera,self.controls,&self.next_mouse,self.time)*rocket_force;
-						}
 						self.touching.constrain_acceleration(&self.models,&mut a);
 						self.body.acceleration=a;
 						//check ground
@@ -1495,12 +1488,10 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								//TODO: make this more advanced checking contacts
 								self.move_state=MoveState::Air;
 							},
-							_=>if let Some(a)=self.refresh_walk_target(){
-								self.body.acceleration=a;
-							},
+							_=>self.refresh_walk_target(),
 						}
 					},
-					PhysicsCollisionAttributes::Intersect{intersecting: _,general: _}=>{
+					PhysicsCollisionAttributes::Intersect{intersecting,general}=>{
 						self.touching.remove_intersect(c.model);
 					},
 				}
@@ -1574,14 +1565,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 					PhysicsInputInstruction::Idle => {refresh_walk_target=false;},//literally idle!
 				}
 				if refresh_walk_target{
-					if let Some(a)=self.refresh_walk_target(){
-						self.body.acceleration=a;
-					}else if let Some(rocket_force)=self.style.rocket_force{
-						let mut a=self.style.gravity;
-						a+=self.style.get_propulsion_control_dir(&self.camera,self.controls,&self.next_mouse,self.time)*rocket_force;
-						self.touching.constrain_acceleration(&self.models,&mut a);
-						self.body.acceleration=a;
-					}
+					self.refresh_walk_target();
 				}
 			},
 		}

src/zeroes.rs

@@ -6,7 +6,7 @@ pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
 	if a2==Planar64::ZERO{
 		return zeroes1(a0, a1);
 	}
-	let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
+	let mut radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
 	if 0<radicand {
 		//start with f64 sqrt
 		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});