snf/src/bot.rs

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)
	}
}