94 lines
2.6 KiB
Rust
94 lines
2.6 KiB
Rust
use binrw::{BinReaderExt, binrw};
|
|
|
|
pub enum Error{
|
|
InvalidHeader,
|
|
InvalidSegment(binrw::Error),
|
|
InvalidSegmentId(u64),
|
|
File(crate::file::Error),
|
|
}
|
|
|
|
/* block types
|
|
|
|
BLOCK_BOT_HEADER:
|
|
u128 map_resource_uuid //which map is this bot running
|
|
//don't include style info in bot header because it's in the simulation state
|
|
//blocks are laid out in chronological order, but indices may jump around.
|
|
u64 num_segments
|
|
for _ in 0..num_segments{
|
|
i64 time //simulation_state timestamp
|
|
u64 block_id
|
|
}
|
|
|
|
BLOCK_BOT_SEGMENT:
|
|
//format version indicates what version of these structures to use
|
|
SimulationState simulation_state //SimulationState is just under ClientState which includes Play/Pause events that the simulation doesn't know about.
|
|
//to read, greedily decode instructions until eof
|
|
loop{
|
|
//delta encode as much as possible (time,mousepos)
|
|
//strafe ticks are implied
|
|
//physics can be implied in an input-only bot file
|
|
TimedInstruction<SimulationInstruction> instruction
|
|
}
|
|
|
|
*/
|
|
|
|
//error hiding mock code
|
|
mod simulation{
|
|
#[super::binrw]
|
|
#[brw(little)]
|
|
pub struct State{}
|
|
#[super::binrw]
|
|
#[brw(little)]
|
|
pub struct Instruction{}
|
|
}
|
|
// mod instruction{
|
|
// #[super::binrw]
|
|
// #[brw(little)]
|
|
// pub struct TimedInstruction<Instruction:binrw::BinRead+binrw::BinWrite>{
|
|
// time:u64,
|
|
// instruction:Instruction
|
|
// }
|
|
// }
|
|
// mod timeline{
|
|
// #[super::binrw]
|
|
// #[brw(little)]
|
|
// pub struct Timeline<Instruction:binrw::BinRead+binrw::BinWrite>{
|
|
// #[bw(try_calc(u32::try_from(instructions.len())))]
|
|
// instruction_count:u32,
|
|
// #[br(count=instruction_count)]
|
|
// instructions:Vec<super::instruction::TimedInstruction<Instruction>>
|
|
// }
|
|
// }
|
|
|
|
//serious code
|
|
|
|
#[binrw]
|
|
#[brw(little)]
|
|
struct SegmentId(u64);
|
|
|
|
#[binrw]
|
|
#[brw(little)]
|
|
pub struct Segment{
|
|
state:simulation::State,
|
|
//#[bw(try_calc(u32::try_from(instructions.len())))]
|
|
//instruction_count:u32,
|
|
//#[br(count=instruction_count)]
|
|
//instructions:Vec<instruction::TimedInstruction<simulation::Instruction>>
|
|
}
|
|
|
|
pub struct StreamableBot<R:BinReaderExt>{
|
|
file:crate::file::File<R>,
|
|
//timeline:timeline::Timeline<SegmentId>,
|
|
segment_id_to_block_id:Vec<crate::file::BlockId>,
|
|
}
|
|
impl<R:BinReaderExt> StreamableBot<R>{
|
|
pub(crate) fn new(file:crate::file::File<R>)->Result<Self,Error>{
|
|
Err(Error::InvalidHeader)
|
|
}
|
|
pub fn load_segment(&mut self,segment_id:SegmentId)->Result<Segment,Error>{
|
|
let block_id=*self.segment_id_to_block_id.get(segment_id.0 as usize).ok_or(Error::InvalidSegmentId(segment_id.0))?;
|
|
let mut block=self.file.take_block(block_id).map_err(|e|Error::File(e))?;
|
|
let segment=block.read_le().map_err(|e|Error::InvalidSegment(e))?;
|
|
Ok(segment)
|
|
}
|
|
} |