}

impl<'l> Placement<'l> {

pub fn get_pos(&self) -> GridPos {

self.pos

}

pub fn get_block(&self) -> &'l Block {

self.block

}

pub fn get_state(&self) -> Option<&dyn Any> {

match self.state {

None => None,

Ok(std::mem::replace(&mut self.state, state))

}

pub fn get_rotation(&self) -> Rotation {

self.rot

}

}

impl<'l> Schematic<'l> {

pub fn new(width: u16, height: u16) -> Self {

match Self::try_new(width, height) {

Ok(s) => s,

})

}

pub fn get_width(&self) -> u16 {

self.width

}

pub fn get_height(&self) -> u16 {

self.height

}

pub fn get_tags(&self) -> &HashMap<String, String> {

&self.tags

}

&mut self.tags

}

pub fn is_empty(&self) -> bool {

self.blocks.is_empty()

}

pub fn get_block_count(&self) -> usize {

self.blocks.len()

}

pub fn is_region_empty(&self, x: u16, y: u16, w: u16, h: u16) -> bool {

return true;

}

if x >= self.width || y >= self.height || w == 0 || h == 0 {

h: self.height,

});

}

return Ok(None);

}

let pos = (x as usize) + (y as usize) * (self.width as usize);

h: self.height,

});

}

return Ok(None);

}

let pos = (x as usize) + (y as usize) * (self.width as usize);

}

fn fill_lookup(&mut self, x: usize, y: usize, sz: usize, val: Option<usize>) {

self.lookup

.resize((self.width as usize) * (self.height as usize), None);

}

if sz > 1 {

let (x0, y0) = (x - off, y - off);

for dy in 0..sz {

for dx in 0..sz {

data: DynData,

rot: Rotation,

) -> Result<&Placement<'l>, PlaceError> {

let off = (sz - 1) / 2;

if x < off || y < off {

return Err(PlaceError::Bounds {

rot: Rotation,

collect: bool,

) -> Result<Option<Vec<Placement<'l>>>, PlaceError> {

let off = (sz - 1) / 2;

if x < off || y < off {

return Err(PlaceError::Bounds {

h: self.height,

});

}

let pos = (x as usize) + (y as usize) * (self.width as usize);

match self.lookup[pos] {

None => Ok(None),

Some(idx) => Ok(Some(self.swap_remove(idx))),

}

}

}

fn rebuild_lookup(&mut self) {

self.lookup.clear();

self.lookup

.resize((self.width as usize) * (self.height as usize), None);

for (i, curr) in self.blocks.iter().enumerate() {

pub fn mirror(&mut self, horizontally: bool, vertically: bool) {

if !self.blocks.is_empty() && (horizontally || vertically) {

// because position is the bottom left of the center (which changes during mirroring)

if horizontally {

curr.pos.0 = self.width - 1 - curr.pos.0 - shift;

}

self.width = h;

self.height = w;

if !self.blocks.is_empty() {

let x = curr.pos.0;

let y = curr.pos.1;

// because position is the bottom left of the center (which changes during rotation)

if clockwise {

curr.pos.0 = y;

curr.pos.1 = w - 1 - x - shift;

let top_bound = dy + h as i16 - 1;

let left_bound = dx;

let bottom_bound = dy;

let (x0, y0, x1, y1) = (

pos.0 - (sz - 1) / 2,

pos.1 - (sz - 1) / 2,

bottom = bottom_bound as u16 - y0;

}

}

return Err(ResizeError::Truncated {

right,

top,

}

self.width = w;

self.height = h;

pos.0 = (pos.0 as i16 + dx) as u16;

pos.1 = (pos.1 as i16 + dy) as u16;

}

self.mirror(true, true);

}

pub fn pos_iter(&self) -> PosIter {

PosIter {

x: 0,

self.blocks.iter()

}

pub fn compute_total_cost(&self) -> (ItemStorage, bool) {

let mut cost = ItemStorage::new();

let mut sandbox = false;

if let Some(curr) = block.get_build_cost() {

cost.add_all(curr, u32::MAX);

} else {

// find unique letters for each block, more common blocks pick first

let mut name_cnt = HashMap::<&str, u16>::new();

match name_cnt.entry(p.block.get_name()) {

Entry::Occupied(mut e) => *e.get_mut() += 1,

Entry::Vacant(e) => {

0x70u8, 0x00u8, 0x00u8, 0x40u8, 0x90u8,

];

let mut types = HashMap::<&str, char>::new();

let mut found = false;

for c in name.chars() {

if c > ' ' && c <= '~' {

}

// coordinates start in the bottom left, so y starts at self.height - 1

for y in (0..self.height as usize).rev() {

let mut x = 0usize;

while x < self.width as usize {

let v = *types.get(k).unwrap();

write!(f, "\n({v}) {k}")?;

}

}

Ok(())

}

buff.write_u32(SCHEMATIC_HEADER)?;

buff.write_u8(1)?;

// don't have to check dimensions because they're already limited to MAX_DIMENSION

rbuff.write_i16(data.width as i16)?;

rbuff.write_i16(data.height as i16)?;

return Err(WriteError::TagCount(data.tags.len()));

}

rbuff.write_u8(data.tags.len() as u8)?;

rbuff.write_utf(k)?;

rbuff.write_utf(v)?;

}

// use string keys here to avoid issues with different block refs with the same name

let mut block_map = HashMap::<&str, u32>::new();

let mut block_table = Vec::<&str>::new();

}

}

if block_table.len() > i8::MAX as usize {

}

// else: implies contents are also valid i8 (they're strictly less than the map length)

rbuff.write_i8(block_table.len() as i8)?;

rbuff.write_utf(name)?;

}

// don't have to check data.blocks.len() because dimensions don't allow exceeding MAX_BLOCKS

rbuff.write_i32(data.blocks.len() as i32)?;

let mut num = 0;

rbuff.write_i8(block_map[curr.block.get_name()] as i8)?;

rbuff.write_u32(u32::from(curr.pos))?;

let data = match curr.state {

assert_eq!(num, data.blocks.len());

// compress into the provided buffer

let mut comp = Compress::new(Compression::default(), true);

// compress the immediate buffer into a temp buffer to copy it to buff? no thanks

match buff.data {

}

pub fn serialize_base64(&mut self, data: &Schematic<'l>) -> Result<String, W64Error> {

self.serialize(&mut buff, data)?;

let buff = buff.get_written();

// round up because of padding

let mut text = Vec::<u8>::new();

text.resize(required, 0);

let n_out = base64::encode(buff, text.as_mut())?;