????

.gitattributes

@@ -1,2 +0,0 @@
-*.qbot filter=lfs diff=lfs merge=lfs -text
-*.snfm filter=lfs diff=lfs merge=lfs -text

Cargo.toml

@@ -15,14 +15,14 @@ codegen-units = 1
 
 [workspace.dependencies]
 glam = "0.32.0"
-wgpu = "29.0.0"
+wgpu = "28.0.0"
 
-strafesnet_common = { version = "0.9.0", registry = "strafesnet" }
+strafesnet_common = { version = "0.8.6", registry = "strafesnet" }
-strafesnet_graphics = { version = "0.0.11", registry = "strafesnet" }
+strafesnet_graphics = { version = "0.0.7", registry = "strafesnet" }
-strafesnet_roblox_bot_file = { version = "0.9.4", registry = "strafesnet" }
+strafesnet_roblox_bot_file = { version = "0.9.3", registry = "strafesnet" }
-strafesnet_snf = { version = "0.4.0", registry = "strafesnet" }
+strafesnet_snf = { version = "0.3.2", registry = "strafesnet" }
 
-strafesnet_roblox_bot_player = { version = "0.6.2", path = "lib", registry = "strafesnet" }
+strafesnet_roblox_bot_player = { version = "0.2.0", path = "lib" }
 
 # strafesnet_common = { path = "../strafe-project/lib/common" }
 # strafesnet_graphics = { path = "../strafe-project/engine/graphics" }

integration-tests/bot-cruncher-errors.txt

@@ -1,46 +0,0 @@
-error: Some("03f3eb2c-d33d-44ea-ba60-67b685d1140d") Time conversion failed: Overflow
-error: Some("05997e14-08a7-4aa1-b346-dcd6cf517102") Time conversion failed: Overflow
-error: Some("0a32b95e-1d7d-4fd0-8ad7-d7b796cb4f27") Time conversion failed: Overflow
-error: Some("13f88cbd-f137-445d-9980-c4dff97f2af0") Time conversion failed: Overflow
-error: Some("1a4904fe-a6be-4059-934d-a42de5231a9f") Time conversion failed: Overflow
-error: Some("2340d553-dd29-4646-8317-44bcff565048") Time conversion failed: Overflow
-error: Some("23729b36-4014-4348-b2f0-9a0c3532ef03") Time conversion failed: Overflow
-error: Some("23fb8a0b-38f4-4abc-b3e3-07b2044d3bc2") Time conversion failed: Overflow
-error: Some("2a84d8a7-4655-4d2e-a99f-be70c1599417") Time conversion failed: Overflow
-error: Some("339b4577-4c7f-443b-a407-ad94609d15ed") Time conversion failed: Overflow
-error: Some("3568f1a6-48a5-4378-b46b-2715bd152078") Time conversion failed: Overflow
-error: Some("37b12044-d086-4564-9d5b-2a75b7356714") Time conversion failed: Overflow
-error: Some("3d0eed0d-3f40-4106-b939-bdf6d37288fd") Time conversion failed: Overflow
-error: Some("4242a0cd-bb7d-4e86-89db-3d5007118abd") Time conversion failed: Overflow
-error: Some("46180b28-da3f-43da-ac2a-f814c570920d") Time conversion failed: Overflow
-error: Some("5deda980-247f-4d6d-93a8-61db987d38cd") Time conversion failed: Overflow
-error: Some("6fe42692-dea4-4392-8831-6add36b27b26") Time conversion failed: Overflow
-error: Some("74e88825-409f-46d7-82c5-d20d056cadfc") Time conversion failed: Overflow
-error: Some("7996a8d5-5007-4859-be7c-f48fabfbc26b") Time conversion failed: Overflow
-error: Some("8c23df4f-8174-4d92-bd2d-c5295031233d") Time conversion failed: Overflow
-error: Some("90be213f-e057-418a-9031-a757bcd8da5d") Time conversion failed: Overflow
-error: Some("9ecdfbdc-694b-4e2c-b7be-b90182a24b14") Time conversion failed: Overflow
-error: Some("9fe0ac20-875b-49b4-b309-2144a6e35d5c") Time conversion failed: Overflow
-error: Some("a2581786-6425-4ea1-8def-26e4a2150660") Time conversion failed: Overflow
-error: Some("a343edb6-5038-4b51-b296-c9d806410443") Time conversion failed: Overflow
-error: Some("a83ba7f9-c856-4110-9927-11f9ba052704") Time conversion failed: Overflow
-error: Some("a8ed621f-1829-4c02-90c2-1f667e9b1d6d") Time conversion failed: Overflow
-error: Some("aad6ab3b-7580-4e1b-9981-2409ded7e519") Time conversion failed: Overflow
-error: Some("ab06ed6f-c308-491e-9086-dfb16e2d56b0") Time conversion failed: Overflow
-error: Some("b0ce6510-7d58-461a-b24f-61370b68f700") Time conversion failed: Overflow
-error: Some("b21fbcab-faf1-4f95-9b5c-60195777c814") Time conversion failed: Overflow
-error: Some("b400fa0f-af30-473a-b2f2-359e677e00e7") Time conversion failed: Overflow
-error: Some("bb96ff40-2bcf-4632-b61a-1f4c2c68d3fe") Time conversion failed: Overflow
-error: Some("bba5e324-c17d-486e-aef3-3d4ea93f920a") Time conversion failed: Overflow
-error: Some("bfcc633b-287d-4f0e-bf1d-94944b909614") Time conversion failed: Overflow
-error: Some("cc4454ad-7b5e-4b2b-b547-7e3ffd99103a") Time conversion failed: Overflow
-error: Some("d162d94b-d3f7-47ef-8338-e83cfafdabd8") Time conversion failed: Overflow
-error: Some("d714eba0-6cba-4eb9-b4a8-e71c6d0da8e9") Time conversion failed: Overflow
-error: Some("d9178578-dd59-41cb-bcf7-95d902e783a3") Time conversion failed: Overflow
-error: Some("e7219ca8-e7bd-4b29-8081-91406e4d8764") Time conversion failed: Overflow
-error: Some("e9271e47-db0b-4228-9b3d-dd372e6585ac") Time conversion failed: Overflow
-error: Some("ecb5dfc8-fb3f-4a5d-a864-3a05ea054b7a") Time conversion failed: Overflow
-error: Some("edec8dce-8c27-4a66-8c48-59bfc19e96ca") Time conversion failed: Overflow
-error: Some("f184200c-1bcb-48ca-862d-c43118a0a307") Time conversion failed: Overflow
-error: Some("f76013c7-b4cd-431b-8cc6-ad827cecd923") Time conversion failed: Overflow
-error: Some("f9e4316a-b15d-4417-89c6-8fcba4ee746d") Time conversion failed: Overflow

integration-tests/src/main.rs

@@ -6,7 +6,7 @@ use strafesnet_common::session::Time as SessionTime;
 fn main(){
 	let bot=include_bytes!("../../web-demo/bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d.qbot");
 	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
+	let bot=bot::CompleteBot::new(timelines);
 	let bvh=bvh::Bvh::new(&bot);
 
 	// sample the position at 0.24s
@@ -23,28 +23,3 @@ fn main(){
 	// let mut playback1=head::PlaybackHead::new(&bot,SessionTime::ZERO);
 	// playback1.set_time(&bot,SessionTime::ZERO,sample_time);
 }
-
-#[test]
-fn get_position_no_panic(){
-	let bot_file=include_bytes!("../../files/000002d3-852a-4e9f-b0c9-c95411683806.qbot");
-	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot_file)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
-	let head=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	// This can panic if the head is mismanaged!
-	let _pos=head.get_position(&bot,SessionTime::ZERO);
-}
-
-#[test]
-fn get_position_no_panic2(){
-	let bot_file=include_bytes!("../../files/03f3eb2c-d33d-44ea-ba60-67b685d1140d.qbot");
-	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot_file)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
-	println!("duration={}",bot.duration());
-	println!("num_events={}",bot.timelines().output_events.len());
-	for event in &bot.timelines().output_events{
-		println!("time={}",event.time);
-	}
-	let head=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	// This can panic if the head is mismanaged!
-	let _pos=head.get_position(&bot,SessionTime::ZERO);
-}

lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_roblox_bot_player"
-version = "0.6.2"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]
@@ -9,4 +9,3 @@ wgpu.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true
-thiserror = "2.0.18"

lib/src/bot.rs

@@ -4,25 +4,6 @@ use strafesnet_common::physics::{Time as PhysicsTime,TimeInner as PhysicsTimeInn
 use strafesnet_roblox_bot_file::v0;
 
 use crate::head::{Time as PlaybackTime,TimeInner as PlaybackTimeInner};
-use crate::time;
-
-#[derive(Debug,thiserror::Error)]
-pub enum Error{
-	#[error("Bot output timeline has no events")]
-	NoOutputEvents,
-	#[error("Time conversion failed: {0}")]
-	Time(#[from]time::Error),
-}
-
-#[derive(Debug,thiserror::Error)]
-pub enum RunDurationError{
-	#[error("Bot run timeline has no RunStart event")]
-	NoRunStart,
-	#[error("Bot run timeline has no RunFinish event")]
-	NoRunFinish,
-	#[error("Time conversion failed: {0}")]
-	Time(time::Error),
-}
 
 /// A loaded bot file.
 pub struct CompleteBot{
@@ -36,21 +17,19 @@ impl CompleteBot{
 	pub(crate) const CAMERA_OFFSET:glam::Vec3=glam::vec3(0.0,2.0,0.0);
 	pub fn new(
 		timelines:v0::Block,
-	)->Result<Self,Error>{
+	)->Self{
-		let start_event=timelines.output_events.first().ok_or(Error::NoOutputEvents)?;
+		let start=crate::time::from_float(timelines.output_events.first().unwrap().time).unwrap();
-		let end_event=timelines.output_events.last().ok_or(Error::NoOutputEvents)?;
+		let end=crate::time::from_float(timelines.output_events.last().unwrap().time).unwrap();
-		let start=time::from_float(start_event.time).map_err(Error::Time)?;
-		let end=time::from_float(end_event.time).map_err(Error::Time)?;
 		let world_position=timelines.world_events.iter().find_map(|event|match &event.event{
 			v0::WorldEvent::Reset(world_reset_event)=>Some(world_reset_event.position),
 			_=>None,
 		}).expect("Map must contain a WorldReset event");
-		Ok(Self{
+		Self{
 			timer:TimerFixed::new(PlaybackTime::ZERO,start),
 			duration:end-start,
 			timelines,
 			world_offset:glam::vec3(world_position.x,world_position.y,world_position.z),
-		})
+		}
 	}
 	pub fn time(&self,time:PlaybackTime)->PhysicsTime{
 		self.timer.time(time)
@@ -68,18 +47,18 @@ impl CompleteBot{
 	pub const fn timelines(&self)->&v0::Block{
 		&self.timelines
 	}
-	pub fn run_duration(&self,mode_id:v0::ModeID)->Result<RunTime,RunDurationError>{
+	pub fn run_duration(&self,mode_id:v0::ModeID)->Option<RunTime>{
 		let mut it=self.timelines.run_events.iter().rev();
 		let end=it.find_map(|event|match &event.event{
 			v0::RunEvent::Finish(run_start_event) if run_start_event.mode==mode_id=>Some(event.time),
 			_=>None,
-		}).ok_or(RunDurationError::NoRunFinish)?;
+		})?;
 		let start=it.find_map(|event|match &event.event{
 			v0::RunEvent::Start(run_start_event) if run_start_event.mode==mode_id=>Some(event.time),
 			_=>None,
-		}).ok_or(RunDurationError::NoRunStart)?;
+		})?;
-		let start=time::from_float(start).map_err(RunDurationError::Time)?;
+		let start=crate::time::from_float(start).unwrap();
-		let end=time::from_float(end).map_err(RunDurationError::Time)?;
+		let end=crate::time::from_float(end).unwrap();
-		Ok(end-start)
+		Some(end-start)
 	}
 }

lib/src/bvh.rs

@@ -7,10 +7,6 @@ use strafesnet_common::physics::Time as PhysicsTime;
 use crate::bot::CompleteBot;
 use strafesnet_roblox_bot_file::v0;
 
-fn v3(position:v0::Vector3)->strafesnet_common::integer::Planar64Vec3{
-	vec3::try_from_f32_array([position.x,position.y,position.z]).unwrap()
-}
-
 const MAX_SLICE_LEN:usize=16;
 struct EventSlice{
 	slice:Range<usize>,
@@ -44,6 +40,7 @@ impl Bvh{
 			let len=index-last_index;
 			let count=len.div_ceil(MAX_SLICE_LEN);
 			let slice_len=MAX_SLICE_LEN;
+			println!("push_slices index={index} len={len} count={count} slice_len={slice_len}");
 			bvh_nodes.reserve(count);
 			// 0123456789
 			// split into groups of MAX_SLICE_LEN=4
@@ -51,12 +48,13 @@ impl Bvh{
 			let mut push_slice=|slice:Range<usize>,inclusive:bool|{
 				let mut aabb=Aabb::default();
 				for event in &output_events[slice.start..slice.end]{
-					aabb.grow(v3(event.event.position));
+					aabb.grow(vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap());
 				}
 				if inclusive{
 					let event=&output_events[slice.end];
-					aabb.grow(v3(event.event.position));
+					aabb.grow(vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap());
 				}
+				println!("EventSlice slice={slice:?} {}",if inclusive{"inclusive"}else{"exclusive"});
 				bvh_nodes.push((EventSlice{slice,inclusive},aabb));
 			};
 			// push fixed-size groups
@@ -87,13 +85,14 @@ impl Bvh{
 			// calculate the distance to the leaf contents
 			let mut best_distance=output_events[event_slice.slice.start..event_slice.slice.end].iter().map(|event|{
 				let p=event.event.position;
-				let p=v3(p);
+				let p=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
 				(start_point-p).length_squared()
 			}).min()?;
 			let mut prev_event=&output_events[event_slice.slice.start];
+			let start_time=bot.playback_time(crate::time::from_float(prev_event.time).unwrap());
 			let mut f=|event:&'a v0::Timed<v0::OutputEvent>|{
-				let p0=v3(prev_event.event.position);
+				let p0=vec3::try_from_f32_array([prev_event.event.position.x,prev_event.event.position.y,prev_event.event.position.z]).unwrap();
-				let p1=v3(event.event.position);
+				let p1=vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap();
 				let d=p1-p0;
 				let d0=p0.dot(d);
 				let d1=p1.dot(d);
@@ -103,7 +102,7 @@ impl Bvh{
 					let t0=d1-sp_d;
 					let t1=sp_d-d0;
 					let dt=d1-d0;
-					let distance=(((p0*t0+p1*t1)/dt).divide().wrap_64()-start_point).length_squared();
+					let distance=(((p0*t0+p1*t1)/dt).divide().wrap_1()-start_point).length_squared();
 					if distance<best_distance{
 						best_distance=distance;
 					}
@@ -115,7 +114,10 @@ impl Bvh{
 			}
 			if event_slice.inclusive{
 				f(&output_events[event_slice.slice.end]);
+			}else{
 			}
+			let end_time=bot.playback_time(crate::time::from_float(prev_event.time).unwrap());
+			println!("intersect_leaf {:?} {} start_time={} end_time={}",event_slice.slice,if event_slice.inclusive{"inclusive"}else{"exclusive"},start_time,end_time);
 			Some(best_distance)
 		};
 		let intersect_aabb=|aabb:&Aabb|{
@@ -123,20 +125,19 @@ impl Bvh{
 			let clamped_point=start_point.min(aabb.max()).max(aabb.min());
 			Some((start_point-clamped_point).length_squared())
 		};
-		// traverse uses strict `start_time < t`, so use NEG_EPSILON to keep exact-zero-distance hits.
+		let (_,event_slice)=self.bvh.traverse(start_point,Fixed::ZERO,Fixed::MAX,intersect_leaf,intersect_aabb)?;
-		let (_,event_slice)=self.bvh.traverse(start_point,Fixed::NEG_EPSILON,Fixed::MAX,intersect_leaf,intersect_aabb)?;
 
 		// find time at the closest point
 		let (best_time,mut best_distance)=output_events[event_slice.slice.start..event_slice.slice.end].iter().map(|event|{
 			let p=event.event.position;
-			let p=v3(p);
+			let p=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
 			(event.time,(start_point-p).length_squared())
 		}).min_by_key(|&(_,distance)|distance)?;
 		let mut best_time=crate::time::from_float(best_time).unwrap();
 		let mut prev_event=&output_events[event_slice.slice.start];
 		let mut f=|event:&'a v0::Timed<v0::OutputEvent>|{
-			let p0=v3(prev_event.event.position);
+			let p0=vec3::try_from_f32_array([prev_event.event.position.x,prev_event.event.position.y,prev_event.event.position.z]).unwrap();
-			let p1=v3(event.event.position);
+			let p1=vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap();
 			let d=p1-p0;
 			let d0=p0.dot(d);
 			let d1=p1.dot(d);
@@ -146,7 +147,7 @@ impl Bvh{
 				let t0=d1-sp_d;
 				let t1=sp_d-d0;
 				let dt=d1-d0;
-				let distance=(((p0*t0+p1*t1)/dt).divide().wrap_64()-start_point).length_squared();
+				let distance=(((p0*t0+p1*t1)/dt).divide().wrap_1()-start_point).length_squared();
 				if distance<best_distance{
 					best_distance=distance;
 					let p0:Planar64=prev_event.time.try_into().unwrap();

lib/src/graphics.rs

@@ -1,44 +1,29 @@
 use strafesnet_graphics::graphics::GraphicsState;
 
-#[derive(Debug,thiserror::Error)]
-pub enum ChangeMapError{
-	#[error("Map does not have a main mode")]
-	NoMainMode,
-	#[error("Map does not have a start zone")]
-	NoStartZone,
-}
-
 /// The graphics state, essentially a handle to all the information on the GPU.
 pub struct Graphics{
 	graphics:GraphicsState,
 	start_offset:glam::Vec3,
 }
 impl Graphics{
-	pub fn new(device:&wgpu::Device,queue:&wgpu::Queue,size:glam::UVec2,view_format:wgpu::TextureFormat,limits:wgpu::Limits)->Self{
+	pub fn new(device:&wgpu::Device,queue:&wgpu::Queue,size:glam::UVec2,view_format:wgpu::TextureFormat)->Self{
-		let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format,limits);
+		let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format);
 		Self{
 			graphics,
 			start_offset:glam::Vec3::ZERO,
 		}
 	}
-	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap)->Result<(),ChangeMapError>{
+	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap){
 		self.graphics.clear();
 		self.graphics.generate_models(device,queue,map);
 		let modes=map.modes.clone().denormalize();
-		let mode=modes.get_mode(strafesnet_common::gameplay_modes::ModeId::MAIN).ok_or(ChangeMapError::NoMainMode)?;
+		let mode=modes.get_mode(strafesnet_common::gameplay_modes::ModeId::MAIN).expect("Map does not have a main mode");
-		let start_zone=map.models.get(mode.get_start().get() as usize).ok_or(ChangeMapError::NoStartZone)?;
+		let start_zone=map.models.get(mode.get_start().get() as usize).expect("Map does not have a start zone");
 		self.start_offset=glam::Vec3::from_array(start_zone.transform.translation.map(|f|f.into()).to_array());
-		Ok(())
 	}
 	pub fn resize(&mut self,device:&wgpu::Device,size:glam::UVec2,fov:glam::Vec2){
 		self.graphics.resize(device,size,fov);
 	}
-	pub const fn depth_texture(&self)->&wgpu::Texture{
-		self.graphics.depth_texture()
-	}
-	pub const fn depth_texture_view(&self)->&wgpu::TextureView{
-		self.graphics.depth_texture_view()
-	}
 	pub fn encode_commands(&mut self,encoder:&mut wgpu::CommandEncoder,view:&wgpu::TextureView,pos:glam::Vec3,angles:glam::Vec2){
 		self.graphics.encode_commands(encoder,view,strafesnet_graphics::graphics::view_inv(pos+self.start_offset,angles));
 	}

lib/src/head.rs

@@ -1,8 +1,7 @@
 use glam::Vec3Swizzles;
-use strafesnet_common::physics::Time as PhysicsTime;
 use strafesnet_common::timer::{Scaled,Timer,TimerState};
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_roblox_bot_file::v0::{Block,EventType,Head,Timed};
+use strafesnet_roblox_bot_file::v0::{EventType,Head,Timed};
 
 use crate::bot::CompleteBot;
 use crate::state::PlaybackState;
@@ -15,10 +14,6 @@ fn vector3_to_glam(v:&strafesnet_roblox_bot_file::v0::Vector3)->glam::Vec3{
 pub enum TimeInner{}
 pub type Time=strafesnet_common::integer::Time<TimeInner>;
 
-fn head_after_time(block:&Block,time:PhysicsTime)->Head{
-	Head::partition_point(block,|event_time|crate::time::from_float(event_time).unwrap()<=time)
-}
-
 /// A playback context.  Advance time and then generate a camera position to pass to the renderer.
 pub struct PlaybackHead{
 	head:Head,
@@ -28,7 +23,7 @@ pub struct PlaybackHead{
 impl PlaybackHead{
 	pub fn new(bot:&CompleteBot,time:SessionTime)->Self{
 		let timer=Timer::unpaused(time,Time::ZERO);
-		let head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
+		let head=Head::after_time(bot.timelines(),bot.time(Time::ZERO).into());
 		let mut state=PlaybackState::new();
 		state.process_head(bot.timelines(),&head);
 		Self{
@@ -53,7 +48,7 @@ impl PlaybackHead{
 		let new_time=new_time.rem_euclid(bot.duration().coerce());
 		self.timer.set_time(time,new_time);
 		// reset head
-		self.head=head_after_time(bot.timelines(),bot.time(new_time));
+		self.head=Head::after_time(bot.timelines(),bot.time(new_time).into());
 
 		self.state=PlaybackState::new();
 		self.state.process_head(bot.timelines(),&self.head);
@@ -73,10 +68,11 @@ impl PlaybackHead{
 	}
 	pub fn advance_time(&mut self,bot:&CompleteBot,time:SessionTime){
 		let mut simulation_time=bot.time(self.time(time));
+		let mut time_float=simulation_time.into();
 		loop{
 			match self.next_event(bot){
 				Some(next_event)=>{
-					if crate::time::from_float(next_event.time).unwrap()<simulation_time{
+					if next_event.time<time_float{
 						self.process_event(bot,next_event.event);
 					}else{
 						break;
@@ -84,7 +80,7 @@ impl PlaybackHead{
 				},
 				None=>{
 					//reset playback
-					self.head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
+					self.head=Head::after_time(bot.timelines(),bot.time(Time::ZERO).into());
 					self.state=PlaybackState::new();
 					self.state.process_head(bot.timelines(),&self.head);
 
@@ -96,6 +92,7 @@ impl PlaybackHead{
 
 					// update loop variables
 					simulation_time-=bot.duration();
+					time_float=simulation_time.into();
 				},
 			}
 		}

lib/src/time.rs

@@ -20,14 +20,13 @@ pub fn from_float<T>(time:f64)->Result<Time<T>,Error>{
 		core::num::FpCategory::Infinite
 		|core::num::FpCategory::Subnormal
 		|core::num::FpCategory::Normal=>{
-			let time_raw=time*Time::<T>::ONE_SECOND.get() as f64;
+			if time<Time::<T>::MIN.get() as f64{
-			if time_raw<Time::<T>::MIN.get() as f64{
 				return Err(Error::Underflow);
 			}
-			if (Time::<T>::MAX.get() as f64)<time_raw{
+			if (Time::<T>::MAX.get() as f64)<time{
 				return Err(Error::Overflow);
 			}
-			Ok(Time::raw(time_raw as i64))
+			Ok(Time::raw((time*Time::<T>::ONE_SECOND.get() as f64) as i64))
 		}
 	}
 }

native-player/src/player.rs

@@ -80,7 +80,7 @@ impl<'a> PlayerWorker<'a>{
 				let (pos,angles)=playback.playback_head.get_position_angles(&playback.bot,ins.time);
 
 				//this has to go deeper somehow
-				let frame=self.surface.new_frame(device).expect("Error creating new frame");
+				let frame=self.surface.new_frame(device);
 
 				let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 
@@ -99,10 +99,10 @@ impl<'a> PlayerWorker<'a>{
 				self.graphics_thread.resize(device,size,fov);
 			},
 			Instruction::ChangeMap(complete_map)=>{
-				self.graphics_thread.change_map(device,queue,&complete_map).unwrap();
+				self.graphics_thread.change_map(device,queue,&complete_map);
 			},
 			Instruction::LoadReplay(bot)=>{
-				let bot=CompleteBot::new(bot).unwrap();
+				let bot=CompleteBot::new(bot);
 				let playback_head=PlaybackHead::new(&bot,SessionTime::ZERO);
 				self.playback=Some(Playback{
 					bot,

native-player/src/setup.rs

@@ -1,7 +1,5 @@
 use strafesnet_graphics::setup;
 
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-
 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);
@@ -15,14 +13,13 @@ pub async fn setup_and_start(title:&str){
 
 	println!("Initializing the surface...");
 
-	let desc=wgpu::InstanceDescriptor::new_with_display_handle_from_env(Box::new(event_loop.owned_display_handle()));
+	let instance=setup::step1::create_instance();
-	let instance=wgpu::Instance::new(desc);
 
 	let surface=setup::step2::create_surface(&instance,&window).unwrap();
 
 	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
 
-	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).await.unwrap();
+	let (device,queue)=setup::step4::request_device(&adapter).await.unwrap();
 
 	let size=window.inner_size();
 	let surface=setup::step5::configure_surface(&adapter,&device,surface,(size.width,size.height)).unwrap();
@@ -35,7 +32,6 @@ pub async fn setup_and_start(title:&str){
 		device,
 		queue,
 		surface,
-		LIMITS,
 	);
 
 	for arg in std::env::args().skip(1){

native-player/src/window.rs

@@ -127,10 +127,9 @@ impl WindowContext<'_>{
 		device:wgpu::Device,
 		queue:wgpu::Queue,
 		surface:strafesnet_graphics::surface::Surface<'a>,
-		limits:wgpu::Limits,
 	)->WindowContext<'a>{
 		let size=surface.size();
-		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format(),limits);
+		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format());
 		WindowContext{
 			simulation_paused:false,
 			window,

video-encoder/src/encode.rs

@@ -90,8 +90,6 @@ struct EncodeParams{
 	output_file:PathBuf,
 }
 
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-
 fn encode(params:EncodeParams)->Result<(),EncodeError>{
 	let size = glam::uvec2(params.width.get(),params.height.get());
 	let target_framerate = params.target_framerate;
@@ -128,7 +126,7 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 		.map_err(EncodeError::CreateDevice)?;
 
 	// playback
-	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines).unwrap();
+	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines);
 	let mut playback_head=strafesnet_roblox_bot_player::head::PlaybackHead::new(&bot,SessionTime::ZERO);
 
 	let mut wgpu_state = WgpuState::new(
@@ -246,7 +244,7 @@ impl WgpuState {
 		size: glam::UVec2,
 	) -> WgpuState {
 		const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
-		let graphics = strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,FORMAT,LIMITS);
+		let graphics = strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,FORMAT);
 
 		let shader = wgpu::include_wgsl!("../shaders/rgb_to_yuv.wgsl");
 		let shader = device.create_shader_module(shader);
@@ -321,7 +319,7 @@ impl WgpuState {
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 			label: Some("wgpu pipeline layout"),
 			bind_group_layouts: &[
-				Some(&graphics_texture_bind_group_layout),
+				&graphics_texture_bind_group_layout
 			],
 			immediate_size: 0,
 		});
@@ -373,7 +371,7 @@ impl WgpuState {
 	}
 
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
-		self.graphics.change_map(&self.device,&self.queue,map).unwrap();
+		self.graphics.change_map(&self.device,&self.queue,map);
 	}
 
 	fn render(&mut self,pos:glam::Vec3,angles:glam::Vec2) {

wasm-module/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [lib]
-crate-type = ["lib", "cdylib"]
+crate-type = ["cdylib"]
 
 [features]
 default = []

wasm-module/src/lib.rs

@@ -19,12 +19,6 @@ impl From<ToSurfaceTarget> for wgpu::SurfaceTarget<'static>{
 	}
 }
 
-// select limits based on presence of webgl feature
-#[cfg(not(feature="webgl"))]
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-#[cfg(feature="webgl")]
-const LIMITS:wgpu::Limits=wgpu::Limits::downlevel_webgl2_defaults();
-
 #[wasm_bindgen]
 pub struct Graphics{
 	graphics:graphics::Graphics,
@@ -36,18 +30,18 @@ pub struct Graphics{
 pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Result<Graphics,JsError>{
 	let size=glam::uvec2(canvas.width(),canvas.height());
 
-	let instance_desc=wgpu::InstanceDescriptor::new_without_display_handle_from_env();
+	let instance_desc=wgpu::InstanceDescriptor::from_env_or_default();
-	let instance=wgpu::util::new_instance_with_webgpu_detection(instance_desc).await;
+	let instance=wgpu::util::new_instance_with_webgpu_detection(&instance_desc).await;
 	let surface=setup::step2::create_surface(&instance,ToSurfaceTarget(canvas)).map_err(|e|JsError::new(&e.to_string()))?;
 	let adapter=instance.request_adapter(&wgpu::RequestAdapterOptions{
 		power_preference:wgpu::PowerPreference::HighPerformance,
 		force_fallback_adapter:false,
 		compatible_surface:Some(&surface),
 	}).await.map_err(|e|JsError::new(&e.to_string()))?;
-	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).await.map_err(|e|JsError::new(&e.to_string()))?;
+	let (device,queue)=setup::step4::request_device(&adapter).await.map_err(|e|JsError::new(&e.to_string()))?;
 	let surface=setup::step5::configure_surface(&adapter,&device,surface,(size.x,size.y)).map_err(|e|JsError::new(&e.to_string()))?;
 	Ok(Graphics{
-		graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format(),LIMITS),
+		graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format()),
 		surface,
 		device,
 		queue,
@@ -59,7 +53,7 @@ impl Graphics{
 	pub fn render(&mut self,bot:&CompleteBot,head:&PlaybackHead,time:f64){
 		let time=time::from_float(time).unwrap();
 		let (pos,angles)=head.head.get_position_angles(&bot.bot,time);
-		let frame=self.surface.new_frame(&self.device).expect("Error creating new frame");
+		let frame=self.surface.new_frame(&self.device);
 		let mut encoder=self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 		self.graphics.encode_commands(&mut encoder,frame.view(),pos,angles);
 		self.queue.submit([encoder.finish()]);
@@ -72,9 +66,8 @@ impl Graphics{
 		self.graphics.resize(&self.device,size,[fov_slope_x as f32,fov_slope_y as f32].into());
 	}
 	#[wasm_bindgen]
-	pub fn change_map(&mut self,map:&CompleteMap)->Result<(),JsError>{
+	pub fn change_map(&mut self,map:&CompleteMap){
-		self.graphics.change_map(&self.device,&self.queue,&map.map).map_err(|e|JsError::new(&e.to_string()))?;
+		self.graphics.change_map(&self.device,&self.queue,&map.map);
-		Ok(())
 	}
 }
 
@@ -88,7 +81,7 @@ impl CompleteBot{
 	pub fn new(data:&[u8])->Result<Self,JsError>{
 		let timelines=v0::read_all_to_block(std::io::Cursor::new(data)).map_err(|e|JsError::new(&e.to_string()))?;
 		Ok(Self{
-			bot:bot::CompleteBot::new(timelines).map_err(|e|JsError::new(&e.to_string()))?,
+			bot:bot::CompleteBot::new(timelines),
 		})
 	}
 	#[wasm_bindgen]
@@ -96,9 +89,9 @@ impl CompleteBot{
 		self.bot.duration().into()
 	}
 	#[wasm_bindgen]
-	pub fn run_duration(&self,mode_id:u32)->Result<f64,JsError>{
+	pub fn run_duration(&self,mode_id:u32)->Option<f64>{
 		let mode=v0::ModeID(mode_id);
-		Ok(self.bot.run_duration(mode).map_err(|e|JsError::new(&e.to_string()))?.into())
+		Some(self.bot.run_duration(mode)?.into())
 	}
 }
 

web-demo/.gitattributes

@@ -0,0 +1,2 @@
+bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d.qbot filter=lfs diff=lfs merge=lfs -text
+bhop_marble_5692093612.snfm filter=lfs diff=lfs merge=lfs -text