Compare commits
2 Commits
master
...
workaround
| Author | SHA1 | Date | |
|---|---|---|---|
| b6fede20bf | |||
| 020eae4781 |
61
Cargo.lock
generated
61
Cargo.lock
generated
@ -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",
|
||||
|
||||
@ -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" }
|
||||
|
||||
@ -12,7 +12,6 @@ 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),
|
||||
@ -215,7 +214,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|
|
||||
@ -357,7 +356,7 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
|
||||
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());
|
||||
aabb.grow(model.transform.transform_point3(pos));
|
||||
}
|
||||
Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
|
||||
}).collect::<Result<Vec<_>,_>>()?;
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
mod common;
|
||||
pub mod aabb;
|
||||
pub mod model;
|
||||
pub mod integer;
|
||||
|
||||
@ -8,16 +8,16 @@ 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(),
|
||||
max:value.max().get().to_array(),
|
||||
min:value.min().get().to_array(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,6 +1,28 @@
|
||||
use super::common::{flag,Boolio};
|
||||
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{
|
||||
@ -84,16 +106,16 @@ 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),
|
||||
velocity:strafesnet_common::integer::Planar64Vec3::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(),
|
||||
viscosity:value.viscosity.get(),
|
||||
density:value.density.get(),
|
||||
velocity:value.velocity.get().to_array(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -106,14 +128,14 @@ 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)
|
||||
acceleration:strafesnet_common::integer::Planar64Vec3::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:value.acceleration.get().to_array(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -125,32 +147,19 @@ pub enum Booster{
|
||||
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)
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -158,16 +167,12 @@ 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()),
|
||||
Booster::Velocity(velocity.get().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(),
|
||||
direction:direction.get().to_array(),
|
||||
energy:energy.get(),
|
||||
},
|
||||
strafesnet_common::gameplay_attributes::Booster::AirTime(time)=>
|
||||
Booster::AirTime(time.get()),
|
||||
strafesnet_common::gameplay_attributes::Booster::Height(height)=>
|
||||
Booster::Height(height.to_raw()),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -235,23 +240,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)
|
||||
strafesnet_common::integer::Planar64Vec3::raw_array(velocity)
|
||||
),
|
||||
}
|
||||
}
|
||||
@ -265,27 +270,27 @@ impl From<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajecto
|
||||
),
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::Height(height)=>
|
||||
SetTrajectory::Height(
|
||||
height.to_raw()
|
||||
height.get()
|
||||
),
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::DotVelocity{direction,dot}=>
|
||||
SetTrajectory::DotVelocity{
|
||||
direction:direction.map(|t|t.to_raw()).to_array(),
|
||||
dot:dot.to_raw(),
|
||||
direction:direction.get().to_array(),
|
||||
dot:dot.get(),
|
||||
},
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointTime{target_point,time}=>
|
||||
SetTrajectory::TargetPointTime{
|
||||
target_point:target_point.map(|t|t.to_raw()).to_array(),
|
||||
target_point:target_point.get().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(),
|
||||
target_point:target_point.get().to_array(),
|
||||
speed:speed.get(),
|
||||
trajectory_choice:trajectory_choice.into(),
|
||||
},
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::Velocity(velocity)=>
|
||||
SetTrajectory::Velocity(
|
||||
velocity.map(|t|t.to_raw()).to_array()
|
||||
velocity.get().to_array()
|
||||
),
|
||||
}
|
||||
}
|
||||
@ -313,46 +318,48 @@ 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>,
|
||||
pub struct GeneralAttributesHeader{
|
||||
pub booster:u8,
|
||||
pub trajectory:u8,
|
||||
pub wormhole:u8,
|
||||
pub accelerator:u8,
|
||||
}
|
||||
impl GeneralAttributes{
|
||||
const BOOSTER:u8=1<<0;
|
||||
const TRAJECTORY:u8=1<<1;
|
||||
const WORMHOLE:u8=1<<2;
|
||||
const ACCELERATOR:u8=1<<3;
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
pub struct GeneralAttributes{
|
||||
pub header:GeneralAttributesHeader,
|
||||
#[br(count=header.booster)]
|
||||
pub booster:Vec<Booster>,
|
||||
#[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),
|
||||
trajectory:self.trajectory.map(Into::into),
|
||||
wormhole:self.wormhole.map(Into::into),
|
||||
accelerator:self.accelerator.map(Into::into),
|
||||
booster:self.booster.pop().map(Into::into),
|
||||
trajectory:self.trajectory.pop().map(Into::into),
|
||||
wormhole:self.wormhole.pop().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{
|
||||
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),
|
||||
header:GeneralAttributesHeader{
|
||||
booster:value.booster.is_some() as u8,
|
||||
trajectory:value.trajectory.is_some() as u8,
|
||||
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)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -360,25 +367,22 @@ 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;
|
||||
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{
|
||||
header:flag(value.contact_behaviour.is_some(),ContactingAttributes::CONTACTING_BEHAVIOUR),
|
||||
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)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -386,71 +390,22 @@ 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;
|
||||
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{
|
||||
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(),
|
||||
water_enabled:value.water.is_some() as u8,
|
||||
water:super::gameplay_style::stupid(value.water.map(Into::into)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -461,19 +416,25 @@ pub enum CollisionAttributes{
|
||||
#[brw(magic=0u8)]
|
||||
Decoration,
|
||||
#[brw(magic=1u8)]
|
||||
Contact(ContactAttributes),
|
||||
Contact{
|
||||
contacting:ContactingAttributes,
|
||||
general:GeneralAttributes,
|
||||
},
|
||||
#[brw(magic=2u8)]
|
||||
Intersect(IntersectAttributes),
|
||||
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()),
|
||||
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()},
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -482,10 +443,10 @@ impl From<strafesnet_common::gameplay_attributes::CollisionAttributes> for Colli
|
||||
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()),
|
||||
strafesnet_common::gameplay_attributes::CollisionAttributes::Contact{contacting,general}=>
|
||||
CollisionAttributes::Contact{contacting:contacting.into(),general:general.into()},
|
||||
strafesnet_common::gameplay_attributes::CollisionAttributes::Intersect{intersecting,general}=>
|
||||
CollisionAttributes::Intersect{intersecting:intersecting.into(),general:general.into()},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,74 +1,68 @@
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
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:StageId,
|
||||
#[br(if(header&Self::JUMP_LIMIT!=0))]
|
||||
pub jump_limit:Option<u8>,
|
||||
pub stage_id:u32,//which stage spawn to send to
|
||||
pub behaviour:StageElementBehaviour,
|
||||
pub jump_limit_enabled:u8,
|
||||
#[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 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(mut 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.jump_limit,
|
||||
))
|
||||
self.force.into(),
|
||||
self.behaviour.into(),
|
||||
self.jump_limit.pop(),
|
||||
)
|
||||
}
|
||||
}
|
||||
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(),
|
||||
behaviour:value.behaviour().into(),
|
||||
jump_limit_enabled:value.jump_limit().is_some() as u8,
|
||||
jump_limit:super::gameplay_style::stupid(value.jump_limit()),
|
||||
force:value.force().into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -123,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,
|
||||
@ -150,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,
|
||||
@ -168,31 +164,19 @@ 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)?,
|
||||
))
|
||||
(strafesnet_common::model::ModelId::new(model_id),stage_element.into())
|
||||
).collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
|
||||
|
||||
@ -1,103 +1,89 @@
|
||||
use super::common::flag;
|
||||
use super::integer::{Time,Ratio64,Planar64,Planar64Vec3};
|
||||
|
||||
pub type Controls=u32;
|
||||
#[derive(Debug)]
|
||||
pub enum ControlsError{
|
||||
UnknownBits,
|
||||
|
||||
#[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,
|
||||
}
|
||||
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 header:StyleModifiersHeader,
|
||||
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>,
|
||||
#[br(count=header.strafe)]
|
||||
pub strafe:Vec<StrafeSettings>,
|
||||
#[br(count=header.rocket)]
|
||||
pub rocket:Vec<PropulsionSettings>,
|
||||
#[br(count=header.jump)]
|
||||
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 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 Into<strafesnet_common::gameplay_style::StyleModifiers> for 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.pop().map(Into::into),
|
||||
rocket:self.rocket.pop().map(Into::into),
|
||||
jump:self.jump.pop().map(Into::into),
|
||||
walk:self.walk.pop().map(Into::into),
|
||||
ladder:self.ladder.pop().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),
|
||||
mass:strafesnet_common::integer::Planar64::raw(self.mass),
|
||||
}
|
||||
}
|
||||
}
|
||||
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)?,
|
||||
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),
|
||||
hitbox:self.hitbox.into(),
|
||||
camera_offset:strafesnet_common::integer::vec3::raw_array(self.camera_offset),
|
||||
mass:strafesnet_common::integer::Planar64::raw(self.mass),
|
||||
})
|
||||
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{
|
||||
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,
|
||||
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),
|
||||
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(),
|
||||
strafe:stupid(value.strafe.map(Into::into)),
|
||||
rocket:stupid(value.rocket.map(Into::into)),
|
||||
jump:stupid(value.jump.map(Into::into)),
|
||||
walk:stupid(value.walk.map(Into::into)),
|
||||
ladder:stupid(value.ladder.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.map(|t|t.to_raw()).to_array(),
|
||||
mass:value.mass.to_raw(),
|
||||
camera_offset:value.camera_offset.get().to_array(),
|
||||
mass:value.mass.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -105,52 +91,54 @@ 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,
|
||||
JumpCalculation::Capped=>strafesnet_common::gameplay_style::JumpCalculation::Capped,
|
||||
JumpCalculation::Energy=>strafesnet_common::gameplay_style::JumpCalculation::Energy,
|
||||
JumpCalculation::Linear=>strafesnet_common::gameplay_style::JumpCalculation::Linear,
|
||||
}
|
||||
}
|
||||
}
|
||||
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,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Capped=>JumpCalculation::Capped,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Energy=>JumpCalculation::Energy,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Linear=>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)),
|
||||
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)),
|
||||
}
|
||||
}
|
||||
}
|
||||
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()),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromTime(time)=>JumpImpulse::FromTime(time.get()),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromHeight(height)=>JumpImpulse::FromHeight(height.get()),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(deltav)=>JumpImpulse::FromDeltaV(deltav.get()),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(energy)=>JumpImpulse::FromEnergy(energy.get()),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -162,22 +150,21 @@ 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 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(),
|
||||
)
|
||||
}
|
||||
}
|
||||
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(),
|
||||
controls_mask:value.controls_mask().bits(),
|
||||
controls_intersects:value.controls_intersects().bits(),
|
||||
controls_contains:value.controls_contains().bits(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -185,47 +172,32 @@ 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>,
|
||||
air_accel_limit_enabled:u8,
|
||||
#[br(count=air_accel_limit_enabled)]
|
||||
air_accel_limit:Vec<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 Into<strafesnet_common::gameplay_style::StrafeSettings> for 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.pop().map(strafesnet_common::integer::Planar64::raw),
|
||||
self.tick_rate.into(),
|
||||
)
|
||||
}
|
||||
}
|
||||
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);
|
||||
let (enable,mv,air_accel_limit,tick_rate)=value.into_inner();
|
||||
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(),
|
||||
enable:enable.into(),
|
||||
mv:mv.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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -237,15 +209,15 @@ 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)
|
||||
}
|
||||
strafesnet_common::gameplay_style::PropulsionSettings::new(
|
||||
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(),
|
||||
magnitude:value.magnitude().get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -253,69 +225,23 @@ impl From<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionS
|
||||
#[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 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(),
|
||||
)
|
||||
}
|
||||
}
|
||||
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);
|
||||
let (impulse,calculation)=value.into_inner();
|
||||
Self{
|
||||
header,
|
||||
impulse,
|
||||
impulse:impulse.into(),
|
||||
calculation:calculation.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -328,17 +254,17 @@ 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),
|
||||
}
|
||||
strafesnet_common::gameplay_style::AccelerateSettings::new(
|
||||
strafesnet_common::integer::Planar64::raw(self.accel),
|
||||
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(),
|
||||
accel:value.accel().get(),
|
||||
topspeed:value.topspeed().get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -353,21 +279,22 @@ 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),
|
||||
}
|
||||
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),
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
|
||||
fn from(value:strafesnet_common::gameplay_style::WalkSettings)->Self{
|
||||
let (accelerate,static_friction,kinetic_friction,surf_dot)=value.into_inner();
|
||||
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(),
|
||||
accelerate:accelerate.into(),
|
||||
static_friction:static_friction.get(),
|
||||
kinetic_friction:kinetic_friction.get(),
|
||||
surf_dot:surf_dot.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -380,17 +307,18 @@ 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),
|
||||
}
|
||||
strafesnet_common::gameplay_style::LadderSettings::new(
|
||||
self.accelerate.into(),
|
||||
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{
|
||||
let (accelerate,dot)=value.into_inner();
|
||||
Self{
|
||||
accelerate:value.accelerate.into(),
|
||||
dot:value.dot.to_raw(),
|
||||
accelerate:accelerate.into(),
|
||||
dot:dot.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -427,7 +355,7 @@ 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(),
|
||||
}
|
||||
}
|
||||
@ -435,7 +363,7 @@ impl Into<strafesnet_common::gameplay_style::Hitbox> for Hitbox{
|
||||
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(),
|
||||
halfsize:value.halfsize.get().to_array(),
|
||||
mesh:value.mesh.into(),
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,21 +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 Into<strafesnet_common::integer::Ratio64> for Ratio64{
|
||||
fn into(self)->strafesnet_common::integer::Ratio64{
|
||||
strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap()
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::integer::Ratio64> for Ratio64{
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
use super::common::flag;
|
||||
use strafesnet_common::model::PolygonIter;
|
||||
|
||||
use super::integer::{Planar64Vec3,Planar64Affine3};
|
||||
@ -61,26 +60,22 @@ 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;
|
||||
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{
|
||||
let header=flag(value.texture.is_some(),RenderConfig::TEXTURE);
|
||||
Self{
|
||||
header,
|
||||
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())),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -153,8 +148,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{
|
||||
@ -200,10 +195,10 @@ impl From<strafesnet_common::model::Mesh> for Mesh{
|
||||
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())
|
||||
.map(|pos|pos.get().to_array())
|
||||
.collect(),
|
||||
unique_normal:value.unique_normal.into_iter()
|
||||
.map(|normal|normal.map(|t|t.to_raw()).to_array())
|
||||
.map(|normal|normal.get().to_array())
|
||||
.collect(),
|
||||
unique_tex:value.unique_tex.into_iter()
|
||||
.map(|tex|tex.to_array())
|
||||
@ -243,12 +238,12 @@ 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)
|
||||
),
|
||||
}
|
||||
}
|
||||
@ -261,10 +256,10 @@ impl From<strafesnet_common::model::Model> for Model{
|
||||
[_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()
|
||||
value.transform.matrix3.x_axis.get().to_array(),
|
||||
value.transform.matrix3.y_axis.get().to_array(),
|
||||
value.transform.matrix3.z_axis.get().to_array(),
|
||||
value.transform.translation.get().to_array()
|
||||
);
|
||||
Self{
|
||||
mesh:value.mesh.get(),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user