[package]

name = "mindus"

edition = "2021"

description = "A library for working with mindustry data formats (eg schematics) (fork of plandustry)"

authors = [

//! conveyors ( & ducts )

use std::error::Error;

use std::fmt;

use crate::item;

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

make_register! {

"conveyor" => SimpleBlock::new(1, false, cost!(Copper: 1));

"titanium-conveyor" => SimpleBlock::new(1, false, cost!(Copper: 1, Lead: 1, Titanium: 1));

Ok(DynData::Content(content::Type::Item, config as u16))

}

match data {

DynData::Empty => Ok(Some(Self::create_state(None))),

DynData::Content(content::Type::Item, id) => Ok(Some(Self::create_state(Some(

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

match Self::get_state(state) {

None => Ok(DynData::Empty),

Some(item) => Ok(DynData::Content(content::Type::Item, (*item).into())),

}

}

if !matches!(

name,

"unloader" | "item-source" | "sorter" | "inverted-sorter"

Ok(DynData::Point2(dx, dy))

}

match data {

DynData::Empty => Ok(Some(Self::create_state(None))),

DynData::Point2(dx, dy) => {

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

match Self::get_state_mut(state) {

None => (),

Some((dx, dy)) => {

}

}

match Self::get_state_mut(state) {

None => (),

Some((dx, dy)) => {

}

}

match Self::get_state(state) {

None => Ok(DynData::Empty),

Some((dx, dy)) => Ok(DynData::Point2(*dx, *dy)),

//! liquid related things

use std::error::Error;

use std::fmt;

use crate::block::distribution::BridgeBlock;

use crate::block::simple::{cost, state_impl, BuildCost, SimpleBlock};

use crate::block::{

Ok(DynData::Content(content::Type::Fluid, config as u16))

}

match data {

DynData::Empty => Ok(Some(Self::create_state(None))),

DynData::Content(content::Type::Fluid, id) => Ok(Some(Self::create_state(Some(

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

match Self::get_state(state) {

None => Ok(DynData::Empty),

Some(fluid) => Ok(DynData::Content(content::Type::Fluid, (*fluid).into())),

}

}

let mut p = load(category, name).unwrap();

if let Some(state) = state {

if let Some(s) = Self::get_state(state) {

//! logic processors and stuff

use std::borrow::Cow;

use std::error::Error;

use std::fmt;

FlushDecompress, Status,

};

use crate::block::simple::{cost, state_impl, BuildCost, SimpleBlock};

use crate::block::{

impl_block, make_register, BlockLogic, DataConvertError, DeserializeError, SerializeError,

Ok(DynData::Empty)

}

match data {

DynData::Empty | DynData::String(None) => Ok(Some(Self::create_state(String::new()))),

DynData::String(Some(s)) => Ok(Some(Self::create_state(s))),

}

}

Box::new(Self::get_state(state).clone())

}

Ok(DynData::String(Some(Self::get_state(state).clone())))

}

}

Ok(DynData::Empty)

}

match data {

DynData::Empty => Ok(Some(Self::create_state(true))),

DynData::Boolean(enabled) => Ok(Some(Self::create_state(enabled))),

}

}

Box::new(*Self::get_state(state))

}

Ok(DynData::Boolean(*Self::get_state(state)))

}

}

Ok(DynData::Empty)

}

match data {

DynData::Empty => Ok(Some(Self::create_state(ProcessorState::default()))),

DynData::ByteArray(arr) => {

}

}

Box::new(Self::get_state(state).clone())

}

for link in &mut Self::get_state_mut(state).links {

if horizontally {

link.x = -link.x;

}

}

for link in &mut Self::get_state_mut(state).links {

let (cdx, cdy) = link.get_pos();

link.x = if clockwise { cdy } else { -cdy };

}

}

let state = Self::get_state(state);

let mut rbuff = DataWrite::default();

ProcessorSerializeError::forward(rbuff.write_u8(1))?;

pub mod turrets;

pub mod walls;

pub trait BlockLogic {

/// mindustry blocks are the same width and height

fn get_size(&self) -> u8;

fn data_from_i32(&self, config: i32, pos: GridPos) -> Result<DynData, DataConvertError>;

None

}

}

}

/// draw this block, with this state

if let Some(p) = self

.logic

.as_ref()

pub(crate) fn deserialize_state(

&self,

data: DynData,

self.logic.deserialize_state(data)

}

self.logic.clone_state(state)

}

self.logic.mirror_state(state, horizontally, vertically);

}

self.logic.rotate_state(state, clockwise);

}

self.logic.serialize_state(state)

}

}

//! payload related bits and bobs

use std::error::Error;

use std::fmt;

use crate::data::GridPos;

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

use crate::unit;

const GROUND_UNITS: &[unit::Type] = &[unit::Type::Dagger, unit::Type::Crawler, unit::Type::Nova];

const AIR_UNITS: &[unit::Type] = &[unit::Type::Flare, unit::Type::Mono];

Ok(DynData::Int(-1))

}

match data {

DynData::Empty => Ok(Some(Self::create_state(None))),

DynData::Int(idx) => {

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

if let Some(state) = Self::get_state(state) {

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

if curr == state {

Ok(DynData::Empty)

}

match data {

DynData::Empty => Ok(Some(Self::create_state(Payload::Empty))),

DynData::Content(content::Type::Block, id) => {

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

match Self::get_state(state) {

Payload::Empty => Ok(DynData::Empty),

Payload::Block(block) => Ok(DynData::Content(content::Type::Block, (*block).into())),

//! power connection and generation

use std::error::Error;

use std::fmt;

use crate::block::simple::{cost, state_impl, BuildCost, SimpleBlock};

use crate::block::{

impl_block, make_register, BlockLogic, DataConvertError, DeserializeError, SerializeError,

Ok(DynData::Empty)

}

match data {

DynData::Empty => Ok(Some(Self::create_state(Vec::new()))),

DynData::Point2Array(s) => Ok(Some(Self::create_state(s))),

}

}

Box::new(Self::get_state(state).clone())

}

for (dx, dy) in Self::get_state_mut(state).iter_mut() {

if horizontally {

*dx = -*dx;

}

}

for (dx, dy) in Self::get_state_mut(state).iter_mut() {

let (cdx, cdy) = (*dx, *dy);

*dx = if clockwise { cdy } else { -cdy };

}

}

Ok(DynData::Point2Array(Self::get_state(state).clone()))

}

}

Ok(DynData::Int(config))

}

match data {

DynData::Int(rgba) => Ok(Some(Self::create_state(RGBA::from(rgba as u32)))),

_ => Err(DeserializeError::InvalidType {

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

let state = Self::get_state(state);

Ok(DynData::Int(u32::from(*state) as i32))

}

//! type used for basic blocks, eg turrets and factorys

use crate::block::{impl_block, BlockLogic, DataConvertError, DeserializeError, SerializeError};

use crate::data::dynamic::DynData;

use crate::data::renderer::{load, read};

macro_rules! state_impl {

($vis:vis $type:ty) =>

{

where Self: Sized

{

state.downcast_ref::<$type>().unwrap()

}

where Self: Sized

{

state.downcast_mut::<$type>().unwrap()

}

where Self: Sized

{

Box::new(val)

Ok(DynData::Empty)

}

Ok(None)

}

panic!("{} has no custom state", type_name::<Self>())

}

panic!("{} has no custom state", type_name::<Self>());

}

panic!("{} has no custom state", type_name::<Self>());

}

Ok(DynData::Empty)

}

if category != "turrets" {

return None;

}

//! walls

use crate::block::simple::{cost, state_impl, BuildCost, SimpleBlock};

use crate::block::{

impl_block, make_register, BlockLogic, DataConvertError, DeserializeError, SerializeError,

Ok(DynData::Boolean(false))

}

match data {

DynData::Boolean(opened) => Ok(Some(Self::create_state(opened))),

_ => Err(DeserializeError::InvalidType {

}

}

let state = Self::get_state(state);

Box::new(Self::create_state(*state))

}

let state = Self::get_state(state);

Ok(DynData::Boolean(*state))

}

//! schematic parsing

use std::collections::hash_map::Entry;

use std::collections::HashMap;

use std::error::Error;

};

use image::RgbaImage;

use crate::data::base64;

use crate::data::dynamic::{self, DynData, DynSerializer};

use crate::data::{self, DataRead, DataWrite, GridPos, Serializer};

pub pos: GridPos,

pub block: &'l Block,

pub rot: Rotation,

}

impl PartialEq for Placement<'_> {

impl<'l> Placement<'l> {

/// gets the current state of this placement. you can cast it with `placement.block::get_state(placement.get_state()?)?`

#[must_use]

match self.state {

None => None,

}

}

/// get mutable state.

match self.state {

None => None,

}

}

}

/// set the state

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

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

}

curr.rot.mirror(horizontally, vertically);

}

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

}

}

self.rebuild_lookup();

curr.rot.rotate(clockwise);

}

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

}

}

self.rebuild_lookup();

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

let data = match curr.state {

None => DynData::Empty,

};

DynSerializer.serialize(&mut rbuff, &data)?;

rbuff.write_u8(curr.rot.into())?;