test map loading speed

This reverts commit 65b49d27261754903b2e39194c80ac096afc1da2.

README.md

@@ -3,6 +3,9 @@
 # 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`

strafe-client/src/file.rs

@@ -34,11 +34,20 @@ pub enum ReadFormat{
 }
 
 pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
+	let t=std::time::Instant::now();
+	println!("reading fourcc...");
 	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();
+	let dt=t.elapsed();
+	println!("{:?} elapsed={:?}",core::str::from_utf8(&peek),dt);
+
+	let t=std::time::Instant::now();
+	println!("reading entire file...");
 	// 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)?;
+	println!("elapsed={:?}",t.elapsed());
+
 	let cursor=std::io::Cursor::new(entire_file);
 	match peek.as_slice(){
 		#[cfg(feature="roblox")]
@@ -46,10 +55,15 @@ pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
 		#[cfg(feature="source")]
 		b"VBSP"=>Ok(ReadFormat::Source(strafesnet_bsp_loader::read(cursor).map_err(ReadError::Source)?)),
 		#[cfg(feature="snf")]
-		b"SNFM"=>Ok(ReadFormat::SNFM(
-			strafesnet_snf::read_map(cursor).map_err(ReadError::StrafesNET)?
-			.into_complete_map().map_err(ReadError::StrafesNETMap)?
-		)),
+		b"SNFM"=>{
+			let t=std::time::Instant::now();
+			println!("decoding map...");
+			let map=
+				strafesnet_snf::read_map(cursor).map_err(ReadError::StrafesNET)?
+				.into_complete_map().map_err(ReadError::StrafesNETMap)?;
+			println!("elapsed={:?}",t.elapsed());
+			Ok(ReadFormat::SNFM(map))
+		},
 		#[cfg(feature="snf")]
 		b"SNFB"=>Ok(ReadFormat::SNFB(
 			strafesnet_snf::read_bot(cursor).map_err(ReadError::StrafesNET)?

strafe-client/src/model_physics.rs

@@ -1,5 +1,6 @@
 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};
@@ -718,8 +719,8 @@ impl MinkowskiMesh<'_>{
 	//
 	// 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().map_or(None,|dir|{
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
+		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
@@ -729,23 +730,23 @@ impl MinkowskiMesh<'_>{
 			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,start_time:Time,time_limit:Time)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),start_time).map_or(None,|fev|{
+	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|{
 			//continue forwards along the body parabola
 			fev.crawl(self,relative_body,start_time,time_limit).hit()
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,start_time:Time,time_limit:Time)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<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).map_or(None,|fev|{
+		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|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))
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,start_time:Time,time_limit:Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	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)>{
 		//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={

strafe-client/src/physics.rs

@@ -28,9 +28,9 @@ use gameplay::ModeState;
 // 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(1);
+pub const VERSION:PhysicsVersion=PhysicsVersion(2);
 const LATEST_COMPATIBLE_VERSION:[u32;1+VERSION.0 as usize]=const{
-	let compat=[0,1];
+	let compat=[0,1,2];
 
 	let mut input_version=0;
 	while input_version<compat.len(){
@@ -836,7 +836,7 @@ impl TouchingState{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(contact);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time,collector.time(),contact.face_id).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),contact.face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -850,7 +850,7 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(intersect);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&relative_body,start_time,collector.time()).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -1185,9 +1185,9 @@ impl PhysicsData{
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_in(relative_body,state.time,collector.time())
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
 				//temp (?) code to avoid collision loops
-				.map_or(None,|(face,dt)|{
+				.and_then(|(face,dt)|{
 					// this must be rounded to avoid the infinite loop when hitting the start zone
 					let time=relative_body.time+dt.into();
 					(state.time<time).then_some((time,face,dt))
@@ -1294,7 +1294,7 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 	let mut culled=false;
 	touching.contacts.retain(|contact|{
 		let n=contact_normal(models,hitbox_mesh,contact);
-		let r=(n.dot(v)>>52).is_positive();
+		let r=n.dot(v).is_positive();
 		if r{
 			culled=true;
 		}
@@ -1922,7 +1922,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO,Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1940,7 +1940,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO,Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){