-seq-macro = "0.3.4"

- method: zip::CompressionMethod,

- let options = FileOptions::default()

- .compression_method(method)

- zip::CompressionMethod::Zstd,

-use std::error::Error;

-use std::fmt;

-use crate::data::renderer::{load, ImageHolder};

-use crate::utils::ImageUtils;

-make_simple!(ConveyorBlock);

- |_, _, _, _| None,

- }

- "plastanium-conveyor" => ConveyorBlock::new(1, false, cost!(Graphite: 1, Silicon: 1, Plastanium: 1));

- "router" => ConveyorBlock::new(1, true, cost!(Copper: 3));

- "distributor" => ConveyorBlock::new(2, true, cost!(Copper: 4, Lead: 4));

- "overflow-gate" => ConveyorBlock::new(1, true, cost!(Copper: 4, Lead: 2));

- "underflow-gate" => ConveyorBlock::new(1, true, cost!(Copper: 4, Lead: 2));

- "overflow-duct" => ConveyorBlock::new(1, true, cost!(Graphite: 8, Beryllium: 8));

- "underflow-duct" => ConveyorBlock::new(1, true, cost!(Graphite: 8, Beryllium: 8));

- "surge-conveyor" => ConveyorBlock::new(1, false, cost!(SurgeAlloy: 1, Tungsten: 1));

- "surge-router" => ConveyorBlock::new(1, false, cost!(SurgeAlloy: 5, Tungsten: 1)); // not symmetric

- "unit-cargo-loader" => ConveyorBlock::new(3, true, cost!(Silicon: 80, SurgeAlloy: 50, Oxide: 20));

- fn draw(&self, category: &str, name: &str, state: Option<&State>) -> Option<ImageHolder> {

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for ItemConvertError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(f, "invalid config ({}) for item", self.0)

- }

-}

-

-impl Error for ItemConvertError {}

-

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

- NotFound(item::TryFromU16Error),

-impl From<item::TryFromU16Error> for ItemDeserializeError {

- fn from(err: item::TryFromU16Error) -> Self {

- Self::NotFound(err)

- }

-}

-

-impl fmt::Display for ItemDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::ContentType(have) => write!(

- f,

- "expected content {:?} but got {have:?}",

- content::Type::Item

- ),

- Self::NotFound(..) => f.write_str("target item not found"),

- }

- }

-}

-

-impl Error for ItemDeserializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::NotFound(e) => Some(e),

- _ => None,

- }

- }

-}

-

- let dx = i32::from(x) - i32::from(pos.0);

- let dy = i32::from(y) - i32::from(pos.1);

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-

-impl fmt::Display for BridgeConvertError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(f, "invalid coordinate ({} / {}) for bridge", self.x, self.y)

- }

-}

-

-impl Error for BridgeConvertError {}

-make_simple!(DrillBlock, |me: &DrillBlock, _, name, _| {

- make_simple!(EnvironmentBlock, |_, _, name, _| {

-use std::error::Error;

-use std::fmt;

- fn draw(&self, category: &str, name: &str, state: Option<&State>) -> Option<ImageHolder> {

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for FluidConvertError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(f, "invalid config ({}) for fluid", self.0)

- }

-}

-

-impl Error for FluidConvertError {}

-

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

- NotFound(fluid::TryFromU16Error),

-

-impl From<fluid::TryFromU16Error> for FluidDeserializeError {

- fn from(err: fluid::TryFromU16Error) -> Self {

- Self::NotFound(err)

- }

-}

-

-impl fmt::Display for FluidDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::ContentType(have) => write!(

- f,

- "expected content {:?} but got {have:?}",

- content::Type::Fluid

- ),

- Self::NotFound(..) => f.write_str("fluid not found"),

- }

- }

-}

-

-impl Error for FluidDeserializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::NotFound(e) => Some(e),

- _ => None,

- }

- }

-}

-use std::error::Error;

-use std::fmt;

-use flate2::{

- Compress, CompressError, Compression, Decompress, DecompressError, FlushCompress,

- FlushDecompress, Status,

-};

-

-use crate::data::{self, DataRead, DataWrite};

- let mut input = arr.as_ref();

- let mut dec = Decompress::new(true);

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

- raw.reserve(1024);

- loop {

- let t_in = dec.total_in();

- let t_out = dec.total_out();

- let res = ProcessorDeserializeError::forward(dec.decompress_vec(

- input,

- &mut raw,

- FlushDecompress::Finish,

- ))?;

- if dec.total_in() > t_in {

- // we have to advance input every time, decompress_vec only knows the output position

- input = &input[(dec.total_in() - t_in) as usize..];

- }

- match res {

- // there's no more input (and the flush mode says so), we need to reserve additional space

- Status::Ok | Status::BufError => (),

- // input was already at the end, so this is referring to the output

- Status::StreamEnd => break,

- }

- if dec.total_in() == t_in && dec.total_out() == t_out {

- // protect against looping forever

- return Err(DeserializeError::Custom(Box::new(

- ProcessorDeserializeError::DecompressStall,

- )));

- }

- raw.reserve(1024);

- }

- let mut buff = DataRead::new(&raw);

- let mut input = rbuff.get_written();

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

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

- dst.reserve(1024);

- loop {

- let t_in = comp.total_in();

- let t_out = comp.total_out();

- let res = ProcessorSerializeError::forward(comp.compress_vec(

- input,

- &mut dst,

- FlushCompress::Finish,

- ))?;

- if comp.total_in() > t_in {

- // we have to advance input every time, compress_vec only knows the output position

- input = &input[(comp.total_in() - t_in) as usize..];

- }

- match res {

- // there's no more input (and the flush mode says so), we need to reserve additional space

- Status::Ok | Status::BufError => (),

- // input was already at the end, so this is referring to the output

- Status::StreamEnd => break,

- }

- if comp.total_in() == t_in && comp.total_out() == t_out {

- // protect against looping forever

- return Err(SerializeError::Custom(Box::new(

- ProcessorSerializeError::CompressStall,

- )));

- }

- dst.reserve(1024);

- }

- Ok(DynData::ByteArray(dst))

-#[derive(Debug)]

- Read(data::ReadError),

- Decompress(DecompressError),

- DecompressStall,

- FromUtf8(FromUtf8Error),

-impl From<data::ReadError> for ProcessorDeserializeError {

- fn from(value: data::ReadError) -> Self {

- Self::Read(value)

- }

-}

-

-impl From<DecompressError> for ProcessorDeserializeError {

- fn from(value: DecompressError) -> Self {

- Self::Decompress(value)

- }

-}

-

-impl From<FromUtf8Error> for ProcessorDeserializeError {

- fn from(value: FromUtf8Error) -> Self {

- Self::FromUtf8(value)

- }

-}

-

-impl fmt::Display for ProcessorDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::Read(..) => f.write_str("failed to read state data"),

- Self::Decompress(..) => f.write_str("zlib decompression failed"),

- Self::DecompressStall => f.write_str("decompressor stalled before completion"),

- Self::FromUtf8(..) => f.write_str("malformed utf-8 in processor code"),

- Self::Version(ver) => write!(f, "unsupported version ({ver})"),

- Self::CodeLength(len) => write!(f, "invalid code length ({len})"),

- Self::LinkCount(cnt) => write!(f, "invalid link count ({cnt})"),

- }

- }

-}

-

-impl Error for ProcessorDeserializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::Decompress(e) => Some(e),

- Self::FromUtf8(e) => Some(e),

- _ => None,

- }

- }

-}

-

-#[derive(Debug)]

- Write(data::WriteError),

- Compress(CompressError),

- CompressEof(usize),

- CompressStall,

-impl From<data::WriteError> for ProcessorSerializeError {

- fn from(value: data::WriteError) -> Self {

- Self::Write(value)

- }

-}

-

-impl From<CompressError> for ProcessorSerializeError {

- fn from(value: CompressError) -> Self {

- Self::Compress(value)

- }

-}

-

-impl fmt::Display for ProcessorSerializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::Write(..) => f.write_str("failed to write state data"),

- Self::Compress(..) => f.write_str("zlib compression failed"),

- Self::CompressEof(remain) => write!(

- f,

- "compression overflow with {remain} bytes of input remaining"

- ),

- Self::CompressStall => f.write_str("compressor stalled before completion"),

- }

- }

-}

-

-impl Error for ProcessorSerializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::Compress(e) => Some(e),

- _ => None,

- }

- }

-}

-

-#[derive(Clone, Debug, Eq, PartialEq)]

-impl fmt::Display for CodeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::TooLong(len) => write!(f, "code too long ({len} bytes)"),

- }

- }

-}

-

-impl Error for CodeError {}

-

-#[derive(Clone, Debug, Eq, PartialEq)]

-

-impl fmt::Display for CreateError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::NameLength(len) => write!(f, "link name too long ({len} bytes)"),

- Self::DuplicateName(name) => write!(f, "there already is a link named {name}"),

- Self::DuplicatePos { name, x, y } => {

- write!(f, "link {name} already points to {x} / {y}")

- }

- }

- }

-}

-

-impl Error for CreateError {}

-use crate::data::renderer::ImageHolder;

-pub mod campaign;

-pub mod content;

-pub mod defense;

-pub mod distribution;

-pub mod drills;

-pub mod environment;

-pub mod liquid;

-pub mod logic;

-pub mod payload;

-pub mod power;

-pub mod production;

-pub mod simple;

-pub mod storage;

-pub mod turrets;

-pub mod walls;

- fn draw(&self, _category: &str, _name: &str, _state: Option<&State>) -> Option<ImageHolder> {

-#[derive(Debug)]

- Custom(Box<dyn Error + Sync + Send>),

-impl fmt::Display for DataConvertError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::Custom(e) => e.fmt(f),

- }

- }

-}

-

-impl Error for DataConvertError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::Custom(e) => e.source(),

- }

- }

-}

-

-#[derive(Debug)]

- Custom(Box<dyn Error + Sync + Send>),

-impl fmt::Display for DeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::InvalidType { have, expect } => {

- write!(f, "expected type {expect:?} but got {have:?}")

- }

- Self::Custom(e) => e.fmt(f),

- }

- }

-}

-

-impl Error for DeserializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::Custom(e) => e.source(),

- _ => None,

- }

- }

-}

-

-#[derive(Debug)]

- Custom(Box<dyn Error + Sync + Send>),

-impl fmt::Display for SerializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::Custom(e) => e.fmt(f),

- }

- }

-}

-

-impl Error for SerializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::Custom(e) => e.source(),

- }

- }

-}

-

- pub fn image(&self, state: Option<&State>) -> ImageHolder {

- if let Some(p) = self.logic.as_ref().draw(&self.category, &self.name, state) {

- use crate::data::renderer::read;

- write!(f, "Block {{ name: {name:?} }}")

- pub fn register(reg: &mut $crate::block::BlockRegistry<'_>) {

-use std::error::Error;

-use std::fmt;

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for AssemblerDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(

- f,

- "invalid unit index ({}, #valid: {})",

- self.idx, self.count

- )

- }

-}

-

-impl Error for AssemblerDeserializeError {}

-

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for AssemblerSerializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(f, "invalid unit ({:?}) is not valid", self.0)

- }

-}

-

-impl Error for AssemblerSerializeError {}

-

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

- BlockNotFound(block::content::TryFromU16Error),

- UnitNotFound(unit::TryFromU16Error),

-

-impl From<block::content::TryFromU16Error> for PayloadDeserializeError {

- fn from(err: block::content::TryFromU16Error) -> Self {

- Self::BlockNotFound(err)

- }

-}

-

-impl From<unit::TryFromU16Error> for PayloadDeserializeError {

- fn from(err: unit::TryFromU16Error) -> Self {

- Self::UnitNotFound(err)

- }

-}

-

-impl fmt::Display for PayloadDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::ContentType(have) => write!(

- f,

- "expected content {:?} or {:?} but got {have:?}",

- content::Type::Block,

- content::Type::Unit

- ),

- Self::BlockNotFound(..) => f.write_str("payload block not found"),

- Self::UnitNotFound(..) => f.write_str("payload unit not found"),

- }

- }

-}

-

-impl Error for PayloadDeserializeError {

- fn source(&self) -> Option<&(dyn Error + 'static)> {

- match self {

- Self::BlockNotFound(e) => Some(e),

- Self::UnitNotFound(e) => Some(e),

- _ => None,

- }

- }

-}

-use std::error::Error;

-use std::fmt;

-#[derive(Debug)]

-impl fmt::Display for ConnectorDeserializeError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- match self {

- Self::LinkCount { have, max } => {

- write!(f, "too many links ({have} but only {max} supported)")

- }

- }

- }

-}

-

-impl Error for ConnectorDeserializeError {}

-

- |_, _, _, _| None,

- |_, _, _, _| None,

- ($name: ident, $draw: expr, $read: expr) => {

- $draw(self, category, name, state)

- crate::block::simple::make_simple!($name, $draw, |_, _, _, _, _, _| Ok(()));

- crate::block::simple::make_simple!($name, |_, _, _, _| None, |_, _, _, _, _, _| { Ok(()) });

-crate::block::simple::make_simple!(TurretBlock, |me: &Self, _, name, _| {

-make_simple!(WallBlock, |_, _, name, _| {

-//! note: utf = `len<u16>` + utf8(read(len))

-//! - 4 bytes of idk (skip)

-//! - iterate `i8` (should = `8`)'//! - the type: `i8` (0: item, block: 1, liquid: 4, status: 5, unit: 6, weather: 7, sector: 9, planet: 13//! - item count: `u1\'6` (item: 22, block: 412, liquid: 11, status: 21, unit: 66, weather: 6, sector: 35, planet: 7)

-//! - these types all have their own modules: [`crate::item`], [`crate::block::content`], [`crate::fluid`], [`crate::modifier`], [`crate::unit`], [`crate::data::weather`], [`crate::data::sector`], [`crate::data::planet`]

-//! - o: `DynData` (refer to [crate::data::dynamic::DynSerializer])

-use crate::block::{Block, BlockRegistry, Rotation};

-use crate::item::storage::Storage;

-use crate::item::Type as Item;

-use super::GridPos;

- pub pos: GridPos,

- pub build: Option<Build<'l>>,

- pub fn image(&self) -> ImageHolder {

- b.image()

- let mut i = self.floor.image(None).own();

- i.overlay(ore.image(None).borrow(), 0, 0);

- "Tile<{},{}>@{}+{}{}",

- self.pos.0,

- self.pos.1,

- ore.name()

- ""

-#[derive(Debug)]

- pub fn image(&self) -> ImageHolder {

- self.block.image(None)

- reg: &BlockRegistry,

- map: &EntityMapping,

- let rot = dbg!(buff.read_u8()?); // 5

- let _t = dbg!(buff.read_u8()?); // 6

- let _v = dbg!(buff.read_u8()?); // 7

- let mask = dbg!(buff.read_u8()?); // 8

- if dbg!((mask & 1) != 0) {

- self.items.clear();

- // 10

- for _ in 0..dbg!(buff.read_u16()?) {

- let item = buff.read_u16()?;

- let amount = buff.read_u32()?;

- if let Ok(item) = Item::try_from(item) {

- self.items.set(item, amount);

- }

- }

- }

- if mask & 2 == 0 {

- let n = buff.read_u16()? as usize;

- buff.skip((n * 4) + 1)?;

- }

- if mask & 4 == 0 {

- self.liquids.clear();

- for _ in 0..buff.read_u16()? {

- let fluid = buff.read_u16()?;

- let amount = buff.read_f32()?;

- if let Ok(fluid) = Fluid::try_from(fluid) {

- self.liquids.set(fluid, (amount * 100.0) as u32);

- }

- }

- }

- let _ = buff.read_u8()?;

- let _ = buff.read_u8()?;

- let _ = buff.read_i64()?;

- // "overriden by subclasses"

- self.block.read(buff, reg, map)?;

- Ok(())

-/// a map

- pub width: u32,

- pub height: u32,

-/// error ocurring when reading a map fails

- buff.read_chunk(|buff| {

- buff.read_chunk(|buff| {

- // we skip these (just keep the respective modules updated)

- for _ in 0..buff.read_i8()? {

- // let _ty = buff.read_u8()?;

- // for _ in 0..buff.read_i16()? {

- // let name = dbg!(buff.read_utf()?);

- // }

- buff.skip(1)?;

- for _ in 0..buff.read_u16()? {

- let n = buff.read_u16()?;

- buff.skip(n as usize)?;

- }

- }

- Ok::<(), super::ReadError>(())

- })?;

-

- // map section

- let mut tiles = vec![];

- buff.read_chunk(|buff| {

- w = buff.read_u16()? as u32;

- h = buff.read_u16()? as u32;

- let x = (i % w) as u16;

- let y = (i / w) as u16;

- .unwrap_or(&crate::block::environment::STONE);

- debug_assert!(

- x < w as u16 && y < h as u16,

- "{x} or {y} out of bounds ({floor:?} {ore:?})"

- );

- tiles.push(Tile {

- floor,

- ore,

- pos: GridPos(x, y),

- build: None,

- });

- let consecutives = buff.read_u8()? as u32;

- let x = (i % w) as u16;

- let y = (i / w) as u16;

- tiles.push(Tile {

- floor,

- ore,

- pos: GridPos(x, y),

- build: None,

- })

- while i < count as usize {

- tiles[i].set_block(block);

- // TODO: actually read

- let n = buff.read_u16()?;

- buff.skip(n as usize)?;

- // let _ = buff.read_i8()?;

- // tiles[i]

- // .build

- // .as_mut()

- // .unwrap()

- // // map not initialized yet

- // .read(&mut buff, self.0, &HashMap::new())?;

- tiles[i].set_block(block);

- tiles[i].build.as_mut().unwrap().data = buff.read_i8()?;

- for tile in tiles.iter_mut().take(consecutives).skip(i + 1) {

- buff.read_chunk(|buff| {

- Ok(Map {

- width: w,

- height: h,

- tags,

- tiles,

- })

- Compress, CompressError, Compression, Decompress, DecompressError, FlushCompress,

- FlushDecompress, Status,

- pub fn read_chunk<E>(&mut self, f: impl FnOnce(&mut DataRead) -> Result<(), E>) -> Result<(), E>

- let len = self.read_u32()? as usize;

- pub fn deflate(&mut self) -> Result<Vec<u8>, ReadError> {

- return Err(ReadError::DecompressStall);

-pub enum ReadError {

- #[error("zlib decompession failed")]

- Decompress(#[from] DecompressError),

- pub fn inflate(self, to: &mut DataWrite) -> Result<(), WriteError> {

- return Err(WriteError::CompressEof(

- return Err(WriteError::CompressStall);

- #[error("zlib compression failed")]

- Compress {

- #[from]

- source: CompressError,

- },

- #[error("compression overflow with {0} bytes of input remaining")]

- CompressEof(usize),

- #[error("compressor stalled before completion")]

- CompressStall,

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-pub struct GridPos(pub u16, pub u16);

- GridPos((value >> 16) as u16, value as u16)

- (u32::from(value.0) << 16) | u32::from(value.1)

-use image::{DynamicImage, RgbaImage};

-use crate::data::map::Tile;

-use crate::utils::ImageUtils;

-pub use std::borrow::Borrow;

- Some(DynamicImage::from_decoder(r).unwrap().into_rgba8())

-/// renderer for creating images of schematics

-pub struct Renderer {}

-impl<'l> Renderer {

- /// creates a picture of a schematic. Bridges and node connections are not drawn, and there is no background.

- /// conveyors, conduits, and ducts currently do not render.

- /// s.put(0, 3, &block::distribution::ROUTER);

- /// s.put(1, 3, &block::walls::COPPER_WALL);

- /// let output /*: RgbaImage */ = Renderer::render_schematic(&s);

- pub fn render_schematic(s: &'l Schematic<'_>) -> RgbaImage {

- let mut canvas = RgbaImage::new((s.width * 32).into(), (s.height * 32).into());

- canvas.repeat(METAL_FLOOR.image(None).borrow());

- for tile in s.block_iter() {

- let x = (tile.pos.0 - ((tile.block.get_size() - 1) / 2) as u16) as u32;

- let y = (s.height - tile.pos.1 - ((tile.block.get_size() / 2) + 1) as u16) as u32;

- canvas.overlay(tile.image().borrow(), x * 32, y * 32);

- canvas

- pub fn render_map(m: &'l Map<'_>) -> RgbaImage {

- let mut canvas = RgbaImage::new(m.width * 8, m.height * 8);

- const VEC: Vec<&Tile<'_>> = vec![];

- let mut layers = [VEC; 2];

- for tile in m.tiles.iter() {

- if tile.has_building() {

- layers[1].push(tile)

- layers[0].push(tile)

- }

- }

- for tiles in layers {

- for tile in tiles {

- let s = if let Some(build) = &tile.build {

- let x = (tile.pos.0 - ((s - 1) / 2) as u16) as u32;

- let y = (m.height as u16 - tile.pos.1 - ((s / 2) + 1) as u16) as u32;

- canvas.overlay(

- // SAFETY: surely not 0. (tile.size can never be 0). im not sure if you can load a 0 sized image.. but you might be able to.

- unsafe { &tile.image().own().scale(tile.size() as u32 * 8) },

- x * 8,

- y * 8,

- canvas

-use std::iter::FusedIterator;

-use std::slice::Iter;

-pub const MAX_DIMENSION: u16 = 256;

- pub pos: GridPos,

- self.pos == rhs.pos && self.block == rhs.block && self.rot == rhs.rot

- pub fn image(&self) -> crate::data::renderer::ImageHolder {

- self.block.image(self.get_state())

- pos: self.pos,

-#[derive(Clone)]

- pub width: u16,

- pub height: u16,

- pub blocks: Vec<Placement<'l>>,

- lookup: Vec<Option<usize>>,

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

- pub fn try_new(width: u16, height: u16) -> Result<Self, NewError> {

- blocks: Vec::new(),

- lookup: Vec::new(),

- #[must_use]

- /// have blocks?

- pub fn is_empty(&self) -> bool {

- self.blocks.is_empty()

- }

- #[must_use]

- /// count blocks

- pub fn get_block_count(&self) -> usize {

- self.blocks.len()

- }

-

- #[must_use]

- /// check if a rect is empty

- /// let s = Schematic::new(5, 5);

- /// assert!(s.is_region_empty(1, 1, 4, 4) == true);

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

- if self.blocks.is_empty() {

- return true;

- }

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

- return true;

- }

- if w > 1 || h > 1 {

- let stride = self.width as usize;

- let x_end = if self.width - x > w {

- x + w

- } else {

- self.width

- } as usize;

- let y_end = if self.height - y > h {

- y + h

- } else {

- self.height

- } as usize;

- let x = x as usize;

- let y = y as usize;

- for cy in y..y_end {

- for cx in x..x_end {

- if self.lookup[cx + cy * stride].is_some() {

- return false;

- }

- }

- }

- true

- } else {

- self.lookup[(x as usize) + (y as usize) * (self.width as usize)].is_none()

- }

- }

-

- /// gets a block

- pub fn get(&self, x: u16, y: u16) -> Result<Option<&Placement<'l>>, PosError> {

- if self.blocks.is_empty() {

- return Ok(None);

- }

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

- match self.lookup[pos] {

- None => Ok(None),

- Some(idx) => Ok(Some(&self.blocks[idx])),

- pub fn get_mut(&mut self, x: u16, y: u16) -> Result<Option<&mut Placement<'l>>, PosError> {

- if self.blocks.is_empty() {

- return Ok(None);

- }

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

- match self.lookup[pos] {

- None => Ok(None),

- Some(idx) => Ok(Some(&mut self.blocks[idx])),

- fn remove(&mut self, idx: usize) -> Placement<'l> {

- // swap_remove not only avoids moves in self.blocks but also reduces the lookup changes we have to do

- let prev = self.blocks.swap_remove(idx);

- self.fill_lookup(

- prev.pos.0 as usize,

- prev.pos.1 as usize,

- prev.block.get_size() as usize,

- None,

- );

- if idx < self.blocks.len() {

- // fix the swapped block's lookup entries

- let swapped = &self.blocks[idx];

- self.fill_lookup(

- swapped.pos.0 as usize,

- swapped.pos.1 as usize,

- swapped.block.get_size() as usize,

- Some(idx),

- );

- }

- prev

- }

-

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

- if self.lookup.is_empty() {

- self.lookup

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

- }

- if sz > 1 {

- let off = (sz - 1) / 2;

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

- for dy in 0..sz {

- for dx in 0..sz {

- self.lookup[(x0 + dx) + (y0 + dy) * (self.width as usize)] = val;

- }

- }

- } else {

- self.lookup[x + y * (self.width as usize)] = val;

- }

- }

-

- /// put a block in (same as [Schematic::set], but less arguments)

- /// # use mindus::DynData;

- /// # use mindus::block::Rotation;

- pub fn put(&mut self, x: u16, y: u16, block: &'l Block) -> Result<&Placement<'l>, PlaceError> {

- self.set(x, y, block, DynData::Empty, Rotation::Up)

- x: u16,

- y: u16,

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

- let sz = u16::from(block.get_size());

- let off = (sz - 1) / 2;

- if x < off || y < off {

- return Err(PlaceError::Bounds {

- x,

- y,

- sz: block.get_size(),

- w: self.width,

- h: self.height,

- });

- }

- if self.width - x < sz - off || self.height - y < sz - off {

- return Err(PlaceError::Bounds {

- x,

- y,

- sz: block.get_size(),

- w: self.width,

- h: self.height,

- });

- }

- if self.is_region_empty(x - off, y - off, sz, sz) {

- let idx = self.blocks.len();

- let state = block.deserialize_state(data)?;

- self.blocks.push(Placement {

- pos: GridPos(x, y),

- block,

- state,

- rot,

- });

- self.fill_lookup(x as usize, y as usize, block.get_size() as usize, Some(idx));

- Ok(&self.blocks[idx])

- } else {

- Err(PlaceError::Overlap { x, y })

- }

- }

-

- pub fn replace(

- &mut self,

- x: u16,

- y: u16,

- block: &'l Block,

- data: DynData,

- rot: Rotation,

- collect: bool,

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

- let sz = u16::from(block.get_size());

- if sz > 1 {

- let mut result = if collect { Some(Vec::new()) } else { None };

- // remove all blocks in the region

- for dy in 0..(sz as usize) {

- for dx in 0..(sz as usize) {

- if let Some(idx) =

- self.lookup[(x as usize + dx) + (y as usize + dy) * (self.width as usize)]

- {

- let prev = self.remove(idx);

- if let Some(ref mut v) = result {

- v.push(prev);

- }

- }

- }

- }

- let idx = self.blocks.len();

- let state = block.deserialize_state(data)?;

- self.blocks.push(Placement {

- pos: GridPos(x, y),

- block,

- state,

- rot,

- });

- self.fill_lookup(x as usize, y as usize, sz as usize, Some(idx));

- Ok(result)

- } else {

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

- match self.lookup[pos] {

- None => {

- let idx = self.blocks.len();

- let state = block.deserialize_state(data)?;

- self.blocks.push(Placement {

- pos: GridPos(x, y),

- block,

- state,

- rot,

- });

- self.lookup[pos] = Some(idx);

- Ok(if collect { Some(Vec::new()) } else { None })

- }

- Some(idx) => {

- let state = block.deserialize_state(data)?;

- let prev = std::mem::replace(

- &mut self.blocks[idx],

- Placement {

- pos: GridPos(x, y),

- block,

- state,

- rot,

- },

- );

- self.fill_lookup(

- prev.pos.0 as usize,

- prev.pos.1 as usize,

- prev.block.get_size() as usize,

- None,

- );

- self.fill_lookup(x as usize, y as usize, sz as usize, Some(idx));

- Ok(if collect { Some(vec![prev]) } else { None })

- }

- }

- }

- pub fn take(&mut self, x: u16, y: u16) -> Result<Option<Placement<'l>>, PosError> {

- if self.blocks.is_empty() {

- Ok(None)

- } else {

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

- match self.lookup[pos] {

- None => Ok(None),

- Some(idx) => Ok(Some(self.remove(idx))),

- }

- }

- }

-

- fn rebuild_lookup(&mut self) {

- self.lookup.clear();

- if !self.blocks.is_empty() {

- self.lookup

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

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

- let sz = curr.block.get_size() as usize;

- let x = curr.pos.0 as usize - (sz - 1) / 2;

- let y = curr.pos.1 as usize - (sz - 1) / 2;

- if sz > 1 {

- for dy in 0..sz {

- for dx in 0..sz {

- self.lookup[(x + dx) + (y + dy) * (self.width as usize)] = Some(i);

- }

- }

- } else {

- self.lookup[x + y * (self.width as usize)] = Some(i);

- }

- }

- }

- }

-

- /// flip it

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

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

- for curr in &mut self.blocks {

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

- let shift = (u16::from(curr.block.get_size()) - 1) % 2;

- if horizontally {

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

- }

- if vertically {

- curr.pos.1 = self.height - 1 - curr.pos.1 - shift;

- }

- if !curr.block.is_symmetric() {

- curr.rot.mirror(horizontally, vertically);

- }

- if let Some(ref mut state) = curr.state {

- curr.block.mirror_state(state, horizontally, vertically);

- }

- }

- self.rebuild_lookup();

- }

- }

-

- /// turn

- /// ```

- /// # use mindus::Schematic;

- /// # use mindus::DynData;

- /// # use mindus::block::Rotation;

- ///

- /// let mut s = Schematic::new(5, 5);

- /// // 0, 0 == bottom left

- /// s.put(0, 0, &mindus::block::turrets::HAIL);

- /// s.rotate(true);

- /// assert!(s.get(0, 4).unwrap().is_some() == true);

- /// ```

- pub fn rotate(&mut self, clockwise: bool) {

- let w = self.width;

- let h = self.height;

- self.width = h;

- self.height = w;

- if !self.blocks.is_empty() {

- for curr in &mut self.blocks {

- let x = curr.pos.0;

- let y = curr.pos.1;

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

- let shift = (u16::from(curr.block.get_size()) - 1) % 2;

- if clockwise {

- curr.pos.0 = y;

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

- } else {

- curr.pos.0 = h - 1 - y - shift;

- curr.pos.1 = x;

- }

- if !curr.block.is_symmetric() {

- curr.rot.rotate(clockwise);

- }

- if let Some(ref mut state) = curr.state {

- curr.block.rotate_state(state, clockwise);

- }

- }

- self.rebuild_lookup();

- }

- }

-

- /// resize this schematic

- pub fn resize(&mut self, dx: i16, dy: i16, w: u16, h: u16) -> Result<(), ResizeError> {

- if w > MAX_DIMENSION {

- return Err(ResizeError::TargetWidth(w));

- }

- if h > MAX_DIMENSION {

- return Err(ResizeError::TargetHeight(h));

- }

- if dx <= -(w as i16) || dx >= self.width as i16 {

- return Err(ResizeError::XOffset {

- dx,

- old_w: self.width,

- new_w: w,

- });

- }

- if dy <= -(h as i16) || dy >= self.height as i16 {

- return Err(ResizeError::YOffset {

- dy,

- old_h: self.height,

- new_h: h,

- });

- }

- // check that all blocks fit into the new bounds

- let mut right = 0u16;

- let mut top = 0u16;

- let mut left = 0u16;

- let mut bottom = 0u16;

- let right_bound = dx + w as i16 - 1;

- let top_bound = dy + h as i16 - 1;

- let left_bound = dx;

- let bottom_bound = dy;

- for Placement { pos, block, .. } in &self.blocks {

- let sz = u16::from(block.get_size());

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

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

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

- pos.0 + sz / 2,

- pos.1 + sz / 2,

- );

- if (x1 as i16) > right_bound && x1 - right_bound as u16 > right {

- right = x1 - right_bound as u16;

- }

- if (y1 as i16) > top_bound && y1 - top_bound as u16 > top {

- top = y1 - top_bound as u16;

- }

- if (x0 as i16) < left_bound && left_bound as u16 - x0 > left {

- left = left_bound as u16 - x0;

- }

- if (y0 as i16) < bottom_bound && bottom_bound as u16 - y0 > bottom {

- bottom = bottom_bound as u16 - y0;

- }

- }

- if left > 0 || top > 0 || right > 0 || bottom > 0 {

- return Err(TruncatedError {

- right,

- top,

- left,

- bottom,

- })?;

- }

- self.width = w;

- self.height = h;

- for Placement { pos, .. } in &mut self.blocks {

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

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

- }

- Ok(())

- }

-

- /// like rotate(), but 180

- pub fn rotate_180(&mut self) {

- self.mirror(true, true);

- }

-

- #[must_use]

- pub fn pos_iter(&self) -> PosIter {

- PosIter {

- x: 0,

- y: 0,

- w: self.width,

- h: self.height,

- }

- pub fn block_iter<'s>(&'s self) -> Iter<'s, Placement<'l>> {

- self.blocks.iter()

- /// s.put(0, 0, &mindus::block::turrets::CYCLONE);

- /// // assert_eq!(s.compute_total_cost().0.get_total(), 405);

- for &Placement { block, .. } in &self.blocks {

- Width(u16),

- Height(u16),

- pub x: u16,

- pub y: u16,

- pub w: u16,

- pub h: u16,

- x: u16,

- y: u16,

- w: u16,

- h: u16,

- Overlap { x: u16, y: u16 },

-impl fmt::Debug for Schematic<'_> {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- fmt::Display::fmt(self, f)

- }

-}

-

-impl<'l> fmt::Display for Schematic<'l> {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- /*

- Because characters are about twice as tall as they are wide, two are used to represent a single block.

- Each block has a single letter to describe what it is + an optional rotation.

- For size-1 blocks, that's "*]" for symmetric and "*>", "*^", "*<", "*v" for rotations.

- Larger blocks are formed using pipes, slashes and minuses to form a border, which is filled with spaces.

- Then, the letter is placed inside followed by the rotation (if any).

- */

-

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

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

- for p in &self.blocks {

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

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

- Entry::Vacant(e) => {

- e.insert(1);

- }

- }

- }

- // only needed the map for counting

- let mut name_cnt = Vec::from_iter(name_cnt);

- name_cnt.sort_by(|l, r| r.1.cmp(&l.1));

- // set for control characters, space, b'*', DEL and b">^<v]/|\\-"

- let mut used = [

- 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0x01u8, 0xA4u8, 0x00u8, 0x50u8, 0x00u8, 0x00u8, 0x00u8,

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

- ];

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

- for &(name, _) in &name_cnt {

- let mut found = false;

- for c in name.chars() {

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

- let upper = c.to_ascii_uppercase() as usize;

- let lower = c.to_ascii_lowercase() as usize;

- if used[upper >> 3] & (1 << (upper & 7)) == 0 {

- found = true;

- used[upper >> 3] |= 1 << (upper & 7);

- types.insert(name, unsafe { char::from_u32_unchecked(upper as u32) });

- break;

- }

- if lower != upper && used[lower >> 3] & (1 << (lower & 7)) == 0 {

- found = true;

- used[lower >> 3] |= 1 << (lower & 7);

- types.insert(name, unsafe { char::from_u32_unchecked(lower as u32) });

- break;

- }

- }

- }

- if !found {

- // just take whatever symbol's still free (avoids collisions with letters)

- match used.iter().enumerate().find(|(_, &v)| v != u8::MAX) {

- // there's no more free symbols... how? use b'*' instead for all of them (reserved)

- None => {

- types.insert(name, '*');

- }

- Some((i, v)) => {

- let idx = i + v.trailing_ones() as usize;

- used[idx >> 3] |= 1 << (idx & 7);

- types.insert(name, unsafe { char::from_u32_unchecked(idx as u32) });

- }

- }

- }

- }

-

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

- if self.blocks.is_empty() {

- write!(f, "<empty {} * {}>", self.width, self.height)?;

- } else {

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

- let mut x = 0usize;

- while x < self.width as usize {

- if let Some(idx) = self.lookup[x + y * (self.width as usize)] {

- let Placement {

- pos,

- block,

- state: _,

- rot,

- } = self.blocks[idx];

- let c = *types.get(block.get_name()).unwrap();

- match block.get_size() as usize {

- 0 => unreachable!(),

- 1 => {

- f.write_char(c)?;

- match rot {

- _ if block.is_symmetric() => f.write_char(']')?,

- Rotation::Right => f.write_char('>')?,

- Rotation::Up => f.write_char('^')?,

- Rotation::Left => f.write_char('<')?,

- Rotation::Down => f.write_char('v')?,

- }

- }

- s => {

- let y0 = pos.1 as usize - (s - 1) / 2;

- if y == y0 + (s - 1) {

- // top row, which looks like /---[...]---\

- f.write_char('/')?;

- if s == 2 {

- // label & rotation are in this row

- f.write_char(c)?;

- match rot {

- _ if block.is_symmetric() => f.write_char('-')?,

- Rotation::Right => f.write_char('>')?,

- Rotation::Up => f.write_char('^')?,

- Rotation::Left => f.write_char('<')?,

- Rotation::Down => f.write_char('v')?,

- }

- } else {

- // label & rotation are not in this row

- for _ in 0..(2 * s - 2) {

- f.write_char('-')?;

- }

- }

- f.write_char('\\')?;

- } else if y == y0 {

- // bottom row, which looks like \---[...]---/

- f.write_char('\\')?;

- for _ in 0..(2 * s - 2) {

- f.write_char('-')?;

- }

- f.write_char('/')?;

- } else if s > 2 && y == y0 + s / 2 {

- // middle row with label

- f.write_char('|')?;

- for cx in 0..(2 * s - 2) {

- if cx == s - 2 {

- f.write_char(c)?;

- } else if cx == s - 1 {

- match rot {

- _ if block.is_symmetric() => f.write_char(' ')?,

- Rotation::Right => f.write_char('>')?,

- Rotation::Up => f.write_char('^')?,

- Rotation::Left => f.write_char('<')?,

- Rotation::Down => f.write_char('v')?,

- }

- } else {

- f.write_char(' ')?;

- }

- }

- f.write_char('|')?;

- } else {

- // middle row, which looks like | [...] |

- f.write_char('|')?;

- for _ in 0..(2 * s - 2) {

- f.write_char(' ')?;

- }

- f.write_char('|')?;

- }

- }

- }

- x += block.get_size() as usize;

- } else {

- f.write_str(" ")?;

- x += 1;

- }

- }

- writeln!(f)?;

- }

- // print the letters assigned to blocks

- for (k, _) in name_cnt {

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

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

- }

- }

- Ok(())

- }

-}

-

- let w = buff.read_i16()?;

- let h = buff.read_i16()?;

- if w < 0 || h < 0 || w as u16 > MAX_DIMENSION || h as u16 > MAX_DIMENSION {

- let mut schematic = Schematic::new(w as u16, h as u16);

- for _ in 0..num_table {

- let num_blocks = buff.read_i32()?;

- let idx = buff.read_i8()?;

- let pos = GridPos::from(buff.read_u32()?);

- for curr in &data.blocks {

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

- let mut num = 0;

- for curr in &data.blocks {

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

- num += 1;

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

- #[error("invalid schematic dimensions ({0} * {1})")]

- Dimensions(i16, i16),

- /// assert!(s.get(0, 0).unwrap().unwrap().block.name() == "payload-router");

-pub struct PosIter {

- x: u16,

- y: u16,

- w: u16,

- h: u16,

-}

-

-impl Iterator for PosIter {

- type Item = GridPos;

-

- fn next(&mut self) -> Option<Self::Item> {

- if self.w > 0 && self.y < self.h {

- let p = GridPos(self.x, self.y);

- self.x += 1;

- if self.x == self.w {

- self.x = 0;

- self.y += 1;

- }

- Some(p)

- } else {

- None

- }

- }

-

- fn size_hint(&self) -> (usize, Option<usize>) {

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

- let end = (self.w as usize) * (self.h as usize);

- (end - pos, Some(end - pos))

- }

-

- fn count(self) -> usize {

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

- let end = (self.w as usize) * (self.h as usize);

- end - pos

- }

-

- fn last(self) -> Option<Self::Item> {

- // self.y < self.h implies self.h > 0

- if self.w > 0 && self.y < self.h {

- Some(GridPos(self.w - 1, self.h - 1))

- } else {

- None

- }

- }

-}

-

-impl FusedIterator for PosIter {}

-

-

- macro_rules! test_iter {

- ($name:ident, $it:expr, $($val:expr),+) => {

- #[test]

- fn $name() {

- let mut it = $it;

- $(test_iter!(impl it, $val);)+

- }

- };

- (impl $it:ident, $val:literal) => {

- for _ in 0..$val {

- assert_ne!($it.next(), None, "iterator returned None too early");

- }

- };

- (impl $it:ident, $val:expr) => {

- assert_eq!($it.next(), $val);

- };

- }

- ($name:ident, $($val:expr),+) => {

- let parsed = ser.deserialize_base64($val).unwrap();

- println!("{}", parsed.tags.get("name").unwrap());

- let unparsed = ser.serialize_base64(&parsed).unwrap();

- let parsed2 = ser.deserialize_base64(&unparsed).unwrap();

- assert_eq!(parsed, parsed2);

- "bXNjaAF4nCVNy07DMBCcvC1c4MBnoNz4G8TBSSxRycSRbVr646iHlmUc2/KOZ3dmFo9QDdrVfFkMb9Gsi5mgFxvncNzS0a8Aemcm6yLq948Bz2eTbBjtTwpmTj7gafs00Y6zX0/2Qt6dzLdLeNj8mbrVLxZ6ciamcQlH59BHH5iAYTKJeOGCF6AisFSoBxF55V+hJm1Lvwca8lpVIuzlS0eGLoMqTGUG6OLRJes3Mw40E5ijc2QedkPuU3DfLX0eHriDsgMapaScu9zkT26o5Uq8EmV/zS5vi4tr/wHvJE7M",

- "bXNjaAF4nE2MzWrEMAyEJ7bjdOnPobDQvfUF8kSlhyTWFlOv3VWcQvv0lRwoawzSjL4ZHOAtXJ4uhEdi+oz8ek5bDCvuA60Lx68aSwbg0zRTWmHe3j2emWI+F14ojEvJYYsVD5RoqVzSzy8xDjNNlzGXQHi5gVO8SvnIZasCnW4uM8fwQf9tT9+Ua1OUV0GBI9ozHToY6IeDtaIACxkOnaoe1rVrg2RV1cP0CuycLA5+LxuUU+U055W0Yrb4sEcGNQ3u1NTh9iHmH6qaOTI=",

- "bXNjaAF4nE2R226kQAxEzW1oYC5kopV23/IDfMw+R3ng0klaYehsD6w2+fqtamuiDILCLtvH9MgPaTLJl/5ipR3cy4MN9s2FB//PTVaayV7H4N5X5xcR2c39YOerpI9Pe/kVrFuefRjt1A3BTS+2G/0ybW6V41+7rDGyy9UGjNnGtQt+W78C7ZCcgVSD7S/d4kH8+W3q7P5sbrr1nb85N9DeznZcg58/PlFxx6V77tqNr/1lQOr0anuQ7eQCCn2QQ6Rvy+z7Cb7Ib9xSSJpICsGDV5bxoVJKxpSRLIdUKrVkBQoSkVxYJDuWq5SaNByboUEYJ5LgmFlZRhdejit6oDO5Uw/trDTqgWfgpCqFiiG91MVL7IJfLKck3NooyBDEZM4Gw+9jtJOEXgQZ7TQAJZSaM+POFd5TSWpIoVHEVsqrlUcX8xq+U2pi94wyCHZpICn625jAGdVy4DxGpdom2gXeKu2OIw+6w5E7UABnMgKO9CgxOukiHBGjmGz1dFp+VQO57cA7pUR4+wVvFd5q9x2aQT0r/Ew4k/FfPyvunjhGaPgPoVJdLw==",

- "bXNjaAF4nD1TDUxTVxS+r6+vr30triCSVjLXiulKoAjMrJRkU8b4qSgLUAlIZ1rah7yt9L31h1LMMCNbRAQhYrKwOnEslhCcdmzJuohL1DjZT4FJtiVsoG5LFtzmGgGngHm790mam7x77ne+c945934HKIAcB2K3vYUGScXmWvM+TQ3jYhysG8idtNfhYTgfAw8ASFz2RtrlBaKG12VA6X1KMjg8fgfT6KLBJi7osfsYH21oYdpoD6A4NkB7DG7WSQOJl/X4IPYM426loeU0bABSv9vF2p3I1cI4PKyB87AO2gu9gGi1+10+kMTCiCYXGzActvtoWEY+ABhcIgzaOBCJ4EZICYDx6xAV86vCdx2IAS5QJJAEIRkQ4XAjAHSIIITBUCCGRwIuESCgheEIkwgYIpEAF4I3wSw9bWccTpvNmVkZy5raWT1p3r+vajJ2odyQb+HAW9HxvV556vfvpNy4oVUfDyq36Kyqe73xsdemprMyv52uAreYwcXzJaPU+aDp8fFM24nuzUvVqYo9yr7CjFT/aDDzUUz8S8W7g+X3VCpVnargblNubl4kI1q6J+cFPH2HS6VSF5xzZWhCyYCKO2FjqAEprB9WRsJbwNFFoLKhITRCQheBbByQCMAQQwow1I8M9oPJ2870npqvvq5RvvfFyYE3hjrLmst3TixrV0XSN08Uax/UrMSeHdmKDdj8uhh3Pef2Wa+qDljrj82pK+aM300sl0eTrC/rL3zzZKZhRWFMq+mLvvTZb0bbweGZL/85ywwnl4RLzR9MBdIGy0LJowOWHxoOY2EiaJ/7s7ZP0Tg2wjWb3y6Lm3IPRNonw/0yT/+lZsdFy/LmUEp2RojHl68B41zDx43WJ/qANkwdVOvGtxjzpgo/keUURn2XK6zerz9Km10w3Vb8Ww/t/UdmHyx7fXwEcPiP0w1Xx9f+/m/X/d13Wiees8yPnk69ePlS9Yuf9sQf1dvVB27mm68U+51Fj7emzS+mzw1jzwuvTKFXHoK30l9EXctVlozIiSPdpk5djrW965BmV1XW4qsp8kNXmtWztdklXXTa0u6lO0d1+GS3TV/Q95O+17+S23Hs5sIfP4e/uqvd9oo+p7u0cYiPb4+9f/L+Qn3PmuXDdDai/ev0ts69I9nuNTOXp9HfOmoy/a5Y9D2cYYsebq+cKgB1V9vXdYFfOz7vWiVCLNnUUVkLOGO9umVN0jl2KoIjYSINEzgUORoDBKAnJwSLTLikQOBSAoC0ABBAbMgDWYIuBBeFRE7CbBCXCAwxFBAJPRgCSAFADBlykokcZCKHFAkPbSRKRaFUUsRGUyZLTJksMWWyjSlDJKhfFALZmFAJdFPo1+gkQVKXw/EW8/zToeZ5fh0t/H+V6k8+",

- "bXNjaAF4nGNgZ2BjZmDJS8xNZRByrkzOyc9LdctJLEpVT1F4v3AaA3dKanFyUWZBSWZ+HgMDA1tOYlJqTjEDU3QsFwN/eWJJapFuakVJUWJySX4RA3tSYglQpJKBPRliEgNXQX45UElefkoqA39SUWZKeqpucn5eWWolSDmQlVKaWcIgkpyfm1RaDLJDNz01L7UoEWQaf3JRZX5aTmlmim5uZkUqUCA3M7koX7egKD85tbgYqIIlIzEzB+gqQQYwYGYEEkwgxMjAAuQCKSYOZgam//8ZWP7/+/+HgZGZBSTPDlEGVMEKVssAooAMNqAWBpA0SCdQKTMDMzvEZAZGRhCXBZXLyv7///8cIC4AKgZaCOKGAHEh0DBWBpAKIAW0hQNkAR9Q16+KOXtDbhfNNhBQneu5XNV+o/0FSYFCtbrHC+dm3v/MnK3TnKUYGCv0+X3uygksNwzr3jbr755T/O3NuiOxk+7YX7lSoNb3oW3CUq7vKxq4bn1rUKqJsqldfsLX2KkoICQ679L8bW8fCLaY3K+LfGLIe6hoXlaW3iMvrsUq7Hc9Mq1W/OrydlRf+VK9+Ov1iSmsK1deCPKVPF69dG+I5RQ3qSf2PLmlH2bkLwgT4Q3V5+3qnBDPqcG1dNuqZfETim+6G0UqT9b5bGsUznqqb7GZxoxc5eUMT/JvvC79UdlruPvxJis9XhbeTZXLN+68WFB41+DkNRv7uZEGOr/2rvPPu8ZfyXRLI+zoUnmLXRu3+nz0EnP1Omq39TLX3c23cleZ8F62FSnMVCviO2H6tWXB7z2LpA02vleTOXiJK20BT+ADsencfQd0tlqrfQuoWut5dHaX1OP/KwIY5r66Zp4T9+2p241L0XvPfu5w/Zu3bNX77V89kt42zOLf9jJ9vk+msV1vy/Knlywv7Lh4NEY7fvHay0t3Sxo+2q918+je/O23P+50/qEWe45XqGzaR1vh0h1idRwBYZter2DKPJv559VDhbXSHzgin2x8PeXIKsvmtRIVB5V5b/1zcBP+f7VpfuP1OLcJKiePP7n8paroYrul0uF88dp5619+MN8Z7WT0p7DTUqftYOt3XqN51hGf+IVDH0UwcDKwAZMFMwCWiVNe"

-

- test_iter!(

- block_iter,

- Schematic::new(3, 4).pos_iter(),

- Some(GridPos(0, 0)),

- Some(GridPos(1, 0)),

- Some(GridPos(2, 0)),

- Some(GridPos(0, 1)),

- 7,

- Some(GridPos(2, 3)),

- None

- );

-use mindus::Renderer;

- Renderer::render_schematic(&s).save("x.png").unwrap();

-use mindus::{build_registry, Renderer};

- Renderer::render_map(&m).save("x.png").unwrap();

-mod print;

- ($err:expr, $($msg:tt)*) => {

- {

- use std::error::Error;

- let err = $err;

- eprint!($($msg)*);

- eprintln!(": {err}");

- let mut err_ref = &err as &dyn Error;

- loop

- {

- if let Some(next) = err_ref.source()

- {

- eprintln!("\tSource: {next}");

- err_ref = next;

- }

- else {break;}

- None => eprintln!("Not enough arguments, valid commands are: draw, print"),

- Some(s) if s == "print" => print::main(args),

- Some(s) => eprintln!("Unknown argument {s}, valid commands are: draw, print"),

-use std::env::Args;

-

-use mindus::build_registry;

-use mindus::{Schematic, SchematicSerializer};

-

-use crate::print_err;

-

-pub fn main(args: Args) {

- let reg = build_registry();

- let mut ss = SchematicSerializer(&reg);

- let mut first = true;

- let mut need_space = false;

- // process schematics from command line

- for curr in args {

- match ss.deserialize_base64(&curr) {

- Ok(s) => {

- if !first || need_space {

- println!();

- }

- first = false;

- need_space = true;

- println!("Schematic: {curr}");

- print_schematic(&s);

- }

- // continue processing literals & maybe interactive mode

- Err(e) => {

- if need_space {

- println!();

- }

- first = false;

- need_space = false;

- print_err!(e, "Could not read schematic");

- }

- }

- }

-}

-

-pub fn print_schematic(s: &Schematic) {

- if let Some(name) = s.tags.get("name") {

- if !name.is_empty() {

- println!("Name: {name}");

- }

- }

- if let Some(desc) = s.tags.get("description") {

- if !desc.is_empty() {

- println!("Desc: {desc}");

- }

- }

- if let Some(labels) = s.tags.get("labels") {

- if !labels.is_empty() && labels != "[]" {

- println!("Tags: {:?}", labels);

- }

- }

- let (cost, sandbox) = s.compute_total_cost();

- if !cost.is_empty() {

- println!(

- "Build cost: {cost}{}",

- if sandbox { " (Sandbox only)" } else { "" }

- );

- } else if sandbox {

- println!("Can only be built in the Sandbox");

- }

- println!("\n{s}");

-}

-use std::error::Error;

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for TryAddError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(

- f,

- "adding {:?} to current {} would exceed {}",

- self.add, self.have, self.max

- )

- }

-}

-

-impl Error for TryAddError {}

-

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]

-impl fmt::Display for TrySubError {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(

- f,

- "removing {} from current {} would drop below {}",

- self.sub, self.have, self.min

- )

- }

-}

-

-impl Error for TrySubError {}

-

-pub use data::renderer::Renderer;

-use std::error::Error;

-#[derive(Copy, Clone, Debug, Eq, PartialEq)]

-impl fmt::Display for TryFromU16Error {

- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

- write!(f, "no content of type Team for value {}", self.0)

- }

-}

-

-impl Error for TryFromU16Error {}

-

-use image::{Rgb, Rgba, RgbaImage};

-

- fn repeat(&mut self, with: &RgbaImage) -> &mut Self;

-

- fn overlay(&mut self, with: &RgbaImage, x: u32, y: u32) -> &mut Self;

-

- if get[3] > 5 {

- /// scales a image

- ///

- /// SAFETY: to and width and height cannot be 0.