newtypes

don't allocate models twice
complete map loader
2024-07-25 10:42:03 -07:00 · 2024-07-24 14:39:21 -07:00 · 2024-07-24 14:39:21 -07:00 · 2024-07-24 14:39:21 -07:00 · 2024-07-24 14:39:21 -07:00 · 2024-07-24 12:00:24 -07:00
15 changed files with 184 additions and 1152 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -8,12 +8,6 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"

-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
 [[package]]
 name = "binrw"
 version = "0.14.0"
@ -44,17 +38,11 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

-[[package]]
-name = "bnum"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50202def95bf36cb7d1d7a7962cea1c36a3f8ad42425e5d2b71d7acb8041b5b8"
-
 [[package]]
 name = "bytemuck"
-version = "1.16.3"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "102087e286b4677862ea56cf8fc58bb2cdfa8725c40ffb80fe3a008eb7f2fc83"
+checksum = "b236fc92302c97ed75b38da1f4917b5cdda4984745740f153a5d3059e48d725e"

 [[package]]
 name = "either"
@ -62,18 +50,6 @@ version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"

-[[package]]
-name = "fixed_wide"
-version = "0.1.0"
-source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "7a8d6e10c51c9df39ead915c62288afbc41d13e00368e526037e530ee5c58e13"
-dependencies = [
- "arrayvec",
- "bnum",
- "paste",
- "ratio_ops",
-]
-
 [[package]]
 name = "glam"
 version = "0.28.0"
@ -91,29 +67,12 @@ dependencies = [
 "syn 2.0.72",
 ]

-[[package]]
-name = "linear_ops"
-version = "0.1.0"
-source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "b2e6977ac24f47086d8a7a2d4ae1c720e86dfdc8407cf5e34c18bfa01053c456"
-dependencies = [
- "fixed_wide",
- "paste",
- "ratio_ops",
-]
-
 [[package]]
 name = "owo-colors"
 version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"

-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"
@ -132,30 +91,20 @@ dependencies = [
 "proc-macro2",
 ]

-[[package]]
-name = "ratio_ops"
-version = "0.1.0"
-source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "01239195d6afe0509e7e3511b716c0540251dfe7ece0a9a5a27116afb766c42c"
-
 [[package]]
 name = "strafesnet_common"
-version = "0.5.0"
+version = "0.1.3"
 source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
-checksum = "d8fcc44793ae84a1d80882f367980913292241c94eb87584de4010bdad4a918d"
+checksum = "10a7e3b69506893bbdde90ce8a9d75cd56d280c0424d2dfdf98f8520179d0c1b"
 dependencies = [
- "arrayvec",
 "bitflags",
- "fixed_wide",
 "glam",
 "id",
- "linear_ops",
- "ratio_ops",
 ]

 [[package]]
 name = "strafesnet_snf"
-version = "0.2.0"
+version = "0.1.0"
 dependencies = [
 "binrw",
 "id",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_snf"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@ -8,4 +8,4 @@ edition = "2021"
 [dependencies]
 binrw = "0.14.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { version = "0.5.0", registry = "strafesnet" }
+strafesnet_common = { version = "0.1.3", registry = "strafesnet" }
--- a/src/bot.rs
+++ b/src/bot.rs
@ -1,6 +1,5 @@
 use binrw::{BinReaderExt, binrw};

-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader,
 	InvalidSegment(binrw::Error),
@ -65,7 +64,7 @@ mod simulation{

 #[binrw]
 #[brw(little)]
-#[derive(Clone,Copy,Debug,id::Id)]
+#[derive(Clone,Copy,id::Id)]
 pub struct SegmentId(u32);

 #[binrw]
--- a/src/demo.rs
+++ b/src/demo.rs
@ -1,6 +1,5 @@
 use binrw::BinReaderExt;

-#[derive(Debug)]
 pub enum Error{
 	InvalidHeader,
 }
--- a/src/file.rs
+++ b/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,25 +51,24 @@ pub(crate) enum FourCC{
 }
 #[binrw]
 #[brw(little)]
-#[derive(Debug)]
-pub struct Header{
+struct Header{
 	/// Type of file
-	pub fourcc:FourCC,
-	/// File format version
-	pub version:u32,
+	fourcc:FourCC,
+	/// Type version
+	version:u32,
 	/// Minimum data required to know the location of all streamable resources for this specific file
-	pub priming:u64,
+	priming:u64,
 	/// uuid for this file
-	pub resource:u128,
+	resource:u128,
 	//don't need try_calc: the struct will force field initialization anyways and it can be calculated there
-	pub block_count:u32,
+	block_count:u32,
 	#[br(count=block_count+1)]
-	pub block_location:Vec<u64>,
+	block_location:Vec<u64>,
 }

 #[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>{
--- a/src/lib.rs
+++ b/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>),
--- a/src/map.rs
+++ b/src/map.rs
@ -3,30 +3,21 @@ use std::collections::HashMap;

 use crate::newtypes;
 use crate::file::BlockId;
-use binrw::{binrw,BinReaderExt,BinWriterExt};
+use binrw::{binrw,BinReaderExt};
 use strafesnet_common::model;
 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

@ -144,18 +135,21 @@ struct ResourceExternalHeader{
 #[binrw]
 #[brw(little)]
 struct MapHeader{
+	num_nodes:u32,
 	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,
+	#[br(count=num_nodes)]
+	nodes:Vec<u32>,
 	#[br(count=num_spacial_blocks)]
 	spacial_blocks:Vec<SpacialBlockHeader>,
 	#[br(count=num_resource_blocks)]
 	resource_blocks:Vec<ResourceBlockHeader>,
-	//#[br(count=num_resources_external)]
-	//external_resources:Vec<ResourceExternalHeader>,
+	#[br(count=num_resources_external)]
+	external_resources:Vec<ResourceExternalHeader>,
 	#[br(count=num_modes)]
 	modes:Vec<newtypes::gameplay_modes::Mode>,
 	#[br(count=num_attributes)]
@ -170,20 +164,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)|
-		(model::ModelId::new(model_id),model.into())
-	).collect())
+	Ok(region.models.into_iter().map(Into::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 +207,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|
@ -252,10 +244,10 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 	pub fn get_intersecting_region_block_ids(&self,aabb:&Aabb)->Vec<BlockId>{
 		let mut block_ids=Vec::new();
-		self.bvh.the_tester(aabb,&mut |&block_id|block_ids.push(block_id));
+		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 +259,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)?);
-		}
-		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)?);
+			models.append(&mut read_region(&mut self.file,block_id)?);
 		}
 		Ok(strafesnet_common::map::CompleteMap{
 			modes:self.modes,
@ -305,140 +284,3 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		})
 	}
 }
-
-const BVH_NODE_MAX_WEIGHT:usize=64*1024;//64 kB
-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)>
-)->Result<(),Error>{
-	//inspect the node weights top-down.
-	//When a node weighs less than the limit,
-	//serialize its entire contents into a region block
-	if *bvh_node.weight()<BVH_NODE_MAX_WEIGHT{
-		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)|{
-			model_count+=1;
-			models.push((model_id.get(),model));
-		});
-		let id=BlockId::new(block_headers.len() as u32+1);
-		block_headers.push(SpacialBlockHeader{
-			id,
-			extents,
-		});
-		let region=Region{
-			model_count,
-			models,
-		};
-		binrw::BinWrite::write_le(&region,sequential_block_data).map_err(Error::InvalidData)?;
-		block_location.push(sequential_block_data.position());
-	}else{
-		match bvh_node.into_content(){
-			strafesnet_common::bvh::RecursiveContent::Branch(bvh_node_list)=>{
-				for bvh_node in bvh_node_list{
-					collect_spacial_blocks(block_location,block_headers,sequential_block_data,bvh_node)?;
-				}
-			},
-			strafesnet_common::bvh::RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
-		}
-	}
-	Ok(())
-}
-
-/// TODO: Optionally provide a bot that describes the path through the map
-/// 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)|{
-		//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).fix_1());
-		}
-		Ok(((model::ModelId::new(model_id as u32),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
-	//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 resource_blocks=Vec::new();//for map header
-	//meshes
-	for mesh in map.meshes.into_iter(){
-		resource_blocks.push(ResourceBlockHeader{
-			resource:ResourceType::Mesh,
-			id:BlockId::new(block_count),
-		});
-		block_count+=1;
-		let serializable_mesh:newtypes::model::Mesh=mesh.into();
-		binrw::BinWrite::write_le(&serializable_mesh,&mut cursor_to_data).map_err(Error::InvalidData)?;
-		block_location.push(cursor_to_data.position());
-	}
-	//textures
-	for mut texture in map.textures.into_iter(){
-		resource_blocks.push(ResourceBlockHeader{
-			resource:ResourceType::Texture,
-			id:BlockId::new(block_count),
-		});
-		block_count+=1;
-		sequential_block_data.append(&mut texture);
-		block_location.push(sequential_block_data.len() as u64);
-	}
-	//build header
-	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_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(),
-		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(),
-	};
-	let mut file_header=crate::file::Header{
-		fourcc:crate::file::FourCC::Map,
-		version:0,
-		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)?;
-	//write map header
-	writer.write(&map_header_data).map_err(Error::IO)?;
-	//write blocks
-	writer.write(&sequential_block_data).map_err(Error::IO)?;
-	Ok(())
-}
--- a/src/newtypes.rs
+++ b/src/newtypes.rs
@ -1,4 +1,3 @@
-mod common;
 pub mod aabb;
 pub mod model;
 pub mod integer;
--- a/src/newtypes/aabb.rs
+++ b/src/newtypes/aabb.rs
@ -8,16 +8,8 @@ pub struct Aabb{
 impl Into<strafesnet_common::aabb::Aabb> for Aabb{
 	fn into(self)->strafesnet_common::aabb::Aabb{
 		strafesnet_common::aabb::Aabb::new(
-			strafesnet_common::integer::vec3::raw_array(self.min),
-			strafesnet_common::integer::vec3::raw_array(self.max),
+			strafesnet_common::integer::Planar64Vec3::raw_array(self.min),
+			strafesnet_common::integer::Planar64Vec3::raw_array(self.max),
 		)
 	}
 }
-impl From<strafesnet_common::aabb::Aabb> for Aabb{
-	fn from(value:strafesnet_common::aabb::Aabb)->Self{
-		Self{
-			max:value.max().map(|t|t.to_raw()).to_array(),
-			min:value.min().map(|t|t.to_raw()).to_array(),
-		}
-	}
-}
--- a/src/newtypes/common.rs
+++ b/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,
-		}
-	}
-}
--- a/src/newtypes/gameplay_attributes.rs
+++ b/src/newtypes/gameplay_attributes.rs
@ -1,22 +1,14 @@
-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(),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactingLadder)->Self{
-		Self{
-			sticky:value.sticky.into(),
+			sticky:self.sticky.is_some(),
 		}
 	}
 }
@ -24,15 +16,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{
@ -53,24 +40,6 @@ impl Into<strafesnet_common::gameplay_attributes::ContactingBehaviour> for Conta
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::ContactingBehaviour> for ContactingBehaviour{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactingBehaviour)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Surf=>
-			ContactingBehaviour::Surf,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Ladder(contacting_ladder)=>
-			ContactingBehaviour::Ladder(
-				contacting_ladder.into()
-			),
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::NoJump=>
-			ContactingBehaviour::NoJump,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Cling=>
-			ContactingBehaviour::Cling,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Elastic(elasticity)=>
-			ContactingBehaviour::Elastic(elasticity),
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -84,16 +53,7 @@ impl Into<strafesnet_common::gameplay_attributes::IntersectingWater> for Interse
 		strafesnet_common::gameplay_attributes::IntersectingWater{
 			viscosity:strafesnet_common::integer::Planar64::raw(self.viscosity),
 			density:strafesnet_common::integer::Planar64::raw(self.density),
-			velocity:strafesnet_common::integer::vec3::raw_array(self.velocity),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::IntersectingWater> for IntersectingWater{
-	fn from(value:strafesnet_common::gameplay_attributes::IntersectingWater)->Self{
-		Self{
-			viscosity:value.viscosity.to_raw(),
-			density:value.density.to_raw(),
-			velocity:value.velocity.map(|t|t.to_raw()).to_array(),
+			velocity:strafesnet_common::integer::Planar64Vec3::raw_array(self.velocity),
 		}
 	}
 }
@ -106,14 +66,7 @@ pub struct Accelerator{
 impl Into<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
 	fn into(self)->strafesnet_common::gameplay_attributes::Accelerator{
 		strafesnet_common::gameplay_attributes::Accelerator{
-			acceleration:strafesnet_common::integer::vec3::raw_array(self.acceleration)
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
-	fn from(value:strafesnet_common::gameplay_attributes::Accelerator)->Self{
-		Self{
-			acceleration:value.acceleration.map(|t|t.to_raw()).to_array(),
+			acceleration:strafesnet_common::integer::Planar64Vec3::raw_array(self.acceleration)
 		}
 	}
 }
@ -121,53 +74,21 @@ 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},
-	#[brw(magic=2u8)]
-	AirTime(Time),
-	#[brw(magic=3u8)]
-	Height(Planar64),
-
 }
 impl Into<strafesnet_common::gameplay_attributes::Booster> for Booster{
 	fn into(self)->strafesnet_common::gameplay_attributes::Booster{
 		match self{
 			Booster::Velocity(velocity)=>
 			strafesnet_common::gameplay_attributes::Booster::Velocity(
-				strafesnet_common::integer::vec3::raw_array(velocity)
+				strafesnet_common::integer::Planar64Vec3::raw_array(velocity)
 			),
 			Booster::Energy{direction,energy}=>
 			strafesnet_common::gameplay_attributes::Booster::Energy{
-				direction:strafesnet_common::integer::vec3::raw_array(direction),
+				direction:strafesnet_common::integer::Planar64Vec3::raw_array(direction),
 				energy:strafesnet_common::integer::Planar64::raw(energy)
 			},
-			Booster::AirTime(time)=>
-			strafesnet_common::gameplay_attributes::Booster::AirTime(
-				strafesnet_common::integer::Time::raw(time)
-			),
-			Booster::Height(height)=>
-			strafesnet_common::gameplay_attributes::Booster::Height(
-				strafesnet_common::integer::Planar64::raw(height)
-			),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::Booster> for Booster{
-	fn from(value:strafesnet_common::gameplay_attributes::Booster)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::Booster::Velocity(velocity)=>
-			Booster::Velocity(velocity.map(|t|t.to_raw()).to_array()),
-			strafesnet_common::gameplay_attributes::Booster::Energy{direction,energy}=>
-			Booster::Energy{
-				direction:direction.map(|t|t.to_raw()).to_array(),
-				energy:energy.to_raw(),
-			},
-			strafesnet_common::gameplay_attributes::Booster::AirTime(time)=>
-			Booster::AirTime(time.get()),
-			strafesnet_common::gameplay_attributes::Booster::Height(height)=>
-			Booster::Height(height.to_raw()),
 		}
 	}
 }
@ -188,38 +109,22 @@ impl Into<strafesnet_common::gameplay_attributes::TrajectoryChoice> for Trajecto
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::TrajectoryChoice> for TrajectoryChoice{
-	fn from(value:strafesnet_common::gameplay_attributes::TrajectoryChoice)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::TrajectoryChoice::HighArcLongDuration=>
-			TrajectoryChoice::HighArcLongDuration,
-			strafesnet_common::gameplay_attributes::TrajectoryChoice::LowArcShortDuration=>
-			TrajectoryChoice::LowArcShortDuration,
-		}
-	}
-}

 #[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{
@ -235,57 +140,23 @@ impl Into<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajecto
 			),
 			SetTrajectory::DotVelocity{direction,dot}=>
 			strafesnet_common::gameplay_attributes::SetTrajectory::DotVelocity{
-				direction:strafesnet_common::integer::vec3::raw_array(direction),
+				direction:strafesnet_common::integer::Planar64Vec3::raw_array(direction),
 				dot:strafesnet_common::integer::Planar64::raw(dot),
 			},
 			SetTrajectory::TargetPointTime{target_point,time}=>
 			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointTime{
-				target_point:strafesnet_common::integer::vec3::raw_array(target_point),
+				target_point:strafesnet_common::integer::Planar64Vec3::raw_array(target_point),
 				time:strafesnet_common::integer::Time::raw(time),
 			},
 			SetTrajectory::TargetPointSpeed{target_point,speed,trajectory_choice}=>
 			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointSpeed{
-				target_point:strafesnet_common::integer::vec3::raw_array(target_point),
+				target_point:strafesnet_common::integer::Planar64Vec3::raw_array(target_point),
 				speed:strafesnet_common::integer::Planar64::raw(speed),
 				trajectory_choice:trajectory_choice.into(),
 			},
 			SetTrajectory::Velocity(velocity)=>
 			strafesnet_common::gameplay_attributes::SetTrajectory::Velocity(
-				strafesnet_common::integer::vec3::raw_array(velocity)
-			),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajectory{
-	fn from(value:strafesnet_common::gameplay_attributes::SetTrajectory)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::SetTrajectory::AirTime(time)=>
-			SetTrajectory::AirTime(
-				time.get()
-			),
-			strafesnet_common::gameplay_attributes::SetTrajectory::Height(height)=>
-			SetTrajectory::Height(
-				height.to_raw()
-			),
-			strafesnet_common::gameplay_attributes::SetTrajectory::DotVelocity{direction,dot}=>
-			SetTrajectory::DotVelocity{
-				direction:direction.map(|t|t.to_raw()).to_array(),
-				dot:dot.to_raw(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointTime{target_point,time}=>
-			SetTrajectory::TargetPointTime{
-				target_point:target_point.map(|t|t.to_raw()).to_array(),
-				time:time.get(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointSpeed{target_point,speed,trajectory_choice}=>
-			SetTrajectory::TargetPointSpeed{
-				target_point:target_point.map(|t|t.to_raw()).to_array(),
-				speed:speed.to_raw(),
-				trajectory_choice:trajectory_choice.into(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::Velocity(velocity)=>
-			SetTrajectory::Velocity(
-				velocity.map(|t|t.to_raw()).to_array()
+				strafesnet_common::integer::Planar64Vec3::raw_array(velocity)
 			),
 		}
 	}
@ -303,33 +174,15 @@ impl Into<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
-	fn from(value:strafesnet_common::gameplay_attributes::Wormhole)->Self{
-		Self{
-			destination_model:value.destination_model.get(),
-		}
-	}
-}

 #[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{
@ -340,33 +193,12 @@ 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),
-			accelerator:value.accelerator.map(Into::into),
-		}
-	}
-}

 #[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{
@ -374,25 +206,12 @@ 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),
-		}
-	}
-}

 #[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{
@ -400,92 +219,28 @@ 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),
-		}
-	}
-}
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct ContactAttributes{
-	contacting:ContactingAttributes,
-	general:GeneralAttributes,
-}
-impl Into<strafesnet_common::gameplay_attributes::ContactAttributes> for ContactAttributes{
-	fn into(self)->strafesnet_common::gameplay_attributes::ContactAttributes{
-		strafesnet_common::gameplay_attributes::ContactAttributes{
-			contacting:self.contacting.into(),
-			general:self.general.into(),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::ContactAttributes> for ContactAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactAttributes)->Self{
-		Self{
-			contacting:value.contacting.into(),
-			general:value.general.into(),
-		}
-	}
-}
-
-#[binrw::binrw]
-#[brw(little)]
-pub struct IntersectAttributes{
-	intersecting:IntersectingAttributes,
-	general:GeneralAttributes,
-}
-impl Into<strafesnet_common::gameplay_attributes::IntersectAttributes> for IntersectAttributes{
-	fn into(self)->strafesnet_common::gameplay_attributes::IntersectAttributes{
-		strafesnet_common::gameplay_attributes::IntersectAttributes{
-			intersecting:self.intersecting.into(),
-			general:self.general.into(),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::IntersectAttributes> for IntersectAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::IntersectAttributes)->Self{
-		Self{
-			intersecting:value.intersecting.into(),
-			general:value.general.into(),
-		}
-	}
-}
-
 #[binrw::binrw]
 #[brw(little)]
 pub enum CollisionAttributes{
-	#[brw(magic=0u8)]
 	Decoration,
-	#[brw(magic=1u8)]
-	Contact(ContactAttributes),
-	#[brw(magic=2u8)]
-	Intersect(IntersectAttributes),
+	Contact{
+		contacting:ContactingAttributes,
+		general:GeneralAttributes,
+	},
+	Intersect{
+		intersecting:IntersectingAttributes,
+		general:GeneralAttributes,
+	},
 }
 impl Into<strafesnet_common::gameplay_attributes::CollisionAttributes> for CollisionAttributes{
 	fn into(self)->strafesnet_common::gameplay_attributes::CollisionAttributes{
 		match self{
 			CollisionAttributes::Decoration=>
 			strafesnet_common::gameplay_attributes::CollisionAttributes::Decoration,
-			CollisionAttributes::Contact(attr)=>
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Contact(attr.into()),
-			CollisionAttributes::Intersect(attr)=>
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Intersect(attr.into()),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_attributes::CollisionAttributes> for CollisionAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::CollisionAttributes)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Decoration=>
-			CollisionAttributes::Decoration,
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Contact(attr)=>
-			CollisionAttributes::Contact(attr.into()),
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Intersect(attr)=>
-			CollisionAttributes::Intersect(attr.into()),
+			CollisionAttributes::Contact{contacting,general}=>
+			strafesnet_common::gameplay_attributes::CollisionAttributes::Contact{contacting:contacting.into(),general:general.into()},
+			CollisionAttributes::Intersect{intersecting,general}=>
+			strafesnet_common::gameplay_attributes::CollisionAttributes::Intersect{intersecting:intersecting.into(),general:general.into()},
 		}
 	}
 }
--- a/src/newtypes/gameplay_modes.rs
+++ b/src/newtypes/gameplay_modes.rs
@ -1,75 +1,44 @@
-use super::common::flag;
-
-pub type ModeId=u32;
-pub type StageId=u32;
+#[binrw::binrw]
+#[brw(little,repr=u8)]
+pub enum StageElementBehaviour{
+	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,
+		}
+	}
+}

 #[binrw::binrw]
 #[brw(little)]
 pub struct StageElement{
-	pub header:u8,
-	pub stage_id:StageId,
-	#[br(if(header&Self::JUMP_LIMIT!=0))]
+	pub stage_id:u32,//which stage spawn to send to
+	pub behaviour:StageElementBehaviour,
 	pub jump_limit:Option<u8>,
+	pub force:Option<()>,//allow setting to lower spawn id i.e. 7->3
 }
-impl StageElement{
-	const BEHAVIOUR:u8=0b00111;
-	const JUMP_LIMIT:u8=1<<3;
-	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(
+impl Into<strafesnet_common::gameplay_modes::StageElement> for StageElement{
+	fn into(self)->strafesnet_common::gameplay_modes::StageElement{
+		strafesnet_common::gameplay_modes::StageElement::new(
 			strafesnet_common::gameplay_modes::StageId::new(self.stage_id),
-			self.force(),
-			self.behaviour().ok_or(StageElementError::InvalidBehaviour)?,
+			self.force.is_some(),
+			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(),
-			jump_limit:value.jump_limit(),
-		}
+		)
 	}
 }

@ -102,25 +71,6 @@ impl Into<strafesnet_common::gameplay_modes::Stage> for Stage{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Stage> for Stage{
-	fn from(value:strafesnet_common::gameplay_modes::Stage)->Self{
-		let spawn=value.spawn().get();
-		let ordered_checkpoints_count=value.ordered_checkpoints_count();
-		let unordered_checkpoints_count=value.unordered_checkpoints_count();
-		let (ordered_checkpoints,unordered_checkpoints)=value.into_inner();
-		Self{
-			spawn,
-			ordered_checkpoints_count,
-			unordered_checkpoints_count,
-			ordered_checkpoints:ordered_checkpoints.into_iter()
-			.map(|(checkpoint_id,model_id)|(checkpoint_id.get(),model_id.get()))
-			.collect(),
-			unordered_checkpoints:unordered_checkpoints.into_iter()
-			.map(|model_id|model_id.get())
-			.collect(),
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little,repr=u8)]
@ -138,15 +88,6 @@ impl Into<strafesnet_common::gameplay_modes::Zone> for Zone{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Zone> for Zone{
-	fn from(value:strafesnet_common::gameplay_modes::Zone)->Self{
-		match value{
-			strafesnet_common::gameplay_modes::Zone::Start=>Zone::Start,
-			strafesnet_common::gameplay_modes::Zone::Finish=>Zone::Finish,
-			strafesnet_common::gameplay_modes::Zone::Anticheat=>Zone::Anticheat,
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -168,53 +109,18 @@ pub struct Mode{
 	#[br(count=header.elements)]
 	pub elements:Vec<(u32,StageElement)>,
 }
-#[derive(Debug)]
-pub enum ModeError{
-	StyleModifier(super::gameplay_style::StyleModifierError),
-	StageElement(StageElementError),
-}
-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)?,
+impl Into<strafesnet_common::gameplay_modes::Mode> for Mode{
+	fn into(self)->strafesnet_common::gameplay_modes::Mode{
+		strafesnet_common::gameplay_modes::Mode::new(
+			self.style.into(),
 			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()?))
-			).collect::<Result<_,_>>().map_err(ModeError::StageElement)?,
-		))
-	}
-}
-impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
-	fn from(value:strafesnet_common::gameplay_modes::Mode)->Self{
-		let (style,start,zones,stages,elements)=value.into_inner();
-		Self{
-			header:ModeHeader{
-				zones:zones.len() as u32,
-				stages:stages.len() as u32,
-				elements:elements.len() as u32,
-			},
-			style:style.into(),
-			start:start.get(),
-			zones:zones.into_iter()
-			.map(|(model_id,zone)|(model_id.get(),zone.into()))
-			.collect(),
-			stages:stages.into_iter()
-			.map(Into::into)
-			.collect(),
-			elements:elements.into_iter()
-			.map(|(model_id,stage_element)|(model_id.get(),stage_element.into()))
-			.collect(),
-		}
+				(strafesnet_common::model::ModelId::new(model_id),stage_element.into())
+			).collect(),
+		)
 	}
 }
--- a/src/newtypes/gameplay_style.rs
+++ b/src/newtypes/gameplay_style.rs
@ -1,103 +1,39 @@
-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{
-	const STRAFE:u8=1<<0;
-	const ROCKET:u8=1<<1;
-	const JUMP:u8=1<<2;
-	const WALK:u8=1<<3;
-	const LADDER:u8=1<<4;
-	const SWIM:u8=1<<5;
-}
-#[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)?,
+impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
+	fn into(self)->strafesnet_common::gameplay_style::StyleModifiers{
+		strafesnet_common::gameplay_style::StyleModifiers{
+			//TODO: fail gracefully in binrw instead of panicing here
+			controls_mask:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).unwrap(),
+			controls_mask_state:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask_state).unwrap(),
+			strafe:self.strafe.map(Into::into),
 			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),
-			gravity:strafesnet_common::integer::vec3::raw_array(self.gravity),
+			gravity:strafesnet_common::integer::Planar64Vec3::raw_array(self.gravity),
 			hitbox:self.hitbox.into(),
-			camera_offset:strafesnet_common::integer::vec3::raw_array(self.camera_offset),
+			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),
-			rocket:value.rocket.map(Into::into),
-			jump:value.jump.map(Into::into),
-			walk:value.walk.map(Into::into),
-			ladder:value.ladder.map(Into::into),
-			swim:value.swim.map(Into::into),
-			gravity:value.gravity.map(|t|t.to_raw()).to_array(),
-			hitbox:value.hitbox.into(),
-			camera_offset:value.camera_offset.map(|t|t.to_raw()).to_array(),
-			mass:value.mass.to_raw(),
 		}
 	}
 }
@ -105,52 +41,35 @@ impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 #[binrw::binrw]
 #[brw(little,repr=u8)]
 pub enum JumpCalculation{
-	Max,
-	BoostThenJump,
-	JumpThenBoost,
+	Capped,
+	Energy,
+	Linear,
 }
 impl Into<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculation{
 	fn into(self)->strafesnet_common::gameplay_style::JumpCalculation{
 		match self{
-			JumpCalculation::Max=>strafesnet_common::gameplay_style::JumpCalculation::Max,
-			JumpCalculation::BoostThenJump=>strafesnet_common::gameplay_style::JumpCalculation::BoostThenJump,
-			JumpCalculation::JumpThenBoost=>strafesnet_common::gameplay_style::JumpCalculation::JumpThenBoost,
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculation{
-	fn from(value:strafesnet_common::gameplay_style::JumpCalculation)->Self{
-		match value{
-			strafesnet_common::gameplay_style::JumpCalculation::Max=>JumpCalculation::Max,
-			strafesnet_common::gameplay_style::JumpCalculation::BoostThenJump=>JumpCalculation::BoostThenJump,
-			strafesnet_common::gameplay_style::JumpCalculation::JumpThenBoost=>JumpCalculation::JumpThenBoost,
+			JumpCalculation::Capped=>strafesnet_common::gameplay_style::JumpCalculation::Capped,
+			JumpCalculation::Energy=>strafesnet_common::gameplay_style::JumpCalculation::Energy,
+			JumpCalculation::Linear=>strafesnet_common::gameplay_style::JumpCalculation::Linear,
 		}
 	}
 }

+#[binrw::binrw]
+#[brw(little)]
 pub enum JumpImpulse{
-	Time(Time),
-	Height(Planar64),
-	Linear(Planar64),
-	Energy(Planar64),
+	FromTime(Time),
+	FromHeight(Planar64),
+	FromDeltaV(Planar64),
+	FromEnergy(Planar64),
 }
 impl Into<strafesnet_common::gameplay_style::JumpImpulse> for JumpImpulse{
 	fn into(self)->strafesnet_common::gameplay_style::JumpImpulse{
 		match self{
-			JumpImpulse::Time(time)=>strafesnet_common::gameplay_style::JumpImpulse::Time(strafesnet_common::integer::Time::raw(time)),
-			JumpImpulse::Height(height)=>strafesnet_common::gameplay_style::JumpImpulse::Height(strafesnet_common::integer::Planar64::raw(height)),
-			JumpImpulse::Linear(deltav)=>strafesnet_common::gameplay_style::JumpImpulse::Linear(strafesnet_common::integer::Planar64::raw(deltav)),
-			JumpImpulse::Energy(energy)=>strafesnet_common::gameplay_style::JumpImpulse::Energy(strafesnet_common::integer::Planar64::raw(energy)),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::JumpImpulse> for JumpImpulse{
-	fn from(value:strafesnet_common::gameplay_style::JumpImpulse)->Self{
-		match value{
-			strafesnet_common::gameplay_style::JumpImpulse::Time(time)=>JumpImpulse::Time(time.get()),
-			strafesnet_common::gameplay_style::JumpImpulse::Height(height)=>JumpImpulse::Height(height.to_raw()),
-			strafesnet_common::gameplay_style::JumpImpulse::Linear(deltav)=>JumpImpulse::Linear(deltav.to_raw()),
-			strafesnet_common::gameplay_style::JumpImpulse::Energy(energy)=>JumpImpulse::Energy(energy.to_raw()),
+			JumpImpulse::FromTime(time)=>strafesnet_common::gameplay_style::JumpImpulse::FromTime(strafesnet_common::integer::Time::raw(time)),
+			JumpImpulse::FromHeight(height)=>strafesnet_common::gameplay_style::JumpImpulse::FromHeight(strafesnet_common::integer::Planar64::raw(height)),
+			JumpImpulse::FromDeltaV(deltav)=>strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(strafesnet_common::integer::Planar64::raw(deltav)),
+			JumpImpulse::FromEnergy(energy)=>strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(strafesnet_common::integer::Planar64::raw(energy)),
 		}
 	}
 }
@ -162,71 +81,32 @@ pub struct ControlsActivation{
 	controls_intersects:Controls,
 	controls_contains:Controls,
 }
-impl TryInto<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
-	type Error=ControlsError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_style::ControlsActivation,Self::Error>{
-		Ok(strafesnet_common::gameplay_style::ControlsActivation{
-			controls_mask:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_mask).ok_or(ControlsError::UnknownBits)?,
-			controls_intersects:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_intersects).ok_or(ControlsError::UnknownBits)?,
-			controls_contains:strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_contains).ok_or(ControlsError::UnknownBits)?,
-		})
-	}
-}
-impl From<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
-	fn from(value:strafesnet_common::gameplay_style::ControlsActivation)->Self{
-		Self{
-			controls_mask:value.controls_mask.bits(),
-			controls_intersects:value.controls_intersects.bits(),
-			controls_contains:value.controls_contains.bits(),
-		}
+impl Into<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
+	fn into(self)->strafesnet_common::gameplay_style::ControlsActivation{
+		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_intersects).unwrap(),
+			strafesnet_common::controls_bitflag::Controls::from_bits(self.controls_contains).unwrap(),
+		)
 	}
 }

 #[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{
-	const AIR_ACCEL_LIMIT:u8=1<<0;
-}
-#[derive(Debug)]
-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{
-			enable:self.enable.try_into().map_err(StrafeSettingsError::Controls)?,
-			mv:strafesnet_common::integer::Planar64::raw(self.mv),
-			air_accel_limit:self.air_accel_limit.map(strafesnet_common::integer::Planar64::raw),
-			tick_rate:self.tick_rate.try_into().map_err(StrafeSettingsError::Ratio)?,
-		})
-	}
-}
-impl From<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
-	fn from(value:strafesnet_common::gameplay_style::StrafeSettings)->Self{
-		let header=flag(value.air_accel_limit.is_some(),StrafeSettings::AIR_ACCEL_LIMIT);
-		Self{
-			header,
-			enable:value.enable.into(),
-			mv:value.mv.to_raw(),
-			air_accel_limit:value.air_accel_limit.map(|a|a.to_raw()),
-			tick_rate:value.tick_rate.into(),
-		}
+impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
+	fn into(self)->strafesnet_common::gameplay_style::StrafeSettings{
+		strafesnet_common::gameplay_style::StrafeSettings::new(
+			self.enable.into(),
+			strafesnet_common::integer::Planar64::raw(self.mv),
+			self.air_accel_limit.map(strafesnet_common::integer::Planar64::raw),
+			self.tick_rate.into(),
+		)
 	}
 }

@ -237,86 +117,24 @@ pub struct PropulsionSettings{
 }
 impl Into<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionSettings{
 	fn into(self)->strafesnet_common::gameplay_style::PropulsionSettings{
-		strafesnet_common::gameplay_style::PropulsionSettings{
-			magnitude:strafesnet_common::integer::Planar64::raw(self.magnitude)
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionSettings{
-	fn from(value:strafesnet_common::gameplay_style::PropulsionSettings)->Self{
-		Self{
-			magnitude:value.magnitude.to_raw(),
-		}
+		strafesnet_common::gameplay_style::PropulsionSettings::new(
+			strafesnet_common::integer::Planar64::raw(self.magnitude)
+		)
 	}
 }

 #[binrw::binrw]
 #[brw(little)]
 pub struct JumpSettings{
-	header:u8,
-	impulse:i64,
+	impulse:JumpImpulse,
+	calculation:JumpCalculation,
 }
-impl JumpSettings{
-	const IMPULSE:u8=0b00011;
-	const CALCULATION:u8=0b01100;
-	const LIMIT_MINIMUM:u8=0b10000;
-	const fn impulse(&self)->Option<strafesnet_common::gameplay_style::JumpImpulse>{
-		match self.header&Self::IMPULSE{
-			0=>Some(strafesnet_common::gameplay_style::JumpImpulse::Time(strafesnet_common::integer::Time::raw(self.impulse))),
-			1=>Some(strafesnet_common::gameplay_style::JumpImpulse::Height(strafesnet_common::integer::Planar64::raw(self.impulse))),
-			2=>Some(strafesnet_common::gameplay_style::JumpImpulse::Linear(strafesnet_common::integer::Planar64::raw(self.impulse))),
-			3=>Some(strafesnet_common::gameplay_style::JumpImpulse::Energy(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::Max),
-			1=>Some(strafesnet_common::gameplay_style::JumpCalculation::JumpThenBoost),
-			2=>Some(strafesnet_common::gameplay_style::JumpCalculation::BoostThenJump),
-			_=>None,
-		}
-	}
-	const fn limit_minimum(&self)->bool{
-		self.header&Self::LIMIT_MINIMUM!=0
-	}
-}
-#[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{
-			impulse:self.impulse().ok_or(JumpSettingsError::InvalidImpulseDiscriminant)?,
-			calculation:self.calculation().ok_or(JumpSettingsError::InvalidCalculationDiscriminant)?,
-			limit_minimum:self.limit_minimum(),
-		})
-	}
-}
-impl From<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
-	fn from(value:strafesnet_common::gameplay_style::JumpSettings)->Self{
-		let (impulse,impulse_header)=match value.impulse{
-			strafesnet_common::gameplay_style::JumpImpulse::Time(impulse)=>(impulse.get(),0),
-			strafesnet_common::gameplay_style::JumpImpulse::Height(impulse)=>(impulse.to_raw(),1),
-			strafesnet_common::gameplay_style::JumpImpulse::Linear(impulse)=>(impulse.to_raw(),2),
-			strafesnet_common::gameplay_style::JumpImpulse::Energy(impulse)=>(impulse.to_raw(),3),
-		};
-		let calculation_header=match value.calculation{
-			strafesnet_common::gameplay_style::JumpCalculation::Max=>0,
-			strafesnet_common::gameplay_style::JumpCalculation::JumpThenBoost=>1,
-			strafesnet_common::gameplay_style::JumpCalculation::BoostThenJump=>2,
-		};
-		let header=
-			impulse_header
-			|(calculation_header<<2)
-			|((value.limit_minimum as u8)<<4);
-		Self{
-			header,
-			impulse,
-		}
+impl Into<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
+	fn into(self)->strafesnet_common::gameplay_style::JumpSettings{
+		strafesnet_common::gameplay_style::JumpSettings::new(
+			self.impulse.into(),
+			self.calculation.into(),
+		)
 	}
 }

@ -328,18 +146,10 @@ pub struct AccelerateSettings{
 }
 impl Into<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateSettings{
 	fn into(self)->strafesnet_common::gameplay_style::AccelerateSettings{
-		strafesnet_common::gameplay_style::AccelerateSettings{
-			accel:strafesnet_common::integer::Planar64::raw(self.accel),
-			topspeed:strafesnet_common::integer::Planar64::raw(self.topspeed),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateSettings{
-	fn from(value:strafesnet_common::gameplay_style::AccelerateSettings)->Self{
-		Self{
-			accel:value.accel.to_raw(),
-			topspeed:value.topspeed.to_raw(),
-		}
+		strafesnet_common::gameplay_style::AccelerateSettings::new(
+			strafesnet_common::integer::Planar64::raw(self.accel),
+			strafesnet_common::integer::Planar64::raw(self.topspeed),
+		)
 	}
 }

@ -353,22 +163,12 @@ pub struct WalkSettings{
 }
 impl Into<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
 	fn into(self)->strafesnet_common::gameplay_style::WalkSettings{
-		strafesnet_common::gameplay_style::WalkSettings{
-			accelerate:self.accelerate.into(),
-			static_friction:strafesnet_common::integer::Planar64::raw(self.static_friction),
-			kinetic_friction:strafesnet_common::integer::Planar64::raw(self.kinetic_friction),
-			surf_dot:strafesnet_common::integer::Planar64::raw(self.surf_dot),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
-	fn from(value:strafesnet_common::gameplay_style::WalkSettings)->Self{
-		Self{
-			accelerate:value.accelerate.into(),
-			static_friction:value.static_friction.to_raw(),
-			kinetic_friction:value.kinetic_friction.to_raw(),
-			surf_dot:value.surf_dot.to_raw(),
-		}
+		strafesnet_common::gameplay_style::WalkSettings::new(
+			self.accelerate.into(),
+			strafesnet_common::integer::Planar64::raw(self.static_friction),
+			strafesnet_common::integer::Planar64::raw(self.kinetic_friction),
+			strafesnet_common::integer::Planar64::raw(self.surf_dot),
+		)
 	}
 }

@ -380,18 +180,10 @@ pub struct LadderSettings{
 }
 impl Into<strafesnet_common::gameplay_style::LadderSettings> for LadderSettings{
 	fn into(self)->strafesnet_common::gameplay_style::LadderSettings{
-		strafesnet_common::gameplay_style::LadderSettings{
-			accelerate:self.accelerate.into(),
-			dot:strafesnet_common::integer::Planar64::raw(self.dot),
-		}
-	}
-}
-impl From<strafesnet_common::gameplay_style::LadderSettings> for LadderSettings{
-	fn from(value:strafesnet_common::gameplay_style::LadderSettings)->Self{
-		Self{
-			accelerate:value.accelerate.into(),
-			dot:value.dot.to_raw(),
-		}
+		strafesnet_common::gameplay_style::LadderSettings::new(
+			self.accelerate.into(),
+			strafesnet_common::integer::Planar64::raw(self.dot),
+		)
 	}
 }

@ -409,14 +201,6 @@ impl Into<strafesnet_common::gameplay_style::HitboxMesh> for HitboxMesh{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::HitboxMesh> for HitboxMesh{
-	fn from(value:strafesnet_common::gameplay_style::HitboxMesh)->Self{
-		match value{
-			strafesnet_common::gameplay_style::HitboxMesh::Box=>HitboxMesh::Box,
-			strafesnet_common::gameplay_style::HitboxMesh::Cylinder=>HitboxMesh::Cylinder,
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -427,16 +211,8 @@ pub struct Hitbox{
 impl Into<strafesnet_common::gameplay_style::Hitbox> for Hitbox{
 	fn into(self)->strafesnet_common::gameplay_style::Hitbox{
 		strafesnet_common::gameplay_style::Hitbox{
-			halfsize:strafesnet_common::integer::vec3::raw_array(self.halfsize),
+			halfsize:strafesnet_common::integer::Planar64Vec3::raw_array(self.halfsize),
 			mesh:self.mesh.into(),
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::Hitbox> for Hitbox{
-	fn from(value:strafesnet_common::gameplay_style::Hitbox)->Self{
-		Self{
-			halfsize:value.halfsize.map(|t|t.to_raw()).to_array(),
-			mesh:value.mesh.into(),
-		}
-	}
-}
--- a/src/newtypes/integer.rs
+++ b/src/newtypes/integer.rs
@ -6,29 +6,9 @@ pub struct Ratio64{
 	num:i64,
 	den:u64,
 }
-#[derive(Debug)]
-pub enum RatioError{
-	ZeroDenominator,
-}
-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{
-	fn from(value:strafesnet_common::integer::Ratio64)->Self{
-		Self{
-			num:value.num(),
-			den:value.den(),
-		}
+impl Into<strafesnet_common::integer::Ratio64> for Ratio64{
+	fn into(self)->strafesnet_common::integer::Ratio64{
+		strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap()
 	}
 }

--- a/src/newtypes/model.rs
+++ b/src/newtypes/model.rs
@ -1,6 +1,3 @@
-use super::common::flag;
-use strafesnet_common::model::PolygonIter;
-
 use super::integer::{Planar64Vec3,Planar64Affine3};

 pub type TextureCoordinate=[f32;2];
@ -14,16 +11,6 @@ pub struct IndexedVertex{
 	pub normal:u32,
 	pub color:u32,
 }
-impl From<strafesnet_common::model::IndexedVertex> for IndexedVertex{
-	fn from(value:strafesnet_common::model::IndexedVertex)->Self{
-		Self{
-			pos:value.pos.get(),
-			tex:value.tex.get(),
-			normal:value.normal.get(),
-			color:value.color.get(),
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -39,35 +26,11 @@ pub struct PolygonGroup{
 	#[br(count=count)]
 	pub polys:Vec<Polygon>,
 }
-impl From<strafesnet_common::model::PolygonGroup> for PolygonGroup{
-	fn from(value:strafesnet_common::model::PolygonGroup)->Self{
-		match value{
-			strafesnet_common::model::PolygonGroup::PolygonList(polygon_list)=>{
-				let polys:Vec<Polygon>=polygon_list.polys().map(|poly|{
-					let vertices:Vec<u32>=poly.iter().map(|vert|vert.get()).collect();
-					Polygon{
-						count:vertices.len() as u32,
-						vertices,
-					}
-				}).collect();
-				Self{
-					count:polys.len() as u32,
-					polys,
-				}
-			}
-		}
-	}
-}
 #[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{
@ -75,15 +38,6 @@ 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()),
-		}
-	}
-}
 #[binrw::binrw]
 #[brw(little)]
 pub struct IndexedGraphicsGroup{
@ -92,15 +46,6 @@ pub struct IndexedGraphicsGroup{
 	#[br(count=count)]
 	pub groups:Vec<u32>,
 }
-impl From<strafesnet_common::model::IndexedGraphicsGroup> for IndexedGraphicsGroup{
-	fn from(value:strafesnet_common::model::IndexedGraphicsGroup)->Self{
-		Self{
-			count:value.groups.len() as u32,
-			render:value.render.get(),
-			groups:value.groups.into_iter().map(|group_id|group_id.get()).collect(),
-		}
-	}
-}
 #[binrw::binrw]
 #[brw(little)]
 pub struct IndexedPhysicsGroup{
@ -108,14 +53,6 @@ pub struct IndexedPhysicsGroup{
 	#[br(count=count)]
 	pub groups:Vec<u32>,
 }
-impl From<strafesnet_common::model::IndexedPhysicsGroup> for IndexedPhysicsGroup{
-	fn from(value:strafesnet_common::model::IndexedPhysicsGroup)->Self{
-		Self{
-			count:value.groups.len() as u32,
-			groups:value.groups.into_iter().map(|group_id|group_id.get()).collect(),
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -153,8 +90,8 @@ pub struct Mesh{
 impl Into<strafesnet_common::model::Mesh> for Mesh{
 	fn into(self)->strafesnet_common::model::Mesh{
 		strafesnet_common::model::Mesh{
-			unique_pos:self.unique_pos.into_iter().map(strafesnet_common::integer::vec3::raw_array).collect(),
-			unique_normal:self.unique_normal.into_iter().map(strafesnet_common::integer::vec3::raw_array).collect(),
+			unique_pos:self.unique_pos.into_iter().map(strafesnet_common::integer::Planar64Vec3::raw_array).collect(),
+			unique_normal:self.unique_normal.into_iter().map(strafesnet_common::integer::Planar64Vec3::raw_array).collect(),
 			unique_tex:self.unique_tex.into_iter().map(strafesnet_common::model::TextureCoordinate::from_array).collect(),
 			unique_color:self.unique_color.into_iter().map(strafesnet_common::model::Color4::from_array).collect(),
 			unique_vertices:self.unique_vertices.into_iter().map(|vert|strafesnet_common::model::IndexedVertex{
@ -186,46 +123,6 @@ impl Into<strafesnet_common::model::Mesh> for Mesh{
 		}
 	}
 }
-impl From<strafesnet_common::model::Mesh> for Mesh{
-	fn from(value:strafesnet_common::model::Mesh)->Self{
-		Self{
-			header:MeshHeader{
-				unique_pos:value.unique_pos.len() as u32,
-				unique_normal:value.unique_normal.len() as u32,
-				unique_tex:value.unique_tex.len() as u32,
-				unique_color:value.unique_color.len() as u32,
-				unique_vertices:value.unique_vertices.len() as u32,
-				polygon_groups:value.polygon_groups.len() as u32,
-				graphics_groups:value.graphics_groups.len() as u32,
-				physics_groups:value.physics_groups.len() as u32,
-			},
-			unique_pos:value.unique_pos.into_iter()
-			.map(|pos|pos.map(|t|t.to_raw()).to_array())
-			.collect(),
-			unique_normal:value.unique_normal.into_iter()
-			.map(|normal|normal.map(|t|t.to_raw()).to_array())
-			.collect(),
-			unique_tex:value.unique_tex.into_iter()
-			.map(|tex|tex.to_array())
-			.collect(),
-			unique_color:value.unique_color.into_iter()
-			.map(|color|color.to_array())
-			.collect(),
-			unique_vertices:value.unique_vertices.into_iter()
-			.map(Into::into)
-			.collect(),
-			polygon_groups:value.polygon_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-			graphics_groups:value.graphics_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-			physics_groups:value.physics_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-		}
-	}
-}

 #[binrw::binrw]
 #[brw(little)]
@ -243,34 +140,13 @@ impl Into<strafesnet_common::model::Model> for Model{
 			attributes:strafesnet_common::gameplay_attributes::CollisionAttributesId::new(self.attributes),
 			color:strafesnet_common::model::Color4::from_array(self.color),
 			transform:strafesnet_common::integer::Planar64Affine3::new(
-				strafesnet_common::integer::Planar64Mat3::from_cols([
-					strafesnet_common::integer::vec3::raw_xyz(_0,_1,_2),
-					strafesnet_common::integer::vec3::raw_xyz(_3,_4,_5),
-					strafesnet_common::integer::vec3::raw_xyz(_6,_7,_8)
-				]),
-				strafesnet_common::integer::vec3::raw_xyz(_9,_a,_b)
+				strafesnet_common::integer::Planar64Mat3::from_cols(
+					strafesnet_common::integer::Planar64Vec3::raw_xyz(_0,_1,_2),
+					strafesnet_common::integer::Planar64Vec3::raw_xyz(_3,_4,_5),
+					strafesnet_common::integer::Planar64Vec3::raw_xyz(_6,_7,_8)
+				),
+				strafesnet_common::integer::Planar64Vec3::raw_xyz(_9,_a,_b)
 			),
 		}
 	}
 }
-impl From<strafesnet_common::model::Model> for Model{
-	fn from(value:strafesnet_common::model::Model)->Self{
-		let (
-			[_0,_1,_2],
-			[_3,_4,_5],
-			[_6,_7,_8],
-			[_9,_a,_b]
-		)=(
-			value.transform.matrix3.x_axis.map(|t|t.to_raw()).to_array(),
-			value.transform.matrix3.y_axis.map(|t|t.to_raw()).to_array(),
-			value.transform.matrix3.z_axis.map(|t|t.to_raw()).to_array(),
-			value.transform.translation.map(|t|t.to_raw()).to_array()
-		);
-		Self{
-			mesh:value.mesh.get(),
-			attributes:value.attributes.get(),
-			color:value.color.to_array(),
-			transform:[_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b],
-		}
-	}
-}
Author	SHA1	Message	Date
Quaternions	50d1a3188e	newtypes	2024-07-25 10:42:03 -07:00
Quaternions	9cc099a6eb	don't allocate models twice	2024-07-24 14:39:21 -07:00
Quaternions	5d9c124e76	complete map loader	2024-07-24 14:39:21 -07:00
Quaternions	d60486acc3	newtypes	2024-07-24 14:39:21 -07:00
Quaternions	2eef7843a2	generate resource ids + implement load_mesh	2024-07-24 14:39:21 -07:00
Quaternions	5e644c7eed	newtypes	2024-07-24 12:00:24 -07:00
Quaternions	567ce86370	wip	2024-07-24 12:00:03 -07:00
Quaternions	9cef23c519	wip	2024-07-23 19:32:29 -07:00
Quaternions	4f90956e16	implement map file format	2024-07-23 19:08:30 -07:00
Quaternions	1883c06f12	newtypes (boilerplate)	2024-07-23 19:08:30 -07:00