whoops forgot file header

Cargo.lock

@@ -44,35 +44,12 @@ version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b236fc92302c97ed75b38da1f4917b5cdda4984745740f153a5d3059e48d725e"
 
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
 [[package]]
 name = "either"
 version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
-[[package]]
-name = "getrandom"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
 [[package]]
 name = "glam"
 version = "0.28.0"
@@ -90,27 +67,12 @@ dependencies = [
  "syn 2.0.72",
 ]
 
-[[package]]
-name = "libc"
-version = "0.2.155"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
-
 [[package]]
 name = "owo-colors"
 version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
 
-[[package]]
-name = "ppv-lite86"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee4364d9f3b902ef14fab8a1ddffb783a1cb6b4bba3bfc1fa3922732c7de97f"
-dependencies = [
- "zerocopy",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"
@@ -129,41 +91,11 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
 [[package]]
 name = "strafesnet_common"
-version = "0.2.0"
+version = "0.1.3"
 source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "74580c59a09194ce39db49cd814a5c2fc2d61513c88c6b811b5b40c0da6de057"
+checksum = "10a7e3b69506893bbdde90ce8a9d75cd56d280c0424d2dfdf98f8520179d0c1b"
 dependencies = [
  "bitflags",
  "glam",
@@ -172,11 +104,10 @@ dependencies = [
 
 [[package]]
 name = "strafesnet_snf"
-version = "0.1.1"
+version = "0.1.0"
 dependencies = [
  "binrw",
  "id",
- "rand",
  "strafesnet_common",
 ]
 
@@ -207,30 +138,3 @@ name = "unicode-ident"
 version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "zerocopy"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "854e949ac82d619ee9a14c66a1b674ac730422372ccb759ce0c39cabcf2bf8e6"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "125139de3f6b9d625c39e2efdd73d41bdac468ccd556556440e322be0e1bbd91"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.72",
-]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_snf"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,5 +8,4 @@ edition = "2021"
 [dependencies]
 binrw = "0.14.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-rand = "0.8.5"
+strafesnet_common = { version = "0.1.3", registry = "strafesnet" }
-strafesnet_common = { version = "0.2.0", registry = "strafesnet" }

src/bot.rs

@@ -1,9 +1,5 @@
-use std::io::Seek;
+use binrw::{BinReaderExt, binrw};
 
-use binrw::{binrw,BinReaderExt,BinWriterExt};
-use crate::newtypes::instruction::TimedPhysicsInstruction;
-
-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader,
 	InvalidSegment(binrw::Error),
@@ -11,46 +7,6 @@ pub enum Error{
 	File(crate::file::Error),
 }
 
-pub struct BotDebug{
-	name:String,
-	file:std::fs::File,
-}
-
-impl BotDebug{
-	pub fn new()->std::io::Result<Self>{
-		let rng:u128=rand::random();
-		let name=format!("debug_bots/{rng:x}");
-		Ok(Self{
-			file:std::fs::File::create(name.as_str())?,
-			name,
-		})
-	}
-	pub fn delete(self)->std::io::Result<()>{
-		std::mem::drop(self.file);
-		std::fs::remove_file(self.name)
-	}
-	pub fn push(&mut self,ins:strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>)->Result<(),binrw::Error>{
-		let ret=match TryInto::<TimedPhysicsInstruction>::try_into(ins){
-			Ok(ins)=>self.file.write_le(&ins),
-			Err(crate::newtypes::physics::PhysicsInputInstructionError::DropInstruction)=>Ok(()),
-		};
-		//check if too much data has written to be reasonable
-		//avoid filling my hard drive on an infinite loop basically
-		if self.file.stream_position().is_ok_and(|pos|50*1024*1024<pos){
-			panic!();
-		}
-		ret
-	}
-}
-
-pub fn read_bot_debug(mut reader:impl BinReaderExt)->Result<Vec<strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>>,binrw::Error>{
-	let mut instructions=Vec::new();
-	while let Ok(ins)=reader.read_le::<TimedPhysicsInstruction>(){
-		instructions.push(ins.try_into().unwrap());
-	}
-	Ok(instructions)
-}
-
 /* block types
 
 BLOCK_BOT_HEADER:
@@ -108,7 +64,7 @@ mod simulation{
 
 #[binrw]
 #[brw(little)]
-#[derive(Clone,Copy,Debug,id::Id)]
+#[derive(Clone,Copy,id::Id)]
 pub struct SegmentId(u32);
 
 #[binrw]

src/demo.rs

@@ -1,6 +1,5 @@
 use binrw::BinReaderExt;
 
-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader,
 }

src/file.rs

@@ -2,19 +2,12 @@
 
 use binrw::{binrw, BinReaderExt, io::TakeSeekExt};
 
-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader(binrw::Error),
 	UnexpectedEOF,
 	InvalidBlockId(BlockId),
 	Seek(std::io::Error),
 }
-impl std::fmt::Display for Error{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for Error{}
 
 /* spec
 
@@ -47,7 +40,7 @@ for block_id in 1..num_blocks{
 */
 #[binrw]
 #[brw(little)]
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy)]
 pub(crate) enum FourCC{
 	#[brw(magic=b"SNFM")]
 	Map,
@@ -58,7 +51,6 @@ pub(crate) enum FourCC{
 }
 #[binrw]
 #[brw(little)]
-#[derive(Debug)]
 pub struct Header{
 	/// Type of file
 	pub fourcc:FourCC,
@@ -76,7 +68,7 @@ pub struct Header{
 
 #[binrw]
 #[brw(little)]
-#[derive(Clone,Copy,Debug,Hash,id::Id,Eq,Ord,PartialEq,PartialOrd)]
+#[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct BlockId(u32);
 
 pub(crate) struct File<R:BinReaderExt>{

src/lib.rs

@@ -7,7 +7,6 @@ pub mod map;
 pub mod bot;
 pub mod demo;
 
-#[derive(Debug)]
 pub enum Error{
 	UnexpectedFourCC,
 	Header(file::Error),
@@ -15,12 +14,6 @@ pub enum Error{
 	Bot(bot::Error),
 	Demo(demo::Error),
 }
-impl std::fmt::Display for Error{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for Error{}
 
 pub enum SNF<R:BinReaderExt>{
 	Map(map::StreamableMap<R>),

src/map.rs

@@ -9,24 +9,15 @@ use strafesnet_common::aabb::Aabb;
 use strafesnet_common::bvh::BvhNode;
 use strafesnet_common::gameplay_modes;
 
-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader(binrw::Error),
-	InvalidMode(newtypes::gameplay_modes::ModeError),
 	InvalidBlockId(BlockId),
 	InvalidMeshId(model::MeshId),
-	InvalidModelId(model::ModelId),
 	InvalidTextureId(model::TextureId),
 	InvalidData(binrw::Error),
 	IO(std::io::Error),
 	File(crate::file::Error),
 }
-impl std::fmt::Display for Error{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for Error{}
 
 /* block types
 
@@ -146,7 +137,7 @@ struct ResourceExternalHeader{
 struct MapHeader{
 	num_spacial_blocks:u32,
 	num_resource_blocks:u32,
-	//num_resources_external:u32,
+	num_resources_external:u32,
 	num_modes:u32,
 	num_attributes:u32,
 	num_render_configs:u32,
@@ -154,8 +145,8 @@ struct MapHeader{
 	spacial_blocks:Vec<SpacialBlockHeader>,
 	#[br(count=num_resource_blocks)]
 	resource_blocks:Vec<ResourceBlockHeader>,
-	//#[br(count=num_resources_external)]
+	#[br(count=num_resources_external)]
-	//external_resources:Vec<ResourceExternalHeader>,
+	external_resources:Vec<ResourceExternalHeader>,
 	#[br(count=num_modes)]
 	modes:Vec<newtypes::gameplay_modes::Mode>,
 	#[br(count=num_attributes)]
@@ -170,20 +161,18 @@ struct Region{
 	//consider including a bvh in the region instead of needing to rebalance the physics bvh on the fly
 	model_count:u32,
 	#[br(count=model_count)]
-	models:Vec<(u32,newtypes::model::Model)>,
+	models:Vec<newtypes::model::Model>,
 }
 
 //code deduplication reused in into_complete_map
-fn read_region<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
+fn read_region<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<model::Model>,Error>{
 	//load region from disk
 	//parse the models and determine what resources need to be loaded
 	//load resources into self.resources
 	//return Region
 	let mut block=file.block_reader(block_id).map_err(Error::File)?;
 	let region:Region=block.read_le().map_err(Error::InvalidData)?;
-	Ok(region.models.into_iter().map(|(model_id,model)|
+	Ok(region.models.into_iter().map(Into::into).collect())
-		(model::ModelId::new(model_id),model.into())
-	).collect())
 }
 fn read_mesh<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<model::Mesh,Error>{
 	let mut block=file.block_reader(block_id).map_err(Error::File)?;
@@ -215,7 +204,7 @@ impl<R:BinReaderExt> StreamableMap<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 a map header
 		let header:MapHeader=file.as_mut().read_le().map_err(Error::InvalidHeader)?;
-		let modes=header.modes.into_iter().map(TryInto::try_into).collect::<Result<_,_>>().map_err(Error::InvalidMode)?;
+		let modes=header.modes.into_iter().map(Into::into).collect();
 		let attributes=header.attributes.into_iter().map(Into::into).collect();
 		let render_configs=header.render_configs.into_iter().map(Into::into).collect();
 		let bvh=header.spacial_blocks.into_iter().map(|spacial_block|
@@ -255,7 +244,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		self.bvh.the_tester(aabb,&mut |&block_id|block_ids.push(block_id));
 		block_ids
 	}
-	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
+	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<model::Model>,Error>{
 		read_region(&mut self.file,block_id)
 	}
 	pub fn load_mesh(&mut self,mesh_id:model::MeshId)->Result<model::Mesh,Error>{
@@ -267,33 +256,20 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		read_texture(&mut self.file,block_id)
 	}
 	pub fn into_complete_map(mut self)->Result<strafesnet_common::map::CompleteMap,Error>{
+		//load all meshes
+		let meshes=self.resource_blocks.meshes.into_values().map(|block_id|
+			read_mesh(&mut self.file,block_id)
+		).collect::<Result<Vec<_>,_>>()?;
+		//load all textures
+		let textures=self.resource_blocks.textures.into_values().map(|block_id|
+			read_texture(&mut self.file,block_id)
+		).collect::<Result<Vec<_>,_>>()?;
 		let mut block_ids=Vec::new();
 		self.bvh.into_visitor(&mut |block_id|block_ids.push(block_id));
-		//count on reading the file in sequential order being fastest
-		block_ids.sort_unstable();
 		//load all regions
-		let mut model_pairs=HashMap::new();
+		let mut models=Vec::new();
 		for block_id in block_ids{
-			model_pairs.extend(read_region(&mut self.file,block_id)?);
+			models.append(&mut read_region(&mut self.file,block_id)?);
-		}
-		let mut models=Vec::with_capacity(model_pairs.len());
-		for model_id in 0..model_pairs.len() as u32{
-			let model_id=model::ModelId::new(model_id);
-			models.push(model_pairs.remove(&model_id).ok_or(Error::InvalidModelId(model_id))?);
-		}
-		//load all meshes
-		let mut meshes=Vec::with_capacity(self.resource_blocks.meshes.len());
-		for mesh_id in 0..self.resource_blocks.meshes.len() as u32{
-			let mesh_id=model::MeshId::new(mesh_id);
-			let block_id=self.resource_blocks.meshes[&mesh_id];
-			meshes.push(read_mesh(&mut self.file,block_id)?);
-		};
-		//load all textures
-		let mut textures=Vec::with_capacity(self.resource_blocks.textures.len());
-		for texture_id in 0..self.resource_blocks.textures.len() as u32{
-			let texture_id=model::TextureId::new(texture_id);
-			let block_id=self.resource_blocks.textures[&texture_id];
-			textures.push(read_texture(&mut self.file,block_id)?);
 		}
 		Ok(strafesnet_common::map::CompleteMap{
 			modes:self.modes,
@@ -311,7 +287,7 @@ fn collect_spacial_blocks(
 	block_location:&mut Vec<u64>,
 	block_headers:&mut Vec<SpacialBlockHeader>,
 	sequential_block_data:&mut std::io::Cursor<&mut Vec<u8>>,
-	bvh_node:strafesnet_common::bvh::BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
+	bvh_node:strafesnet_common::bvh::BvhWeightNode<usize,newtypes::model::Model>
 )->Result<(),Error>{
 	//inspect the node weights top-down.
 	//When a node weighs less than the limit,
@@ -320,11 +296,11 @@ fn collect_spacial_blocks(
 		let mut models=Vec::new();
 		let mut model_count=0;
 		let extents=bvh_node.aabb().clone().into();
-		bvh_node.into_visitor(&mut |(model_id,model)|{
+		bvh_node.into_visitor(&mut |model|{
 			model_count+=1;
-			models.push((model_id.get(),model));
+			models.push(model);
 		});
-		let id=BlockId::new(block_headers.len() as u32+1);
+		let id=BlockId::new(block_headers.len() as u32);
 		block_headers.push(SpacialBlockHeader{
 			id,
 			extents,
@@ -352,28 +328,23 @@ fn collect_spacial_blocks(
 /// otherwise sort by distance to start zone
 pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::CompleteMap)->Result<(),Error>{
 	//serialize models and make a bvh that knows the file size of the branch
-	let boxen=map.models.into_iter().enumerate().map(|(model_id,model)|{
+	let boxen=map.models.into_iter().map(|model|{
 		//grow your own aabb
 		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
 		let mut aabb=strafesnet_common::aabb::Aabb::default();
 		for &pos in &mesh.unique_pos{
 			aabb.grow(model.transform.transform_point3(pos));
 		}
-		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
+		Ok((model.into(),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
 	let bvh=strafesnet_common::bvh::generate_bvh(boxen).weigh_contents(&|_|std::mem::size_of::<newtypes::model::Model>());
 	//build blocks
-	//block location is initialized with two values
+	let mut block_location=vec![0];//for file header
-	//the first value represents the location of the first byte after the file header
-	//the second value represents the first byte of the second data block
-	//the first data block is always the map header, so the difference is the map header size.
-	//this information is filled in later after the sizes are known.
-	let mut block_location=vec![0,0];//for file header
 	let mut spacial_blocks=Vec::new();//for map header
 	let mut sequential_block_data=Vec::new();
 	let mut cursor_to_data=std::io::Cursor::new(&mut sequential_block_data);
 	collect_spacial_blocks(&mut block_location,&mut spacial_blocks,&mut cursor_to_data,bvh)?;
-	let mut block_count=spacial_blocks.len() as u32+1;//continue block id
+	let mut block_count=spacial_blocks.len() as u32;//continue block id
 	let mut resource_blocks=Vec::new();//for map header
 	//meshes
 	for mesh in map.meshes.into_iter(){
@@ -400,13 +371,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 	let map_header=MapHeader{
 		num_spacial_blocks:spacial_blocks.len() as u32,
 		num_resource_blocks:resource_blocks.len() as u32,
-		//num_resources_external:0,
+		num_resources_external:0,
 		num_modes:map.modes.modes.len() as u32,
 		num_attributes:map.attributes.len() as u32,
 		num_render_configs:map.render_configs.len() as u32,
 		spacial_blocks,
 		resource_blocks,
-		//external_resources:Vec::new(),
+		external_resources:Vec::new(),
 		modes:map.modes.modes.into_iter().map(Into::into).collect(),
 		attributes:map.attributes.into_iter().map(Into::into).collect(),
 		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
@@ -414,27 +385,25 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 	let mut file_header=crate::file::Header{
 		fourcc:crate::file::FourCC::Map,
 		version:0,
-		priming:0,
+		priming:0,//TODO
 		resource:0,
 		block_count,
 		block_location,
 	};
-	//probe header length
+	//probe header lengths
 	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;
+	let offset=file_header_data.len() as u64+map_header_data.len() as u64;
 	file_header.priming=offset;
-	file_header.block_location[0]=offset;
+	for position in &mut file_header.block_location{
-	offset+=map_header_data.len() as u64;
-	for position in &mut file_header.block_location[1..]{
 		*position+=offset;
 	}
 
-	//write (updated) file header
+	//write file header
 	writer.write_le(&file_header).map_err(Error::InvalidData)?;
 	//write map header
 	writer.write(&map_header_data).map_err(Error::IO)?;

src/newtypes.rs

@@ -1,10 +1,6 @@
-mod common;
 pub mod aabb;
 pub mod model;
-pub mod mouse;
 pub mod integer;
-pub mod physics;
-pub mod instruction;
 pub mod gameplay_modes;
 pub mod gameplay_style;
 pub mod gameplay_attributes;

src/newtypes/common.rs

@@ -1,26 +0,0 @@
-pub const fn flag(b:bool,mask:u8)->u8{
-	(-(b as i8) as u8)&mask
-}
-
-#[binrw::binrw]
-#[brw(little,repr=u8)]
-pub enum Boolio{
-	True,
-	False
-}
-impl Into<bool> for Boolio{
-	fn into(self)->bool{
-		match self{
-			Boolio::True=>true,
-			Boolio::False=>false,
-		}
-	}
-}
-impl From<bool> for Boolio{
-	fn from(value:bool)->Self{
-		match value{
-			true=>Boolio::True,
-			false=>Boolio::False,
-		}
-	}
-}

src/newtypes/gameplay_attributes.rs

@@ -1,22 +1,24 @@
-use super::common::{flag,Boolio};
 use super::integer::{Time,Planar64,Planar64Vec3};
 
 #[binrw::binrw]
 #[brw(little)]
 pub struct ContactingLadder{
-	pub sticky:Boolio,
+	pub sticky:Option<()>,
 }
 impl Into<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
 	fn into(self)->strafesnet_common::gameplay_attributes::ContactingLadder{
 		strafesnet_common::gameplay_attributes::ContactingLadder{
-			sticky:self.sticky.into(),
+			sticky:self.sticky.is_some(),
 		}
 	}
 }
 impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
 	fn from(value:strafesnet_common::gameplay_attributes::ContactingLadder)->Self{
 		Self{
-			sticky:value.sticky.into(),
+			sticky:match value.sticky{
+				true=>Some(()),
+				false=>None,
+			}
 		}
 	}
 }
@@ -24,15 +26,10 @@ impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for Contacti
 #[binrw::binrw]
 #[brw(little)]
 pub enum ContactingBehaviour{
-	#[brw(magic=0u8)]
 	Surf,
-	#[brw(magic=1u8)]
 	Ladder(ContactingLadder),
-	#[brw(magic=2u8)]
 	NoJump,
-	#[brw(magic=3u8)]
 	Cling,
-	#[brw(magic=4u8)]
 	Elastic(u32),
 }
 impl Into<strafesnet_common::gameplay_attributes::ContactingBehaviour> for ContactingBehaviour{
@@ -121,9 +118,7 @@ impl From<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
 #[binrw::binrw]
 #[brw(little)]
 pub enum Booster{
-	#[brw(magic=0u8)]
 	Velocity(Planar64Vec3),
-	#[brw(magic=1u8)]
 	Energy{direction:Planar64Vec3,energy:Planar64},
 }
 impl Into<strafesnet_common::gameplay_attributes::Booster> for Booster{
@@ -185,24 +180,18 @@ impl From<strafesnet_common::gameplay_attributes::TrajectoryChoice> for Trajecto
 #[binrw::binrw]
 #[brw(little)]
 pub enum SetTrajectory{
-	#[brw(magic=0u8)]
 	AirTime(Time),
-	#[brw(magic=1u8)]
 	Height(Planar64),
-	#[brw(magic=2u8)]
 	DotVelocity{direction:Planar64Vec3,dot:Planar64},
-	#[brw(magic=3u8)]
 	TargetPointTime{
 		target_point:Planar64Vec3,
 		time:Time,
 	},
-	#[brw(magic=4u8)]
 	TargetPointSpeed{
 		target_point:Planar64Vec3,
 		speed:Planar64,
 		trajectory_choice:TrajectoryChoice,
 	},
-	#[brw(magic=5u8)]
 	Velocity(Planar64Vec3),
 }
 impl Into<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajectory{
@@ -297,22 +286,11 @@ impl From<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
 #[binrw::binrw]
 #[brw(little)]
 pub struct GeneralAttributes{
-	pub header:u8,
-	#[br(if(header&Self::BOOSTER!=0))]
 	pub booster:Option<Booster>,
-	#[br(if(header&Self::TRAJECTORY!=0))]
 	pub trajectory:Option<SetTrajectory>,
-	#[br(if(header&Self::WORMHOLE!=0))]
 	pub wormhole:Option<Wormhole>,
-	#[br(if(header&Self::ACCELERATOR!=0))]
 	pub accelerator:Option<Accelerator>,
 }
-impl GeneralAttributes{
-	const BOOSTER:u8=1<<0;
-	const TRAJECTORY:u8=1<<1;
-	const WORMHOLE:u8=1<<2;
-	const ACCELERATOR:u8=1<<3;
-}
 impl Into<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
 	fn into(self)->strafesnet_common::gameplay_attributes::GeneralAttributes{
 		strafesnet_common::gameplay_attributes::GeneralAttributes{
@@ -325,13 +303,7 @@ impl Into<strafesnet_common::gameplay_attributes::GeneralAttributes> for General
 }
 impl From<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::GeneralAttributes)->Self{
-		let header=
-		flag(value.booster.is_some(),GeneralAttributes::BOOSTER)
-		|flag(value.trajectory.is_some(),GeneralAttributes::TRAJECTORY)
-		|flag(value.wormhole.is_some(),GeneralAttributes::WORMHOLE)
-		|flag(value.accelerator.is_some(),GeneralAttributes::ACCELERATOR);
 		Self{
-			header,
 			booster:value.booster.map(Into::into),
 			trajectory:value.trajectory.map(Into::into),
 			wormhole:value.wormhole.map(Into::into),
@@ -343,13 +315,8 @@ impl From<strafesnet_common::gameplay_attributes::GeneralAttributes> for General
 #[binrw::binrw]
 #[brw(little)]
 pub struct ContactingAttributes{
-	pub header:u8,
-	#[br(if(header&Self::CONTACTING_BEHAVIOUR!=0))]
 	pub contact_behaviour:Option<ContactingBehaviour>,
 }
-impl ContactingAttributes{
-	const CONTACTING_BEHAVIOUR:u8=1<<0;
-}
 impl Into<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
 	fn into(self)->strafesnet_common::gameplay_attributes::ContactingAttributes{
 		strafesnet_common::gameplay_attributes::ContactingAttributes{
@@ -360,7 +327,6 @@ impl Into<strafesnet_common::gameplay_attributes::ContactingAttributes> for Cont
 impl From<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::ContactingAttributes)->Self{
 		Self{
-			header:flag(value.contact_behaviour.is_some(),ContactingAttributes::CONTACTING_BEHAVIOUR),
 			contact_behaviour:value.contact_behaviour.map(Into::into),
 		}
 	}
@@ -369,13 +335,8 @@ impl From<strafesnet_common::gameplay_attributes::ContactingAttributes> for Cont
 #[binrw::binrw]
 #[brw(little)]
 pub struct IntersectingAttributes{
-	pub header:u8,
-	#[br(if(header&Self::INTERSECTING_WATER!=0))]
 	pub water:Option<IntersectingWater>,
 }
-impl IntersectingAttributes{
-	const INTERSECTING_WATER:u8=1<<0;
-}
 impl Into<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
 	fn into(self)->strafesnet_common::gameplay_attributes::IntersectingAttributes{
 		strafesnet_common::gameplay_attributes::IntersectingAttributes{
@@ -386,7 +347,6 @@ impl Into<strafesnet_common::gameplay_attributes::IntersectingAttributes> for In
 impl From<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::IntersectingAttributes)->Self{
 		Self{
-			header:flag(value.water.is_some(),IntersectingAttributes::INTERSECTING_WATER),
 			water:value.water.map(Into::into),
 		}
 	}
@@ -395,14 +355,11 @@ impl From<strafesnet_common::gameplay_attributes::IntersectingAttributes> for In
 #[binrw::binrw]
 #[brw(little)]
 pub enum CollisionAttributes{
-	#[brw(magic=0u8)]
 	Decoration,
-	#[brw(magic=1u8)]
 	Contact{
 		contacting:ContactingAttributes,
 		general:GeneralAttributes,
 	},
-	#[brw(magic=2u8)]
 	Intersect{
 		intersecting:IntersectingAttributes,
 		general:GeneralAttributes,

src/newtypes/gameplay_modes.rs

@@ -1,74 +1,65 @@
-use super::common::flag;
+#[binrw::binrw]
-
+#[brw(little,repr=u8)]
-pub type ModeId=u32;
+pub enum StageElementBehaviour{
-pub type StageId=u32;
+	SpawnAt,//must be standing on top to get effect. except cancollide false
+	Trigger,
+	Teleport,
+	Platform,
+	//Check(point) acts like a trigger if you haven't hit all the checkpoints on previous stages yet.
+	//Note that all stage elements act like this, this is just the isolated behaviour.
+	Check,
+	Checkpoint,//this is a combined behaviour for Ordered & Unordered in case a model is used multiple times or for both.
+}
+impl Into<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageElementBehaviour{
+	fn into(self)->strafesnet_common::gameplay_modes::StageElementBehaviour{
+		match self{
+			StageElementBehaviour::SpawnAt=>strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt,
+			StageElementBehaviour::Trigger=>strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger,
+			StageElementBehaviour::Teleport=>strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport,
+			StageElementBehaviour::Platform=>strafesnet_common::gameplay_modes::StageElementBehaviour::Platform,
+			StageElementBehaviour::Check=>strafesnet_common::gameplay_modes::StageElementBehaviour::Check,
+			StageElementBehaviour::Checkpoint=>strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint,
+		}
+	}
+}
+impl From<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageElementBehaviour{
+	fn from(value:strafesnet_common::gameplay_modes::StageElementBehaviour)->Self{
+		match value{
+			strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt=>StageElementBehaviour::SpawnAt,
+			strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger=>StageElementBehaviour::Trigger,
+			strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport=>StageElementBehaviour::Teleport,
+			strafesnet_common::gameplay_modes::StageElementBehaviour::Platform=>StageElementBehaviour::Platform,
+			strafesnet_common::gameplay_modes::StageElementBehaviour::Check=>StageElementBehaviour::Check,
+			strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint=>StageElementBehaviour::Checkpoint,
+		}
+	}
+}
 
 #[binrw::binrw]
 #[brw(little)]
 pub struct StageElement{
-	pub header:u8,
+	pub stage_id:u32,//which stage spawn to send to
-	pub stage_id:StageId,
+	pub behaviour:StageElementBehaviour,
-	#[br(if(header&Self::JUMP_LIMIT!=0))]
 	pub jump_limit:Option<u8>,
+	pub force:Option<()>,//allow setting to lower spawn id i.e. 7->3
 }
-impl StageElement{
+impl Into<strafesnet_common::gameplay_modes::StageElement> for StageElement{
-	const BEHAVIOUR:u8=0b00111;
+	fn into(self)->strafesnet_common::gameplay_modes::StageElement{
-	const JUMP_LIMIT:u8=1<<3;
+		strafesnet_common::gameplay_modes::StageElement::new(
-	const FORCE:u8=1<<4;
-	const fn behaviour(&self)->Option<strafesnet_common::gameplay_modes::StageElementBehaviour>{
-		match self.header&Self::BEHAVIOUR{
-			0=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt),
-			1=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger),
-			2=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport),
-			3=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Platform),
-			4=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Check),
-			5=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint),
-			_=>None,
-		}
-	}
-	const fn force(&self)->bool{
-		self.header&Self::FORCE!=0
-	}
-}
-#[derive(Debug)]
-pub enum StageElementError{
-	InvalidBehaviour,
-}
-impl std::fmt::Display for StageElementError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for StageElementError{}
-impl TryInto<strafesnet_common::gameplay_modes::StageElement> for StageElement{
-	type Error=StageElementError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_modes::StageElement,Self::Error>{
-		Ok(strafesnet_common::gameplay_modes::StageElement::new(
 			strafesnet_common::gameplay_modes::StageId::new(self.stage_id),
-			self.force(),
+			self.force.is_some(),
-			self.behaviour().ok_or(StageElementError::InvalidBehaviour)?,
+			self.behaviour.into(),
 			self.jump_limit,
-		))
+		)
 	}
 }
 impl From<strafesnet_common::gameplay_modes::StageElement> for StageElement{
 	fn from(value:strafesnet_common::gameplay_modes::StageElement)->Self{
-		let behaviour=match value.behaviour(){
-			strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt=>0,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger=>1,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport=>2,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Platform=>3,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Check=>4,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint=>5,
-		};
-		let header=
-			behaviour
-			|flag(value.jump_limit().is_some(),StageElement::JUMP_LIMIT)
-			|flag(value.force(),StageElement::FORCE);
 		Self{
-			header,
 			stage_id:value.stage_id().get(),
+			behaviour:value.behaviour().into(),
 			jump_limit:value.jump_limit(),
+			force:match value.force(){true=>Some(()),false=>None},
 		}
 	}
 }
@@ -168,31 +159,19 @@ pub struct Mode{
 	#[br(count=header.elements)]
 	pub elements:Vec<(u32,StageElement)>,
 }
-#[derive(Debug)]
+impl Into<strafesnet_common::gameplay_modes::Mode> for Mode{
-pub enum ModeError{
+	fn into(self)->strafesnet_common::gameplay_modes::Mode{
-	StyleModifier(super::gameplay_style::StyleModifierError),
+		strafesnet_common::gameplay_modes::Mode::new(
-	StageElement(StageElementError),
+			self.style.into(),
-}
-impl std::fmt::Display for ModeError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ModeError{}
-impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
-	type Error=ModeError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_modes::Mode,Self::Error>{
-		Ok(strafesnet_common::gameplay_modes::Mode::new(
-			self.style.try_into().map_err(ModeError::StyleModifier)?,
 			strafesnet_common::model::ModelId::new(self.start),
 			self.zones.into_iter().map(|(model_id,zone)|
 				(strafesnet_common::model::ModelId::new(model_id),zone.into())
 			).collect(),
 			self.stages.into_iter().map(Into::into).collect(),
 			self.elements.into_iter().map(|(model_id,stage_element)|
-				Ok((strafesnet_common::model::ModelId::new(model_id),stage_element.try_into()?))
+				(strafesnet_common::model::ModelId::new(model_id),stage_element.into())
-			).collect::<Result<_,_>>().map_err(ModeError::StageElement)?,
+			).collect(),
-		))
+		)
 	}
 }
 impl From<strafesnet_common::gameplay_modes::Mode> for Mode{

src/newtypes/gameplay_style.rs

@@ -1,70 +1,32 @@
-use super::common::flag;
 use super::integer::{Time,Ratio64,Planar64,Planar64Vec3};
 
 pub type Controls=u32;
-#[derive(Debug)]
-pub enum ControlsError{
-	UnknownBits,
-}
-impl std::fmt::Display for ControlsError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ControlsError{}
 
 #[binrw::binrw]
 #[brw(little)]
 pub struct StyleModifiers{
-	pub header:u8,
 	pub controls_mask:Controls,
 	pub controls_mask_state:Controls,
-	#[br(if(header&Self::STRAFE!=0))]
 	pub strafe:Option<StrafeSettings>,
-	#[br(if(header&Self::ROCKET!=0))]
 	pub rocket:Option<PropulsionSettings>,
-	#[br(if(header&Self::JUMP!=0))]
 	pub jump:Option<JumpSettings>,
-	#[br(if(header&Self::WALK!=0))]
 	pub walk:Option<WalkSettings>,
-	#[br(if(header&Self::LADDER!=0))]
 	pub ladder:Option<LadderSettings>,
-	#[br(if(header&Self::SWIM!=0))]
 	pub swim:Option<PropulsionSettings>,
 	pub gravity:Planar64Vec3,
 	pub hitbox:Hitbox,
 	pub camera_offset:Planar64Vec3,
 	pub mass:Planar64,
 }
-impl StyleModifiers{
+impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
-	const STRAFE:u8=1<<0;
+	fn into(self)->strafesnet_common::gameplay_style::StyleModifiers{
-	const ROCKET:u8=1<<1;
+		strafesnet_common::gameplay_style::StyleModifiers{
-	const JUMP:u8=1<<2;
+			//TODO: fail gracefully in binrw instead of panicing here
-	const WALK:u8=1<<3;
+			controls_mask:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).unwrap(),
-	const LADDER:u8=1<<4;
+			controls_mask_state:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask_state).unwrap(),
-	const SWIM:u8=1<<5;
+			strafe:self.strafe.map(Into::into),
-}
-#[derive(Debug)]
-pub enum StyleModifierError{
-	Controls(ControlsError),
-	JumpSettings(JumpSettingsError),
-	StrafeSettings(StrafeSettingsError),
-}
-impl std::fmt::Display for StyleModifierError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for StyleModifierError{}
-impl TryInto<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
-	type Error=StyleModifierError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_style::StyleModifiers,Self::Error>{
-		Ok(strafesnet_common::gameplay_style::StyleModifiers{
-			controls_mask:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).ok_or(StyleModifierError::Controls(ControlsError::UnknownBits))?,
-			controls_mask_state:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask_state).ok_or(StyleModifierError::Controls(ControlsError::UnknownBits))?,
-			strafe:self.strafe.map(TryInto::try_into).transpose().map_err(StyleModifierError::StrafeSettings)?,
 			rocket:self.rocket.map(Into::into),
-			jump:self.jump.map(TryInto::try_into).transpose().map_err(StyleModifierError::JumpSettings)?,
+			jump:self.jump.map(Into::into),
 			walk:self.walk.map(Into::into),
 			ladder:self.ladder.map(Into::into),
 			swim:self.swim.map(Into::into),
@@ -72,20 +34,12 @@ impl TryInto<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifie
 			hitbox:self.hitbox.into(),
 			camera_offset:strafesnet_common::integer::Planar64Vec3::raw_array(self.camera_offset),
 			mass:strafesnet_common::integer::Planar64::raw(self.mass),
-		})
+		}
 	}
 }
 impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 	fn from(value:strafesnet_common::gameplay_style::StyleModifiers)->Self{
-		let header=
-			flag(value.strafe.is_some(),StyleModifiers::STRAFE)
-			|flag(value.rocket.is_some(),StyleModifiers::ROCKET)
-			|flag(value.jump.is_some(),StyleModifiers::JUMP)
-			|flag(value.walk.is_some(),StyleModifiers::WALK)
-			|flag(value.ladder.is_some(),StyleModifiers::LADDER)
-			|flag(value.swim.is_some(),StyleModifiers::SWIM);
 		Self{
-			header,
 			controls_mask:value.controls_mask.bits(),
 			controls_mask_state:value.controls_mask_state.bits(),
 			strafe:value.strafe.map(Into::into),
@@ -128,6 +82,8 @@ impl From<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculatio
 	}
 }
 
+#[binrw::binrw]
+#[brw(little)]
 pub enum JumpImpulse{
 	FromTime(Time),
 	FromHeight(Planar64),
@@ -162,14 +118,13 @@ pub struct ControlsActivation{
 	controls_intersects:Controls,
 	controls_contains:Controls,
 }
-impl TryInto<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
+impl Into<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
-	type Error=ControlsError;
+	fn into(self)->strafesnet_common::gameplay_style::ControlsActivation{
-	fn try_into(self)->Result<strafesnet_common::gameplay_style::ControlsActivation,Self::Error>{
+		strafesnet_common::gameplay_style::ControlsActivation::new(
-		Ok(strafesnet_common::gameplay_style::ControlsActivation::new(
+			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).unwrap(),
-			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).ok_or(ControlsError::UnknownBits)?,
+			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_intersects).unwrap(),
-			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_intersects).ok_or(ControlsError::UnknownBits)?,
+			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_contains).unwrap(),
-			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_contains).ok_or(ControlsError::UnknownBits)?,
+		)
-		))
 	}
 }
 impl From<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
@@ -185,44 +140,25 @@ impl From<strafesnet_common::gameplay_style::ControlsActivation> for ControlsAct
 #[binrw::binrw]
 #[brw(little)]
 pub struct StrafeSettings{
-	header:u8,
 	enable:ControlsActivation,
 	mv:Planar64,
-	#[br(if(header&Self::AIR_ACCEL_LIMIT!=0))]
 	air_accel_limit:Option<Planar64>,
 	tick_rate:Ratio64,
 }
-impl StrafeSettings{
+impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
-	const AIR_ACCEL_LIMIT:u8=1<<0;
+	fn into(self)->strafesnet_common::gameplay_style::StrafeSettings{
-}
+		strafesnet_common::gameplay_style::StrafeSettings::new(
-#[derive(Debug)]
+			self.enable.into(),
-pub enum StrafeSettingsError{
-	Ratio(super::integer::RatioError),
-	Controls(ControlsError),
-}
-impl std::fmt::Display for StrafeSettingsError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for StrafeSettingsError{}
-impl TryInto<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
-	type Error=StrafeSettingsError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_style::StrafeSettings,Self::Error>{
-		Ok(strafesnet_common::gameplay_style::StrafeSettings::new(
-			self.enable.try_into().map_err(StrafeSettingsError::Controls)?,
 			strafesnet_common::integer::Planar64::raw(self.mv),
 			self.air_accel_limit.map(strafesnet_common::integer::Planar64::raw),
-			self.tick_rate.try_into().map_err(StrafeSettingsError::Ratio)?,
+			self.tick_rate.into(),
-		))
+		)
 	}
 }
 impl From<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
 	fn from(value:strafesnet_common::gameplay_style::StrafeSettings)->Self{
 		let (enable,mv,air_accel_limit,tick_rate)=value.into_inner();
-		let header=flag(air_accel_limit.is_some(),StrafeSettings::AIR_ACCEL_LIMIT);
 		Self{
-			header,
 			enable:enable.into(),
 			mv:mv.get(),
 			air_accel_limit:air_accel_limit.map(|a|a.get()),
@@ -254,64 +190,23 @@ impl From<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionS
 #[binrw::binrw]
 #[brw(little)]
 pub struct JumpSettings{
-	header:u8,
+	impulse:JumpImpulse,
-	impulse:i64,
+	calculation:JumpCalculation,
 }
-impl JumpSettings{
+impl Into<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
-	const IMPULSE:u8=0b0011;
+	fn into(self)->strafesnet_common::gameplay_style::JumpSettings{
-	const CALCULATION:u8=0b1100;
+		strafesnet_common::gameplay_style::JumpSettings::new(
-	const fn impulse(&self)->Option<strafesnet_common::gameplay_style::JumpImpulse>{
+			self.impulse.into(),
-		match self.header&Self::IMPULSE{
+			self.calculation.into(),
-			0=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromTime(strafesnet_common::integer::Time::raw(self.impulse))),
+		)
-			1=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromHeight(strafesnet_common::integer::Planar64::raw(self.impulse))),
-			2=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(strafesnet_common::integer::Planar64::raw(self.impulse))),
-			3=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(strafesnet_common::integer::Planar64::raw(self.impulse))),
-			_=>None,
-		}
-	}
-	const fn calculation(&self)->Option<strafesnet_common::gameplay_style::JumpCalculation>{
-		match (self.header&Self::CALCULATION)>>2{
-			0=>Some(strafesnet_common::gameplay_style::JumpCalculation::Capped),
-			1=>Some(strafesnet_common::gameplay_style::JumpCalculation::Energy),
-			2=>Some(strafesnet_common::gameplay_style::JumpCalculation::Linear),
-			_=>None,
-		}
-	}
-}
-#[derive(Debug)]
-pub enum JumpSettingsError{
-	InvalidImpulseDiscriminant,
-	InvalidCalculationDiscriminant,
-}
-impl TryInto<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
-	type Error=JumpSettingsError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_style::JumpSettings,Self::Error>{
-		Ok(strafesnet_common::gameplay_style::JumpSettings::new(
-			self.impulse().ok_or(JumpSettingsError::InvalidImpulseDiscriminant)?,
-			self.calculation().ok_or(JumpSettingsError::InvalidCalculationDiscriminant)?,
-		))
 	}
 }
 impl From<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
 	fn from(value:strafesnet_common::gameplay_style::JumpSettings)->Self{
-		let (impulse_enum,calculation)=value.into_inner();
+		let (impulse,calculation)=value.into_inner();
-		let (impulse,impulse_header)=match impulse_enum{
-			strafesnet_common::gameplay_style::JumpImpulse::FromTime(impulse)=>(impulse.get(),0),
-			strafesnet_common::gameplay_style::JumpImpulse::FromHeight(impulse)=>(impulse.get(),1),
-			strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(impulse)=>(impulse.get(),2),
-			strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(impulse)=>(impulse.get(),3),
-		};
-		let calculation_header=match calculation{
-			strafesnet_common::gameplay_style::JumpCalculation::Capped=>0,
-			strafesnet_common::gameplay_style::JumpCalculation::Energy=>1,
-			strafesnet_common::gameplay_style::JumpCalculation::Linear=>2,
-		};
-		let header=
-			impulse_header
-			|(calculation_header<<2);
 		Self{
-			header,
+			impulse:impulse.into(),
-			impulse,
+			calculation:calculation.into(),
 		}
 	}
 }

src/newtypes/instruction.rs

@@ -1,27 +0,0 @@
-use super::integer::Time;
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct TimedPhysicsInstruction{
-	pub time:Time,
-	pub instruction:super::physics::PhysicsInputInstruction,
-}
-
-impl TryInto<strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>> for TimedPhysicsInstruction{
-	type Error=super::integer::RatioError;
-	fn try_into(self)->Result<strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>,Self::Error>{
-		Ok(strafesnet_common::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::raw(self.time),
-			instruction:self.instruction.try_into()?,
-		})
-	}
-}
-impl TryFrom<strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>> for TimedPhysicsInstruction{
-	type Error=super::physics::PhysicsInputInstructionError;
-	fn try_from(value:strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction>)->Result<Self,Self::Error>{
-		Ok(Self{
-			time:value.time.get(),
-			instruction:value.instruction.try_into()?,
-		})
-	}
-}

src/newtypes/integer.rs

@@ -6,21 +6,9 @@ pub struct Ratio64{
 	num:i64,
 	den:u64,
 }
-#[derive(Debug)]
+impl Into<strafesnet_common::integer::Ratio64> for Ratio64{
-pub enum RatioError{
+	fn into(self)->strafesnet_common::integer::Ratio64{
-	ZeroDenominator,
+		strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap()
-}
-impl std::fmt::Display for RatioError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for RatioError{}
-impl TryInto<strafesnet_common::integer::Ratio64> for Ratio64{
-	type Error=RatioError;
-	fn try_into(self)->Result<strafesnet_common::integer::Ratio64,Self::Error>{
-		strafesnet_common::integer::Ratio64::new(self.num,self.den)
-		.ok_or(RatioError::ZeroDenominator)
 	}
 }
 impl From<strafesnet_common::integer::Ratio64> for Ratio64{
@@ -38,23 +26,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;

src/newtypes/model.rs

@@ -1,4 +1,3 @@
-use super::common::flag;
 use strafesnet_common::model::PolygonIter;
 
 use super::integer::{Planar64Vec3,Planar64Affine3};
@@ -61,13 +60,8 @@ impl From<strafesnet_common::model::PolygonGroup> for PolygonGroup{
 #[binrw::binrw]
 #[brw(little)]
 pub struct RenderConfig{
-	pub header:u8,
-	#[br(if(header&Self::TEXTURE!=0))]
 	pub texture:Option<u32>,
 }
-impl RenderConfig{
-	const TEXTURE:u8=1<<0;
-}
 impl Into<strafesnet_common::model::RenderConfig> for RenderConfig{
 	fn into(self)->strafesnet_common::model::RenderConfig{
 		strafesnet_common::model::RenderConfig{
@@ -77,9 +71,7 @@ impl Into<strafesnet_common::model::RenderConfig> for RenderConfig{
 }
 impl From<strafesnet_common::model::RenderConfig> for RenderConfig{
 	fn from(value:strafesnet_common::model::RenderConfig)->Self{
-		let header=flag(value.texture.is_some(),RenderConfig::TEXTURE);
 		Self{
-			header,
 			texture:value.texture.map(|texture_id|texture_id.get()),
 		}
 	}

src/newtypes/mouse.rs

@@ -1,37 +0,0 @@
-use super::integer::Time;
-
-#[binrw::binrw]
-#[brw(little)]
-pub enum EncodedMouseDelta{
-	//X did not move Y has 1 byte, time has 2 bytes
-	X0Y1T2{
-		y:i8,
-		t:u16,
-	},
-	X1Y1T2
-}
-///TODO: delta delta encoding lol
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct MouseState{
-	pub pos:[i32;2],
-	pub time:Time,
-}
-
-impl Into<strafesnet_common::mouse::MouseState> for MouseState{
-	fn into(self)->strafesnet_common::mouse::MouseState{
-		strafesnet_common::mouse::MouseState{
-			pos:self.pos.into(),
-			time:strafesnet_common::integer::Time::raw(self.time),
-		}
-	}
-}
-impl From<strafesnet_common::mouse::MouseState> for MouseState{
-	fn from(value:strafesnet_common::mouse::MouseState)->Self{
-		Self{
-			pos:value.pos.to_array(),
-			time:value.time.get(),
-		}
-	}
-}

src/newtypes/physics.rs

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