toc

Cargo.toml

@@ -1,10 +1,5 @@
 [workspace]
 members = [
-	"engine/graphics",
-	"engine/physics",
-	"engine/session",
-	"engine/settings",
-	"integration-testing",
 	"lib/bsp_loader",
 	"lib/common",
 	"lib/deferred_loader",

README.md

@@ -3,9 +3,6 @@
 # Strafe Project
 Monorepo for working on projects related to strafe client.
 
-## Try it out
-See [releases](https://git.itzana.me/StrafesNET/strafe-project/releases) for downloads.
-
 ## How to build and run
 1. Have rust and git installed
 2. `git clone https://git.itzana.me/StrafesNET/strafe-project`
@@ -13,4 +10,4 @@ See [releases](https://git.itzana.me/StrafesNET/strafe-project/releases) for dow
 4. `cargo run --release --bin strafe-client`
 
 ## Licenses
-Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client and engine crates have a sole proprietor license.
+Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client has a sole proprietor license.

engine/graphics/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "strafesnet_graphics"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bytemuck = { version = "1.13.1", features = ["derive"] }
-ddsfile = "0.5.1"
-glam = "0.29.0"
-id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-strafesnet_session = { path = "../session", registry = "strafesnet" }
-strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "24.0.0"

engine/graphics/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/graphics/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod model;
-pub mod graphics;

engine/physics/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "strafesnet_physics"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-arrayvec = "0.7.6"
-glam = "0.29.0"
-id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/physics/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/physics/src/body.rs

@@ -1,160 +0,0 @@
-use strafesnet_common::aabb;
-use strafesnet_common::integer::{self,vec3,Time,Planar64,Planar64Vec3};
-#[derive(Clone,Copy,Debug,Hash)]
-pub struct Body<T>{
-	pub position:Planar64Vec3,//I64 where 2^32 = 1 u
-	pub velocity:Planar64Vec3,//I64 where 2^32 = 1 u/s
-	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
-	pub time:Time<T>,//nanoseconds x xxxxD!
-}
-impl<T> std::ops::Neg for Body<T>{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		Self{
-			position:self.position,
-			velocity:-self.velocity,
-			acceleration:self.acceleration,
-			time:-self.time,
-		}
-	}
-}
-
-impl<T> Body<T>
-	where Time<T>:Copy,
-{
-	pub const ZERO:Self=Self::new(vec3::ZERO,vec3::ZERO,vec3::ZERO,Time::ZERO);
-	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
-		Self{
-			position,
-			velocity,
-			acceleration,
-			time,
-		}
-	}
-	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
-		//(p0,v0,a0,t0)
-		//(p1,v1,a1,t1)
-		VirtualBody{
-			body0,
-			body1:self,
-		}
-	}
-	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
-		let dt=time-self.time;
-		self.position
-		+(self.velocity*dt).map(|elem|elem.divide().fix_1())
-		+self.acceleration.map(|elem|(dt*dt*elem/2).divide().fix_1())
-	}
-	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
-		let dt=time-self.time;
-		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().fix_1())
-	}
-	pub fn advance_time(&mut self,time:Time<T>){
-		self.position=self.extrapolated_position(time);
-		self.velocity=self.extrapolated_velocity(time);
-		self.time=time;
-	}
-	pub fn extrapolated_position_ratio_dt<Num,Den,N1,D1,N2,N3,D2,N4,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
-		where
-			// Why?
-			// All of this can be removed with const generics because the type can be specified as
-			// Ratio<Fixed<N,NF>,Fixed<D,DF>>
-			// which is known to implement all the necessary traits
-			Num:Copy,
-			Den:Copy+core::ops::Mul<i64,Output=D1>,
-			D1:Copy,
-			Num:core::ops::Mul<Planar64,Output=N1>,
-			Planar64:core::ops::Mul<D1,Output=N2>,
-			N1:core::ops::Add<N2,Output=N3>,
-			Num:core::ops::Mul<N3,Output=N4>,
-			Den:core::ops::Mul<D1,Output=D2>,
-			D2:Copy,
-			Planar64:core::ops::Mul<D2,Output=N4>,
-			N4:integer::Divide<D2,Output=T1>,
-			T1:integer::Fix<Planar64>,
-	{
-		// a*dt^2/2 + v*dt + p
-		// (a*dt/2+v)*dt+p
-		(self.acceleration.map(|elem|dt*elem/2)+self.velocity).map(|elem|dt.mul_ratio(elem))
-		.map(|elem|elem.divide().fix())+self.position
-	}
-	pub fn extrapolated_velocity_ratio_dt<Num,Den,N1,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
-		where
-			Num:Copy,
-			Den:Copy,
-			Num:core::ops::Mul<Planar64,Output=N1>,
-			Planar64:core::ops::Mul<Den,Output=N1>,
-			N1:integer::Divide<Den,Output=T1>,
-			T1:integer::Fix<Planar64>,
-	{
-		// a*dt + v
-		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
-	}
-	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
-		self.position=self.extrapolated_position_ratio_dt(dt);
-		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
-		self.time+=dt.into();
-	}
-	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
-		if self.velocity==vec3::ZERO{
-			if self.acceleration==vec3::ZERO{
-				None
-			}else{
-				Some(self.acceleration)
-			}
-		}else{
-			Some(self.velocity)
-		}
-	}
-	pub fn grow_aabb(&self,aabb:&mut aabb::Aabb,t0:Time<T>,t1:Time<T>){
-		aabb.grow(self.extrapolated_position(t0));
-		aabb.grow(self.extrapolated_position(t1));
-		//v+a*t==0
-		//goober code
-		if !self.acceleration.x.is_zero(){
-			let t=-self.velocity.x/self.acceleration.x;
-			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
-				aabb.grow(self.extrapolated_position_ratio_dt(t));
-			}
-		}
-		if !self.acceleration.y.is_zero(){
-			let t=-self.velocity.y/self.acceleration.y;
-			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
-				aabb.grow(self.extrapolated_position_ratio_dt(t));
-			}
-		}
-		if !self.acceleration.z.is_zero(){
-			let t=-self.velocity.z/self.acceleration.z;
-			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
-				aabb.grow(self.extrapolated_position_ratio_dt(t));
-			}
-		}
-	}
-
-}
-impl<T> std::fmt::Display for Body<T>{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"p({}) v({}) a({}) t({})",self.position,self.velocity,self.acceleration,self.time)
-	}
-}
-
-pub struct VirtualBody<'a,T>{
-	body0:&'a Body<T>,
-	body1:&'a Body<T>,
-}
-impl<T> VirtualBody<'_,T>
-	where Time<T>:Copy,
-{
-	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
-		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
-	}
-	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
-		self.body1.extrapolated_velocity(time)-self.body0.extrapolated_velocity(time)
-	}
-	pub fn acceleration(&self)->Planar64Vec3{
-		self.body1.acceleration-self.body0.acceleration
-	}
-	pub fn body(&self,time:Time<T>)->Body<T>{
-		Body::new(self.extrapolated_position(time),self.extrapolated_velocity(time),self.acceleration(),time)
-	}
-}

engine/physics/src/lib.rs

@@ -1,45 +0,0 @@
-mod body;
-mod push_solve;
-mod face_crawler;
-mod model;
-
-pub mod physics;
-
-// Physics bug fixes can easily desync all bots.
-//
-// When replaying a bot, use the exact physics version which it was recorded with.
-//
-// When validating a new bot, ignore the version and use the latest version,
-// and overwrite the version in the file.
-//
-// Compatible physics versions should be determined
-// empirically at development time via leaderboard resimulation.
-//
-// Compatible physics versions should result in an identical leaderboard state,
-// or the only bots which fail are ones exploiting a surgically patched bug.
-#[derive(Clone,Copy,Hash,Debug,id::Id,Eq,PartialEq,Ord,PartialOrd)]
-pub struct PhysicsVersion(u32);
-pub const VERSION:PhysicsVersion=PhysicsVersion(0);
-const LATEST_COMPATIBLE_VERSION:[u32;1+VERSION.0 as usize]=const{
-	let compat=[0];
-
-	let mut input_version=0;
-	while input_version<compat.len(){
-		// compatible version must be greater than or equal to the input version
-		assert!(input_version as u32<=compat[input_version]);
-		// compatible version must be a version that exists
-		assert!(compat[input_version]<=VERSION.0);
-		input_version+=1;
-	}
-	compat
-};
-pub enum PhysicsVersionError{
-	UnknownPhysicsVersion,
-}
-pub const fn get_latest_compatible_version(PhysicsVersion(version):PhysicsVersion)->Result<PhysicsVersion,PhysicsVersionError>{
-	if (version as usize)<LATEST_COMPATIBLE_VERSION.len(){
-		Ok(PhysicsVersion(LATEST_COMPATIBLE_VERSION[version as usize]))
-	}else{
-		Err(PhysicsVersionError::UnknownPhysicsVersion)
-	}
-}

engine/physics/src/push_solve.rs

@@ -1,349 +0,0 @@
-use strafesnet_common::integer::{self,vec3::{self,Vector3},Fixed,Planar64,Planar64Vec3,Ratio};
-
-// This algorithm is based on Lua code
-// written by Trey Reynolds in 2021
-
-// EPSILON=1/2^10
-
-// A stack-allocated variable-size list that holds up to 4 elements
-// Direct references are used instead of indices i0, i1, i2, i3
-type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
-
-// hack to allow comparing ratios to zero
-const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
-
-struct Ray{
-	origin:Planar64Vec3,
-	direction:Planar64Vec3,
-}
-impl Ray{
-	fn extrapolate<Num,Den,N1,T1>(&self,t:Ratio<Num,Den>)->Planar64Vec3
-	where
-		Num:Copy,
-		Den:Copy,
-		Num:core::ops::Mul<Planar64,Output=N1>,
-		Planar64:core::ops::Mul<Den,Output=N1>,
-		N1:integer::Divide<Den,Output=T1>,
-		T1:integer::Fix<Planar64>,
-	{
-		self.origin+self.direction.map(|elem|(t*elem).divide().fix())
-	}
-}
-
-/// Information about a contact restriction
-pub struct Contact{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub normal:Planar64Vec3,
-}
-impl Contact{
-	fn relative_to(&self,point:Planar64Vec3)->Self{
-		Self{
-			position:self.position-point,
-			velocity:self.velocity,
-			normal:self.normal,
-		}
-	}
-	fn relative_dot(&self,direction:Planar64Vec3)->Fixed<2,64>{
-		(direction-self.velocity).dot(self.normal)
-	}
-	/// Calculate the time of intersection. (previously get_touch_time)
-	fn solve(&self,ray:&Ray)->Ratio<Fixed<2,64>,Fixed<2,64>>{
-		(self.position-ray.origin).dot(self.normal)/(ray.direction-self.velocity).dot(self.normal)
-	}
-}
-
-//note that this is horrible with fixed point arithmetic
-fn solve1(c0:&Contact)->Option<Ratio<Vector3<Fixed<3,96>>,Fixed<2,64>>>{
-	const EPSILON:Fixed<2,64>=Fixed::from_bits(Fixed::<2,64>::ONE.to_bits().shr(10));
-	let det=c0.normal.dot(c0.velocity);
-	if det.abs()<EPSILON{
-		return None;
-	}
-	let d0=c0.normal.dot(c0.position);
-	Some(c0.normal*d0/det)
-}
-fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,128>>>{
-	const EPSILON:Fixed<4,128>=Fixed::from_bits(Fixed::<4,128>::ONE.to_bits().shr(10));
-	let u0_u1=c0.velocity.cross(c1.velocity);
-	let n0_n1=c0.normal.cross(c1.normal);
-	let det=u0_u1.dot(n0_n1);
-	if det.abs()<EPSILON{
-		return None;
-	}
-	let d0=c0.normal.dot(c0.position);
-	let d1=c1.normal.dot(c1.position);
-	Some((c1.normal.cross(u0_u1)*d0+u0_u1.cross(c0.normal)*d1)/det)
-}
-fn solve3(c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ratio<Vector3<Fixed<4,128>>,Fixed<3,96>>>{
-	const EPSILON:Fixed<3,96>=Fixed::from_bits(Fixed::<3,96>::ONE.to_bits().shr(10));
-	let n0_n1=c0.normal.cross(c1.normal);
-	let det=c2.normal.dot(n0_n1);
-	if det.abs()<EPSILON{
-		return None;
-	}
-	let d0=c0.normal.dot(c0.position);
-	let d1=c1.normal.dot(c1.position);
-	let d2=c2.normal.dot(c2.position);
-	Some((c1.normal.cross(c2.normal)*d0+c2.normal.cross(c0.normal)*d1+c0.normal.cross(c1.normal)*d2)/det)
-}
-
-fn decompose1(point:Planar64Vec3,u0:Planar64Vec3)->Option<[Ratio<Fixed<2,64>,Fixed<2,64>>;1]>{
-	let det=u0.dot(u0);
-	if det==Fixed::ZERO{
-		return None;
-	}
-	let s0=u0.dot(point)/det;
-	Some([s0])
-}
-fn decompose2(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3)->Option<[Ratio<Fixed<4,128>,Fixed<4,128>>;2]>{
-	let u0_u1=u0.cross(u1);
-	let det=u0_u1.dot(u0_u1);
-	if det==Fixed::ZERO{
-		return None;
-	}
-	let s0=u0_u1.dot(point.cross(u1))/det;
-	let s1=u0_u1.dot(u0.cross(point))/det;
-	Some([s0,s1])
-}
-fn decompose3(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3,u2:Planar64Vec3)->Option<[Ratio<Fixed<3,96>,Fixed<3,96>>;3]>{
-	let det=u0.cross(u1).dot(u2);
-	if det==Fixed::ZERO{
-		return None;
-	}
-	let s0=point.cross(u1).dot(u2)/det;
-	let s1=u0.cross(point).dot(u2)/det;
-	let s2=u0.cross(u1).dot(point)/det;
-	Some([s0,s1,s2])
-}
-
-fn is_space_enclosed_2(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-)->bool{
-	a.cross(b)==Vector3::new([Fixed::ZERO;3])
-	&&a.dot(b).is_negative()
-}
-fn is_space_enclosed_3(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-	c:Planar64Vec3
-)->bool{
-	a.cross(b).dot(c)==Fixed::ZERO
-	&&{
-		let det_abac=a.cross(b).dot(a.cross(c));
-		let det_abbc=a.cross(b).dot(b.cross(c));
-		let det_acbc=a.cross(c).dot(b.cross(c));
-		return!( det_abac*det_abbc).is_positive()
-			&&!( det_abbc*det_acbc).is_positive()
-			&&!(-det_acbc*det_abac).is_positive()
-			||is_space_enclosed_2(a,b)
-			||is_space_enclosed_2(a,c)
-			||is_space_enclosed_2(b,c)
-	}
-}
-fn is_space_enclosed_4(
-	a:Planar64Vec3,
-	b:Planar64Vec3,
-	c:Planar64Vec3,
-	d:Planar64Vec3,
-)->bool{
-	let det_abc=a.cross(b).dot(c);
-	let det_abd=a.cross(b).dot(d);
-	let det_acd=a.cross(c).dot(d);
-	let det_bcd=b.cross(c).dot(d);
-	return( det_abc*det_abd).is_negative()
-		&&(-det_abc*det_acd).is_negative()
-		&&( det_abd*det_acd).is_negative()
-		&&( det_abc*det_bcd).is_negative()
-		&&(-det_abd*det_bcd).is_negative()
-		&&( det_acd*det_bcd).is_negative()
-		||is_space_enclosed_3(a,b,c)
-		||is_space_enclosed_3(a,b,d)
-		||is_space_enclosed_3(a,c,d)
-		||is_space_enclosed_3(b,c,d)
-}
-
-const fn get_push_ray_0(point:Planar64Vec3)->Ray{
-	Ray{origin:point,direction:vec3::ZERO}
-}
-fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
-	let direction=solve1(c0)?.divide().fix_1();
-	let [s0]=decompose1(direction,c0.velocity)?;
-	if s0.lt_ratio(RATIO_ZERO){
-		return None;
-	}
-	let origin=point+solve1(
-		&c0.relative_to(point),
-	)?.divide().fix_1();
-	Some(Ray{origin,direction})
-}
-fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
-	let direction=solve2(c0,c1)?.divide().fix_1();
-	let [s0,s1]=decompose2(direction,c0.velocity,c1.velocity)?;
-	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO){
-		return None;
-	}
-	let origin=point+solve2(
-		&c0.relative_to(point),
-		&c1.relative_to(point),
-	)?.divide().fix_1();
-	Some(Ray{origin,direction})
-}
-fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ray>{
-	let direction=solve3(c0,c1,c2)?.divide().fix_1();
-	let [s0,s1,s2]=decompose3(direction,c0.velocity,c1.velocity,c2.velocity)?;
-	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO)||s2.lt_ratio(RATIO_ZERO){
-		return None;
-	}
-	let origin=point+solve3(
-		&c0.relative_to(point),
-		&c1.relative_to(point),
-		&c2.relative_to(point),
-	)?.divide().fix_1();
-	Some(Ray{origin,direction})
-}
-
-const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->(Ray,Conts<'a>){
-	(get_push_ray_0(point),Conts::new_const())
-}
-fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
-	get_push_ray_1(point,c0)
-		.map(|ray|(ray,Conts::from_iter([c0])))
-}
-fn get_best_push_ray_and_conts_2<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_2(c0.normal,c1.normal){
-		return None;
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c1){
-		return Some((ray,Conts::from_iter([c0,c1])));
-	}
-	if let Some(ray)=get_push_ray_1(point,c0){
-		if !c1.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0])));
-		}
-	}
-	return None;
-}
-fn get_best_push_ray_and_conts_3<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_3(c0.normal,c1.normal,c2.normal){
-		return None;
-	}
-	if let Some(ray)=get_push_ray_3(point,c0,c1,c2){
-		return Some((ray,Conts::from_iter([c0,c1,c2])));
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c1){
-		if !c2.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0,c1])));
-		}
-	}
-	if let Some(ray)=get_push_ray_2(point,c0,c2){
-		if !c1.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0,c2])));
-		}
-	}
-	if let Some(ray)=get_push_ray_1(point,c0){
-		if !c1.relative_dot(ray.direction).is_negative()
-		 &&!c2.relative_dot(ray.direction).is_negative(){
-			return Some((ray,Conts::from_iter([c0])));
-		}
-	}
-	return None;
-}
-fn get_best_push_ray_and_conts_4<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact,c3:&'a Contact)->Option<(Ray,Conts<'a>)>{
-	if is_space_enclosed_4(c0.normal,c1.normal,c2.normal,c3.normal){
-		return None;
-	}
-
-	let (ray012,conts012)=get_best_push_ray_and_conts_3(point,c0,c1,c2)?;
-	let (ray013,conts013)=get_best_push_ray_and_conts_3(point,c0,c1,c3)?;
-	let (ray023,conts023)=get_best_push_ray_and_conts_3(point,c0,c2,c3)?;
-
-	let err012=c3.relative_dot(ray012.direction);
-	let err013=c2.relative_dot(ray013.direction);
-	let err023=c1.relative_dot(ray023.direction);
-
-	let best_err=err012.max(err013).max(err023);
-
-	if best_err==err012{
-		return Some((ray012,conts012))
-	}else if best_err==err013{
-		return Some((ray013,conts013))
-	}else if best_err==err023{
-		return Some((ray023,conts023))
-	}
-	unreachable!()
-}
-
-fn get_best_push_ray_and_conts<'a>(
-	point:Planar64Vec3,
-	conts:&[&'a Contact],
-)->Option<(Ray,Conts<'a>)>{
-	match conts{
-		&[c0,c1,c2,c3]=>get_best_push_ray_and_conts_4(point,c0,c1,c2,c3),
-		&[c0,c1,c2]=>get_best_push_ray_and_conts_3(point,c0,c1,c2),
-		&[c0,c1]=>get_best_push_ray_and_conts_2(point,c0,c1),
-		&[c0]=>get_best_push_ray_and_conts_1(point,c0),
-		&[]=>Some(get_best_push_ray_and_conts_0(point)),
-		_=>unreachable!(),
-	}
-}
-
-fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ratio<Fixed<2,64>,Fixed<2,64>>,&'a Contact)>{
-	contacts.iter()
-		.filter(|&contact|
-			!conts.iter().any(|&c|std::ptr::eq(c,contact))
-			&&contact.relative_dot(ray.direction).is_negative()
-		)
-		.map(|contact|(contact.solve(ray),contact))
-		.min_by_key(|&(t,_)|t)
-}
-
-pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
-	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
-	loop{
-		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
-			Some((t,cont))=>(t,cont),
-			None=>return ray.origin,
-		};
-
-		if RATIO_ZERO.le_ratio(next_t){
-			return ray.origin;
-		}
-
-		//push_front
-		if conts.len()==conts.capacity(){
-			//this is a dead case, new_conts never has more than 3 elements
-			conts.rotate_right(1);
-			conts[0]=next_cont;
-		}else{
-			conts.push(next_cont);
-			conts.rotate_right(1);
-		}
-
-		let meet_point=ray.extrapolate(next_t);
-		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
-			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return meet_point,
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests{
-	use super::*;
-	#[test]
-	fn test_push_solve(){
-		let contacts=vec![
-			Contact{
-				position:vec3::ZERO,
-				velocity:vec3::Y,
-				normal:vec3::Y,
-			}
-		];
-		assert_eq!(
-			vec3::ZERO,
-			push_solve(&contacts,vec3::NEG_Y)
-		);
-	}
-}

engine/session/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "strafesnet_session"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-glam = "0.29.0"
-replace_with = "0.1.7"
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-strafesnet_physics = { path = "../physics", registry = "strafesnet" }
-strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }

engine/session/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/session/src/lib.rs

@@ -1,2 +0,0 @@
-mod mouse_interpolator;
-pub mod session;

engine/session/src/mouse_interpolator.rs

@@ -1,281 +0,0 @@
-use strafesnet_common::mouse::MouseState;
-use strafesnet_common::physics::{
-	MouseInstruction,SetControlInstruction,ModeInstruction,MiscInstruction,
-	Instruction as PhysicsInstruction,
-	TimeInner as PhysicsTimeInner,
-	Time as PhysicsTime,
-};
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,TimedInstruction};
-
-type TimedSelfInstruction=TimedInstruction<Instruction,PhysicsTimeInner>;
-type DoubleTimedSelfInstruction=TimedInstruction<TimedSelfInstruction,SessionTimeInner>;
-
-type TimedPhysicsInstruction=TimedInstruction<PhysicsInstruction,PhysicsTimeInner>;
-
-const MOUSE_TIMEOUT:SessionTime=SessionTime::from_millis(10);
-
-/// To be fed into MouseInterpolator
-#[derive(Clone,Debug)]
-pub(crate) enum Instruction{
-	MoveMouse(glam::IVec2),
-	SetControl(SetControlInstruction),
-	Mode(ModeInstruction),
-	Misc(MiscInstruction),
-	Idle,
-}
-#[derive(Clone,Debug)]
-enum UnbufferedInstruction{
-	MoveMouse(glam::IVec2),
-	NonMouse(NonMouseInstruction),
-}
-#[derive(Clone,Debug)]
-enum BufferedInstruction{
-	Mouse(MouseInstruction),
-	NonMouse(NonMouseInstruction),
-}
-#[derive(Clone,Debug)]
-pub(crate) enum NonMouseInstruction{
-	SetControl(SetControlInstruction),
-	Mode(ModeInstruction),
-	Misc(MiscInstruction),
-	Idle,
-}
-impl From<Instruction> for UnbufferedInstruction{
-	#[inline]
-	fn from(value:Instruction)->Self{
-		match value{
-			Instruction::MoveMouse(mouse_instruction)=>UnbufferedInstruction::MoveMouse(mouse_instruction),
-			Instruction::SetControl(set_control_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::SetControl(set_control_instruction)),
-			Instruction::Mode(mode_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Mode(mode_instruction)),
-			Instruction::Misc(misc_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Misc(misc_instruction)),
-			Instruction::Idle=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Idle),
-		}
-	}
-}
-impl From<BufferedInstruction> for PhysicsInstruction{
-	#[inline]
-	fn from(value:BufferedInstruction)->Self{
-		match value{
-			BufferedInstruction::Mouse(mouse_instruction)=>PhysicsInstruction::Mouse(mouse_instruction),
-			BufferedInstruction::NonMouse(non_mouse_instruction)=>match non_mouse_instruction{
-				NonMouseInstruction::SetControl(set_control_instruction)=>PhysicsInstruction::SetControl(set_control_instruction),
-				NonMouseInstruction::Mode(mode_instruction)=>PhysicsInstruction::Mode(mode_instruction),
-				NonMouseInstruction::Misc(misc_instruction)=>PhysicsInstruction::Misc(misc_instruction),
-				NonMouseInstruction::Idle=>PhysicsInstruction::Idle,
-			},
-		}
-	}
-}
-
-pub(crate) enum StepInstruction{
-	Pop,
-	Timeout,
-}
-
-#[derive(Clone,Debug)]
-enum BufferState{
-	Unbuffered,
-	Initializing(SessionTime,MouseState<PhysicsTimeInner>),
-	Buffered(SessionTime,MouseState<PhysicsTimeInner>),
-}
-
-pub struct MouseInterpolator{
-	buffer_state:BufferState,
-	// double timestamped timeline?
-	buffer:std::collections::VecDeque<TimedPhysicsInstruction>,
-	output:std::collections::VecDeque<TimedPhysicsInstruction>,
-}
-// Maybe MouseInterpolator manipulation is better expressed using impls
-// and called from Instruction trait impls in session
-impl InstructionConsumer<TimedSelfInstruction> for MouseInterpolator{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:DoubleTimedSelfInstruction){
-		self.push_unbuffered_input(ins.time,ins.instruction.time,ins.instruction.instruction.into())
-	}
-}
-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{
-			buffer_state:BufferState::Unbuffered,
-			buffer:std::collections::VecDeque::new(),
-			output:std::collections::VecDeque::new(),
-		}
-	}
-	fn push_mouse_and_flush_buffer(&mut self,ins:TimedInstruction<MouseInstruction,PhysicsTimeInner>){
-		self.buffer.push_front(TimedInstruction{
-			time:ins.time,
-			instruction:BufferedInstruction::Mouse(ins.instruction).into(),
-		});
-		// flush buffer to output
-		if self.output.len()==0{
-			// swap buffers
-			core::mem::swap(&mut self.buffer,&mut self.output);
-		}else{
-			// append buffer contents to output
-			self.output.append(&mut self.buffer);
-		}
-	}
-	fn get_mouse_timedout_at(&self,time_limit:SessionTime)->Option<SessionTime>{
-		match &self.buffer_state{
-			BufferState::Unbuffered=>None,
-			BufferState::Initializing(time,_mouse_state)
-			|BufferState::Buffered(time,_mouse_state)=>{
-				let timeout=*time+MOUSE_TIMEOUT;
-				(timeout<time_limit).then_some(timeout)
-			}
-		}
-	}
-	fn timeout_mouse(&mut self,timeout_time:PhysicsTime){
-		// the state always changes to unbuffered
-		let buffer_state=core::mem::replace(&mut self.buffer_state,BufferState::Unbuffered);
-		match buffer_state{
-			BufferState::Unbuffered=>(),
-			BufferState::Initializing(_time,mouse_state)=>{
-				// only a single mouse move was sent in 10ms, this is very much an edge case!
-				self.push_mouse_and_flush_buffer(TimedInstruction{
-					time:mouse_state.time,
-					instruction:MouseInstruction::ReplaceMouse{
-						m1:MouseState{pos:mouse_state.pos,time:timeout_time},
-						m0:mouse_state,
-					},
-				});
-			}
-			BufferState::Buffered(_time,mouse_state)=>{
-				// duplicate the currently buffered mouse state but at a later (future, from the physics perspective) time
-				self.push_mouse_and_flush_buffer(TimedInstruction{
-					time:mouse_state.time,
-					instruction:MouseInstruction::SetNextMouse(MouseState{pos:mouse_state.pos,time:timeout_time}),
-				});
-			},
-		}
-	}
-	fn push_unbuffered_input(&mut self,session_time:SessionTime,physics_time:PhysicsTime,ins:UnbufferedInstruction){
-		// new input
-		// if there is zero instruction buffered, it means the mouse is not moving
-		// case 1: unbuffered
-		// no mouse event is buffered
-		// - ins is mouse event? change to buffered
-		// - ins other -> write to timeline
-		// case 2: buffered
-		// a mouse event is buffered, and exists within the last 10ms
-		// case 3: stop
-		// a mouse event is buffered, but no mouse events have transpired within 10ms
-
-		// replace_with allows the enum variant to safely be replaced
-		// from behind a mutable reference, but a panic in the closure means that
-		// the entire program terminates rather than completing an unwind.
-		let (ins_mouse,ins_other)=replace_with::replace_with_or_abort_and_return(&mut self.buffer_state,|buffer_state|{
-			match ins{
-				UnbufferedInstruction::MoveMouse(pos)=>{
-					let next_mouse_state=MouseState{pos,time:physics_time};
-					match buffer_state{
-						BufferState::Unbuffered=>{
-							((None,None),BufferState::Initializing(session_time,next_mouse_state))
-						},
-						BufferState::Initializing(_time,mouse_state)=>{
-							let ins_mouse=TimedInstruction{
-								time:mouse_state.time,
-								instruction:MouseInstruction::ReplaceMouse{
-									m0:mouse_state,
-									m1:next_mouse_state.clone(),
-								},
-							};
-							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
-						},
-						BufferState::Buffered(_time,mouse_state)=>{
-							let ins_mouse=TimedInstruction{
-								time:mouse_state.time,
-								instruction:MouseInstruction::SetNextMouse(next_mouse_state.clone()),
-							};
-							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
-						},
-					}
-				},
-				UnbufferedInstruction::NonMouse(other_instruction)=>((None,Some(TimedInstruction{
-					time:physics_time,
-					instruction:other_instruction,
-				})),buffer_state),
-			}
-		});
-		if let Some(ins)=ins_mouse{
-			self.push_mouse_and_flush_buffer(ins);
-		}
-		if let Some(ins)=ins_other{
-			let instruction=TimedInstruction{
-				time:ins.time,
-				instruction:BufferedInstruction::NonMouse(ins.instruction).into(),
-			};
-			if matches!(self.buffer_state,BufferState::Unbuffered){
-				self.output.push_back(instruction);
-			}else{
-				self.buffer.push_back(instruction);
-			}
-		}
-	}
-	fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTimeInner>>{
-		match self.get_mouse_timedout_at(time_limit){
-			Some(timeout)=>Some(TimedInstruction{
-				time:timeout,
-				instruction:StepInstruction::Timeout,
-			}),
-			None=>(self.output.len()!=0).then_some(TimedInstruction{
-				// this timestamp should not matter
-				time:time_limit,
-				instruction:StepInstruction::Pop,
-			}),
-		}
-	}
-	pub fn pop_buffered_instruction(&mut self,ins:TimedInstruction<StepInstruction,PhysicsTimeInner>)->Option<TimedPhysicsInstruction>{
-		match ins.instruction{
-			StepInstruction::Pop=>(),
-			StepInstruction::Timeout=>self.timeout_mouse(ins.time),
-		}
-		self.output.pop_front()
-	}
-}
-
-#[cfg(test)]
-mod test{
-	use super::*;
-	#[test]
-	fn test(){
-		let mut interpolator=MouseInterpolator::new();
-
-		let timer=strafesnet_common::timer::Timer::<strafesnet_common::timer::Scaled<SessionTimeInner,PhysicsTimeInner>>::unpaused(SessionTime::ZERO,PhysicsTime::from_secs(1000));
-
-		macro_rules! push{
-			($time:expr,$ins:expr)=>{
-				println!("in={:?}",$ins);
-				interpolator.push_unbuffered_input(
-					$time,
-					timer.time($time),
-					$ins,
-				);
-				while let Some(ins)=interpolator.buffered_instruction_with_timeout($time){
-					let ins_retimed=TimedInstruction{
-						time:timer.time(ins.time),
-						instruction:ins.instruction,
-					};
-					let out=interpolator.pop_buffered_instruction(ins_retimed);
-					println!("out={out:?}");
-				}
-			};
-		}
-
-		// test each buffer_state transition
-		let mut t=SessionTime::ZERO;
-		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
-		t+=SessionTime::from_millis(5);
-		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
-		t+=SessionTime::from_millis(5);
-		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
-		t+=SessionTime::from_millis(1);
-	}
-}

engine/session/src/session.rs

@@ -1,443 +0,0 @@
-use std::collections::HashMap;
-
-use strafesnet_common::gameplay_modes::{ModeId,StageId};
-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::{
-	ModeInstruction,MiscInstruction,
-	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 strafesnet_settings::directories::Directories;
-
-use crate::mouse_interpolator::{MouseInterpolator,StepInstruction,Instruction as MouseInterpolatorInstruction};
-use strafesnet_physics::physics::{self,PhysicsContext,PhysicsData};
-use strafesnet_settings::settings::UserSettings;
-
-pub enum Instruction<'a>{
-	Input(SessionInputInstruction),
-	Control(SessionControlInstruction),
-	Playback(SessionPlaybackInstruction),
-	ChangeMap(&'a strafesnet_common::map::CompleteMap),
-	LoadReplay(strafesnet_snf::bot::Segment),
-	Idle,
-}
-
-pub enum SessionInputInstruction{
-	Mouse(glam::IVec2),
-	SetControl(strafesnet_common::physics::SetControlInstruction),
-	Mode(ImplicitModeInstruction),
-	Misc(strafesnet_common::physics::MiscInstruction),
-}
-/// Implicit mode instruction are fed separately to session.
-/// Session generates the explicit mode instructions interlaced with a SetSensitivity instruction
-#[derive(Clone,Debug)]
-pub enum ImplicitModeInstruction{
-	ResetAndRestart,
-	ResetAndSpawn(ModeId,StageId),
-}
-
-pub enum SessionControlInstruction{
-	SetPaused(bool),
-	// copy the current session simulation recording into a replay and view it
-	CopyRecordingIntoReplayAndSpectate,
-	StopSpectate,
-	SaveReplay,
-	LoadIntoReplayState,
-}
-pub enum SessionPlaybackInstruction{
-	SkipForward,
-	SkipBack,
-	TogglePaused,
-	DecreaseTimescale,
-	IncreaseTimescale,
-}
-
-pub struct FrameState{
-	pub body:physics::Body,
-	pub camera:physics::PhysicsCamera,
-	pub time:PhysicsTime,
-}
-
-pub struct Simulation{
-	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-	physics:physics::PhysicsState,
-}
-impl Simulation{
-	pub const fn new(
-		timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-		physics:physics::PhysicsState,
-	)->Self{
-		Self{
-			timer,
-			physics,
-		}
-	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
-		FrameState{
-			body:self.physics.camera_body(),
-			camera:self.physics.camera(),
-			time:self.timer.time(time),
-		}
-	}
-}
-
-#[derive(Default)]
-pub struct Recording{
-	instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
-}
-impl Recording{
-	pub fn new(
-		instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
-	)->Self{
-		Self{instructions}
-	}
-	fn clear(&mut self){
-		self.instructions.clear();
-	}
-}
-pub struct Replay{
-	next_instruction_id:usize,
-	recording:Recording,
-	simulation:Simulation,
-}
-impl Replay{
-	pub const fn new(
-		recording:Recording,
-		simulation:Simulation,
-	)->Self{
-		Self{
-			next_instruction_id:0,
-			recording,
-			simulation,
-		}
-	}
-	pub fn advance(&mut self,physics_data:&PhysicsData,time_limit:SessionTime){
-		let mut time=self.simulation.timer.time(time_limit);
-		loop{
-			if let Some(ins)=self.recording.instructions.get(self.next_instruction_id){
-				if ins.time<time{
-					PhysicsContext::run_input_instruction(&mut self.simulation.physics,physics_data,ins.clone());
-					self.next_instruction_id+=1;
-				}else{
-					break;
-				}
-			}else{
-				// loop playback
-				self.next_instruction_id=0;
-				// No need to reset physics because the very first instruction is 'Reset'
-				let new_time=self.recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
-				self.simulation.timer.set_time(time_limit,new_time);
-				time=new_time;
-			}
-		}
-	}
-}
-
-#[derive(Clone,Copy,Hash,PartialEq,Eq)]
-struct BotId(u32);
-//#[derive(Clone,Copy,Hash,PartialEq,Eq)]
-//struct PlayerId(u32);
-
-enum ViewState{
-	Play,
-	//Spectate(PlayerId),
-	Replay(BotId),
-}
-
-pub struct Session{
-	directories:Directories,
-	user_settings:UserSettings,
-	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
-	view_state:ViewState,
-	//gui:GuiState
-	geometry_shared:physics::PhysicsData,
-	simulation:Simulation,
-	// below fields not included in lite session
-	recording:Recording,
-	//players:HashMap<PlayerId,Simulation>,
-	replays:HashMap<BotId,Replay>,
-}
-impl Session{
-	pub fn new(
-		user_settings:UserSettings,
-		directories:Directories,
-		simulation:Simulation,
-	)->Self{
-		Self{
-			user_settings,
-			directories,
-			mouse_interpolator:MouseInterpolator::new(),
-			geometry_shared:Default::default(),
-			simulation,
-			view_state:ViewState::Play,
-			recording:Default::default(),
-			replays:HashMap::new(),
-		}
-	}
-	fn clear_recording(&mut self){
-		self.recording.clear();
-	}
-	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
-		self.simulation.physics.clear();
-		self.geometry_shared.generate_models(map);
-	}
-	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
-		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
-			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time)
-			),
-		}
-	}
-	pub fn user_settings(&self)->&UserSettings{
-		&self.user_settings
-	}
-}
-
-// 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<Instruction<'_>> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Self::TimeInner>){
-		// repetitive procedure macro
-		macro_rules! run_mouse_interpolator_instruction{
-			($instruction:expr)=>{
-				self.mouse_interpolator.process_instruction(TimedInstruction{
-					time:ins.time,
-					instruction:TimedInstruction{
-						time:self.simulation.timer.time(ins.time),
-						instruction:$instruction,
-					},
-				});
-			};
-		}
-
-		// process any timeouts that occured since the last instruction
-		self.process_exhaustive(ins.time);
-
-		match ins.instruction{
-			// send it down to MouseInterpolator with two timestamps, SessionTime and PhysicsTime
-			Instruction::Input(SessionInputInstruction::Mouse(pos))=>{
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::MoveMouse(pos));
-			},
-			Instruction::Input(SessionInputInstruction::SetControl(set_control_instruction))=>{
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::SetControl(set_control_instruction));
-			},
-			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndRestart))=>{
-				self.clear_recording();
-				let mode_id=self.simulation.physics.mode();
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Restart(mode_id)));
-			},
-			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(mode_id,spawn_id)))=>{
-				self.clear_recording();
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Spawn(mode_id,spawn_id)));
-			},
-			Instruction::Input(SessionInputInstruction::Misc(misc_instruction))=>{
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(misc_instruction));
-			},
-			Instruction::Control(SessionControlInstruction::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);
-			},
-			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
-				// Bind: B
-
-				// pause simulation
-				_=self.simulation.timer.set_paused(ins.time,true);
-
-				// create recording
-				let mut recording=Recording::default();
-				recording.instructions.extend(self.recording.instructions.iter().cloned());
-
-				// create timer starting at first instruction (or zero if the list is empty)
-				let new_time=recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
-				let timer=Timer::unpaused(ins.time,new_time);
-
-				// create default physics state
-				let simulation=Simulation::new(timer,Default::default());
-
-				// invent a new bot id and insert the replay
-				let bot_id=BotId(self.replays.len() as u32);
-				self.replays.insert(bot_id,Replay::new(
-					recording,
-					simulation,
-				));
-
-				// begin spectate
-				self.view_state=ViewState::Replay(bot_id);
-			},
-			Instruction::Control(SessionControlInstruction::StopSpectate)=>{
-				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
-				// delete the bot, otherwise it's inaccessible and wastes CPU
-				match view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>{
-						self.replays.remove(&bot_id);
-					},
-				}
-				_=self.simulation.timer.set_paused(ins.time,false);
-			},
-			Instruction::Control(SessionControlInstruction::SaveReplay)=>{
-				// Bind: N
-				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
-				match view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
-						let mut replays_path=self.directories.replays.clone();
-						let file_name=format!("{}.snfb",ins.time);
-						std::thread::spawn(move ||{
-							std::fs::create_dir_all(replays_path.as_path()).unwrap();
-							replays_path.push(file_name);
-							let file=std::fs::File::create(replays_path).unwrap();
-							strafesnet_snf::bot::write_bot(
-								std::io::BufWriter::new(file),
-								strafesnet_physics::VERSION.get(),
-								replay.recording.instructions
-							).unwrap();
-							println!("Finished writing bot file!");
-						});
-					},
-				}
-				_=self.simulation.timer.set_paused(ins.time,false);
-			},
-			Instruction::Control(SessionControlInstruction::LoadIntoReplayState)=>{
-				// Bind: J
-				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
-				match view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
-						self.recording.instructions=replay.recording.instructions.into_iter().take(replay.next_instruction_id).collect();
-						self.simulation=replay.simulation;
-					},
-				}
-				// don't unpause -- use the replay timer state whether it is pasued or unpaused
-			},
-			Instruction::Playback(SessionPlaybackInstruction::IncreaseTimescale)=>{
-				match &self.view_state{
-					ViewState::Play=>{
-						// allow simulation timescale for fun
-						let scale=self.simulation.timer.get_scale();
-						self.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*5,scale.den()*4).unwrap());
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						let scale=replay.simulation.timer.get_scale();
-						replay.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*5,scale.den()*4).unwrap());
-					},
-				}
-			},
-			Instruction::Playback(SessionPlaybackInstruction::DecreaseTimescale)=>{
-				match &self.view_state{
-					ViewState::Play=>{
-						// allow simulation timescale for fun
-						let scale=self.simulation.timer.get_scale();
-						self.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*4,scale.den()*5).unwrap());
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						let scale=replay.simulation.timer.get_scale();
-						replay.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*4,scale.den()*5).unwrap());
-					},
-				}
-			},
-			Instruction::Playback(SessionPlaybackInstruction::SkipForward)=>{
-				match &self.view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						let time=replay.simulation.timer.time(ins.time+SessionTime::from_secs(5));
-						replay.simulation.timer.set_time(ins.time,time);
-					},
-				}
-			},
-			Instruction::Playback(SessionPlaybackInstruction::SkipBack)=>{
-				match &self.view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						let time=replay.simulation.timer.time(ins.time+SessionTime::from_secs(5));
-						replay.simulation.timer.set_time(ins.time,time);
-						// resimulate the entire playback lol
-						replay.next_instruction_id=0;
-					},
-				}
-			},
-			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
-				match &self.view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
-					},
-				}
-			}
-			Instruction::ChangeMap(complete_map)=>{
-				self.clear_recording();
-				self.change_map(complete_map);
-			},
-			Instruction::LoadReplay(bot)=>{
-				// pause simulation
-				_=self.simulation.timer.set_paused(ins.time,true);
-
-				// create recording
-				let recording=Recording::new(bot.instructions);
-
-				// create timer starting at first instruction (or zero if the list is empty)
-				let new_time=recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
-				let timer=Timer::unpaused(ins.time,new_time);
-
-				// create default physics state
-				let simulation=Simulation::new(timer,Default::default());
-
-				// invent a new bot id and insert the replay
-				let bot_id=BotId(self.replays.len() as u32);
-				self.replays.insert(bot_id,Replay::new(
-					recording,
-					simulation,
-				));
-
-				// begin spectate
-				self.view_state=ViewState::Replay(bot_id);
-			},
-			Instruction::Idle=>{
-				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Idle);
-				// this just refreshes the replays
-				for replay in self.replays.values_mut(){
-					// TODO: filter idles from recording, inject new idles in real time
-					replay.advance(&self.geometry_shared,ins.time);
-				}
-			}
-		};
-
-		// process all emitted output instructions
-		self.process_exhaustive(ins.time);
-	}
-}
-impl InstructionConsumer<StepInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::TimeInner>){
-		let time=self.simulation.timer.time(ins.time);
-		if let Some(instruction)=self.mouse_interpolator.pop_buffered_instruction(ins.set_time(time)){
-			//record
-			self.recording.instructions.push(instruction.clone());
-			PhysicsContext::run_input_instruction(&mut self.simulation.physics,&self.geometry_shared,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)
-	}
-}

engine/settings/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "strafesnet_settings"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-configparser = "3.0.2"
-directories = "6.0.0"
-glam = "0.29.0"
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/settings/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/settings/src/directories.rs

@@ -1,32 +0,0 @@
-use std::path::PathBuf;
-
-use crate::settings::{UserSettings,load_user_settings};
-
-pub struct Directories{
-	pub settings:PathBuf,
-	pub maps:PathBuf,
-	pub replays:PathBuf,
-}
-impl Directories{
-	pub fn settings(&self)->UserSettings{
-		load_user_settings(&self.settings)
-	}
-	pub fn user()->Option<Self>{
-		let dirs=directories::ProjectDirs::from("net.strafes","StrafesNET","Strafe Client")?;
-		Some(Self{
-			settings:dirs.config_dir().join("settings.conf"),
-			maps:dirs.cache_dir().join("maps"),
-			// separate directory for remote downloaded replays (cache)
-			// bots:dirs.cache_dir().join("bots"),
-			replays:dirs.data_local_dir().join("replays"),
-		})
-	}
-	pub fn portable()->Result<Self,std::io::Error>{
-		let current_dir=std::env::current_dir()?;
-		Ok(Self{
-			settings:current_dir.join("settings.conf"),
-			maps:current_dir.join("maps"),
-			replays:current_dir.join("replays"),
-		})
-	}
-}

engine/settings/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod settings;
-pub mod directories;

integration-testing/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "integration-testing"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-strafesnet_common = { version = "0.5.2", path = "../lib/common", registry = "strafesnet" }
-strafesnet_physics = { version = "0.1.0", path = "../engine/physics", registry = "strafesnet" }
-strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }

integration-testing/src/main.rs

@@ -1,221 +0,0 @@
-
-use std::{io::{Cursor,Read},path::Path};
-
-use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
-
-fn main(){
-	test_determinism().unwrap();
-}
-
-#[allow(unused)]
-#[derive(Debug)]
-enum ReplayError{
-	IO(std::io::Error),
-	SNF(strafesnet_snf::Error),
-	SNFM(strafesnet_snf::map::Error),
-	SNFB(strafesnet_snf::bot::Error),
-}
-impl From<std::io::Error> for ReplayError{
-	fn from(value:std::io::Error)->Self{
-		Self::IO(value)
-	}
-}
-impl From<strafesnet_snf::Error> for ReplayError{
-	fn from(value:strafesnet_snf::Error)->Self{
-		Self::SNF(value)
-	}
-}
-impl From<strafesnet_snf::map::Error> for ReplayError{
-	fn from(value:strafesnet_snf::map::Error)->Self{
-		Self::SNFM(value)
-	}
-}
-impl From<strafesnet_snf::bot::Error> for ReplayError{
-	fn from(value:strafesnet_snf::bot::Error)->Self{
-		Self::SNFB(value)
-	}
-}
-
-fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=std::fs::File::open(path)?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data)?;
-	Ok(Cursor::new(data))
-}
-
-fn run_replay()->Result<(),ReplayError>{
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	println!("loading bot file..");
-	let data=read_entire_file("../tools/replays/535s+159764769ns.snfb")?;
-	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
-
-	// create recording
-	let mut physics_data=PhysicsData::default();
-	println!("generating models..");
-	physics_data.generate_models(&map);
-	println!("simulating...");
-	let mut physics=PhysicsState::default();
-	for ins in bot.instructions{
-		PhysicsContext::run_input_instruction(&mut physics,&physics_data,ins);
-	}
-	match physics.get_finish_time(){
-		Some(time)=>println!("finish time:{}",time),
-		None=>println!("simulation did not end in finished state"),
-	}
-
-	Ok(())
-}
-enum DeterminismResult{
-	Deterministic,
-	NonDeterministic,
-}
-fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->DeterminismResult{
-	// create default physics state
-	let mut physics_deterministic=PhysicsState::default();
-	// create a second physics state
-	let mut physics_filtered=PhysicsState::default();
-
-	// invent a new bot id and insert the replay
-	println!("simulating...");
-
-	let mut non_idle_count=0;
-
-	for (i,ins) in bot.instructions.into_iter().enumerate(){
-		let state_deterministic=physics_deterministic.clone();
-		let state_filtered=physics_filtered.clone();
-		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
-		match ins{
-			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
-			other=>{
-				non_idle_count+=1;
-				// run
-				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
-				// check if position matches
-				let b0=physics_deterministic.camera_body();
-				let b1=physics_filtered.camera_body();
-				if b0.position!=b1.position{
-					println!("desync at instruction #{}",i);
-					println!("non idle instructions completed={non_idle_count}");
-					println!("instruction #{i}={:?}",other);
-					println!("deterministic state0:\n{state_deterministic:?}");
-					println!("filtered state0:\n{state_filtered:?}");
-					println!("deterministic state1:\n{:?}",physics_deterministic);
-					println!("filtered state1:\n{:?}",physics_filtered);
-					return DeterminismResult::NonDeterministic;
-				}
-			},
-		}
-	}
-	match physics_deterministic.get_finish_time(){
-		Some(time)=>println!("[with idle] finish time:{}",time),
-		None=>println!("[with idle] simulation did not end in finished state"),
-	}
-	match physics_filtered.get_finish_time(){
-		Some(time)=>println!("[filtered] finish time:{}",time),
-		None=>println!("[filtered] simulation did not end in finished state"),
-	}
-	DeterminismResult::Deterministic
-}
-type ThreadResult=Result<Option<DeterminismResult>,ReplayError>;
-fn read_and_run(file_path:std::path::PathBuf,physics_data:&PhysicsData)->ThreadResult{
-	let data=read_entire_file(file_path.as_path())?;
-	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
-	println!("Running {:?}",file_path.file_stem());
-	Ok(Some(segment_determinism(bot,physics_data)))
-}
-fn do_thread<'a>(s:&'a std::thread::Scope<'a,'_>,file_path:std::path::PathBuf,send:std::sync::mpsc::Sender<ThreadResult>,physics_data:&'a PhysicsData){
-	s.spawn(move ||{
-		let result=read_and_run(file_path,physics_data);
-		// send when thread is complete
-		send.send(result).unwrap();
-	});
-}
-fn get_file_path(dir_entry:std::fs::DirEntry)->Result<Option<std::path::PathBuf>,std::io::Error>{
-	Ok(dir_entry.file_type()?.is_file().then_some(
-		dir_entry.path()
-	))
-}
-fn test_determinism()->Result<(),ReplayError>{
-	let thread_limit=std::thread::available_parallelism()?.get();
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	let mut physics_data=PhysicsData::default();
-	println!("generating models..");
-	physics_data.generate_models(&map);
-
-	let (send,recv)=std::sync::mpsc::channel();
-
-	let mut read_dir=std::fs::read_dir("../tools/replays")?;
-
-	// promise that &physics_data will outlive the spawned threads
-	let thread_results=std::thread::scope(|s|{
-		let mut thread_results=Vec::new();
-
-		// spawn threads
-		println!("spawning up to {thread_limit} threads...");
-		let mut active_thread_count=0;
-		while active_thread_count<thread_limit{
-			if let Some(dir_entry_result)=read_dir.next(){
-				if let Some(file_path)=get_file_path(dir_entry_result?)?{
-					active_thread_count+=1;
-					do_thread(s,file_path,send.clone(),&physics_data);
-				}
-			}else{
-				break;
-			}
-		}
-
-		// spawn another thread every time a message is received from the channel
-		println!("riding parallelism wave...");
-		while let Some(dir_entry_result)=read_dir.next(){
-			if let Some(file_path)=get_file_path(dir_entry_result?)?{
-				// wait for a thread to complete
-				thread_results.push(recv.recv().unwrap());
-				do_thread(s,file_path,send.clone(),&physics_data);
-			}
-		}
-
-		// wait for remaining threads to complete
-		println!("waiting for all threads to complete...");
-		for _ in 0..active_thread_count{
-			thread_results.push(recv.recv().unwrap());
-		}
-
-		println!("done.");
-		Ok::<_,ReplayError>(thread_results)
-	})?;
-
-	// tally results
-	#[derive(Default)]
-	struct Totals{
-		deterministic:u32,
-		nondeterministic:u32,
-		invalid:u32,
-		error:u32,
-	}
-	let Totals{deterministic,nondeterministic,invalid,error}=thread_results.into_iter().fold(Totals::default(),|mut totals,result|{
-		match result{
-			Ok(Some(DeterminismResult::Deterministic))=>totals.deterministic+=1,
-			Ok(Some(DeterminismResult::NonDeterministic))=>totals.nondeterministic+=1,
-			Ok(None)=>totals.invalid+=1,
-			Err(_)=>totals.error+=1,
-		}
-		totals
-	});
-
-	println!("deterministic={deterministic}");
-	println!("nondeterministic={nondeterministic}");
-	println!("invalid={invalid}");
-	println!("error={error}");
-
-	assert!(nondeterministic==0);
-	assert!(invalid==0);
-	assert!(error==0);
-
-	Ok(())
-}

lib/bsp_loader/src/bsp.rs

@@ -240,7 +240,7 @@ impl PartialMap2{
 		.enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
+		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
 			//this may generate duplicate no-texture render configs but idc
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()

lib/common/src/controls_bitflag.rs

@@ -18,8 +18,13 @@ bitflags::bitflags!{
 		const Use=1<<14;//Interact with object
 		const PrimaryAction=1<<15;//LBM/Shoot/Melee
 		const SecondaryAction=1<<16;//RMB/ADS/Block
-
-		const WASD=Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).bits();
-		const WASDQE=Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).union(Self::MoveUp).union(Self::MoveDown).bits();
+	}
+}
+impl Controls{
+	pub const fn wasd()->Self{
+		Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight)
+	}
+	pub const fn wasdqe()->Self{
+		Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).union(Self::MoveUp).union(Self::MoveDown)
 	}
 }

lib/common/src/gameplay_attributes.rs

@@ -1,5 +1,5 @@
 use crate::model;
-use crate::integer::{AbsoluteTime,Planar64,Planar64Vec3};
+use crate::integer::{Time,Planar64,Planar64Vec3};
 
 //you have this effect while in contact
 #[derive(Clone,Hash,Eq,PartialEq)]
@@ -31,7 +31,7 @@ pub enum Booster{
 	//Affine(crate::integer::Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
 	Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
 	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
-	AirTime(AbsoluteTime),//increase airtime, invariant across mass and gravity changes
+	AirTime(Time),//increase airtime, invariant across mass and gravity changes
 	Height(Planar64),//increase height, invariant across mass and gravity changes
 }
 impl Booster{
@@ -57,13 +57,13 @@ pub enum TrajectoryChoice{
 #[derive(Clone,Hash,Eq,PartialEq)]
 pub enum SetTrajectory{
 	//Speed-type SetTrajectory
-	AirTime(AbsoluteTime),//air time (relative to gravity direction) is invariant across mass and gravity changes
+	AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
 	Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
 	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
 	//Velocity-type SetTrajectory
 	TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
 		target_point:Planar64Vec3,
-		time:AbsoluteTime,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
+		time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
 	},
 	TargetPointSpeed{//launch at a fixed speed and land at a target point
 		target_point:Planar64Vec3,

lib/common/src/gameplay_modes.rs

@@ -110,7 +110,6 @@ impl Stage{
 	pub fn into_inner(self)->(HashMap<CheckpointId,ModelId>,HashSet<ModelId>){
 		(self.ordered_checkpoints,self.unordered_checkpoints)
 	}
-	/// Returns true if the stage has no checkpoints.
 	#[inline]
 	pub const fn is_empty(&self)->bool{
 		self.is_complete(0,0)

lib/common/src/gameplay_style.rs

@@ -1,8 +1,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::integer::{int,vec3::int as int3,Time,Ratio64,Planar64,Planar64Vec3};
 use crate::controls_bitflag::Controls;
-use crate::physics::Time as PhysicsTime;
 
 #[derive(Clone,Debug)]
 pub struct StyleModifiers{
@@ -49,7 +48,7 @@ pub enum JumpCalculation{
 
 #[derive(Clone,Debug)]
 pub enum JumpImpulse{
-	Time(AbsoluteTime),//jump time is invariant across mass and gravity changes
+	Time(Time),//jump time is invariant across mass and gravity changes
 	Height(Planar64),//jump height is invariant across mass and gravity changes
 	Linear(Planar64),//jump velocity is invariant across mass and gravity changes
 	Energy(Planar64),// :)
@@ -200,8 +199,8 @@ impl ControlsActivation{
 	}
 	pub const fn full_3d()->Self{
 		Self{
-			controls_mask:Controls::WASDQE,
-			controls_intersects:Controls::WASDQE,
+			controls_mask:Controls::wasdqe(),
+			controls_intersects:Controls::wasdqe(),
 			controls_contains:Controls::empty(),
 		}
 	}
@@ -209,8 +208,8 @@ impl ControlsActivation{
 	//Normal
 	pub const fn full_2d()->Self{
 		Self{
-			controls_mask:Controls::WASD,
-			controls_intersects:Controls::WASD,
+			controls_mask:Controls::wasd(),
+			controls_intersects:Controls::wasd(),
 			controls_contains:Controls::empty(),
 		}
 	}
@@ -273,8 +272,8 @@ 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 fn next_tick(&self,time:Time)->Time{
+		Time::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)
@@ -436,7 +435,7 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:None,
 				mv:int(3),
-				tick_rate:Ratio64::new(64,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
+				tick_rate:Ratio64::new(64,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
 				impulse:JumpImpulse::Energy(int(512)),
@@ -478,10 +477,10 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:None,
 				mv:int(27)/10,
-				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Time(AbsoluteTime::from_micros(715_588)),
+				impulse:JumpImpulse::Time(Time::from_micros(715_588)),
 				calculation:JumpCalculation::Max,
 				limit_minimum:true,
 			}),
@@ -535,7 +534,7 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:Some(Planar64::raw(150<<28)*100),
 				mv:(Planar64::raw(30)*VALVE_SCALE).fix_1(),
-				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
 				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),
@@ -576,7 +575,7 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:Some((int(150)*66*VALVE_SCALE).fix_1()),
 				mv:(int(30)*VALVE_SCALE).fix_1(),
-				tick_rate:Ratio64::new(66,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
+				tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
 				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),

lib/common/src/instruction.rs

@@ -1,82 +1,53 @@
 use crate::integer::Time;
 
-#[derive(Clone,Debug)]
-pub struct TimedInstruction<I,T>{
-	pub time:Time<T>,
+#[derive(Debug)]
+pub struct TimedInstruction<I>{
+	pub time:Time,
 	pub instruction:I,
 }
-impl<I,T> TimedInstruction<I,T>{
-	#[inline]
-	pub fn set_time<TimeInner>(self,new_time:Time<TimeInner>)->TimedInstruction<I,TimeInner>{
-		TimedInstruction{
-			time:new_time,
-			instruction:self.instruction,
-		}
-	}
-}
 
-/// Ensure all emitted instructions are processed before consuming external instructions
 pub trait InstructionEmitter<I>{
-	type TimeInner;
-	fn next_instruction(&self,time_limit:Time<Self::TimeInner>)->Option<TimedInstruction<I,Self::TimeInner>>;
+	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<I>>;
 }
-/// Apply an atomic state update
 pub trait InstructionConsumer<I>{
-	type TimeInner;
-	fn process_instruction(&mut self,instruction:TimedInstruction<I,Self::TimeInner>);
+	fn process_instruction(&mut self, instruction:TimedInstruction<I>);
 }
-/// If the object produces its own instructions, allow exhaustively feeding them back in
-pub trait InstructionFeedback<I,T>:InstructionEmitter<I,TimeInner=T>+InstructionConsumer<I,TimeInner=T>
-	where
-		Time<T>:Copy,
-{
-	#[inline]
-	fn process_exhaustive(&mut self,time_limit:Time<T>){
-		while let Some(instruction)=self.next_instruction(time_limit){
-			self.process_instruction(instruction);
-		}
-	}
-}
-impl<I,T,X> InstructionFeedback<I,T> for X
-	where
-		Time<T>:Copy,
-		X:InstructionEmitter<I,TimeInner=T>+InstructionConsumer<I,TimeInner=T>,
-{}
 
 //PROPER PRIVATE FIELDS!!!
-pub struct InstructionCollector<I,T>{
-	time:Time<T>,
+pub struct InstructionCollector<I>{
+	time:Time,
 	instruction:Option<I>,
 }
-impl<I,T> InstructionCollector<I,T>
-	where Time<T>:Copy+PartialOrd,
-{
-	#[inline]
-	pub const fn new(time:Time<T>)->Self{
+impl<I> InstructionCollector<I>{
+	pub const fn new(time:Time)->Self{
 		Self{
 			time,
 			instruction:None
 		}
 	}
 	#[inline]
-	pub const fn time(&self)->Time<T>{
+	pub const fn time(&self)->Time{
 		self.time
 	}
-	#[inline]
-	pub fn collect(&mut self,instruction:Option<TimedInstruction<I,T>>){
-		if let Some(ins)=instruction{
-			if ins.time<self.time{
-				self.time=ins.time;
-				self.instruction=Some(ins.instruction);
-			}
+	pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
+		match instruction{
+			Some(unwrap_instruction)=>{
+				if unwrap_instruction.time<self.time {
+					self.time=unwrap_instruction.time;
+					self.instruction=Some(unwrap_instruction.instruction);
+				}
+			},
+			None=>(),
 		}
 	}
-	#[inline]
-	pub fn take(self)->Option<TimedInstruction<I,T>>{
+	pub fn instruction(self)->Option<TimedInstruction<I>>{
 		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
-		self.instruction.map(|instruction|TimedInstruction{
-			time:self.time,
-			instruction
-		})
+		match self.instruction{
+			Some(instruction)=>Some(TimedInstruction{
+				time:self.time,
+				instruction
+			}),
+			None=>None,
+		}
 	}
 }

lib/common/src/integer.rs

@@ -2,26 +2,19 @@ pub use fixed_wide::fixed::{Fixed,Fix};
 pub use ratio_ops::ratio::{Ratio,Divide};
 
 //integer units
-
-/// specific example of a "default" time type
 #[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum TimeInner{}
-pub type AbsoluteTime=Time<TimeInner>;
-
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub struct Time<T>(i64,core::marker::PhantomData<T>);
-impl<T> Time<T>{
-	pub const MIN:Self=Self::raw(i64::MIN);
-	pub const MAX:Self=Self::raw(i64::MAX);
-	pub const ZERO:Self=Self::raw(0);
-	pub const EPSILON:Self=Self::raw(1);
-	pub const ONE_SECOND:Self=Self::raw(1_000_000_000);
-	pub const ONE_MILLISECOND:Self=Self::raw(1_000_000);
-	pub const ONE_MICROSECOND:Self=Self::raw(1_000);
-	pub const ONE_NANOSECOND:Self=Self::raw(1);
+pub struct Time(i64);
+impl Time{
+	pub const MIN:Self=Self(i64::MIN);
+	pub const MAX:Self=Self(i64::MAX);
+	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);
+	pub const ONE_NANOSECOND:Self=Self(1);
 	#[inline]
 	pub const fn raw(num:i64)->Self{
-		Self(num,core::marker::PhantomData)
+		Self(num)
 	}
 	#[inline]
 	pub const fn get(self)->i64{
@@ -29,19 +22,19 @@ impl<T> Time<T>{
 	}
 	#[inline]
 	pub const fn from_secs(num:i64)->Self{
-		Self::raw(Self::ONE_SECOND.0*num)
+		Self(Self::ONE_SECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_millis(num:i64)->Self{
-		Self::raw(Self::ONE_MILLISECOND.0*num)
+		Self(Self::ONE_MILLISECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_micros(num:i64)->Self{
-		Self::raw(Self::ONE_MICROSECOND.0*num)
+		Self(Self::ONE_MICROSECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_nanos(num:i64)->Self{
-		Self::raw(Self::ONE_NANOSECOND.0*num)
+		Self(Self::ONE_NANOSECOND.0*num)
 	}
 	//should I have checked subtraction? force all time variables to be positive?
 	#[inline]
@@ -52,18 +45,14 @@ impl<T> Time<T>{
 	pub const fn to_ratio(self)->Ratio<Planar64,Planar64>{
 		Ratio::new(Planar64::raw(self.0),Planar64::raw(1_000_000_000))
 	}
-	#[inline]
-	pub const fn coerce<U>(self)->Time<U>{
-		Time::raw(self.0)
-	}
 }
-impl<T> From<Planar64> for Time<T>{
+impl From<Planar64> for Time{
 	#[inline]
 	fn from(value:Planar64)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+		Time((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
 	}
 }
-impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
+impl<Num,Den,N1,T1> From<Ratio<Num,Den>> for Time
 	where
 		Num:core::ops::Mul<Planar64,Output=N1>,
 		N1:Divide<Den,Output=T1>,
@@ -71,34 +60,34 @@ impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
 {
 	#[inline]
 	fn from(value:Ratio<Num,Den>)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
+		Time((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
 	}
 }
-impl<T> std::fmt::Display for Time<T>{
+impl std::fmt::Display for Time{
 	#[inline]
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
 	}
 }
-impl<T> std::default::Default for Time<T>{
+impl std::default::Default for Time{
 	fn default()->Self{
-		Self::raw(0)
+		Self(0)
 	}
 }
-impl<T> std::ops::Neg for Time<T>{
-	type Output=Self;
+impl std::ops::Neg for Time{
+	type Output=Time;
 	#[inline]
 	fn neg(self)->Self::Output {
-		Self::raw(-self.0)
+		Time(-self.0)
 	}
 }
 macro_rules! impl_time_additive_operator {
 	($trait:ty, $method:ident) => {
-		impl<T> $trait for Time<T>{
-			type Output=Self;
+		impl $trait for Time{
+			type Output=Time;
 			#[inline]
 			fn $method(self,rhs:Self)->Self::Output {
-				Self::raw(self.0.$method(rhs.0))
+				Time(self.0.$method(rhs.0))
 			}
 		}
 	};
@@ -108,7 +97,7 @@ impl_time_additive_operator!(core::ops::Sub,sub);
 impl_time_additive_operator!(core::ops::Rem,rem);
 macro_rules! impl_time_additive_assign_operator {
 	($trait:ty, $method:ident) => {
-		impl<T> $trait for Time<T>{
+		impl $trait for Time{
 			#[inline]
 			fn $method(&mut self,rhs:Self){
 				self.0.$method(rhs.0)
@@ -119,58 +108,53 @@ macro_rules! impl_time_additive_assign_operator {
 impl_time_additive_assign_operator!(core::ops::AddAssign,add_assign);
 impl_time_additive_assign_operator!(core::ops::SubAssign,sub_assign);
 impl_time_additive_assign_operator!(core::ops::RemAssign,rem_assign);
-impl<T> std::ops::Mul for Time<T>{
+impl std::ops::Mul for Time{
 	type Output=Ratio<fixed_wide::fixed::Fixed<2,64>,fixed_wide::fixed::Fixed<2,64>>;
 	#[inline]
 	fn mul(self,rhs:Self)->Self::Output{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
 	}
 }
-impl<T> std::ops::Div<i64> for Time<T>{
-	type Output=Self;
+impl std::ops::Div<i64> for Time{
+	type Output=Time;
 	#[inline]
 	fn div(self,rhs:i64)->Self::Output{
-		Self::raw(self.0/rhs)
+		Time(self.0/rhs)
 	}
 }
-impl<T> std::ops::Mul<i64> for Time<T>{
-	type Output=Self;
+impl std::ops::Mul<i64> for Time{
+	type Output=Time;
 	#[inline]
 	fn mul(self,rhs:i64)->Self::Output{
-		Self::raw(self.0*rhs)
+		Time(self.0*rhs)
 	}
 }
-impl<T> core::ops::Mul<Time<T>> for Planar64{
+impl core::ops::Mul<Time> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
-	fn mul(self,rhs:Time<T>)->Self::Output{
+	fn mul(self,rhs:Time)->Self::Output{
 		Ratio::new(self*Fixed::raw(rhs.0),Planar64::raw(1_000_000_000))
 	}
 }
-#[cfg(test)]
-mod test_time{
-	use super::*;
-	type Time=super::AbsoluteTime;
-	#[test]
-	fn time_from_planar64(){
-		let a:Time=Planar64::from(1).into();
-		assert_eq!(a,Time::ONE_SECOND);
-	}
-	#[test]
-	fn time_from_ratio(){
-		let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
-		assert_eq!(a,Time::ONE_SECOND);
-	}
-	#[test]
-	fn time_squared(){
-		let a=Time::from_secs(2);
-		assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
-	}
-	#[test]
-	fn time_times_planar64(){
-		let a=Time::from_secs(2);
-		let b=Planar64::from(2);
-		assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
-	}
+#[test]
+fn time_from_planar64(){
+	let a:Time=Planar64::from(1).into();
+	assert_eq!(a,Time::ONE_SECOND);
+}
+#[test]
+fn time_from_ratio(){
+	let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
+	assert_eq!(a,Time::ONE_SECOND);
+}
+#[test]
+fn time_squared(){
+	let a=Time::from_secs(2);
+	assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
+}
+#[test]
+fn time_times_planar64(){
+	let a=Time::from_secs(2);
+	let b=Planar64::from(2);
+	assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
 }
 
 #[inline]

lib/common/src/lib.rs

@@ -7,7 +7,6 @@ pub mod mouse;
 pub mod timer;
 pub mod integer;
 pub mod physics;
-pub mod session;
 pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;

lib/common/src/mouse.rs

@@ -1,11 +1,11 @@
 use crate::integer::Time;
 
 #[derive(Clone,Debug)]
-pub struct MouseState<T>{
+pub struct MouseState{
 	pub pos:glam::IVec2,
-	pub time:Time<T>,
+	pub time:Time,
 }
-impl<T> Default for MouseState<T>{
+impl Default for MouseState{
 	fn default()->Self{
 		Self{
 			time:Time::ZERO,
@@ -13,10 +13,8 @@ impl<T> Default for MouseState<T>{
 		}
 	}
 }
-impl<T> MouseState<T>
-	where Time<T>:Copy,
-{
-	pub fn lerp(&self,target:&MouseState<T>,time:Time<T>)->glam::IVec2{
+impl MouseState{
+	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

lib/common/src/physics.rs

@@ -1,33 +1,7 @@
-use crate::mouse::MouseState;
-use crate::gameplay_modes::{ModeId,StageId};
-
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum TimeInner{}
-pub type Time=crate::integer::Time<TimeInner>;
-
 #[derive(Clone,Debug)]
 pub enum Instruction{
-	Mouse(MouseInstruction),
-	SetControl(SetControlInstruction),
-	Mode(ModeInstruction),
-	Misc(MiscInstruction),
-	/// Idle: there were no input events, but the simulation is safe to advance to this timestep
-	Idle,
-}
-impl Instruction{
-	pub const IDLE:Self=Self::Idle;
-}
-#[derive(Clone,Debug)]
-pub enum MouseInstruction{
-	/// Replace the entire interpolation state to avoid dividing by zero when replacing twice
-	ReplaceMouse{
-		m0:MouseState<TimeInner>,
-		m1:MouseState<TimeInner>,
-	},
-	SetNextMouse(MouseState<TimeInner>),
-}
-#[derive(Clone,Debug)]
-pub enum SetControlInstruction{
+	ReplaceMouse(crate::mouse::MouseState,crate::mouse::MouseState),
+	SetNextMouse(crate::mouse::MouseState),
 	SetMoveRight(bool),
 	SetMoveUp(bool),
 	SetMoveBack(bool),
@@ -36,21 +10,18 @@ pub enum SetControlInstruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
-}
-#[derive(Clone,Debug)]
-pub enum ModeInstruction{
 	/// Reset: fully replace the physics state.
 	/// This forgets all inputs and settings which need to be reapplied.
 	Reset,
 	/// Restart: Teleport to the start zone.
-	/// This runs when you press R or teleport to a bonus
-	Restart(ModeId),
+	Restart,
 	/// Spawn: Teleport to a specific mode's spawn
-	/// This runs when the map loads to put you at the map lobby
-	Spawn(ModeId,StageId),
-}
-#[derive(Clone,Debug)]
-pub enum MiscInstruction{
+	/// Sets current mode & spawn
+	Spawn(crate::gameplay_modes::ModeId,crate::gameplay_modes::StageId),
+	Idle,
+		//Idle: there were no input events, but the simulation is safe to advance to this timestep
+		//for interpolation / networking / playback reasons, most playback heads will always want
+		//to be 1 instruction ahead to generate the next state for interpolation.
 	PracticeFly,
 	SetSensitivity(crate::integer::Ratio64Vec2),
 }

lib/common/src/run.rs

@@ -1,10 +1,5 @@
 use crate::timer::{TimerFixed,Realtime,Paused,Unpaused};
-
-use crate::physics::{TimeInner as PhysicsTimeInner,Time as PhysicsTime};
-
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum TimeInner{}
-pub type Time=crate::integer::Time<TimeInner>;
+use crate::integer::Time;
 
 #[derive(Clone,Copy,Debug)]
 pub enum FlagReason{
@@ -20,11 +15,6 @@ pub enum FlagReason{
 }
 impl ToString for FlagReason{
 	fn to_string(&self)->String{
-		self.as_ref().to_owned()
-	}
-}
-impl AsRef<str> for FlagReason{
-	fn as_ref(&self)->&str{
 		match self{
 			FlagReason::Anticheat=>"Passed through anticheat zone.",
 			FlagReason::StyleChange=>"Changed style.",
@@ -35,7 +25,7 @@ impl AsRef<str> for FlagReason{
 			FlagReason::Timescale=>"Timescale is not allowed in this style.",
 			FlagReason::TimeTravel=>"Time travel is not allowed in this style.",
 			FlagReason::Teleport=>"Illegal teleport.",
-		}
+		}.to_owned()
 	}
 }
 
@@ -55,8 +45,8 @@ impl std::error::Error for Error{}
 #[derive(Clone,Copy,Debug)]
 enum RunState{
 	Created,
-	Started{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Unpaused>},
-	Finished{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Paused>},
+	Started{timer:TimerFixed<Realtime,Unpaused>},
+	Finished{timer:TimerFixed<Realtime,Paused>},
 }
 
 #[derive(Clone,Copy,Debug)]
@@ -72,14 +62,14 @@ impl Run{
 			flagged:None,
 		}
 	}
-	pub fn time(&self,time:PhysicsTime)->Time{
+	pub fn time(&self,time:Time)->Time{
 		match &self.state{
 			RunState::Created=>Time::ZERO,
 			RunState::Started{timer}=>timer.time(time),
-			RunState::Finished{timer}=>timer.time(),
+			RunState::Finished{timer}=>timer.time(time),
 		}
 	}
-	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
+	pub fn start(&mut self,time:Time)->Result<(),Error>{
 		match &self.state{
 			RunState::Created=>{
 				self.state=RunState::Started{
@@ -91,7 +81,7 @@ impl Run{
 			RunState::Finished{..}=>Err(Error::AlreadyFinished),
 		}
 	}
-	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
+	pub fn finish(&mut self,time:Time)->Result<(),Error>{
 		//this uses Copy
 		match &self.state{
 			RunState::Created=>Err(Error::NotStarted),
@@ -110,10 +100,4 @@ impl Run{
 			self.flagged=Some(flag_reason);
 		}
 	}
-	pub fn get_finish_time(&self)->Option<Time>{
-		match &self.state{
-			RunState::Finished{timer}=>Some(timer.time()),
-			_=>None,
-		}
-	}
 }

lib/common/src/session.rs

@@ -1,3 +0,0 @@
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum TimeInner{}
-pub type Time=crate::integer::Time<TimeInner>;

lib/common/src/timer.rs

@@ -22,106 +22,79 @@ impl PauseState for Unpaused{
 	}
 }
 
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum Inner{}
-type InnerTime=Time<Inner>;
-
 #[derive(Clone,Copy,Debug)]
-pub struct Realtime<In,Out>{
-	offset:InnerTime,
-	_in:core::marker::PhantomData<In>,
-	_out:core::marker::PhantomData<Out>,
+pub struct Realtime{
+	offset:Time,
 }
-impl<In,Out> Realtime<In,Out>{
-	pub const fn new(offset:InnerTime)->Self{
-		Self{
-			offset,
-			_in:core::marker::PhantomData,
-			_out:core::marker::PhantomData,
-		}
+impl Realtime{
+	pub const fn new(offset:Time)->Self{
+		Self{offset}
 	}
 }
 
 #[derive(Clone,Copy,Debug)]
-pub struct Scaled<In,Out>{
+pub struct Scaled{
 	scale:Ratio64,
-	offset:InnerTime,
-	_in:core::marker::PhantomData<In>,
-	_out:core::marker::PhantomData<Out>,
+	offset:Time,
 }
-impl<In,Out> Scaled<In,Out>
-	where Time<In>:Copy,
-{
-	pub const fn new(scale:Ratio64,offset:InnerTime)->Self{
-		Self{
-			scale,
-			offset,
-			_in:core::marker::PhantomData,
-			_out:core::marker::PhantomData,
-		}
+impl Scaled{
+	pub const fn new(scale:Ratio64,offset:Time)->Self{
+		Self{scale,offset}
 	}
 	const fn with_scale(scale:Ratio64)->Self{
-		Self::new(scale,InnerTime::ZERO)
+		Self{scale,offset:Time::ZERO}
 	}
-	const fn scale(&self,time:Time<In>)->InnerTime{
-		InnerTime::raw(self.scale.mul_int(time.get()))
+	const fn scale(&self,time:Time)->Time{
+		Time::raw(self.scale.mul_int(time.get()))
 	}
 	const fn get_scale(&self)->Ratio64{
 		self.scale
 	}
-	fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
+	fn set_scale(&mut self,time:Time,new_scale:Ratio64){
 		let new_time=self.get_time(time);
 		self.scale=new_scale;
 		self.set_time(time,new_time);
 	}
 }
 
-pub trait TimerState{
-	type In;
-	type Out;
+pub trait TimerState:Copy+std::fmt::Debug{
 	fn identity()->Self;
-	fn get_time(&self,time:Time<Self::In>)->Time<Self::Out>;
-	fn set_time(&mut self,time:Time<Self::In>,new_time:Time<Self::Out>);
-	fn get_offset(&self)->InnerTime;
-	fn set_offset(&mut self,offset:InnerTime);
+	fn get_time(&self,time:Time)->Time;
+	fn set_time(&mut self,time:Time,new_time:Time);
+	fn get_offset(&self)->Time;
+	fn set_offset(&mut self,offset:Time);
 }
-impl<In,Out> TimerState for Realtime<In,Out>{
-	type In=In;
-	type Out=Out;
+impl TimerState for Realtime{
 	fn identity()->Self{
-		Self::new(InnerTime::ZERO)
+		Self{offset:Time::ZERO}
 	}
-	fn get_time(&self,time:Time<In>)->Time<Out>{
-		time.coerce()+self.offset.coerce()
+	fn get_time(&self,time:Time)->Time{
+		time+self.offset
 	}
-	fn set_time(&mut self,time:Time<In>,new_time:Time<Out>){
-		self.offset=new_time.coerce()-time.coerce();
+	fn set_time(&mut self,time:Time,new_time:Time){
+		self.offset=new_time-time;
 	}
-	fn get_offset(&self)->InnerTime{
+	fn get_offset(&self)->Time{
 		self.offset
 	}
-	fn set_offset(&mut self,offset:InnerTime){
+	fn set_offset(&mut self,offset:Time){
 		self.offset=offset;
 	}
 }
-impl<In,Out> TimerState for Scaled<In,Out>
-	where Time<In>:Copy,
-{
-	type In=In;
-	type Out=Out;
+impl TimerState for Scaled{
 	fn identity()->Self{
-		Self::new(Ratio64::ONE,InnerTime::ZERO)
+		Self{scale:Ratio64::ONE,offset:Time::ZERO}
 	}
-	fn get_time(&self,time:Time<In>)->Time<Out>{
-		(self.scale(time)+self.offset).coerce()
+	fn get_time(&self,time:Time)->Time{
+		self.scale(time)+self.offset
 	}
-	fn set_time(&mut self,time:Time<In>,new_time:Time<Out>){
-		self.offset=new_time.coerce()-self.scale(time);
+	fn set_time(&mut self,time:Time,new_time:Time){
+		self.offset=new_time-self.scale(time);
 	}
-	fn get_offset(&self)->InnerTime{
+	fn get_offset(&self)->Time{
 		self.offset
 	}
-	fn set_offset(&mut self,offset:InnerTime){
+	fn set_offset(&mut self,offset:Time){
 		self.offset=offset;
 	}
 }
@@ -133,10 +106,8 @@ pub struct TimerFixed<T:TimerState,P:PauseState>{
 }
 
 //scaled timer methods are generic across PauseState
-impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
-	where Time<In>:Copy,
-{
-	pub fn scaled(time:Time<In>,new_time:Time<Out>,scale:Ratio64)->Self{
+impl<P:PauseState> TimerFixed<Scaled,P>{
+	pub fn scaled(time:Time,new_time:Time,scale:Ratio64)->Self{
 		let mut timer=Self{
 			state:Scaled::with_scale(scale),
 			_paused:P::new(),
@@ -147,17 +118,15 @@ impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	pub const fn get_scale(&self)->Ratio64{
 		self.state.get_scale()
 	}
-	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
+	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
 		self.state.set_scale(time,new_scale)
 	}
 }
 
 //pause and unpause is generic across TimerState
-impl<T:TimerState> TimerFixed<T,Paused>
-	where Time<T::In>:Copy,
-{
-	pub fn into_unpaused(self,time:Time<T::In>)->TimerFixed<T,Unpaused>{
-		let new_time=self.time();
+impl<T:TimerState> TimerFixed<T,Paused>{
+	pub fn into_unpaused(self,time:Time)->TimerFixed<T,Unpaused>{
+		let new_time=self.time(time);
 		let mut timer=TimerFixed{
 			state:self.state,
 			_paused:Unpaused,
@@ -165,14 +134,9 @@ impl<T:TimerState> TimerFixed<T,Paused>
 		timer.set_time(time,new_time);
 		timer
 	}
-	pub fn time(&self)->Time<T::Out>{
-		self.state.get_offset().coerce()
-	}
 }
-impl<T:TimerState> TimerFixed<T,Unpaused>
-	where Time<T::In>:Copy,
-{
-	pub fn into_paused(self,time:Time<T::In>)->TimerFixed<T,Paused>{
+impl<T:TimerState> TimerFixed<T,Unpaused>{
+	pub fn into_paused(self,time:Time)->TimerFixed<T,Paused>{
 		let new_time=self.time(time);
 		let mut timer=TimerFixed{
 			state:self.state,
@@ -181,14 +145,11 @@ impl<T:TimerState> TimerFixed<T,Unpaused>
 		timer.set_time(time,new_time);
 		timer
 	}
-	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
-		self.state.get_time(time)
-	}
 }
 
 //the new constructor and time queries are generic across both
 impl<T:TimerState,P:PauseState> TimerFixed<T,P>{
-	pub fn new(time:Time<T::In>,new_time:Time<T::Out>)->Self{
+	pub fn new(time:Time,new_time:Time)->Self{
 		let mut timer=Self{
 			state:T::identity(),
 			_paused:P::new(),
@@ -205,9 +166,15 @@ impl<T:TimerState,P:PauseState> TimerFixed<T,P>{
 	pub fn into_state(self)->T{
 		self.state
 	}
-	pub fn set_time(&mut self,time:Time<T::In>,new_time:Time<T::Out>){
+	pub fn time(&self,time:Time)->Time{
 		match P::IS_PAUSED{
-			true=>self.state.set_offset(new_time.coerce()),
+			true=>self.state.get_offset(),
+			false=>self.state.get_time(time),
+		}
+	}
+	pub fn set_time(&mut self,time:Time,new_time:Time){
+		match P::IS_PAUSED{
+			true=>self.state.set_offset(new_time),
 			false=>self.state.set_time(time,new_time),
 		}
 	}
@@ -231,11 +198,7 @@ pub enum Timer<T:TimerState>{
 	Paused(TimerFixed<T,Paused>),
 	Unpaused(TimerFixed<T,Unpaused>),
 }
-impl<T:TimerState> Timer<T>
-	where
-		T:Copy,
-		Time<T::In>:Copy,
-{
+impl<T:TimerState> Timer<T>{
 	pub fn from_state(state:T,paused:bool)->Self{
 		match paused{
 			true=>Self::Paused(TimerFixed::from_state(state)),
@@ -248,32 +211,32 @@ impl<T:TimerState> Timer<T>
 			Self::Unpaused(timer)=>(timer.into_state(),false),
 		}
 	}
-	pub fn paused(time:Time<T::In>,new_time:Time<T::Out>)->Self{
+	pub fn paused(time:Time,new_time:Time)->Self{
 		Self::Paused(TimerFixed::new(time,new_time))
 	}
-	pub fn unpaused(time:Time<T::In>,new_time:Time<T::Out>)->Self{
+	pub fn unpaused(time:Time,new_time:Time)->Self{
 		Self::Unpaused(TimerFixed::new(time,new_time))
 	}
-	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
+	pub fn time(&self,time:Time)->Time{
 		match self{
-			Self::Paused(timer)=>timer.time(),
+			Self::Paused(timer)=>timer.time(time),
 			Self::Unpaused(timer)=>timer.time(time),
 		}
 	}
-	pub fn set_time(&mut self,time:Time<T::In>,new_time:Time<T::Out>){
+	pub fn set_time(&mut self,time:Time,new_time:Time){
 		match self{
 			Self::Paused(timer)=>timer.set_time(time,new_time),
 			Self::Unpaused(timer)=>timer.set_time(time,new_time),
 		}
 	}
-	pub fn pause(&mut self,time:Time<T::In>)->Result<(),Error>{
+	pub fn pause(&mut self,time:Time)->Result<(),Error>{
 		*self=match *self{
 			Self::Paused(_)=>return Err(Error::AlreadyPaused),
 			Self::Unpaused(timer)=>Self::Paused(timer.into_paused(time)),
 		};
 		Ok(())
 	}
-	pub fn unpause(&mut self,time:Time<T::In>)->Result<(),Error>{
+	pub fn unpause(&mut self,time:Time)->Result<(),Error>{
 		*self=match *self{
 			Self::Paused(timer)=>Self::Unpaused(timer.into_unpaused(time)),
 			Self::Unpaused(_)=>return Err(Error::AlreadyUnpaused),
@@ -286,7 +249,7 @@ impl<T:TimerState> Timer<T>
 			Self::Unpaused(_)=>false,
 		}
 	}
-	pub fn set_paused(&mut self,time:Time<T::In>,paused:bool)->Result<(),Error>{
+	pub fn set_paused(&mut self,time:Time,paused:bool)->Result<(),Error>{
 		match paused{
 			true=>self.pause(time),
 			false=>self.unpause(time),
@@ -294,16 +257,14 @@ impl<T:TimerState> Timer<T>
 	}
 }
 //scaled timer methods are generic across PauseState
-impl<In,Out> Timer<Scaled<In,Out>>
-	where Time<In>:Copy,
-{
+impl Timer<Scaled>{
 	pub const fn get_scale(&self)->Ratio64{
 		match self{
 			Self::Paused(timer)=>timer.get_scale(),
 			Self::Unpaused(timer)=>timer.get_scale(),
 		}
 	}
-	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
+	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
 		match self{
 			Self::Paused(timer)=>timer.set_scale(time,new_scale),
 			Self::Unpaused(timer)=>timer.set_scale(time,new_scale),
@@ -319,17 +280,12 @@ mod test{
 			Time::from_secs($s)
 		};
 	}
-
-	#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-	enum Parent{}
-	#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-	enum Calculated{}
 	#[test]
 	fn test_timerfixed_scaled(){
 		//create a paused timer that reads 0s
-		let timer=TimerFixed::<Scaled<Parent,Calculated>,Paused>::from_state(Scaled::new(0.5f32.try_into().unwrap(),sec!(0)));
+		let timer=TimerFixed::<Scaled,Paused>::from_state(Scaled{scale:0.5f32.try_into().unwrap(),offset:sec!(0)});
 		//the paused timer at 1 second should read 0s
-		assert_eq!(timer.time(),sec!(0));
+		assert_eq!(timer.time(sec!(1)),sec!(0));
 
 		//unpause it after one second
 		let timer=timer.into_unpaused(sec!(1));
@@ -339,12 +295,12 @@ mod test{
 		//pause the timer after 11 seconds
 		let timer=timer.into_paused(sec!(11));
 		//the paused timer at 20 seconds should read 5s
-		assert_eq!(timer.time(),sec!(5));
+		assert_eq!(timer.time(sec!(20)),sec!(5));
 	}
 	#[test]
 	fn test_timer()->Result<(),Error>{
 		//create a paused timer that reads 0s
-		let mut timer=Timer::<Realtime<Parent,Calculated>>::paused(sec!(0),sec!(0));
+		let mut timer=Timer::<Realtime>::paused(sec!(0),sec!(0));
 		//the paused timer at 1 second should read 0s
 		assert_eq!(timer.time(sec!(1)),sec!(0));
 

lib/common/src/updatable.rs

@@ -1,5 +1,3 @@
-// This whole thing should be a drive macro
-
 pub trait Updatable<Updater>{
 	fn update(&mut self,update:Updater);
 }
@@ -55,3 +53,4 @@ impl Updatable<OuterUpdate> for Outer{
 		}
 	}
 }
+//*/

lib/deferred_loader/Cargo.toml

@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [features]
 default = ["legacy"]
 legacy = ["dep:url","dep:vbsp"]
-roblox = []
-source = ["dep:vbsp"]
+#roblox = ["dep:lazy-regex"]
+#source = ["dep:vbsp"]
 
 [dependencies]
 strafesnet_common = { path = "../common", registry = "strafesnet" }

lib/fixed_wide/src/fixed.rs

@@ -1,6 +1,6 @@
 use bnum::{BInt,cast::As};
 
-#[derive(Clone,Copy,Debug,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
+#[derive(Clone,Copy,Debug,Default,Hash)]
 /// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
@@ -87,6 +87,12 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
+impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
+	#[inline]
+	fn eq(&self,other:&Self)->bool{
+		self.bits.eq(&other.bits)
+	}
+}
 impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
 where
 		T:Copy,
@@ -97,7 +103,14 @@ where
 		self.bits.eq(&other.into())
 	}
 }
+impl<const N:usize,const F:usize> Eq for Fixed<N,F>{}
 
+impl<const N:usize,const F:usize> PartialOrd for Fixed<N,F>{
+	#[inline]
+	fn partial_cmp(&self,other:&Self)->Option<std::cmp::Ordering>{
+		self.bits.partial_cmp(&other.bits)
+	}
+}
 impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 	where
 		T:Copy,
@@ -108,6 +121,12 @@ impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 		self.bits.partial_cmp(&other.into())
 	}
 }
+impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
+	#[inline]
+	fn cmp(&self,other:&Self)->std::cmp::Ordering{
+		self.bits.cmp(&other.bits)
+	}
+}
 
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;

lib/fixed_wide/src/tests.rs

@@ -57,7 +57,7 @@ fn from_f32(){
 	assert_eq!(b,Ok(a));
 	//I32F32::MIN hits a special case since it's not representable as a positive signed integer
 	//TODO: don't return an overflow because this is technically possible
-	let _a=I32F32::MIN;
+	let a=I32F32::MIN;
 	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	//16 is within the 24 bits of float precision

lib/rbx_loader/src/lib.rs

@@ -42,7 +42,7 @@ pub struct Place{
 	services:roblox_emulator::context::Services,
 }
 impl Place{
-	pub fn new(dom:WeakDom)->Option<Self>{
+	fn new(dom:WeakDom)->Option<Self>{
 		let context=roblox_emulator::context::Context::from_ref(&dom);
 		Some(Self{
 			services:context.find_services()?,

lib/rbx_loader/src/mesh.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use rbx_mesh::mesh::{Vertex2, Vertex2Truncated};
 use strafesnet_common::{integer::vec3,model::{self, ColorId, IndexedVertex, NormalId, PolygonGroup, PolygonList, PositionId, TextureCoordinateId, VertexId}};
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),

lib/rbx_loader/src/primitives.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
+use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,IndexedVertexList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
 use strafesnet_common::integer::{vec3,Planar64Vec3};
 
 #[derive(Debug)]
@@ -126,6 +126,9 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
+pub fn unit_sphere(render:RenderConfigId)->Mesh{
+	unit_cube(render)
+}
 #[derive(Default)]
 pub struct CubeFaceDescription([Option<FaceDescription>;6]);
 impl CubeFaceDescription{
@@ -146,6 +149,10 @@ pub fn unit_cube(render:RenderConfigId)->Mesh{
 	t.insert(CubeFace::Front,FaceDescription::new_with_render_id(render));
 	generate_partial_unit_cube(t)
 }
+pub fn unit_cylinder(render:RenderConfigId)->Mesh{
+	//lmao
+	unit_cube(render)
+}
 #[derive(Default)]
 pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
 impl WedgeFaceDescription{
@@ -156,15 +163,15 @@ impl WedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-// pub fn unit_wedge(render:RenderConfigId)->Mesh{
-// 	let mut t=WedgeFaceDescription::default();
-// 	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-// 	generate_partial_unit_wedge(t)
-// }
+pub fn unit_wedge(render:RenderConfigId)->Mesh{
+	let mut t=WedgeFaceDescription::default();
+	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+	generate_partial_unit_wedge(t)
+}
 #[derive(Default)]
 pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
 impl CornerWedgeFaceDescription{
@@ -175,15 +182,15 @@ impl CornerWedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-// pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
-// 	let mut t=CornerWedgeFaceDescription::default();
-// 	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
-// 	generate_partial_unit_cornerwedge(t)
-// }
+pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
+	let mut t=CornerWedgeFaceDescription::default();
+	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
+	generate_partial_unit_cornerwedge(t)
+}
 
 #[derive(Clone)]
 pub struct FaceDescription{

lib/rbx_loader/src/rbx.rs

@@ -130,9 +130,9 @@ impl ModesBuilder{
 	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
 		self.mode_updates.push((mode_id,mode_update));
 	}
-	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
-	// }
+	fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
+		self.stage_updates.push((mode_id,stage_id,stage_update));
+	}
 }
 fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
 	let mut general=attr::GeneralAttributes::default();
@@ -485,6 +485,9 @@ where
 					continue;
 				}
 
+				//at this point a new model is going to be generated for sure.
+				let model_id=model::ModelId::new(primitive_models_deferred_attributes.len() as u32);
+
 				//TODO: also detect "CylinderMesh" etc here
 				let shape=match object.class.as_str(){
 					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
@@ -886,14 +889,8 @@ impl PartialMap2{
 		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
-			// This may generate duplicate no-texture render configs but idc
-			//
-			// This is because some textures may not exist, so the render config
-			// that it points to is unique but is texture.
-			//
-			// I don't think this needs to be fixed because missing textures
-			// should be a conversion error anyways.
+		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
+			//this may generate duplicate no-texture render configs but idc
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()
 			);

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -33,7 +33,7 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 // LMAO look at this function!
 pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
 	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
-	f(*dom)
+	f(&mut *dom)
 }
 
 fn coerce_float32(value:&mlua::Value)->Option<f32>{

lib/roblox_emulator/src/runner/macros.rs

@@ -1,22 +1,22 @@
 macro_rules! type_from_lua_userdata{
-	($ty:ident)=>{
-		impl mlua::FromLua for $ty{
+	($asd:ident)=>{
+		impl mlua::FromLua for $asd{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
 				}
 			}
 		}
 	};
 }
 macro_rules! type_from_lua_userdata_lua_lifetime{
-	($ty:ident)=>{
-		impl mlua::FromLua for $ty<'static>{
+	($asd:ident)=>{
+		impl mlua::FromLua for $asd<'static>{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
 				}
 			}
 		}

lib/roblox_emulator/src/scheduler.rs

@@ -59,8 +59,8 @@ fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
 			match delay.classify(){
 				std::num::FpCategory::Nan=>Err(mlua::Error::runtime("NaN"))?,
 				// cases where the number is too large to schedule
-				std::num::FpCategory::Infinite
-				|std::num::FpCategory::Normal if (u64::MAX as f64)<delay=>{
+				std::num::FpCategory::Infinite=>return Ok(()),
+				std::num::FpCategory::Normal=>if (u64::MAX as f64)<delay{
 					return Ok(());
 				},
 				_=>(),

lib/snf/src/bot.rs

@@ -1,347 +1,98 @@
-use binrw::{binrw,BinReaderExt,BinWrite,BinWriterExt};
-
-use crate::newtypes;
-use crate::file::BlockId;
-use strafesnet_common::physics::Time;
-
-const VERSION:u32=0;
-
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::TimeInner>;
+use binrw::{BinReaderExt, binrw};
 
 #[derive(Debug)]
 pub enum Error{
-	InvalidHeader(binrw::Error),
+	InvalidHeader,
 	InvalidSegment(binrw::Error),
-	SegmentConvert(newtypes::integer::RatioError),
-	InstructionConvert(newtypes::physics::InstructionConvert),
-	InstructionWrite(binrw::Error),
 	InvalidSegmentId(SegmentId),
-	InvalidData(binrw::Error),
-	IO(std::io::Error),
 	File(crate::file::Error),
 }
 
-// Bot files are simply the sequence of instructions that the physics received during the run.
-// The instructions are partitioned into timestamped blocks for ease of streaming.
-//
-// Keyframe information required for efficient seeking
-// is part of a different file, and is generated from this file.
-
 /* block types
 
 BLOCK_BOT_HEADER:
-// Segments are laid out in chronological order,
-// but block_id is not necessarily in ascending order.
-//
-// This is to place the final segment close to the start of the file,
-// which allows the duration of the bot to be conveniently calculated
-// from the first and last instruction timestamps.
-//
-// Use exact physics version for replay playback
-// Use highest compatible physics version for verification
-u32 physics_version
-u32 num_segments
+u128 map_resource_uuid //which map is this bot running
+//don't include style info in bot header because it's in the simulation state
+//blocks are laid out in chronological order, but indices may jump around.
+u64 num_segments
 for _ in 0..num_segments{
-	i64 time
-	u32 instruction_count
-	u32 block_id
+	i64 time //simulation_state timestamp
+	u64 block_id
 }
 
 BLOCK_BOT_SEGMENT:
-// segments can potentially be losslessly compressed!
-for _ in 0..instruction_count{
-	// TODO: delta encode as much as possible (time,mousepos)
-	i64 time
-	physics::Instruction instruction
+//format version indicates what version of these structures to use
+SimulationState simulation_state //SimulationState is just under ClientState which includes Play/Pause events that the simulation doesn't know about.
+//to read, greedily decode instructions until eof
+loop{
+	//delta encode as much as possible (time,mousepos)
+	//strafe ticks are implied
+	//physics can be implied in an input-only bot file
+	TimedInstruction<SimulationInstruction> instruction
 }
 
 */
 
-#[binrw]
-#[brw(little)]
-struct SegmentHeader{
-	time:i64,
-	instruction_count:u32,
-	block_id:BlockId,
-}
-#[binrw]
-#[brw(little)]
-struct Header{
-	physics_version:u32,
-	num_segments:u32,
-	#[br(count=num_segments)]
-	segments:Vec<SegmentHeader>,
+//error hiding mock code
+mod simulation{
+	#[super::binrw]
+	#[brw(little)]
+	pub struct State{}
+	#[super::binrw]
+	#[brw(little)]
+	pub struct Instruction{}
 }
+// mod instruction{
+	// #[super::binrw]
+	// #[brw(little)]
+	// pub struct TimedInstruction<Instruction:binrw::BinRead+binrw::BinWrite>{
+		// time:u64,
+		// instruction:Instruction
+	// }
+// }
+// mod timeline{
+	// #[super::binrw]
+	// #[brw(little)]
+	// pub struct Timeline<Instruction:binrw::BinRead+binrw::BinWrite>{
+		// #[bw(try_calc(u32::try_from(instructions.len())))]
+		// instruction_count:u32,
+		// #[br(count=instruction_count)]
+		// instructions:Vec<super::instruction::TimedInstruction<Instruction>>
+	// }
+// }
+
+//serious code
 
 #[binrw]
 #[brw(little)]
 #[derive(Clone,Copy,Debug,id::Id)]
 pub struct SegmentId(u32);
 
+#[binrw]
+#[brw(little)]
 pub struct Segment{
-	pub instructions:Vec<TimedPhysicsInstruction>
-}
+	state:simulation::State,
+	//#[bw(try_calc(u32::try_from(instructions.len())))]
+	//instruction_count:u32,
+	//#[br(count=instruction_count)]
+	//instructions:Vec<instruction::TimedInstruction<simulation::Instruction>>
 
-#[derive(Clone,Copy,Debug)]
-pub struct SegmentInfo{
-	/// time of the first instruction in this segment.
-	time:Time,
-	instruction_count:u32,
-	/// How many total instructions in segments up to and including this segment
-	/// Alternatively, the id of the first instruction be in the _next_ segment
-	instructions_subtotal:u64,
-	block_id:BlockId,
+	//please remember that strafe ticks are implicit! 33% smaller bot files
 }
 
 pub struct StreamableBot<R:BinReaderExt>{
 	file:crate::file::File<R>,
-	segment_map:Vec<SegmentInfo>,
+	//timeline:timeline::Timeline<SegmentId>,
+	segment_id_to_block_id:Vec<crate::file::BlockId>,
 }
 impl<R:BinReaderExt> StreamableBot<R>{
-	pub(crate) fn new(mut file:crate::file::File<R>)->Result<Self,Error>{
-		//assume the file seek is in the right place to start reading header
-		let header:Header=file.data_mut().read_le().map_err(Error::InvalidHeader)?;
-		let mut instructions_subtotal=0;
-		let segment_map=header.segments.into_iter().map(|SegmentHeader{time,instruction_count,block_id}|{
-			instructions_subtotal+=instruction_count as u64;
-			SegmentInfo{
-				time:Time::raw(time),
-				instruction_count,
-				instructions_subtotal,
-				block_id,
-			}
-		}).collect();
-		Ok(Self{
-			file,
-			segment_map,
-		})
+	pub(crate) fn new(file:crate::file::File<R>)->Result<Self,Error>{
+		Err(Error::InvalidHeader)
 	}
-	fn get_segment_info(&self,segment_id:SegmentId)->Result<SegmentInfo,Error>{
-		Ok(*self.segment_map.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?)
-	}
-	pub fn find_segments_instruction_range(&self,start_instruction:u64,end_instruction:u64)->&[SegmentInfo]{
-		let start=self.segment_map.partition_point(|segment_info|segment_info.instructions_subtotal<start_instruction);
-		let end=self.segment_map.partition_point(|segment_info|segment_info.instructions_subtotal<end_instruction);
-		&self.segment_map[start..=end]
-	}
-	// pub fn find_segments_time_range(&self,start_time:Time,end_time:Time)->&[SegmentInfo]{
-	// 	// TODO: This is off by one, both should be one less
-	// 	let start=self.segment_map.partition_point(|segment_info|segment_info.time<start_time);
-	// 	let end=self.segment_map.partition_point(|segment_info|segment_info.time<end_time);
-	// 	&self.segment_map[start..=end]
-	// }
-	fn append_to_segment(&mut self,segment_info:SegmentInfo,segment:&mut Segment)->Result<(),Error>{
-		let mut block=self.file.block_reader(segment_info.block_id).map_err(Error::File)?;
-		for _ in 0..segment_info.instruction_count{
-			let instruction:newtypes::physics::TimedInstruction=block.read_le().map_err(Error::InvalidSegment)?;
-			segment.instructions.push(instruction.try_into().map_err(Error::SegmentConvert)?);
-		}
-		Ok(())
-	}
-	pub fn load_segment(&mut self,segment_info:SegmentInfo)->Result<Segment,Error>{
-		let mut segment=Segment{
-			instructions:Vec::with_capacity(segment_info.instruction_count as usize),
-		};
-		self.append_to_segment(segment_info,&mut segment)?;
-		Ok(segment)
-	}
-	pub fn read_all(&mut self)->Result<Segment,Error>{
-		let mut segment=Segment{
-			instructions:Vec::new(),
-		};
-		for i in 0..self.segment_map.len(){
-			let segment_info=self.segment_map[i];
-			self.append_to_segment(segment_info,&mut segment)?;
-		}
+	pub fn load_segment(&mut self,segment_id:SegmentId)->Result<Segment,Error>{
+		let block_id=*self.segment_id_to_block_id.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?;
+		let mut block=self.file.block_reader(block_id).map_err(Error::File)?;
+		let segment=block.read_le().map_err(Error::InvalidSegment)?;
 		Ok(segment)
 	}
 }
-
-const MAX_BLOCK_SIZE:usize=64*1024;//64 kB
-pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:impl IntoIterator<Item=TimedPhysicsInstruction>)->Result<(),Error>{
-	// decide which instructions to put in which segment
-	// write segment 1 to block 1
-	// write segment N to block 2
-	// write rest of segments
-	// 1 2 3 4 5
-	// becomes
-	// [1 5] 2 3 4
-	struct SegmentHeaderInfo{
-		time:Time,
-		instruction_count:u32,
-		range:core::ops::Range<usize>
-	}
-
-	let mut segment_header_infos=Vec::new();
-	let mut raw_segments=std::io::Cursor::new(Vec::new());
-
-	// block info
-	let mut start_time=Time::ZERO;
-	let mut start_position=raw_segments.position() as usize;
-	let mut instruction_count=0;
-
-	let mut last_position=start_position;
-
-	let mut iter=instructions.into_iter();
-
-	macro_rules! collect_instruction{
-		($instruction:expr)=>{
-			let time=$instruction.time;
-			let instruction_writable:newtypes::physics::TimedInstruction=$instruction.try_into().map_err(Error::InstructionConvert)?;
-			instruction_writable.write_le(&mut raw_segments).map_err(Error::InstructionWrite)?;
-			instruction_count+=1;
-			let position=raw_segments.position() as usize;
-			// exceeds max block size
-			if MAX_BLOCK_SIZE<position-last_position{
-				segment_header_infos.push(SegmentHeaderInfo{
-					time:start_time,
-					instruction_count,
-					range:start_position..last_position,
-				});
-				start_position=last_position;
-				instruction_count=0;
-				start_time=time;
-			}
-			last_position=position;
-		}
-	}
-
-	// unroll one loop iteration to grab the starting time
-	if let Some(instruction)=iter.next(){
-		start_time=instruction.time;
-		collect_instruction!(instruction);
-	}
-
-	for instruction in iter{
-		collect_instruction!(instruction);
-	}
-	//last block, whatever size it happens to be
-	{
-		let final_position=raw_segments.position() as usize;
-		segment_header_infos.push(SegmentHeaderInfo{
-			time:start_time,
-			instruction_count,
-			range:start_position..final_position,
-		});
-	}
-	// drop cursor
-	let raw_segments=raw_segments.into_inner();
-
-	let num_segments=segment_header_infos.len();
-
-	// segments list is in chronological order
-	let make_segment_header=|block_id,&SegmentHeaderInfo{time,instruction_count,range:ref _range}|SegmentHeader{
-		time:time.get(),
-		instruction_count,
-		block_id,
-	};
-	let segments=if 2<num_segments{
-		let mut segments=Vec::with_capacity(num_segments);
-		// segment 1 is second block
-		if let Some(seg)=segment_header_infos.first(){
-			segments.push(make_segment_header(BlockId::new(1),seg));
-		}
-		// rest of segments start at fourth block
-		for (i,seg) in segment_header_infos[1..num_segments-1].iter().enumerate(){
-			make_segment_header(BlockId::new(3+i as u32),seg);
-		}
-		// last segment is third block
-		if let Some(seg)=segment_header_infos.last(){
-			segments.push(make_segment_header(BlockId::new(2),seg));
-		}
-		segments
-	}else{
-		// all segments in order
-		segment_header_infos.iter().enumerate().map(|(i,seg)|
-			make_segment_header(BlockId::new(1+i as u32),seg)
-		).collect()
-	};
-
-	let header=Header{
-		physics_version,
-		num_segments:num_segments as u32,
-		segments,
-	};
-
-	// map header is +1
-	let block_count=1+num_segments as u32;
-
-	let mut offset=crate::file::Header::calculate_size(block_count) as u64;
-	// block_location is one longer than block_count
-	let mut block_location=Vec::with_capacity(1+block_count as usize);
-
-	//probe header length
-	let mut bot_header_data=Vec::new();
-	binrw::BinWrite::write_le(&header,&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
-
-	// the first block location is the map header
-	block_location.push(offset);
-	offset+=bot_header_data.len() as u64;
-	block_location.push(offset);
-
-	// priming includes file header + first 3 blocks [bot header, first segment, last segment]
-	let priming=if 2<num_segments{
-		// segment 1 is block 2
-		if let Some(seg)=segment_header_infos.first(){
-			offset+=seg.range.len() as u64;
-			block_location.push(offset);
-		}
-		// last segment is block 3
-		if let Some(seg)=segment_header_infos.last(){
-			offset+=seg.range.len() as u64;
-			block_location.push(offset);
-		}
-
-		let priming=offset;
-
-		// rest of segments
-		for seg in &segment_header_infos[1..num_segments-1]{
-			offset+=seg.range.len() as u64;
-			block_location.push(offset);
-		}
-		priming
-	}else{
-		// all segments in order
-		for seg in &segment_header_infos{
-			offset+=seg.range.len() as u64;
-			block_location.push(offset);
-		}
-		offset
-	};
-
-	let file_header=crate::file::Header{
-		fourcc:crate::file::FourCC::Bot,
-		version:VERSION,
-		priming,
-		resource:0,
-		block_count,
-		block_location,
-	};
-
-	// write file header
-	writer.write_le(&file_header).map_err(Error::InvalidData)?;
-	// write bot header
-	writer.write(&bot_header_data).map_err(Error::IO)?;
-
-	// write blocks
-	if 2<num_segments{
-		// segment 1 is block 2
-		if let Some(seg)=segment_header_infos.first(){
-			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
-		}
-		// last segment is block 3
-		if let Some(seg)=segment_header_infos.last(){
-			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
-		}
-		// rest of segments
-		for seg in &segment_header_infos[1..num_segments-1]{
-			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
-		}
-	}else{
-		// all segments in order
-		for seg in segment_header_infos{
-			writer.write(&raw_segments[seg.range]).map_err(Error::IO)?;
-		}
-	}
-	Ok(())
-}

lib/snf/src/demo.rs

@@ -7,29 +7,21 @@ pub enum Error{
 
 /*
 BLOCK_DEMO_HEADER:
-u32 num_maps
-for map_id in 0..num_maps{
-	i64 simulation_time
-	u128 map_resource_id
-	u64 map_header_block_id
-}
+u128 map_resource_id
+u64 map_header_block_id
 u32 num_bots
 for bot_id in 0..num_bots{
-	i64 simulation_time
 	u128 bot_resource_id
 	u64 bot_header_block_id
 }
 
-//map loading timeline
-
 //bot loading timeline
 how to do worldstate for deathrun!?
-- this is done in the client, there is no worldstate in the demo file
 
 */
 
 pub struct StreamableDemo<R:BinReaderExt>{
-	map:Vec<crate::map::StreamableMap<R>>,
+	map:Box<crate::map::StreamableMap<R>>,
 	bots:Vec<crate::bot::StreamableBot<R>>,
 }
 impl<R:BinReaderExt> StreamableDemo<R>{

lib/snf/src/file.rs

@@ -73,16 +73,6 @@ pub struct Header{
 	#[br(count=block_count+1)]
 	pub block_location:Vec<u64>,
 }
-impl Header{
-	pub const fn calculate_size(block_count:u32)->usize{
-		4 // fourcc
-		+4 // version
-		+8 // priming
-		+16 // resource
-		+4 // block_count
-		+(block_count as usize+1)*8 // block_location
-	}
-}
 
 #[binrw]
 #[brw(little)]

lib/snf/src/map.rs

@@ -86,7 +86,6 @@ for model_id in 0..num_models{
 //if you hash the resource itself and set the first 8 bits to this, that's the resource uuid
 #[binrw]
 #[brw(little,repr=u8)]
-#[repr(u8)]
 enum ResourceType{
 	Mesh,
 	Texture,
@@ -95,6 +94,21 @@ enum ResourceType{
 	//Video,
 	//Animation,
 }
+const RESOURCE_TYPE_VARIANT_COUNT:u8=2;
+#[binrw]
+#[brw(little)]
+struct ResourceId(u128);
+impl ResourceId{
+	fn resource_type(&self)->Option<ResourceType>{
+		let discriminant=self.0 as u8;
+		//TODO: use this when it is stabilized https://github.com/rust-lang/rust/issues/73662
+		//if (discriminant as usize)<std::mem::variant_count::<ResourceType>(){
+		match discriminant<RESOURCE_TYPE_VARIANT_COUNT{
+			true=>Some(unsafe{std::mem::transmute::<u8,ResourceType>(discriminant)}),
+			false=>None,
+		}
+	}
+}
 
 struct ResourceMap<T>{
 	meshes:HashMap<strafesnet_common::model::MeshId,T>,
@@ -121,6 +135,11 @@ struct ResourceBlockHeader{
 	resource:ResourceType,
 	id:BlockId,
 }
+#[binrw]
+#[brw(little)]
+struct ResourceExternalHeader{
+	resource_uuid:ResourceId,
+}
 
 #[binrw]
 #[brw(little)]
@@ -392,26 +411,28 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		attributes:map.attributes.into_iter().map(Into::into).collect(),
 		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
 	};
-	//probe header length
-	let mut map_header_data=Vec::new();
-	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;
-
-	// calculate final file header
-	let mut offset=crate::file::Header::calculate_size(block_count) as u64;
-	offset+=map_header_data.len() as u64;
-	// priming includes map header
-	let priming=offset;
-	for position in &mut block_location{
-		*position+=offset;
-	}
-	let file_header=crate::file::Header{
+	let mut file_header=crate::file::Header{
 		fourcc:crate::file::FourCC::Map,
 		version:0,
-		priming,
+		priming:0,
 		resource:0,
 		block_count,
 		block_location,
 	};
+	//probe header length
+	let mut file_header_data=Vec::new();
+	binrw::BinWrite::write_le(&file_header,&mut std::io::Cursor::new(&mut file_header_data)).map_err(Error::InvalidData)?;
+	let mut map_header_data=Vec::new();
+	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;
+
+	//update file header according to probe data
+	let mut offset=file_header_data.len() as u64;
+	file_header.priming=offset;
+	file_header.block_location[0]=offset;
+	offset+=map_header_data.len() as u64;
+	for position in &mut file_header.block_location[1..]{
+		*position+=offset;
+	}
 
 	//write (updated) file header
 	writer.write_le(&file_header).map_err(Error::InvalidData)?;

lib/snf/src/newtypes.rs

@@ -1,9 +1,7 @@
 mod common;
 pub mod aabb;
 pub mod model;
-pub mod mouse;
 pub mod integer;
-pub mod physics;
 pub mod gameplay_modes;
 pub mod gameplay_style;
 pub mod gameplay_attributes;

lib/snf/src/newtypes/common.rs

@@ -1,9 +1,3 @@
 pub const fn flag(b:bool,mask:u8)->u8{
 	(-(b as i8) as u8)&mask
 }
-pub fn bool_from_u8(value:u8)->bool{
-	value!=0
-}
-pub fn bool_into_u8(value:&bool)->u8{
-	*value as u8
-}

lib/snf/src/newtypes/integer.rs

@@ -38,23 +38,6 @@ pub struct Ratio64Vec2{
 	pub x:Ratio64,
 	pub y:Ratio64,
 }
-impl TryInto<strafesnet_common::integer::Ratio64Vec2> for Ratio64Vec2{
-	type Error=RatioError;
-	fn try_into(self)->Result<strafesnet_common::integer::Ratio64Vec2,Self::Error>{
-		Ok(strafesnet_common::integer::Ratio64Vec2{
-			x:self.x.try_into()?,
-			y:self.y.try_into()?,
-		})
-	}
-}
-impl From<strafesnet_common::integer::Ratio64Vec2> for Ratio64Vec2{
-	fn from(value:strafesnet_common::integer::Ratio64Vec2)->Self{
-		Self{
-			x:value.x.into(),
-			y:value.y.into(),
-		}
-	}
-}
 
 pub type Angle32=i32;
 pub type Planar64=i64;

lib/snf/src/newtypes/mouse.rs

@@ -1,25 +0,0 @@
-use super::integer::Time;
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct MouseState{
-	pub pos:[i32;2],
-	pub time:Time,
-}
-
-impl<T> Into<strafesnet_common::mouse::MouseState<T>> for MouseState{
-	fn into(self)->strafesnet_common::mouse::MouseState<T>{
-		strafesnet_common::mouse::MouseState{
-			pos:self.pos.into(),
-			time:strafesnet_common::integer::Time::raw(self.time),
-		}
-	}
-}
-impl<T> From<strafesnet_common::mouse::MouseState<T>> for MouseState{
-	fn from(value:strafesnet_common::mouse::MouseState<T>)->Self{
-		Self{
-			pos:value.pos.to_array(),
-			time:value.time.get(),
-		}
-	}
-}

lib/snf/src/newtypes/physics.rs

@@ -1,156 +0,0 @@
-use super::integer::Time;
-use super::common::{bool_from_u8,bool_into_u8};
-
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::TimeInner>;
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct TimedInstruction{
-	pub time:Time,
-	pub instruction:Instruction,
-}
-
-impl TryInto<TimedPhysicsInstruction> for TimedInstruction{
-	type Error=super::integer::RatioError;
-	fn try_into(self)->Result<TimedPhysicsInstruction,Self::Error>{
-		Ok(strafesnet_common::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::raw(self.time),
-			instruction:self.instruction.try_into()?,
-		})
-	}
-}
-impl TryFrom<TimedPhysicsInstruction> for TimedInstruction{
-	type Error=super::physics::InstructionConvert;
-	fn try_from(value:TimedPhysicsInstruction)->Result<Self,Self::Error>{
-		Ok(Self{
-			time:value.time.get(),
-			instruction:value.instruction.try_into()?,
-		})
-	}
-}
-#[binrw::binrw]
-#[brw(little)]
-pub enum Instruction{
-	#[brw(magic=0u8)]
-	ReplaceMouse{
-		m0:super::mouse::MouseState,
-		m1:super::mouse::MouseState
-	},
-	#[brw(magic=1u8)]
-	SetNextMouse(super::mouse::MouseState),
-	#[brw(magic=2u8)]
-	SetMoveRight(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=3u8)]
-	SetMoveUp(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=4u8)]
-	SetMoveBack(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=5u8)]
-	SetMoveLeft(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=6u8)]
-	SetMoveDown(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=7u8)]
-	SetMoveForward(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=8u8)]
-	SetJump(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=9u8)]
-	SetZoom(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
-	#[brw(magic=10u8)]
-	Reset,
-	#[brw(magic=11u8)]
-	Restart(super::gameplay_modes::ModeId),
-	#[brw(magic=12u8)]
-	Spawn(super::gameplay_modes::ModeId,super::gameplay_modes::StageId),
-	#[brw(magic=13u8)]
-	PracticeFly,
-	#[brw(magic=14u8)]
-	SetSensitivity(super::integer::Ratio64Vec2),
-	#[brw(magic=255u8)]
-	Idle,
-}
-#[derive(Debug)]
-pub enum InstructionConvert{
-	/// This is an instruction that can be dropped when serializing
-	DropInstruction,
-}
-impl std::fmt::Display for InstructionConvert{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for InstructionConvert{}
-impl TryInto<strafesnet_common::physics::Instruction> for Instruction{
-	type Error=super::integer::RatioError;
-	fn try_into(self)->Result<strafesnet_common::physics::Instruction,Self::Error>{
-		Ok(match self{
-			Instruction::ReplaceMouse{m0,m1}=>strafesnet_common::physics::Instruction::Mouse(strafesnet_common::physics::MouseInstruction::ReplaceMouse{m0:m0.into(),m1:m1.into()}),
-			Instruction::SetNextMouse(m)=>strafesnet_common::physics::Instruction::Mouse(strafesnet_common::physics::MouseInstruction::SetNextMouse(m.into())),
-			Instruction::SetMoveRight(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveRight(state.into())),
-			Instruction::SetMoveUp(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveUp(state.into())),
-			Instruction::SetMoveBack(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveBack(state.into())),
-			Instruction::SetMoveLeft(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveLeft(state.into())),
-			Instruction::SetMoveDown(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveDown(state.into())),
-			Instruction::SetMoveForward(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state.into())),
-			Instruction::SetJump(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state.into())),
-			Instruction::SetZoom(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state.into())),
-			Instruction::Reset=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset),
-			Instruction::Restart(mode_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(strafesnet_common::gameplay_modes::ModeId::new(mode_id))),
-			Instruction::Spawn(mode_id,stage_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(
-				strafesnet_common::gameplay_modes::ModeId::new(mode_id),
-				strafesnet_common::gameplay_modes::StageId::new(stage_id),
-			)),
-			Instruction::PracticeFly=>strafesnet_common::physics::Instruction::Misc(strafesnet_common::physics::MiscInstruction::PracticeFly),
-			Instruction::SetSensitivity(sensitivity)=>strafesnet_common::physics::Instruction::Misc(strafesnet_common::physics::MiscInstruction::SetSensitivity(sensitivity.try_into()?)),
-			Instruction::Idle=>strafesnet_common::physics::Instruction::Idle,
-		})
-	}
-}
-impl TryFrom<strafesnet_common::physics::Instruction> for Instruction{
-	type Error=InstructionConvert;
-	fn try_from(value:strafesnet_common::physics::Instruction)->Result<Self,Self::Error>{
-		match value{
-			strafesnet_common::physics::Instruction::Mouse(strafesnet_common::physics::MouseInstruction::ReplaceMouse{m0,m1})=>Ok(Instruction::ReplaceMouse{m0:m0.into(),m1:m1.into()}),
-			strafesnet_common::physics::Instruction::Mouse(strafesnet_common::physics::MouseInstruction::SetNextMouse(m))=>Ok(Instruction::SetNextMouse(m.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveRight(state))=>Ok(Instruction::SetMoveRight(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveUp(state))=>Ok(Instruction::SetMoveUp(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveBack(state))=>Ok(Instruction::SetMoveBack(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveLeft(state))=>Ok(Instruction::SetMoveLeft(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveDown(state))=>Ok(Instruction::SetMoveDown(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state))=>Ok(Instruction::SetMoveForward(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state))=>Ok(Instruction::SetJump(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state))=>Ok(Instruction::SetZoom(state.into())),
-			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset)=>Ok(Instruction::Reset),
-			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(mode_id))=>Ok(Instruction::Restart(mode_id.get())),
-			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(mode_id,stage_id))=>Ok(Instruction::Spawn(
-				mode_id.get(),
-				stage_id.get(),
-			)),
-			strafesnet_common::physics::Instruction::Misc(strafesnet_common::physics::MiscInstruction::PracticeFly)=>Ok(Instruction::PracticeFly),
-			strafesnet_common::physics::Instruction::Misc(strafesnet_common::physics::MiscInstruction::SetSensitivity(sensitivity))=>Ok(Instruction::SetSensitivity(sensitivity.into())),
-			strafesnet_common::physics::Instruction::Idle=>Ok(Instruction::Idle),
-		}
-	}
-}

lib/snf/src/session.rs

@@ -1,2 +0,0 @@
-// a session is a recording of the client's inputs
-// which should deterministically recreate a bot or whatever the client did

strafe-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.11.0"
+version = "0.10.5"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "Custom"
@@ -9,24 +9,27 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [features]
-user-install=[] # as opposed to portable install
 default = ["snf"]
 snf = ["dep:strafesnet_snf"]
 source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
+bytemuck = { version = "1.13.1", features = ["derive"] }
+chrono = "0.4.39"
+configparser = "3.0.2"
+ddsfile = "0.5.1"
 glam = "0.29.0"
+id = { version = "0.1.0", registry = "strafesnet" }
 parking_lot = "0.12.1"
 pollster = "0.4.0"
 strafesnet_bsp_loader = { path = "../lib/bsp_loader", registry = "strafesnet", optional = true }
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
 strafesnet_deferred_loader = { path = "../lib/deferred_loader", features = ["legacy"], registry = "strafesnet", optional = true }
-strafesnet_graphics = { path = "../engine/graphics", registry = "strafesnet" }
-strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", optional = true }
-strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
-strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "24.0.0"
+wasm-bindgen = "0.2.99"
+wasm-bindgen-futures = "0.4.49"
+web-sys = { version = "0.3.76", features = ["console"] }
+wgpu = "23.0.1"
 winit = "0.30.7"

strafe-client/src/app.rs

@@ -1,68 +0,0 @@
-use crate::window::Instruction;
-use strafesnet_common::integer;
-use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::session::TimeInner as SessionTimeInner;
-
-pub struct App<'a>{
-	root_time:std::time::Instant,
-	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
-}
-impl<'a> App<'a>{
-	pub fn new(
-		root_time:std::time::Instant,
-		window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
-	)->App<'a>{
-		Self{
-			root_time,
-			window_thread,
-		}
-	}
-	fn send_timed_instruction(&mut self,instruction:Instruction){
-		let time=integer::Time::from_nanos(self.root_time.elapsed().as_nanos() as i64);
-		self.window_thread.send(TimedInstruction{time,instruction}).unwrap();
-	}
-}
-impl winit::application::ApplicationHandler for App<'_>{
-	fn resumed(&mut self,_event_loop:&winit::event_loop::ActiveEventLoop){
-		//
-	}
-
-	fn window_event(
-		&mut self,
-		event_loop:&winit::event_loop::ActiveEventLoop,
-		_window_id:winit::window::WindowId,
-		event:winit::event::WindowEvent,
-	){
-		match event{
-			winit::event::WindowEvent::KeyboardInput{
-				event:winit::event::KeyEvent{
-					logical_key:winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
-					state:winit::event::ElementState::Pressed,
-					..
-				},
-				..
-			}
-			|winit::event::WindowEvent::CloseRequested=>{
-				event_loop.exit();
-			},
-			_=>(),
-		}
-		self.send_timed_instruction(Instruction::WindowEvent(event));
-	}
-
-	fn device_event(
-		&mut self,
-		_event_loop:&winit::event_loop::ActiveEventLoop,
-		_device_id:winit::event::DeviceId,
-		event:winit::event::DeviceEvent,
-	){
-		self.send_timed_instruction(Instruction::DeviceEvent(event));
-	}
-
-	fn about_to_wait(
-		&mut self,
-		_event_loop:&winit::event_loop::ActiveEventLoop
-	){
-		self.send_timed_instruction(Instruction::WindowEvent(winit::event::WindowEvent::RedrawRequested));
-	}
-}

strafe-client/src/compat_worker.rs

@@ -3,11 +3,11 @@ pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
 
 pub struct CompatNWorker<'a,Task>{
 	data:std::marker::PhantomData<Task>,
-	f:Box<dyn FnMut(Task)+Send+'a>,
+	f:Box<dyn FnMut(Task)+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
 		Self{
 			data:std::marker::PhantomData,
 			f:Box::new(f),

strafe-client/src/face_crawler.rs

@@ -1,48 +1,23 @@
-use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
-use crate::physics::{Time,Body};
+use crate::physics::Body;
+use crate::model_physics::{GigaTime,FEV,MeshQuery,DirectedEdge,MinkowskiMesh,MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert};
+use strafesnet_common::integer::{Time,Fixed,Ratio};
 
-enum Transition<M:MeshQuery>{
+#[derive(Debug)]
+enum Transition<F,E:DirectedEdge,V>{
 	Miss,
-	Next(FEV<M>,GigaTime),
-	Hit(M::Face,GigaTime),
+	Next(FEV<F,E,V>,GigaTime),
+	Hit(F,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshQuery>{
-	Miss(FEV<M>),
-	Hit(M::Face,GigaTime),
-}
-impl<M:MeshQuery> CrawlResult<M>{
-	pub fn hit(self)->Option<(M::Face,GigaTime)>{
-		match self{
-			CrawlResult::Miss(_)=>None,
-			CrawlResult::Hit(face,time)=>Some((face,time)),
-		}
-	}
-	pub fn miss(self)->Option<FEV<M>>{
-		match self{
-			CrawlResult::Miss(fev)=>Some(fev),
-			CrawlResult::Hit(_,_)=>None,
-		}
-	}
-}
+type MinkowskiFEV=FEV<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
 
-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,
-		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
-		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
-		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
-{
-	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+	fn next_transition(fev:&MinkowskiFEV,body_time:GigaTime,mesh:&MinkowskiMesh,body:&Body,mut best_time:GigaTime)->MinkowskiTransition{
 		//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;
-		match self{
-			&FEV::Face(face_id)=>{
+		let mut best_transition=MinkowskiTransition::Miss;
+		match fev{
+			&MinkowskiFEV::Face(face_id)=>{
 				//test own face collision time, ignoring roots with zero or conflicting derivative
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
@@ -52,7 +27,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 					if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 						best_time=dt;
-						best_transition=Transition::Hit(face_id,dt);
+						best_transition=MinkowskiTransition::Hit(face_id,dt);
 						break;
 					}
 				}
@@ -66,14 +41,14 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
-							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&FEV::Edge(edge_id)=>{
+			&MinkowskiFEV::Edge(edge_id)=>{
 				//test each face collision time, ignoring roots with zero or conflicting derivative
 				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
@@ -86,7 +61,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
-							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Face(edge_face_id),dt);
 							break;
 						}
 					}
@@ -99,14 +74,14 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
 							best_time=dt;
-							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Vert(vert_id),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&FEV::Vert(vert_id)=>{
+			&MinkowskiFEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
 				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
 					//edge is directed away from vertex, but we want the dot product to turn out negative
@@ -115,7 +90,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
 							best_time=dt;
-							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
@@ -125,24 +100,28 @@ 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,start_time:Time,time_limit:Time)->CrawlResult<M>{
-		let mut body_time={
-			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
-		};
-		let time_limit={
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
-		};
-		for _ in 0..20{
-			match self.next_transition(body_time,mesh,relative_body,time_limit){
-				Transition::Miss=>return CrawlResult::Miss(self),
-				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
-				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
-			}
-		}
-		//TODO: fix all bugs
-		//println!("Too many iterations!  Using default behaviour instead of crashing...");
-		CrawlResult::Miss(self)
-	}
+pub enum CrawlResult<F,E:DirectedEdge,V>{
+	Miss(FEV<F,E,V>),
+	Hit(F,GigaTime),
+}
+type MinkowskiCrawlResult=CrawlResult<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+pub fn crawl_fev(mut fev:MinkowskiFEV,mesh:&MinkowskiMesh,relative_body:&Body,start_time:Time,time_limit:Time)->MinkowskiCrawlResult{
+	let mut body_time={
+		let r=(start_time-relative_body.time).to_ratio();
+		Ratio::new(r.num.fix_4(),r.den.fix_4())
+	};
+	let time_limit={
+		let r=(time_limit-relative_body.time).to_ratio();
+		Ratio::new(r.num.fix_4(),r.den.fix_4())
+	};
+	for _ in 0..20{
+		match next_transition(&fev,body_time,mesh,relative_body,time_limit){
+			Transition::Miss=>return CrawlResult::Miss(fev),
+			Transition::Next(next_fev,next_time)=>(fev,body_time)=(next_fev,next_time),
+			Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
+		}
+	}
+	//TODO: fix all bugs
+	//println!("Too many iterations!  Using default behaviour instead of crashing...");
+	CrawlResult::Miss(fev)
 }

strafe-client/src/file.rs

@@ -1,6 +1,5 @@
 use std::io::Read;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum ReadError{
 	#[cfg(feature="roblox")]
@@ -11,8 +10,6 @@ pub enum ReadError{
 	StrafesNET(strafesnet_snf::Error),
 	#[cfg(feature="snf")]
 	StrafesNETMap(strafesnet_snf::map::Error),
-	#[cfg(feature="snf")]
-	StrafesNETBot(strafesnet_snf::bot::Error),
 	Io(std::io::Error),
 	UnknownFileFormat,
 }
@@ -23,44 +20,32 @@ impl std::fmt::Display for ReadError{
 }
 impl std::error::Error for ReadError{}
 
-pub enum ReadFormat{
+pub enum DataStructure{
 	#[cfg(feature="roblox")]
 	Roblox(strafesnet_rbx_loader::Model),
 	#[cfg(feature="source")]
 	Source(strafesnet_bsp_loader::Bsp),
 	#[cfg(feature="snf")]
-	SNFM(strafesnet_common::map::CompleteMap),
-	#[cfg(feature="snf")]
-	SNFB(strafesnet_snf::bot::Segment),
+	StrafesNET(strafesnet_common::map::CompleteMap),
 }
 
-pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
+pub fn read<R:Read+std::io::Seek>(input:R)->Result<DataStructure,ReadError>{
 	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?[0..4].to_owned();
-	// reading the entire file is way faster than round tripping the disk constantly
-	let mut entire_file=Vec::new();
-	buf.read_to_end(&mut entire_file).map_err(ReadError::Io)?;
-	let cursor=std::io::Cursor::new(entire_file);
-	match peek.as_slice(){
+	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
+	match &peek[0..4]{
 		#[cfg(feature="roblox")]
-		b"<rob"=>Ok(ReadFormat::Roblox(strafesnet_rbx_loader::read(cursor).map_err(ReadError::Roblox)?)),
+		b"<rob"=>Ok(DataStructure::Roblox(strafesnet_rbx_loader::read(buf).map_err(ReadError::Roblox)?)),
 		#[cfg(feature="source")]
-		b"VBSP"=>Ok(ReadFormat::Source(strafesnet_bsp_loader::read(cursor).map_err(ReadError::Source)?)),
+		b"VBSP"=>Ok(DataStructure::Source(strafesnet_bsp_loader::read(buf).map_err(ReadError::Source)?)),
 		#[cfg(feature="snf")]
-		b"SNFM"=>Ok(ReadFormat::SNFM(
-			strafesnet_snf::read_map(cursor).map_err(ReadError::StrafesNET)?
+		b"SNFM"=>Ok(DataStructure::StrafesNET(
+			strafesnet_snf::read_map(buf).map_err(ReadError::StrafesNET)?
 			.into_complete_map().map_err(ReadError::StrafesNETMap)?
 		)),
-		#[cfg(feature="snf")]
-		b"SNFB"=>Ok(ReadFormat::SNFB(
-			strafesnet_snf::read_bot(cursor).map_err(ReadError::StrafesNET)?
-			.read_all().map_err(ReadError::StrafesNETBot)?
-		)),
 		_=>Err(ReadError::UnknownFileFormat),
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum LoadError{
 	ReadError(ReadError),
@@ -74,23 +59,17 @@ impl std::fmt::Display for LoadError{
 }
 impl std::error::Error for LoadError{}
 
-pub enum LoadFormat{
-	#[cfg(feature="snf")]
-	Map(strafesnet_common::map::CompleteMap),
-	#[cfg(feature="snf")]
-	Bot(strafesnet_snf::bot::Segment),
-}
-
-pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
+pub fn load_file<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::CompleteMap,LoadError>{
 	//blocking because it's simpler...
 	let file=std::fs::File::open(path).map_err(LoadError::File)?;
-	match read(file).map_err(LoadError::ReadError)?{
+	load(file)
+}
+pub fn load<R:Read+std::io::Seek>(reader:R)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	match read(reader).map_err(LoadError::ReadError)?{
 		#[cfg(feature="snf")]
-		ReadFormat::SNFB(bot)=>Ok(LoadFormat::Bot(bot)),
-		#[cfg(feature="snf")]
-		ReadFormat::SNFM(map)=>Ok(LoadFormat::Map(map)),
+		DataStructure::StrafesNET(map)=>Ok(map),
 		#[cfg(feature="roblox")]
-		ReadFormat::Roblox(model)=>{
+		DataStructure::Roblox(model)=>{
 			let mut place=model.into_place();
 			place.run_scripts();
 
@@ -123,10 +102,10 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 				)
 			);
 
-			Ok(LoadFormat::Map(map))
+			Ok(map)
 		},
 		#[cfg(feature="source")]
-		ReadFormat::Source(bsp)=>{
+		DataStructure::Source(bsp)=>{
 			let mut loader=strafesnet_deferred_loader::source_legacy();
 
 			let (texture_loader,mesh_loader)=loader.get_inner_mut();
@@ -162,7 +141,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 				),
 			);
 
-			Ok(LoadFormat::Map(map))
+			Ok(map)
 		},
 	}
 }

strafe-client/src/graphics.rs

@@ -1,15 +1,10 @@
 use std::borrow::Cow;
 use std::collections::{HashSet,HashMap};
 use strafesnet_common::map;
-use strafesnet_settings::settings;
-use strafesnet_session::session;
+use strafesnet_common::integer;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
-
-pub fn required_limits()->wgpu::Limits{
-	wgpu::Limits::default()
-}
+use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
 
 struct Indices{
 	count:u32,
@@ -103,6 +98,12 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
+pub struct FrameState{
+	pub body:crate::physics::Body,
+	pub camera:crate::physics::PhysicsCamera,
+	pub time:integer::Time,
+}
+
 pub struct GraphicsState{
 	pipelines:GraphicsPipelines,
 	bind_groups:GraphicsBindGroups,
@@ -142,7 +143,7 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
-	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
+	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
@@ -454,7 +455,7 @@ impl GraphicsState{
 		//.into_iter() the modeldata vec so entities can be /moved/ to models.entities
 		let mut model_count=0;
 		let mut instance_count=0;
-		let uniform_buffer_binding_size=required_limits().max_uniform_buffer_binding_size as usize;
+		let uniform_buffer_binding_size=crate::setup::required_limits().max_uniform_buffer_binding_size as usize;
 		let chunk_size=uniform_buffer_binding_size/MODEL_BUFFER_SIZE_BYTES;
 		self.models.reserve(models.len());
 		for model in models.into_iter(){
@@ -614,7 +615,7 @@ impl GraphicsState{
 		// Create the render pipeline
 		let shader=device.create_shader_module(wgpu::ShaderModuleDescriptor{
 			label:None,
-			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../../../strafe-client/src/shader.wgsl"))),
+			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
 		});
 
 		//load textures
@@ -642,10 +643,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../../../strafe-client/images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../../../strafe-client/images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../../../strafe-client/images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../../../strafe-client/images/bgra.dds")[..],
+				}=>&include_bytes!("../images/astc.dds")[..],
+				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
+				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
+				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
 				_=>unreachable!(),
 			};
 
@@ -688,7 +689,7 @@ impl GraphicsState{
 
 		//squid
 		let squid_texture_view={
-			let bytes=include_bytes!("../../../strafe-client/images/squid.dds");
+			let bytes=include_bytes!("../images/squid.dds");
 
 			let image=ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
@@ -870,7 +871,7 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		user_settings:&settings::UserSettings,
+		user_settings:&crate::settings::UserSettings,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
@@ -881,7 +882,7 @@ impl GraphicsState{
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		frame_state:session::FrameState,
+		frame_state:FrameState,
 	){
 		//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 

strafe-client/src/graphics_worker.rs

@@ -1,11 +1,7 @@
-use strafesnet_graphics::graphics;
-use strafesnet_session::session;
-use strafesnet_settings::settings;
-
 pub enum Instruction{
-	Render(session::FrameState),
-	//UpdateModel(graphics::GraphicsModelUpdate),
-	Resize(winit::dpi::PhysicalSize<u32>,settings::UserSettings),
+	Render(crate::graphics::FrameState),
+	//UpdateModel(crate::graphics::GraphicsModelUpdate),
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
 	ChangeMap(strafesnet_common::map::CompleteMap),
 }
 
@@ -18,13 +14,17 @@ WorkerDescription{
 */
 //up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
 
-pub fn new(
-	mut graphics:graphics::GraphicsState,
+fn print(message:&str){
+	web_sys::console::log_1(&message.into());
+}
+pub fn new<'a>(
+	mut graphics:crate::graphics::GraphicsState,
 	mut config:wgpu::SurfaceConfiguration,
-	surface:wgpu::Surface,
+	surface:wgpu::Surface<'a>,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
-)->crate::compat_worker::INWorker<'_,Instruction>{
+)->crate::compat_worker::INWorker<'a,Instruction>{
+	let mut resize=None;
 	crate::compat_worker::INWorker::new(move |ins:Instruction|{
 		match ins{
 			Instruction::ChangeMap(map)=>{
@@ -32,15 +32,26 @@ pub fn new(
 				graphics.generate_models(&device,&queue,&map);
 			},
 			Instruction::Resize(size,user_settings)=>{
-				println!("Resizing to {:?}",size);
-				let t0=std::time::Instant::now();
-				config.width=size.width.max(1);
-				config.height=size.height.max(1);
-				surface.configure(&device,&config);
-				graphics.resize(&device,&config,&user_settings);
-				println!("Resize took {:?}",t0.elapsed());
+				resize=Some((size,user_settings));
 			}
 			Instruction::Render(frame_state)=>{
+				if let Some((size,user_settings))=resize.take(){
+					print(format!("Resizing to {:?}",size).as_str());
+					//let t0=std::time::Instant::now();
+					match size{
+						winit::dpi::PhysicalSize{width:2560,height:1440}=>{
+							config.width=size.width.clamp(1,2560);
+							config.height=size.height.clamp(1,1440);
+						},
+						_=>{
+							config.width=size.width.clamp(1,1280);
+							config.height=size.height.clamp(1,720);
+						}
+					}
+					surface.configure(&device,&config);
+					graphics.resize(&device,&config,&user_settings);
+					//println!("Resize took {:?}",t0.elapsed());
+				}
 				//this has to go deeper somehow
 				let frame=match surface.get_current_texture(){
 					Ok(frame)=>frame,

strafe-client/src/main.rs

@@ -1,14 +1,21 @@
-mod app;
 mod file;
 mod setup;
 mod window;
 mod worker;
+mod physics;
+mod graphics;
+mod settings;
+mod face_crawler;
 mod compat_worker;
+mod model_physics;
+mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
 
-const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
-
 fn main(){
-	setup::setup_and_start(TITLE);
+	let title=format!("Strafe Client v{}",env!("CARGO_PKG_VERSION"));
+	#[cfg(target_arch="wasm32")]
+	wasm_bindgen_futures::spawn_local(setup::setup_and_start(title));
+	#[cfg(not(target_arch="wasm32"))]
+	pollster::block_on(setup::setup_and_start(title));
 }

strafe-client/src/model_physics.rs

@@ -1,12 +1,8 @@
 use std::borrow::{Borrow,Cow};
 use std::collections::{HashSet,HashMap};
-use core::ops::Range;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
-use strafesnet_common::physics::Time;
-
-type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
 
 pub trait UndirectedEdge{
 	type DirectedEdge:Copy+DirectedEdge;
@@ -55,10 +51,10 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 
 //Vertex <-> Edge <-> Face -> Collide
 #[derive(Debug)]
-pub enum FEV<M:MeshQuery>{
-	Face(M::Face),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
-	Vert(M::Vert),
+pub enum FEV<F,E:DirectedEdge,V>{
+	Face(F),
+	Edge(E::UndirectedEdge),
+	Vert(V),
 }
 
 //use Unit32 #[repr(C)] for map files
@@ -68,28 +64,25 @@ struct Face{
 	dot:Planar64,
 }
 struct Vert(Planar64Vec3);
-pub trait MeshQuery{
-	type Face:Clone;
-	type Edge:Clone+DirectedEdge;
-	type Vert:Clone;
+pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
 	// Vertex must be Planar64Vec3 because it represents an actual position
 	type Normal;
 	type Offset;
-	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
+	fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
 		let verts=self.edge_verts(edge_id);
 		self.vert(verts[1].clone())-self.vert(verts[0].clone())
 	}
-	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
+	fn directed_edge_n(&self,directed_edge_id:EDGE)->Planar64Vec3{
 		let verts=self.edge_verts(directed_edge_id.as_undirected());
 		(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
 	}
-	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
-	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
-	fn face_edges(&self,face_id:Self::Face)->Cow<[Self::Edge]>;
-	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Cow<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Cow<[Self::Vert;2]>;
-	fn vert_edges(&self,vert_id:Self::Vert)->Cow<[Self::Edge]>;
-	fn vert_faces(&self,vert_id:Self::Vert)->Cow<[Self::Face]>;
+	fn vert(&self,vert_id:VERT)->Planar64Vec3;
+	fn face_nd(&self,face_id:FACE)->(Self::Normal,Self::Offset);
+	fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
+	fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
+	fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
+	fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
+	fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
 }
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
@@ -280,12 +273,15 @@ struct EdgePool{
 }
 impl EdgePool{
 	fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,SubmeshEdgeId){
-		let edge_id=*self.edge_id_from_guy.entry(edge_ref_verts.clone()).or_insert_with(||{
-			let edge_id=SubmeshEdgeId::new(self.edge_guys.len() as u32);
-			self.edge_guys.push((edge_ref_verts,EdgeRefFaces::new()));
+		let edge_id=if let Some(&edge_id)=self.edge_id_from_guy.get(&edge_ref_verts){
 			edge_id
-		});
-		(&mut self.edge_guys[edge_id.get() as usize].1,edge_id)
+		}else{
+			let edge_id=SubmeshEdgeId::new(self.edge_guys.len() as u32);
+			self.edge_guys.push((edge_ref_verts.clone(),EdgeRefFaces::new()));
+			self.edge_id_from_guy.insert(edge_ref_verts,edge_id);
+			edge_id
+		};
+		(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id.get() as usize)}.1,edge_id)
 	}
 }
 
@@ -320,11 +316,16 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			let mut submesh_verts=Vec::new();
 			let mut submesh_vert_id_from_mesh_vert_id=HashMap::<MeshVertId,SubmeshVertId>::new();
 			//lazy closure
-			let mut get_submesh_vert_id=|vert_id:MeshVertId|*submesh_vert_id_from_mesh_vert_id.entry(vert_id).or_insert_with(||{
-				let submesh_vert_id=SubmeshVertId::new(submesh_verts.len() as u32);
-				submesh_verts.push(vert_id);
-				submesh_vert_id
-			});
+			let mut get_submesh_vert_id=|vert_id:MeshVertId|{
+				if let Some(&submesh_vert_id)=submesh_vert_id_from_mesh_vert_id.get(&vert_id){
+					submesh_vert_id
+				}else{
+					let submesh_vert_id=SubmeshVertId::new(submesh_verts.len() as u32);
+					submesh_verts.push(vert_id);
+					submesh_vert_id_from_mesh_vert_id.insert(vert_id,submesh_vert_id);
+					submesh_vert_id
+				}
+			};
 			let mut edge_pool=EdgePool::default();
 			let mut vert_ref_guys=vec![VertRefGuy::default();mesh.unique_pos.len()];
 			let mut face_ref_guys=Vec::new();
@@ -357,10 +358,10 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 						edge_ref_faces.push(!is_sorted as usize,submesh_face_id);
 						//index edges & face into vertices
 						{
-							let vert_ref_guy=&mut vert_ref_guys[submesh_vert0_id.get() as usize];
+							let vert_ref_guy=unsafe{vert_ref_guys.get_unchecked_mut(submesh_vert0_id.get() as usize)};
 							vert_ref_guy.edges.insert(edge_id.as_directed(is_sorted));
 							vert_ref_guy.faces.insert(submesh_face_id);
-							vert_ref_guys[submesh_vert1_id.get() as usize].edges.insert(edge_id.as_directed(!is_sorted));
+							unsafe{vert_ref_guys.get_unchecked_mut(submesh_vert1_id.get() as usize)}.edges.insert(edge_id.as_directed(!is_sorted));
 						}
 						//return directed_edge_id
 						edge_id.as_directed(is_sorted)
@@ -420,10 +421,7 @@ pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
 }
-impl MeshQuery for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMeshView<'_>{
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -435,7 +433,7 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
 		Cow::Borrowed(&self.topology.face_topology[face_id.get() as usize].edges)
 	}
 	fn edge_faces(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshFaceId;2]>{
@@ -444,10 +442,10 @@ impl MeshQuery for PhysicsMeshView<'_>{
 	fn edge_verts(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshVertId;2]>{
 		Cow::Borrowed(&self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshDirectedEdgeId>>{
 		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].edges)
 	}
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<[SubmeshFaceId]>{
+	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshFaceId>>{
 		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].faces)
 	}
 }
@@ -497,10 +495,7 @@ impl TransformedMesh<'_>{
 		)
 	}
 }
-impl MeshQuery for TransformedMesh<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for TransformedMesh<'_>{
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -513,7 +508,7 @@ impl MeshQuery for TransformedMesh<'_>{
 		self.transform.vertex.transform_point3(self.view.vert(vert_id)).fix_1()
 	}
 	#[inline]
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
 		self.view.face_edges(face_id)
 	}
 	#[inline]
@@ -525,11 +520,11 @@ impl MeshQuery for TransformedMesh<'_>{
 		self.view.edge_verts(edge_id)
 	}
 	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshDirectedEdgeId>>{
 		self.view.vert_edges(vert_id)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<[SubmeshFaceId]>{
+	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshFaceId>>{
 		self.view.vert_faces(vert_id)
 	}
 }
@@ -674,13 +669,13 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh>{
+	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
 		//start on any vertex
 		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 		//cross edge-face boundary if it's uncrossable
 		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
 			//if a vert is returned, it is the closest point to the infinity point
-			EV::Vert(vert_id)=>FEV::Vert(vert_id),
+			EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
 			EV::Edge(edge_id)=>{
 				//cross to face if the boundary is not crossable and we are on the wrong side
 				let edge_n=self.edge_n(edge_id);
@@ -698,61 +693,55 @@ impl MinkowskiMesh<'_>{
 					//infinity_dir can always be treated as a velocity
 					if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
 						//both faces cannot pass this condition, return early if one does.
-						return FEV::Face(face_id);
+						return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
 					}
 				}
-				FEV::Edge(edge_id)
+				FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Edge(edge_id)
 			},
 		}
 	}
-	// TODO: fundamentally improve this algorithm.
-	// All it needs to do is find the closest point on the mesh
-	// and return the FEV which the point resides on.
-	//
-	// What it actually does is use the above functions to trace a ray in from infinity,
-	// crawling the closest point along the mesh surface until the ray reaches
-	// the starting point to discover the final FEV.
-	//
-	// The actual collision prediction probably does a single test
-	// and then immediately returns with 0 FEV transitions on average,
-	// because of the strict time_limit constraint.
-	//
-	// Most of the calculation time is just calculating the starting point
-	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
-		infinity_body.infinity_dir().and_then(|dir|{
+	fn closest_fev_not_inside(&self,mut infinity_body:crate::physics::Body)->Option<FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>>{
+		infinity_body.infinity_dir().map_or(None,|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
 			// TODO: change crawl_fev args to delta time? Optional values?
-			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
+			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
+				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
+				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
+			}
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
+		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,start_time,time_limit).hit()
+			match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
+			}
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
 		//create an extrapolated body at time_limit
-		let infinity_body=-relative_body.clone();
-		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
+		let infinity_body=crate::physics::Body::new(
+			relative_body.extrapolated_position(time_limit),
+			-relative_body.extrapolated_velocity(time_limit),
+			relative_body.acceleration,
+			-time_limit,
+		);
+		self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,-time_limit,-start_time).hit()
-				//no need to test -time<time_limit because of the first step
-				.map(|(face,time)|(face,-time))
+			match crate::face_crawler::crawl_fev(fev,self,&-relative_body.clone(),-time_limit,-relative_body.time){
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
+			}
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let start_time={
-			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num,r.den)
-		};
 		let mut best_time={
 			let r=(time_limit-relative_body.time).to_ratio();
 			Ratio::new(r.num.fix_4(),r.den.fix_4())
@@ -768,7 +757,7 @@ impl MinkowskiMesh<'_>{
 			//WARNING! d outside of *2
 			//WARNING: truncated precision
 			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).fix_4(),n.dot(relative_body.velocity).fix_4()*2,n.dot(relative_body.acceleration).fix_4()){
-				if start_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				if Ratio::new(Planar64::ZERO,Planar64::EPSILON).le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 					best_time=dt;
 					best_edge=Some(directed_edge_id);
 					break;
@@ -777,12 +766,15 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge.map(|e|(e.as_undirected(),best_time))
 	}
-	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
+	fn infinity_in(&self,infinity_body:crate::physics::Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time).hit()
+		match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
+			crate::face_crawler::CrawlResult::Miss(_)=>None,
+			crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
+		}
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
-		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
+		let infinity_body=crate::physics::Body::new(point,vec3::Y,vec3::ZERO,integer::Time::ZERO);
 		//movement must escape the mesh forwards and backwards in time,
 		//otherwise the point is not inside the mesh
 		self.infinity_in(infinity_body)
@@ -792,13 +784,9 @@ impl MinkowskiMesh<'_>{
      	)
 	}
 }
-impl MeshQuery for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
+impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
-	// TODO: relative d
 	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
@@ -828,7 +816,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn face_edges(&self,face_id:MinkowskiFace)->Cow<[MinkowskiDirectedEdge]>{
+	fn face_edges(&self,face_id:MinkowskiFace)->Cow<Vec<MinkowskiDirectedEdge>>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
 				Cow::Owned(self.mesh1.face_edges(f1).iter().map(|&edge_id1|{
@@ -929,7 +917,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<[MinkowskiDirectedEdge]>{
+	fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<Vec<MinkowskiDirectedEdge>>{
 		match vert_id{
 			MinkowskiVert::VertVert(v0,v1)=>{
 				let mut edges=Vec::new();
@@ -971,7 +959,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<[MinkowskiFace]>{
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<Vec<MinkowskiFace>>{
 		unimplemented!()
 	}
 }
@@ -985,7 +973,7 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 			for k in 0..len{
 				if k!=i&&k!=j{
 					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
+					if let Some(comp)=&d_comp{
 						// This is testing if d_comp*d < 0
 						if comp^d{
 							return true;
@@ -1005,3 +993,9 @@ fn test_is_empty_volume(){
 	assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
 	assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
 }
+
+#[test]
+fn build_me_a_cube(){
+	let mesh=PhysicsMesh::unit_cube();
+	//println!("mesh={:?}",mesh);
+}

strafe-client/src/physics_worker.rs

@@ -1,81 +1,242 @@
-use crate::graphics_worker::Instruction as GraphicsInstruction;
-use strafesnet_settings::{directories::Directories,settings};
-use strafesnet_session::session::{
-	Session,Simulation,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction,ImplicitModeInstruction,
-	Instruction as SessionInstruction,
-};
-use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
-use strafesnet_common::physics::Time as PhysicsTime;
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::timer::Timer;
+use strafesnet_common::mouse::MouseState;
+use strafesnet_common::physics::Instruction as PhysicsInputInstruction;
+use strafesnet_common::integer::Time;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::timer::{Scaled,Timer,TimerState};
+use mouse_interpolator::MouseInterpolator;
 
+#[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{
-	SessionInput(SessionInputInstruction),
-	SessionControl(SessionControlInstruction),
-	SessionPlayback(SessionPlaybackInstruction),
+	Input(InputInstruction),
 	Render,
 	Resize(winit::dpi::PhysicalSize<u32>),
 	ChangeMap(strafesnet_common::map::CompleteMap),
-	LoadReplay(strafesnet_snf::bot::Segment),
+	//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>>,
+	last_mouse_time:Time,//this value is pre-transformed to simulation time
+	mouse_blocking:bool,
+	//"Simulation"
+	timer:Timer<Scaled>,
+	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>,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: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!
+	fn map_instruction(&mut self,ins:&TimedInstruction<Instruction>)->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 pause: {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:Time){
+		//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:Time)->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 Time::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>){
+		let should_empty_queue=self.map_instruction(ins);
+		if should_empty_queue{
+			self.empty_queue();
+		}
+	}
+	pub fn get_frame_state(&self,time:Time)->crate::graphics::FrameState{
+		crate::graphics::FrameState{
+			body:self.physics.camera_body(),
+			camera:self.physics.camera(),
+			time:self.timer.time(time),
+		}
+	}
+	pub fn change_map(&mut self,time:Time,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:self.timer.time(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>,
-	directories:Directories,
-	user_settings:settings::UserSettings,
-)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
-	let physics=strafesnet_physics::physics::PhysicsState::default();
-	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
-	let simulation=Simulation::new(timer,physics);
-	let mut session=Session::new(
-		user_settings,
-		directories,
-		simulation,
+	user_settings:crate::settings::UserSettings,
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction>>{
+	let physics=crate::physics::PhysicsContext::default();
+	let mut interpolator=MouseInterpolator::new(
+		physics,
+		user_settings
 	);
-	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
-		// excruciating pain
-		macro_rules! run_session_instruction{
-			($time:expr,$instruction:expr)=>{
-				session.process_instruction(TimedInstruction{
-					time:$time,
-					instruction:$instruction,
-				});
-			};
-		}
-		macro_rules! run_graphics_worker_instruction{
-			($instruction:expr)=>{
-				graphics_worker.send($instruction).unwrap();
-			};
-		}
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+		interpolator.handle_instruction(&ins);
 		match ins.instruction{
-			Instruction::SessionInput(unbuffered_instruction)=>{
-				run_session_instruction!(ins.time,SessionInstruction::Input(unbuffered_instruction));
-			},
-			Instruction::SessionControl(unbuffered_instruction)=>{
-				run_session_instruction!(ins.time,SessionInstruction::Control(unbuffered_instruction));
-			},
-			Instruction::SessionPlayback(unbuffered_instruction)=>{
-				run_session_instruction!(ins.time,SessionInstruction::Playback(unbuffered_instruction));
-			},
 			Instruction::Render=>{
-				run_session_instruction!(ins.time,SessionInstruction::Idle);
-				if let Some(frame_state)=session.get_frame_state(ins.time){
-					run_graphics_worker_instruction!(GraphicsInstruction::Render(frame_state));
-				}
+				let frame_state=interpolator.get_frame_state(ins.time);
+				graphics_worker.send(crate::graphics_worker::Instruction::Render(frame_state)).unwrap();
 			},
-			Instruction::Resize(physical_size)=>{
-				run_session_instruction!(ins.time,SessionInstruction::Idle);
-				let user_settings=session.user_settings().clone();
-				run_graphics_worker_instruction!(GraphicsInstruction::Resize(physical_size,user_settings));
+			Instruction::Resize(size)=>{
+				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
 			},
-			Instruction::ChangeMap(complete_map)=>{
-				run_session_instruction!(ins.time,SessionInstruction::ChangeMap(&complete_map));
-				run_session_instruction!(ins.time,SessionInstruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId::MAIN,strafesnet_common::gameplay_modes::StageId::FIRST))));
-				run_graphics_worker_instruction!(GraphicsInstruction::ChangeMap(complete_map));
+			Instruction::ChangeMap(map)=>{
+				interpolator.change_map(ins.time,&map);
+				graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).unwrap();
 			},
-			Instruction::LoadReplay(bot)=>{
-				run_session_instruction!(ins.time,SessionInstruction::LoadReplay(bot));
-			}
+			Instruction::Input(_)=>(),
+			Instruction::SetPaused(_)=>(),
 		}
 	})
 }

strafe-client/src/settings.rs

@@ -74,9 +74,9 @@ sensitivity_y_from_x_ratio=1
 Sensitivity::DeriveY{x:0.0.001,y:DerivedSensitivity{ratio:1.0}}
 */
 
-pub fn load_user_settings(path:&std::path::Path)->UserSettings{
+pub fn read_user_settings()->UserSettings{
 	let mut cfg=configparser::ini::Ini::new();
-	if let Ok(_)=cfg.load(path){
+	if let Ok(_)=cfg.load("settings.conf"){
 		let (cfg_fov_x,cfg_fov_y)=(cfg.getfloat("camera","fov_x"),cfg.getfloat("camera","fov_y"));
 		let fov=match(cfg_fov_x,cfg_fov_y){
 			(Ok(Some(fov_x)),Ok(Some(fov_y)))=>Fov::Exactly {

strafe-client/src/setup.rs

@@ -1,3 +1,7 @@
+use crate::window::WindowInstruction;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::integer;
+
 fn optional_features()->wgpu::Features{
 	wgpu::Features::TEXTURE_COMPRESSION_ASTC
 	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
@@ -12,6 +16,9 @@ fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
 		..wgpu::DownlevelCapabilities::default()
 	}
 }
+pub fn required_limits()->wgpu::Limits{
+	wgpu::Limits::default()
+}
 
 struct SetupContextPartial1{
 	backends:wgpu::Backends,
@@ -20,13 +27,33 @@ struct SetupContextPartial1{
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
+	#[cfg(windows_OFF)] // TODO
+	{
+		use winit::platform::windows::WindowBuilderExtWindows;
+		builder=builder.with_no_redirection_bitmap(true);
+	}
+	#[cfg(target_arch="wasm32")]
+	{
+		use wasm_bindgen::JsCast;
+		use winit::platform::web::WindowAttributesExtWebSys;
+		let canvas=web_sys::window().unwrap()
+		.document().unwrap()
+		.get_element_by_id("canvas").unwrap()
+		.dyn_into::<web_sys::HtmlCanvasElement>().unwrap();
+		attr=attr.with_canvas(Some(canvas));
+	}
 	event_loop.create_window(attr)
 }
 fn create_instance()->SetupContextPartial1{
-	let backends=wgpu::Backends::from_env().unwrap_or_default();
+	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
+	let dx12_shader_compiler=wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
 	SetupContextPartial1{
 		backends,
-		instance:Default::default(),
+		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
+			backends,
+			dx12_shader_compiler,
+			..Default::default()
+		}),
 	}
 }
 impl SetupContextPartial1{
@@ -44,36 +71,18 @@ struct SetupContextPartial2<'a>{
 	surface:wgpu::Surface<'a>,
 }
 impl<'a> SetupContextPartial2<'a>{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
+	async fn pick_adapter(self)->SetupContextPartial3<'a>{
 		let adapter;
 
 		//TODO: prefer adapter that implements optional features
 		//let optional_features=optional_features();
 		let required_features=required_features();
 
-		//no helper function smh gotta write it myself
-		let adapters=self.instance.enumerate_adapters(self.backends);
-
-		let mut chosen_adapter=None;
-		let mut chosen_adapter_score=0;
-		for adapter in adapters {
-			if !adapter.is_surface_supported(&self.surface) {
-				continue;
-			}
-
-			let score=match adapter.get_info().device_type{
-				wgpu::DeviceType::IntegratedGpu=>3,
-				wgpu::DeviceType::DiscreteGpu=>4,
-				wgpu::DeviceType::VirtualGpu=>2,
-				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
-			};
-
-			let adapter_features=adapter.features();
-			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
-				chosen_adapter_score=score;
-				chosen_adapter=Some(adapter);
-			}
-		}
+		let chosen_adapter=self.instance.request_adapter(&wgpu::RequestAdapterOptions{
+			power_preference:wgpu::PowerPreference::HighPerformance,
+			force_fallback_adapter:false,
+			compatible_surface:Some(&self.surface),
+		}).await;
 
 		if let Some(maybe_chosen_adapter)=chosen_adapter{
 			adapter=maybe_chosen_adapter;
@@ -100,25 +109,27 @@ impl<'a> SetupContextPartial2<'a>{
 			required_downlevel_capabilities.flags - downlevel_capabilities.flags
 		);
 		SetupContextPartial3{
+			instance:self.instance,
 			surface:self.surface,
 			adapter,
 		}
 	}
 }
 struct SetupContextPartial3<'a>{
+	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 }
 impl<'a> SetupContextPartial3<'a>{
-	fn request_device(self)->SetupContextPartial4<'a>{
+	async fn request_device(self)->SetupContextPartial4<'a>{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
 		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
-		let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
+		let needed_limits=required_limits().using_resolution(self.adapter.limits());
 
 		let trace_dir=std::env::var("WGPU_TRACE");
-		let (device, queue)=pollster::block_on(self.adapter
+		let (device, queue)=self.adapter
 			.request_device(
 				&wgpu::DeviceDescriptor {
 					label: None,
@@ -127,10 +138,11 @@ impl<'a> SetupContextPartial3<'a>{
 					memory_hints:wgpu::MemoryHints::Performance,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
-			))
+			).await
 			.expect("Unable to find a suitable GPU adapter!");
 
 		SetupContextPartial4{
+			instance:self.instance,
 			surface:self.surface,
 			adapter:self.adapter,
 			device,
@@ -139,6 +151,7 @@ impl<'a> SetupContextPartial3<'a>{
 	}
 }
 struct SetupContextPartial4<'a>{
+	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
@@ -155,6 +168,7 @@ impl<'a> SetupContextPartial4<'a>{
 		self.surface.configure(&self.device, &config);
 
 		SetupContext{
+			instance:self.instance,
 			surface:self.surface,
 			device:self.device,
 			queue:self.queue,
@@ -163,26 +177,27 @@ impl<'a> SetupContextPartial4<'a>{
 	}
 }
 pub struct SetupContext<'a>{
+	pub instance:wgpu::Instance,
 	pub surface:wgpu::Surface<'a>,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub fn setup_and_start(title:&str){
+pub async fn setup_and_start(title:String){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
 	println!("Initializing the surface...");
 
 	let partial_1=create_instance();
 
-	let window=create_window(title,&event_loop).unwrap();
+	let window=create_window(title.as_str(),&event_loop).unwrap();
 
 	let partial_2=partial_1.create_surface(&window).unwrap();
 
-	let partial_3=partial_2.pick_adapter();
+	let partial_3=partial_2.pick_adapter().await;
 
-	let partial_4=partial_3.request_device();
+	let partial_4=partial_3.request_device().await;
 
 	let size=window.inner_size();
 
@@ -196,17 +211,74 @@ pub fn setup_and_start(title:&str){
 		setup_context,
 	);
 
-	for arg in std::env::args().skip(1){
-		window_thread.send(strafesnet_common::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::ZERO,
-			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(arg.into())),
+	//if let Some(arg)=std::env::args().nth(1){
+		//let path=std::path::PathBuf::from(arg);
+		window_thread.send(TimedInstruction{
+			time:integer::Time::ZERO,
+			instruction:WindowInstruction::WindowEvent(winit::event::WindowEvent::DroppedFile("".into())),
 		}).unwrap();
-	};
+	//};
 
 	println!("Entering event loop...");
-	let mut app=crate::app::App::new(
-		std::time::Instant::now(),
-		window_thread
-	);
-	event_loop.run_app(&mut app).unwrap();
+	let root_time=chrono::Utc::now();
+	run_event_loop(event_loop,window_thread,root_time).unwrap();
+}
+
+fn run_event_loop(
+	event_loop:winit::event_loop::EventLoop<()>,
+	mut window_thread:crate::compat_worker::QNWorker<TimedInstruction<WindowInstruction>>,
+	root_time:chrono::DateTime<chrono::Utc>,
+	)->Result<(),winit::error::EventLoopError>{
+		event_loop.run(move |event,elwt|{
+			let time=integer::Time::from_nanos((chrono::Utc::now()-root_time).num_nanoseconds().unwrap());
+			// *control_flow=if cfg!(feature="metal-auto-capture"){
+			// 	winit::event_loop::ControlFlow::Exit
+			// }else{
+			// 	winit::event_loop::ControlFlow::Poll
+			// };
+			match event{
+				winit::event::Event::AboutToWait=>{
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::RequestRedraw}).unwrap();
+				}
+				winit::event::Event::WindowEvent {
+					event:
+						// WindowEvent::Resized(size)
+						// | WindowEvent::ScaleFactorChanged {
+						// 	new_inner_size: &mut size,
+						// 	..
+						// },
+						winit::event::WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
+					window_id:_,
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Resize(size)}).unwrap();
+				}
+				winit::event::Event::WindowEvent{event,..}=>match event{
+					winit::event::WindowEvent::KeyboardInput{
+						event:
+							winit::event::KeyEvent {
+							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+								state: winit::event::ElementState::Pressed,
+								..
+							},
+						..
+					}
+					|winit::event::WindowEvent::CloseRequested=>{
+						elwt.exit();
+					}
+					winit::event::WindowEvent::RedrawRequested=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Render}).unwrap();
+					}
+					_=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::WindowEvent(event)}).unwrap();
+					}
+				},
+				winit::event::Event::DeviceEvent{
+					event,
+					..
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::DeviceEvent(event)}).unwrap();
+				},
+				_=>{}
+			}
+		})
 }

strafe-client/src/window.rs

@@ -1,43 +1,43 @@
+use crate::physics_worker::InputInstruction;
+use strafesnet_common::integer;
 use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::physics::{MiscInstruction,SetControlInstruction};
-use crate::file::LoadFormat;
-use crate::physics_worker::Instruction as PhysicsWorkerInstruction;
-use strafesnet_session::session::{self,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction};
-use strafesnet_settings::directories::Directories;
 
-pub enum Instruction{
+pub enum WindowInstruction{
+	Resize(winit::dpi::PhysicalSize<u32>),
 	WindowEvent(winit::event::WindowEvent),
 	DeviceEvent(winit::event::DeviceEvent),
+	RequestRedraw,
+	Render,
 }
 
 //holds thread handles to dispatch to
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
-	mouse_pos:glam::DVec2,
+	mouse:strafesnet_common::mouse::MouseState,//std::sync::Arc<std::sync::Mutex<>>
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
-	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTimeInner>>,
+	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<crate::physics_worker::Instruction>>,
 }
 
 impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
-	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
+	fn window_event(&mut self,time:integer::Time,event:winit::event::WindowEvent){
 		match event{
-			winit::event::WindowEvent::DroppedFile(path)=>{
-				match crate::file::load(path.as_path()){
-					Ok(LoadFormat::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}).unwrap(),
-					Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}).unwrap(),
-					Err(e)=>println!("Failed to load file: {e}"),
+			winit::event::WindowEvent::DroppedFile(_path)=>{
+				//match crate::file::load_file(path.as_path()){
+				let data=include_bytes!("/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_snfm/5692152916.snfm");
+				match crate::file::load(std::io::Cursor::new(data.as_slice())){
+					Ok(map)=>self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ChangeMap(map)}).unwrap(),
+					Err(e)=>println!("Failed to load map: {e}"),
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
-					instruction:PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(!state)),
+					instruction:crate::physics_worker::Instruction::SetPaused(!state),
 				}).unwrap();
 				//recalculate pressed keys on focus
 			},
@@ -92,106 +92,42 @@ impl WindowContext<'_>{
 					},
 					(keycode,state)=>{
 						let s=state.is_pressed();
-
-						// internal variants for this scope
-						enum SessionInstructionSubset{
-							Input(SessionInputInstruction),
-							Control(SessionControlInstruction),
-							Playback(SessionPlaybackInstruction),
-						}
-						macro_rules! input_ctrl{
-							($variant:ident,$state:expr)=>{
-								Some(SessionInstructionSubset::Input(SessionInputInstruction::SetControl(SetControlInstruction::$variant($state))))
-							};
-						}
-						macro_rules! input_misc{
-							($variant:ident,$state:expr)=>{
-								s.then_some(SessionInstructionSubset::Input(SessionInputInstruction::Misc(MiscInstruction::$variant)))
-							};
-						}
-						macro_rules! session_ctrl{
-							($variant:ident,$state:expr)=>{
-								s.then_some(SessionInstructionSubset::Control(SessionControlInstruction::$variant))
-							};
-						}
-						macro_rules! session_playback{
-							($variant:ident,$state:expr)=>{
-								s.then_some(SessionInstructionSubset::Playback(SessionPlaybackInstruction::$variant))
-							};
-						}
-						impl From<SessionInstructionSubset> for PhysicsWorkerInstruction{
-							fn from(value:SessionInstructionSubset)->Self{
-								match value{
-									SessionInstructionSubset::Input(session_input_instruction)=>PhysicsWorkerInstruction::SessionInput(session_input_instruction),
-									SessionInstructionSubset::Control(session_control_instruction)=>PhysicsWorkerInstruction::SessionControl(session_control_instruction),
-									SessionInstructionSubset::Playback(session_playback_instruction)=>PhysicsWorkerInstruction::SessionPlayback(session_playback_instruction),
-								}
-							}
-						}
-
-						if let Some(session_instruction)=match keycode{
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
-							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowRight)=>session_playback!(SkipForward,s),
+						if let Some(input_instruction)=match keycode{
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
 							winit::keyboard::Key::Character(key)=>match key.as_str(){
-								"W"|"w"=>input_ctrl!(SetMoveForward,s),
-								"A"|"a"=>input_ctrl!(SetMoveLeft,s),
-								"S"|"s"=>input_ctrl!(SetMoveBack,s),
-								"D"|"d"=>input_ctrl!(SetMoveRight,s),
-								"E"|"e"=>input_ctrl!(SetMoveUp,s),
-								"Q"|"q"=>input_ctrl!(SetMoveDown,s),
-								"Z"|"z"=>input_ctrl!(SetZoom,s),
-								"R"|"r"=>s.then(||{
+								"W"|"w"=>Some(InputInstruction::MoveForward(s)),
+								"A"|"a"=>Some(InputInstruction::MoveLeft(s)),
+								"S"|"s"=>Some(InputInstruction::MoveBack(s)),
+								"D"|"d"=>Some(InputInstruction::MoveRight(s)),
+								"E"|"e"=>Some(InputInstruction::MoveUp(s)),
+								"Q"|"q"=>Some(InputInstruction::MoveDown(s)),
+								"Z"|"z"=>Some(InputInstruction::Zoom(s)),
+								"R"|"r"=>if s{
 									//mouse needs to be reset since the position is absolute
-									self.mouse_pos=glam::DVec2::ZERO;
-									SessionInstructionSubset::Input(SessionInputInstruction::Mode(session::ImplicitModeInstruction::ResetAndRestart))
-								}),
-								"F"|"f"=>input_misc!(PracticeFly,s),
-								"B"|"b"=>session_ctrl!(CopyRecordingIntoReplayAndSpectate,s),
-								"X"|"x"=>session_ctrl!(StopSpectate,s),
-								"N"|"n"=>session_ctrl!(SaveReplay,s),
-								"J"|"j"=>session_ctrl!(LoadIntoReplayState,s),
+									self.mouse=strafesnet_common::mouse::MouseState::default();
+									Some(InputInstruction::ResetAndRestart)
+								}else{None},
+								"F"|"f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
 								_=>None,
 							},
 							_=>None,
 						}{
 							self.physics_thread.send(TimedInstruction{
 								time,
-								instruction:session_instruction.into(),
+								instruction:crate::physics_worker::Instruction::Input(input_instruction),
 							}).unwrap();
 						}
 					},
 				}
 			},
-			winit::event::WindowEvent::Resized(size)=>{
-				self.physics_thread.send(
-					TimedInstruction{
-						time,
-						instruction:PhysicsWorkerInstruction::Resize(size)
-					}
-				).unwrap();
-			},
-			winit::event::WindowEvent::RedrawRequested=>{
-				self.window.request_redraw();
-				self.physics_thread.send(
-					TimedInstruction{
-						time,
-						instruction:PhysicsWorkerInstruction::Render
-					}
-				).unwrap();
-			},
 			_=>(),
 		}
 	}
 
-	fn device_event(&mut self,time:SessionTime,event: winit::event::DeviceEvent){
+	fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent){
 		match event{
 			winit::event::DeviceEvent::MouseMotion{
-			    delta,
+			    delta,//these (f64,f64) are integers on my machine
 			}=>{
 				if self.manual_mouse_lock{
 					match self.window.set_cursor_position(self.get_middle_of_screen()){
@@ -199,10 +135,14 @@ impl WindowContext<'_>{
 						Err(e)=>println!("Could not set cursor position: {:?}",e),
 					}
 				}
-				self.mouse_pos+=glam::dvec2(delta.0,delta.1);
+				//do not step the physics because the mouse polling rate is higher than the physics can run.
+				//essentially the previous input will be overwritten until a true step runs
+				//which is fine because they run all the time.
+				let delta=glam::ivec2(delta.0 as i32,delta.1 as i32);
+				self.mouse.pos+=delta;
 				self.physics_thread.send(TimedInstruction{
 					time,
-					instruction:PhysicsWorkerInstruction::SessionInput(SessionInputInstruction::Mouse(self.mouse_pos.as_ivec2())),
+					instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
 				}).unwrap();
 			},
 			winit::event::DeviceEvent::MouseWheel {
@@ -212,7 +152,7 @@ impl WindowContext<'_>{
 				if false{//self.physics.style.use_scroll{
 					self.physics_thread.send(TimedInstruction{
 						time,
-						instruction:PhysicsWorkerInstruction::SessionInput(SessionInputInstruction::SetControl(SetControlInstruction::SetJump(true))),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
+						instruction:crate::physics_worker::Instruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
 					}).unwrap();
 				}
 			},
@@ -223,16 +163,11 @@ impl WindowContext<'_>{
 pub fn worker<'a>(
 	window:&'a winit::window::Window,
 	setup_context:crate::setup::SetupContext<'a>,
-)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
 	// WindowContextSetup::new
-	#[cfg(feature="user-install")]
-	let directories=Directories::user().unwrap();
-	#[cfg(not(feature="user-install"))]
-	let directories=Directories::portable().unwrap();
+	let user_settings=crate::settings::read_user_settings();
 
-	let user_settings=directories.settings();
-
-	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
+	let mut graphics=crate::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
 	graphics.load_user_settings(&user_settings);
 
 	//WindowContextSetup::into_context
@@ -240,26 +175,44 @@ pub fn worker<'a>(
 	let graphics_thread=crate::graphics_worker::new(graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
-		mouse_pos:glam::DVec2::ZERO,
+		mouse:strafesnet_common::mouse::MouseState::default(),
 		//make sure to update this!!!!!
 		screen_size,
 		window,
 		physics_thread:crate::physics_worker::new(
 			graphics_thread,
-			directories,
 			user_settings,
 		),
 	};
 
 	//WindowContextSetup::into_worker
-	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
 		match ins.instruction{
-			Instruction::WindowEvent(window_event)=>{
+			WindowInstruction::RequestRedraw=>{
+				window_context.window.request_redraw();
+			}
+			WindowInstruction::WindowEvent(window_event)=>{
 				window_context.window_event(ins.time,window_event);
 			},
-			Instruction::DeviceEvent(device_event)=>{
+			WindowInstruction::DeviceEvent(device_event)=>{
 				window_context.device_event(ins.time,device_event);
 			},
+			WindowInstruction::Resize(size)=>{
+				window_context.physics_thread.send(
+					TimedInstruction{
+						time:ins.time,
+						instruction:crate::physics_worker::Instruction::Resize(size)
+					}
+				).unwrap();
+			}
+			WindowInstruction::Render=>{
+				window_context.physics_thread.send(
+					TimedInstruction{
+						time:ins.time,
+						instruction:crate::physics_worker::Instruction::Render
+					}
+				).unwrap();
+			}
 		}
 	})
 }

strafe-client/src/worker.rs

@@ -176,21 +176,21 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 #[cfg(test)]
 mod test{
 	use super::{thread,QRWorker};
-	type Body=strafesnet_physics::physics::Body;
+	use crate::physics;
 	use strafesnet_common::{integer,instruction};
 	#[test]//How to run this test with printing: cargo test --release -- --nocapture
 	fn test_worker() {
 		// Create the worker thread
-		let test_body=Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO);
-		let worker=QRWorker::new(Body::ZERO,
-			|_|Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO)
+		let test_body=physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO);
+		let worker=QRWorker::new(physics::Body::ZERO,
+			|_|physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO)
 		);
 
 		// Send tasks to the worker
 		for _ in 0..5 {
 			let task = instruction::TimedInstruction{
-				time:strafesnet_common::physics::Time::ZERO,
-				instruction:strafesnet_common::physics::Instruction::IDLE,
+				time:integer::Time::ZERO,
+				instruction:strafesnet_common::physics::Instruction::Idle,
 			};
 			worker.send(task).unwrap();
 		}
@@ -204,7 +204,7 @@ mod test{
 		// Send a new task
 		let task = instruction::TimedInstruction{
 			time:integer::Time::ZERO,
-			instruction:strafesnet_common::physics::Instruction::IDLE,
+			instruction:strafesnet_common::physics::Instruction::Idle,
 		};
 		worker.send(task).unwrap();
 

tools/arcane

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692113331.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692113331.snfm

tools/iso

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692124338.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692124338.snfm

tools/replays

@@ -1 +0,0 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/replays

tools/run

@@ -1 +1 @@
-mangohud ../target/release/strafe-client "$@"
+mangohud ../target/release/strafe-client "$1"

tools/toc

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692152916.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692152916.snfm

tools/utopia

@@ -1 +1 @@
-mangohud ../target/release/strafe-client surf_maps/5692145408.snfm "$@"
+mangohud ../target/release/strafe-client surf_maps/5692145408.snfm

web-client/.gitignore

@@ -0,0 +1 @@
+/dist

web-client/Trunk.toml

@@ -0,0 +1,2 @@
+[build]
+target = "index.html"

web-client/index.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1"/>
+    <title>Strafe Client</title>
+
+    <base data-trunk-public-url />
+	<style type="text/css">
+		body {
+			margin: 0px;
+			background: #fff;
+			width: 100%;
+			height: 100%;
+		}
+		.main-canvas {
+			margin: 0;
+		}
+    </style>
+</head>
+<body>
+	<canvas class="main-canvas" id="canvas"></canvas>
+    <link data-trunk rel="rust" href="../strafe-client/Cargo.toml"/>
+</body>
+</html>