[package]

name = "mindus"

edition = "2021"

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

authors = [

{

"air",

"spawn",

"cliff",

"build1",

"build2",

"yellow-stone-vent",

"red-stone-vent",

"crystalline-vent",

"redmat",

"bluemat",

"grass",

"slag-heater",

"phase-heater",

"heat-redirector",

"heat-router",

"slag-incinerator",

"carbide-crucible",

"oil-extractor",

"vent-condenser",

"cliff-crusher",

"plasma-bore",

"large-plasma-bore",

"impact-drill",

"ship-fabricator",

"mech-fabricator",

"tank-refabricator",

"ship-refabricator",

"prime-refabricator",

"tank-assembler",

"ship-assembler",

"legacy-unit-factory-ground",

"command-center",

"launch-pad",

"interplanetary-accelerator",

"message",

"switch",

"memory-bank",

"logic-display",

"large-logic-display",

"canvas",

"reinforced-message",

"world-processor",

"world-cell",

"world-message",

"world-switch",

}

}

impl $tname {

pub const ALL: [Self; $crate::content::count_exprs!($($val)+)] = [$(Self::[<$val:camel>]),+];

}

impl $crate::content::Content for $tname {

//!

//! ZLIB compressed stream contains:

//! - header: 4b = `MSCH` [`MapReader::header`]

//! - tag section `<u32>` [`MapReader::tags`]

//! - 1 byte of idk (skip)

//! - string map (`u16` for map len, iterate each, read `utf`)

//! - the type: `i8` (0: item, block: 1, liquid: 4, status: 5, unit: 6, weather: 7, sector: 9, planet: 13

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

//! - iterate `u16`

//! - name: `utf`

//! - continue

//! - id: `u32`

//! - entity read

use std::collections::HashMap;

use std::ops::CoroutineState::*;

use std::ops::{Coroutine, Index, IndexMut};

#[error("unsupported version ({0})")]

Version(u8),

#[error("unknown block {0:?}")]

#[error("failed to read block data")]

ReadState(#[from] super::dynamic::ReadError),

}

}

macro_rules! tiles {

let mut i = 0;

while i < $count {

let floor_id = $me.buff.read_u16()?;

let overlay_id = $me.buff.read_u16()?;

yield $w::Tile { floor, ore };

let consecutives = $me.buff.read_u8()? as usize;

for _ in 0..consecutives {

};

}

impl MapReader {

pub fn new(buff: &mut DataRead<'_>) -> Result<Self, ReadError> {

let backing = buff.deflate()?;

}

pub fn version(&mut self) -> Result<u32, ReadError> {

let x = self.buff.read_u32()?;

.then_some(x)

.ok_or(ReadError::Version(x.try_into().unwrap_or(0)))

}

Ok(tags)

}

pub fn tags_alloc(&mut self) -> Result<HashMap<String, String>, ReadError> {

let mut tags = HashMap::new();

self.buff

pub fn thin_map(

&mut self,

) -> Result<

impl Coroutine<(), Return = Result<(), ReadError>, Yield = ThinMapData> + '_,

ReadError,

let w = w as usize;

let h = h as usize;

let count = w * h;

let mut i = 0;

while i < count {

} else {

false

};

let block = block.to_block();

let Some(block) = block else {

let consecutives = self.buff.read_u8()?;

Ok(map)

}

let (w, h) = match Pin::new(&mut co).resume(()) {

Yielded(MapData::Init { width, height }) => (width as usize, height as usize),

Complete(Err(x)) => return Err(x),

pub fn map(

&mut self,

) -> Result<impl Coroutine<(), Return = Result<(), ReadError>, Yield = MapData> + '_, ReadError>

{

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

let w = w as usize;

let h = h as usize;

let count = w * h;

let mut i = 0;

while i < count {

} else {

false

};

let block = block.to_block();

let Some(block) = block else {

let consecutives = self.buff.read_u8()?;

fn deserialize(buff: &mut DataRead<'_>) -> Result<Map, Self::ReadError> {

let mut buff = MapReader::new(buff)?;

buff.header()?;

let tags = buff.tags_alloc()?;

m.entities = buff.collect_entities()?;

// skip custom chunks

buff.skip()?;

use super::GridPos;

use crate::block::content::Type;

use crate::color_mapping::BLOCK2COLOR;

use crate::team::Team;

pub(crate) use crate::utils::*;

use crate::Map;

/// Will walk through the map section. use [`draw_units`] after, if you like.

pub fn draw_map_single(

map: &mut crate::data::map::MapReader,

) -> Result<(Image<Box<[u8]>, 3>, (u16, u16)), super::map::ReadError> {

use std::ops::CoroutineState::*;

let (w, h) = match Pin::new(&mut co).resume(()) {

Yielded(ThinMapData::Init { width, height }) => (width, height),

Complete(Err(x)) => return Err(x),

}

/// Draws a map in a single pass. Uses the silly team color thing that mindustry has.

pub fn draw_map_simple(

map: &mut crate::data::map::MapReader,

) -> Result<(Image<Box<[u8]>, 3>, (u16, u16)), super::map::ReadError> {

use std::ops::CoroutineState::*;

let (w, h) = match Pin::new(&mut co).resume(()) {

Yielded(ThinMapData::Init { width, height }) => (width, height),

Complete(Err(x)) => return Err(x),

match (|| {

let mut m = MapReader::new(&mut DataRead::new(&s))?;

m.header()?;

let t = m.tags()?;

dbg!(&t);

println!("rendering {}", t.get("name").unwrap_or(&"<unknown>"));

mindus::data::renderer::draw_units(&mut m, img.as_mut(), sz)?;

Ok::<_, mindus::data::map::ReadError>(img)

})() {

//! crate for dealing with mindustry

#![feature(

maybe_uninit_write_slice,

stmt_expr_attributes,

generic_const_exprs,

Ok(match buff.read_u8()? {

0 => Controller::Player(buff.read_i32()?),

3 => Controller::Logic(buff.read_i32()?),

let has_attack = buff.read_bool()?;

let pos = if buff.read_bool()? {

Some((buff.read_f32()?, buff.read_f32()?))

} else {

None

};

Controller::Command {

target,

pos,

command,

}

}

_ => Controller::Assembler,

})

}

impl UnitClass {

pub fn read(self, buff: &mut DataRead) -> Result<Unit, ReadError> {

let mut state = UnitState::default();

read_abilities(buff)?;

state.ammo = buff.read_f32()?;