Compare commits
10 Commits
workaround
...
file-forma
Author | SHA1 | Date | |
---|---|---|---|
50d1a3188e | |||
9cc099a6eb | |||
5d9c124e76 | |||
d60486acc3 | |||
2eef7843a2 | |||
5e644c7eed | |||
567ce86370 | |||
9cef23c519 | |||
4f90956e16 | |||
1883c06f12 |
@ -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]
|
||||
|
@ -1,6 +1,5 @@
|
||||
use binrw::BinReaderExt;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error{
|
||||
InvalidHeader,
|
||||
}
|
||||
@ -28,4 +27,4 @@ impl<R:BinReaderExt> StreamableDemo<R>{
|
||||
pub(crate) fn new(file:crate::file::File<R>)->Result<Self,Error>{
|
||||
Err(Error::InvalidHeader)
|
||||
}
|
||||
}
|
||||
}
|
28
src/file.rs
28
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>{
|
||||
|
@ -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>),
|
||||
|
201
src/map.rs
201
src/map.rs
@ -3,29 +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),
|
||||
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
|
||||
|
||||
@ -143,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)]
|
||||
@ -169,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)?;
|
||||
@ -251,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>{
|
||||
@ -266,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,
|
||||
@ -304,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(®ion,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));
|
||||
}
|
||||
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(())
|
||||
}
|
||||
|
@ -1,4 +1,3 @@
|
||||
mod common;
|
||||
pub mod aabb;
|
||||
pub mod model;
|
||||
pub mod integer;
|
||||
|
@ -13,11 +13,3 @@ impl Into<strafesnet_common::aabb::Aabb> for Aabb{
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::aabb::Aabb> for Aabb{
|
||||
fn from(value:strafesnet_common::aabb::Aabb)->Self{
|
||||
Self{
|
||||
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,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)]
|
||||
@ -88,15 +57,6 @@ impl Into<strafesnet_common::gameplay_attributes::IntersectingWater> for Interse
|
||||
}
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_attributes::IntersectingWater> for IntersectingWater{
|
||||
fn from(value:strafesnet_common::gameplay_attributes::IntersectingWater)->Self{
|
||||
Self{
|
||||
viscosity:value.viscosity.get(),
|
||||
density:value.density.get(),
|
||||
velocity:value.velocity.get().to_array(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -110,20 +70,11 @@ impl Into<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
|
||||
}
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
|
||||
fn from(value:strafesnet_common::gameplay_attributes::Accelerator)->Self{
|
||||
Self{
|
||||
acceleration:value.acceleration.get().to_array(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[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{
|
||||
@ -141,19 +92,6 @@ impl Into<strafesnet_common::gameplay_attributes::Booster> for Booster{
|
||||
}
|
||||
}
|
||||
}
|
||||
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.get().to_array()),
|
||||
strafesnet_common::gameplay_attributes::Booster::Energy{direction,energy}=>
|
||||
Booster::Energy{
|
||||
direction:direction.get().to_array(),
|
||||
energy:energy.get(),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little,repr=u8)]
|
||||
@ -171,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{
|
||||
@ -239,40 +161,6 @@ impl Into<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajecto
|
||||
}
|
||||
}
|
||||
}
|
||||
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.get()
|
||||
),
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::DotVelocity{direction,dot}=>
|
||||
SetTrajectory::DotVelocity{
|
||||
direction:direction.get().to_array(),
|
||||
dot:dot.get(),
|
||||
},
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointTime{target_point,time}=>
|
||||
SetTrajectory::TargetPointTime{
|
||||
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.get().to_array(),
|
||||
speed:speed.get(),
|
||||
trajectory_choice:trajectory_choice.into(),
|
||||
},
|
||||
strafesnet_common::gameplay_attributes::SetTrajectory::Velocity(velocity)=>
|
||||
SetTrajectory::Velocity(
|
||||
velocity.get().to_array()
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -286,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{
|
||||
@ -323,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{
|
||||
@ -357,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{
|
||||
@ -383,26 +219,14 @@ 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 enum CollisionAttributes{
|
||||
#[brw(magic=0u8)]
|
||||
Decoration,
|
||||
#[brw(magic=1u8)]
|
||||
Contact{
|
||||
contacting:ContactingAttributes,
|
||||
general:GeneralAttributes,
|
||||
},
|
||||
#[brw(magic=2u8)]
|
||||
Intersect{
|
||||
intersecting:IntersectingAttributes,
|
||||
general:GeneralAttributes,
|
||||
@ -420,15 +244,3 @@ impl Into<strafesnet_common::gameplay_attributes::CollisionAttributes> for Colli
|
||||
}
|
||||
}
|
||||
}
|
||||
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{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,63 +1,46 @@
|
||||
use super::common::flag;
|
||||
#[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:u32,
|
||||
#[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>,
|
||||
}
|
||||
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
|
||||
}
|
||||
pub force:Option<()>,//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{
|
||||
strafesnet_common::gameplay_modes::StageElement::new(
|
||||
strafesnet_common::gameplay_modes::StageId::new(self.stage_id),
|
||||
self.force(),
|
||||
self.behaviour().unwrap(),
|
||||
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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -88,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)]
|
||||
@ -124,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)]
|
||||
@ -169,26 +124,3 @@ impl Into<strafesnet_common::gameplay_modes::Mode> for Mode{
|
||||
)
|
||||
}
|
||||
}
|
||||
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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,4 +1,3 @@
|
||||
use super::common::flag;
|
||||
use super::integer::{Time,Ratio64,Planar64,Planar64Vec3};
|
||||
|
||||
pub type Controls=u32;
|
||||
@ -6,34 +5,19 @@ pub type Controls=u32;
|
||||
#[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;
|
||||
}
|
||||
impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
|
||||
fn into(self)->strafesnet_common::gameplay_style::StyleModifiers{
|
||||
strafesnet_common::gameplay_style::StyleModifiers{
|
||||
@ -53,32 +37,6 @@ impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
|
||||
}
|
||||
}
|
||||
}
|
||||
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.get().to_array(),
|
||||
hitbox:value.hitbox.into(),
|
||||
camera_offset:value.camera_offset.get().to_array(),
|
||||
mass:value.mass.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little,repr=u8)]
|
||||
@ -96,17 +54,9 @@ impl Into<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculatio
|
||||
}
|
||||
}
|
||||
}
|
||||
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::Capped=>JumpCalculation::Capped,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Energy=>JumpCalculation::Energy,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Linear=>JumpCalculation::Linear,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//TODO: test this
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
pub enum JumpImpulse{
|
||||
FromTime(Time),
|
||||
FromHeight(Planar64),
|
||||
@ -123,16 +73,6 @@ impl Into<strafesnet_common::gameplay_style::JumpImpulse> for JumpImpulse{
|
||||
}
|
||||
}
|
||||
}
|
||||
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::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()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -150,29 +90,15 @@ impl Into<strafesnet_common::gameplay_style::ControlsActivation> for ControlsAct
|
||||
)
|
||||
}
|
||||
}
|
||||
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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[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;
|
||||
}
|
||||
impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
|
||||
fn into(self)->strafesnet_common::gameplay_style::StrafeSettings{
|
||||
strafesnet_common::gameplay_style::StrafeSettings::new(
|
||||
@ -183,19 +109,6 @@ impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
|
||||
fn from(value:strafesnet_common::gameplay_style::StrafeSettings)->Self{
|
||||
let (enable,mv,air_accel_limit,tick_rate)=value.into_inner();
|
||||
let header=flag(air_accel_limit.is_some(),StrafeSettings::AIR_ACCEL_LIMIT);
|
||||
Self{
|
||||
header,
|
||||
enable:enable.into(),
|
||||
mv:mv.get(),
|
||||
air_accel_limit:air_accel_limit.map(|a|a.get()),
|
||||
tick_rate:tick_rate.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -209,72 +122,21 @@ impl Into<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionS
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionSettings{
|
||||
fn from(value:strafesnet_common::gameplay_style::PropulsionSettings)->Self{
|
||||
Self{
|
||||
magnitude:value.magnitude().get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
pub struct JumpSettings{
|
||||
header:u8,
|
||||
impulse:i64,
|
||||
}
|
||||
impl JumpSettings{
|
||||
const IMPULSE:u8=0b0011;
|
||||
const CALCULATION:u8=0b1100;
|
||||
const fn impulse(&self)->Option<strafesnet_common::gameplay_style::JumpImpulse>{
|
||||
match self.header&Self::IMPULSE{
|
||||
0=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromTime(strafesnet_common::integer::Time::raw(self.impulse))),
|
||||
1=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromHeight(strafesnet_common::integer::Planar64::raw(self.impulse))),
|
||||
2=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(strafesnet_common::integer::Planar64::raw(self.impulse))),
|
||||
3=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(strafesnet_common::integer::Planar64::raw(self.impulse))),
|
||||
_=>None,
|
||||
}
|
||||
}
|
||||
const fn calculation(&self)->Option<strafesnet_common::gameplay_style::JumpCalculation>{
|
||||
match (self.header&Self::CALCULATION)>>2{
|
||||
0=>Some(strafesnet_common::gameplay_style::JumpCalculation::Capped),
|
||||
1=>Some(strafesnet_common::gameplay_style::JumpCalculation::Energy),
|
||||
2=>Some(strafesnet_common::gameplay_style::JumpCalculation::Linear),
|
||||
_=>None,
|
||||
}
|
||||
}
|
||||
impulse:JumpImpulse,
|
||||
calculation:JumpCalculation,
|
||||
}
|
||||
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().unwrap(),
|
||||
self.calculation().unwrap(),
|
||||
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_enum,calculation)=value.into_inner();
|
||||
let (impulse,impulse_header)=match impulse_enum{
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromTime(impulse)=>(impulse.get(),0),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromHeight(impulse)=>(impulse.get(),1),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(impulse)=>(impulse.get(),2),
|
||||
strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(impulse)=>(impulse.get(),3),
|
||||
};
|
||||
let calculation_header=match calculation{
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Capped=>0,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Energy=>1,
|
||||
strafesnet_common::gameplay_style::JumpCalculation::Linear=>2,
|
||||
};
|
||||
let header=
|
||||
impulse_header
|
||||
|(calculation_header<<2);
|
||||
Self{
|
||||
header,
|
||||
impulse,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -290,14 +152,6 @@ impl Into<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateS
|
||||
)
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateSettings{
|
||||
fn from(value:strafesnet_common::gameplay_style::AccelerateSettings)->Self{
|
||||
Self{
|
||||
accel:value.accel().get(),
|
||||
topspeed:value.topspeed().get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -317,17 +171,6 @@ impl Into<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
|
||||
)
|
||||
}
|
||||
}
|
||||
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:accelerate.into(),
|
||||
static_friction:static_friction.get(),
|
||||
kinetic_friction:kinetic_friction.get(),
|
||||
surf_dot:surf_dot.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
@ -343,15 +186,6 @@ impl Into<strafesnet_common::gameplay_style::LadderSettings> for LadderSettings{
|
||||
)
|
||||
}
|
||||
}
|
||||
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:accelerate.into(),
|
||||
dot:dot.get(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little,repr=u8)]
|
||||
@ -367,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)]
|
||||
@ -390,11 +216,3 @@ 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.get().to_array(),
|
||||
mesh:value.mesh.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -11,14 +11,6 @@ impl Into<strafesnet_common::integer::Ratio64> for Ratio64{
|
||||
strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap()
|
||||
}
|
||||
}
|
||||
impl From<strafesnet_common::integer::Ratio64> for Ratio64{
|
||||
fn from(value:strafesnet_common::integer::Ratio64)->Self{
|
||||
Self{
|
||||
num:value.num(),
|
||||
den:value.den(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[binrw::binrw]
|
||||
#[brw(little)]
|
||||
|
@ -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)]
|
||||
@ -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.get().to_array())
|
||||
.collect(),
|
||||
unique_normal:value.unique_normal.into_iter()
|
||||
.map(|normal|normal.get().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)]
|
||||
@ -253,24 +150,3 @@ impl Into<strafesnet_common::model::Model> for Model{
|
||||
}
|
||||
}
|
||||
}
|
||||
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.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(),
|
||||
attributes:value.attributes.get(),
|
||||
color:value.color.to_array(),
|
||||
transform:[_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
Reference in New Issue
Block a user