work around broken binrw enums

src/newtypes/gameplay_attributes.rs

@@ -1,24 +1,44 @@
 use super::integer::{Time,Planar64,Planar64Vec3};
 
+#[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,
+		}
+	}
+}
+
 #[binrw::binrw]
 #[brw(little)]
 pub struct ContactingLadder{
-	pub sticky:Option<()>,
+	pub sticky:Boolio,
 }
 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.is_some(),
+			sticky:self.sticky.into(),
 		}
 	}
 }
 impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
 	fn from(value:strafesnet_common::gameplay_attributes::ContactingLadder)->Self{
 		Self{
-			sticky:match value.sticky{
+			sticky:value.sticky.into(),
-				true=>Some(()),
-				false=>None,
-			}
 		}
 	}
 }
@@ -26,10 +46,15 @@ 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{
@@ -118,7 +143,9 @@ 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{
@@ -180,18 +207,24 @@ 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{
@@ -283,31 +316,50 @@ impl From<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
 	}
 }
 
+#[binrw::binrw]
+#[brw(little)]
+pub struct GeneralAttributesHeader{
+	pub booster:u8,
+	pub trajectory:u8,
+	pub wormhole:u8,
+	pub accelerator:u8,
+}
 #[binrw::binrw]
 #[brw(little)]
 pub struct GeneralAttributes{
-	pub booster:Option<Booster>,
+	pub header:GeneralAttributesHeader,
-	pub trajectory:Option<SetTrajectory>,
+	#[br(count=header.booster)]
-	pub wormhole:Option<Wormhole>,
+	pub booster:Vec<Booster>,
-	pub accelerator:Option<Accelerator>,
+	#[br(count=header.trajectory)]
+	pub trajectory:Vec<SetTrajectory>,
+	#[br(count=header.wormhole)]
+	pub wormhole:Vec<Wormhole>,
+	#[br(count=header.accelerator)]
+	pub accelerator:Vec<Accelerator>,
 }
 impl Into<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
-	fn into(self)->strafesnet_common::gameplay_attributes::GeneralAttributes{
+	fn into(mut self)->strafesnet_common::gameplay_attributes::GeneralAttributes{
 		strafesnet_common::gameplay_attributes::GeneralAttributes{
-			booster:self.booster.map(Into::into),
+			booster:self.booster.pop().map(Into::into),
-			trajectory:self.trajectory.map(Into::into),
+			trajectory:self.trajectory.pop().map(Into::into),
-			wormhole:self.wormhole.map(Into::into),
+			wormhole:self.wormhole.pop().map(Into::into),
-			accelerator:self.accelerator.map(Into::into),
+			accelerator:self.accelerator.pop().map(Into::into),
 		}
 	}
 }
 impl From<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::GeneralAttributes)->Self{
 		Self{
-			booster:value.booster.map(Into::into),
+			header:GeneralAttributesHeader{
-			trajectory:value.trajectory.map(Into::into),
+				booster:value.booster.is_some() as u8,
-			wormhole:value.wormhole.map(Into::into),
+				trajectory:value.trajectory.is_some() as u8,
-			accelerator:value.accelerator.map(Into::into),
+				wormhole:value.wormhole.is_some() as u8,
+				accelerator:value.accelerator.is_some() as u8,
+			},
+			booster:super::gameplay_style::stupid(value.booster.map(Into::into)),
+			trajectory:super::gameplay_style::stupid(value.trajectory.map(Into::into)),
+			wormhole:super::gameplay_style::stupid(value.wormhole.map(Into::into)),
+			accelerator:super::gameplay_style::stupid(value.accelerator.map(Into::into)),
 		}
 	}
 }
@@ -315,19 +367,22 @@ impl From<strafesnet_common::gameplay_attributes::GeneralAttributes> for General
 #[binrw::binrw]
 #[brw(little)]
 pub struct ContactingAttributes{
-	pub contact_behaviour:Option<ContactingBehaviour>,
+	pub contact_behaviour_enabled:u8,
+	#[br(count=contact_behaviour_enabled)]
+	pub contact_behaviour:Vec<ContactingBehaviour>,
 }
 impl Into<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
-	fn into(self)->strafesnet_common::gameplay_attributes::ContactingAttributes{
+	fn into(mut self)->strafesnet_common::gameplay_attributes::ContactingAttributes{
 		strafesnet_common::gameplay_attributes::ContactingAttributes{
-			contact_behaviour:self.contact_behaviour.map(Into::into),
+			contact_behaviour:self.contact_behaviour.pop().map(Into::into),
 		}
 	}
 }
 impl From<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::ContactingAttributes)->Self{
 		Self{
-			contact_behaviour:value.contact_behaviour.map(Into::into),
+			contact_behaviour_enabled:value.contact_behaviour.is_some() as u8,
+			contact_behaviour:super::gameplay_style::stupid(value.contact_behaviour.map(Into::into)),
 		}
 	}
 }
@@ -335,19 +390,22 @@ impl From<strafesnet_common::gameplay_attributes::ContactingAttributes> for Cont
 #[binrw::binrw]
 #[brw(little)]
 pub struct IntersectingAttributes{
-	pub water:Option<IntersectingWater>,
+	pub water_enabled:u8,
+	#[br(count=water_enabled)]
+	pub water:Vec<IntersectingWater>,
 }
 impl Into<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
-	fn into(self)->strafesnet_common::gameplay_attributes::IntersectingAttributes{
+	fn into(mut self)->strafesnet_common::gameplay_attributes::IntersectingAttributes{
 		strafesnet_common::gameplay_attributes::IntersectingAttributes{
-			water:self.water.map(Into::into),
+			water:self.water.pop().map(Into::into),
 		}
 	}
 }
 impl From<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
 	fn from(value:strafesnet_common::gameplay_attributes::IntersectingAttributes)->Self{
 		Self{
-			water:value.water.map(Into::into),
+			water_enabled:value.water.is_some() as u8,
+			water:super::gameplay_style::stupid(value.water.map(Into::into)),
 		}
 	}
 }
@@ -355,11 +413,14 @@ 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

@@ -40,16 +40,18 @@ impl From<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageEle
 pub struct StageElement{
 	pub stage_id:u32,//which stage spawn to send to
 	pub behaviour:StageElementBehaviour,
-	pub jump_limit:Option<u8>,
+	pub jump_limit_enabled:u8,
-	pub force:Option<()>,//allow setting to lower spawn id i.e. 7->3
+	#[br(count=jump_limit_enabled)]
+	pub jump_limit:Vec<u8>,
+	pub force:super::gameplay_attributes::Boolio,//allow setting to lower spawn id i.e. 7->3
 }
 impl Into<strafesnet_common::gameplay_modes::StageElement> for StageElement{
-	fn into(self)->strafesnet_common::gameplay_modes::StageElement{
+	fn into(mut self)->strafesnet_common::gameplay_modes::StageElement{
 		strafesnet_common::gameplay_modes::StageElement::new(
 			strafesnet_common::gameplay_modes::StageId::new(self.stage_id),
-			self.force.is_some(),
+			self.force.into(),
 			self.behaviour.into(),
-			self.jump_limit,
+			self.jump_limit.pop(),
 		)
 	}
 }
@@ -58,8 +60,9 @@ impl From<strafesnet_common::gameplay_modes::StageElement> for StageElement{
 		Self{
 			stage_id:value.stage_id().get(),
 			behaviour:value.behaviour().into(),
-			jump_limit:value.jump_limit(),
+			jump_limit_enabled:value.jump_limit().is_some() as u8,
-			force:match value.force(){true=>Some(()),false=>None},
+			jump_limit:super::gameplay_style::stupid(value.jump_limit()),
+			force:value.force().into(),
 		}
 	}
 }
@@ -114,7 +117,8 @@ impl From<strafesnet_common::gameplay_modes::Stage> for Stage{
 }
 
 #[binrw::binrw]
-#[brw(little,repr=u8)]
+#[brw(little,repr=u32)]
+#[repr(u32)]
 pub enum Zone{
 	Start,
 	Finish,
@@ -141,6 +145,7 @@ impl From<strafesnet_common::gameplay_modes::Zone> for Zone{
 
 #[binrw::binrw]
 #[brw(little)]
+#[derive(Debug)]
 pub struct ModeHeader{
 	pub zones:u32,
 	pub stages:u32,

src/newtypes/gameplay_style.rs

@@ -2,34 +2,52 @@ use super::integer::{Time,Ratio64,Planar64,Planar64Vec3};
 
 pub type Controls=u32;
 
+#[binrw::binrw]
+#[brw(little)]
+pub struct StyleModifiersHeader{
+	pub strafe:u8,
+	pub rocket:u8,
+	pub jump:u8,
+	pub walk:u8,
+	pub ladder:u8,
+	pub swim:u8,
+}
+
 #[binrw::binrw]
 #[brw(little)]
 pub struct StyleModifiers{
+	pub header:StyleModifiersHeader,
 	pub controls_mask:Controls,
 	pub controls_mask_state:Controls,
-	pub strafe:Option<StrafeSettings>,
+	#[br(count=header.strafe)]
-	pub rocket:Option<PropulsionSettings>,
+	pub strafe:Vec<StrafeSettings>,
-	pub jump:Option<JumpSettings>,
+	#[br(count=header.rocket)]
-	pub walk:Option<WalkSettings>,
+	pub rocket:Vec<PropulsionSettings>,
-	pub ladder:Option<LadderSettings>,
+	#[br(count=header.jump)]
-	pub swim:Option<PropulsionSettings>,
+	pub jump:Vec<JumpSettings>,
+	#[br(count=header.walk)]
+	pub walk:Vec<WalkSettings>,
+	#[br(count=header.ladder)]
+	pub ladder:Vec<LadderSettings>,
+	#[br(count=header.swim)]
+	pub swim:Vec<PropulsionSettings>,
 	pub gravity:Planar64Vec3,
 	pub hitbox:Hitbox,
 	pub camera_offset:Planar64Vec3,
 	pub mass:Planar64,
 }
 impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
-	fn into(self)->strafesnet_common::gameplay_style::StyleModifiers{
+	fn into(mut 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),
+			strafe:self.strafe.pop().map(Into::into),
-			rocket:self.rocket.map(Into::into),
+			rocket:self.rocket.pop().map(Into::into),
-			jump:self.jump.map(Into::into),
+			jump:self.jump.pop().map(Into::into),
-			walk:self.walk.map(Into::into),
+			walk:self.walk.pop().map(Into::into),
-			ladder:self.ladder.map(Into::into),
+			ladder:self.ladder.pop().map(Into::into),
-			swim:self.swim.map(Into::into),
+			swim:self.swim.pop().map(Into::into),
 			gravity:strafesnet_common::integer::Planar64Vec3::raw_array(self.gravity),
 			hitbox:self.hitbox.into(),
 			camera_offset:strafesnet_common::integer::Planar64Vec3::raw_array(self.camera_offset),
@@ -37,17 +55,31 @@ impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 		}
 	}
 }
+pub(crate) fn stupid<T>(o:Option<T>)->Vec<T>{
+	match o{
+		Some(v)=>vec![v],
+		None=>Vec::new(),
+	}
+}
 impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 	fn from(value:strafesnet_common::gameplay_style::StyleModifiers)->Self{
 		Self{
+			header:StyleModifiersHeader{
+				strafe:value.strafe.is_some() as u8,
+				rocket:value.rocket.is_some() as u8,
+				jump:value.jump.is_some() as u8,
+				walk:value.walk.is_some() as u8,
+				ladder:value.ladder.is_some() as u8,
+				swim:value.swim.is_some() as u8,
+			},
 			controls_mask:value.controls_mask.bits(),
 			controls_mask_state:value.controls_mask_state.bits(),
-			strafe:value.strafe.map(Into::into),
+			strafe:stupid(value.strafe.map(Into::into)),
-			rocket:value.rocket.map(Into::into),
+			rocket:stupid(value.rocket.map(Into::into)),
-			jump:value.jump.map(Into::into),
+			jump:stupid(value.jump.map(Into::into)),
-			walk:value.walk.map(Into::into),
+			walk:stupid(value.walk.map(Into::into)),
-			ladder:value.ladder.map(Into::into),
+			ladder:stupid(value.ladder.map(Into::into)),
-			swim:value.swim.map(Into::into),
+			swim:stupid(value.swim.map(Into::into)),
 			gravity:value.gravity.get().to_array(),
 			hitbox:value.hitbox.into(),
 			camera_offset:value.camera_offset.get().to_array(),
@@ -142,15 +174,17 @@ impl From<strafesnet_common::gameplay_style::ControlsActivation> for ControlsAct
 pub struct StrafeSettings{
 	enable:ControlsActivation,
 	mv:Planar64,
-	air_accel_limit:Option<Planar64>,
+	air_accel_limit_enabled:u8,
+	#[br(count=air_accel_limit_enabled)]
+	air_accel_limit:Vec<Planar64>,
 	tick_rate:Ratio64,
 }
 impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
-	fn into(self)->strafesnet_common::gameplay_style::StrafeSettings{
+	fn into(mut 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.air_accel_limit.pop().map(strafesnet_common::integer::Planar64::raw),
 			self.tick_rate.into(),
 		)
 	}
@@ -161,7 +195,8 @@ impl From<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
 		Self{
 			enable:enable.into(),
 			mv:mv.get(),
-			air_accel_limit:air_accel_limit.map(|a|a.get()),
+			air_accel_limit_enabled:air_accel_limit.is_some() as u8,
+			air_accel_limit:stupid(air_accel_limit.map(|a|a.get())),
 			tick_rate:tick_rate.into(),
 		}
 	}

src/newtypes/model.rs

@@ -60,19 +60,22 @@ impl From<strafesnet_common::model::PolygonGroup> for PolygonGroup{
 #[binrw::binrw]
 #[brw(little)]
 pub struct RenderConfig{
-	pub texture:Option<u32>,
+	pub texture_enabled:u8,
+	#[br(count=texture_enabled)]
+	pub texture:Vec<u32>,
 }
 impl Into<strafesnet_common::model::RenderConfig> for RenderConfig{
-	fn into(self)->strafesnet_common::model::RenderConfig{
+	fn into(mut self)->strafesnet_common::model::RenderConfig{
 		strafesnet_common::model::RenderConfig{
-			texture:self.texture.map(strafesnet_common::model::TextureId::new),
+			texture:self.texture.pop().map(strafesnet_common::model::TextureId::new),
 		}
 	}
 }
 impl From<strafesnet_common::model::RenderConfig> for RenderConfig{
 	fn from(value:strafesnet_common::model::RenderConfig)->Self{
 		Self{
-			texture:value.texture.map(|texture_id|texture_id.get()),
+			texture_enabled:value.texture.is_some() as u8,
+			texture:super::gameplay_style::stupid(value.texture.map(|texture_id|texture_id.get())),
 		}
 	}
 }