[package]

name = "mindus"

edition = "2021"

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

authors = [

}

let mut warmup = File::create(o.join("warmup.rs")).unwrap();

wr!(warmup => "pub unsafe fn warmup() {{");

wr!(warmup => "LazyLock::load(&EMPTY);");

let path = e.path();

if path.is_file() && let Some(e) = path.extension() && e == "png" {

let p = DynamicImage::from_decoder(PngDecoder::new(BufReader::new(File::open(path).unwrap())).unwrap()).unwrap().into_rgba8();

fn rotate_state(&self, _: &mut State, _: bool) {}

fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> {

}

fn draw(

}

fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> {

}

fn draw(

assert!(size != 0, "invalid size");

assert!(canvas_size != 0, "invalid size");

Self {

size,

symmetric,

build_cost,

}

}

state_impl!(pub RgbImage);

}

let mut p = RgbImage::new(size as u32, size as u32);

for i in 0..(size * size) {

let offset = i * 3;

i as u32 % size as u32,

i as u32 / size as u32,

PALETTE[n as usize],

}

p

}

fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> {

match data {

DynData::ByteArray(b) => Ok(Some(Self::create_state(deser_canvas_image(

self.canvas_size as usize,

)))),

_ => Err(DeserializeError::InvalidType {

let mut b = vec![0; n];

buff.read_bytes(&mut b)?;

build.state = Some(Self::create_state(deser_canvas_image(

self.canvas_size as usize,

)));

Ok(())

//! categorized as mindustry categorizes them in its assets folder, for easy drawing.

//!

//! with the exception of sandbox, that is.

use std::any::Any;

use std::error::Error;

use std::fmt;

logic: BlockLogicEnum,

image: Option<[&'static Lock<RgbaImage>; 3]>,

) -> Self {

}

/// this blocks name

/// ```

/// assert!(mindus::block::distribution::DISTRIBUTOR.name() == "distributor")

/// ```

pub fn name(&self) -> &'static str {

self.name

}

/// should you send context to [`image`]?

pub fn wants_context(&self) -> bool {

self.logic.want_context()

}

/// draw this block, with this state

pub unsafe fn image(

&self,

state: Option<&State>,

scale: Scale,

) -> ImageHolder {

if let Some(imgs) = self.image {

}

self.logic.draw(self.name, state, context, rot, scale)

}

/// size.

pub fn get_size(&self) -> u8 {

self.logic.get_size()

}

/// does it matter if its rotated

pub fn is_symmetric(&self) -> bool {

self.logic.is_symmetric()

}

/// cost

pub fn get_build_cost(&self) -> Option<ItemStorage> {

self.logic.create_build_cost()

}

impl Rotation {

#[must_use]

/// count rotations

self as u8

}

#[must_use]

/// mask

match self {

Rotation::Up => B1000,

Rotation::Right => B0100,

#[must_use]

/// character of this rot (Right => >, Up => ^, Left => <, Down => v)

match self {

Rotation::Right => '>',

Rotation::Up => '^',

#[must_use]

/// mirror the directions.

match self {

Self::Right => {

if horizontally {

#[must_use]

/// rotate the rotation

match self {

Self::Right => {

if clockwise {

#[must_use]

/// rotate 180

match self {

Self::Right => Self::Left,

Self::Up => Self::Down,

}

fn mirror_state(&self, state: &mut State, horizontally: bool, vertically: bool) {

if horizontally {

*dx = -*dx;

}

}

fn rotate_state(&self, state: &mut State, clockwise: bool) {

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

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

*dy = if clockwise { -cdx } else { cdx };

macro_rules! state_impl {

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

where Self: Sized {

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

}

pub(crate) use state_impl;

/// draw is called with self, name, state, context, rotation

macro_rules! make_simple {

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

pub struct $name {

});

impl Type {

match &self {

$(Self::[<$val:camel>] => {

image::Rgb(color_hex::color_from_hex!($col))

}

impl Type {

match self {

Self::Item => gen_by_id!(crate::item::Type, id),

Self::Block => gen_by_id!(crate::block::content::Type, id),

Self::Modifier => gen_by_id!(crate::modifier::Type, id),

Self::Unit => gen_by_id!(crate::unit::Type, id),

Self::Team => gen_by_id!(crate::team::Team, id),

}

}

}

for c in v.chunks(height) {

for c in c {

s.push(c[0].map_or('_', |(_, r)| r.ch()));

s.push(',');

s.push(c.map_or('_', |(_, r)| r.ch()));

}

}

pub fn mask2rotations(mask: U4, rot: Rotation) -> (u8, u8, u8) {

macro_rules! p {

($image:literal, $rotation:literal) => {

($image, $rotation, 0)

Rotation::Down => p!(1, 1, FLIP_Y), // ┐

Rotation::Right => p!(0, 0), // ─

Rotation::Up => p!(1, 3), // ┘

},

// from below

B0010 => match rot {

Rotation::Left => p!(1, 2), // ┐

Rotation::Right => p!(1, 1), // ┌

Rotation::Up => p!(0, 3), // │

},

// from bottom + left

B0011 => match rot {

Rotation::Left => p!(0, 2), // ─

Rotation::Down => p!(1, 1), // ┌

Rotation::Up => p!(1, 1, FLIP_X), // └

},

// from sides

B0101 => match rot {

Rotation::Down => p!(0, 1), // │

Rotation::Left => p!(1, 0, FLIP_X), // ┘

Rotation::Right => p!(1, 0), // └

},

// from top and left

B1001 => match rot {

with.rotate(rot);

}

pub fn rotations2tile((index, rot, flip): (u8, u8, u8), name: &str, scale: Scale) -> ImageHolder {

let mut p = match index {

0 => {

}

}};

}

let mut x = 0b0000;

x |= 8 * c!(ctx.cross[0], rot, n, Down);

pub trait BlockState<'l> {

fn get_block(&'l self) -> Option<&'l Block>;

}

fn cross(&self, j: usize, c: &PositionContext) -> Cross;

}

const BASE64: general_purpose::GeneralPurpose = general_purpose::STANDARD;

BASE64.encode_slice(input, output)

}

BASE64.decode_slice(input, output)

}

}

buff.write_u8(6)?;

buff.write_i16(arr.len() as i16)?;

buff.write_i32(v)?;

}

Ok(())

}

buff.write_u8(8)?;

buff.write_i8(arr.len() as i8)?;

buff.write_i32((i32::from(x) << 16) | (i32::from(y) & 0xFFFF))?;

}

Ok(())

}

buff.write_u8(16)?;

buff.write_i32(arr.len() as i32)?;

buff.write_bool(b)?;

}

Ok(())

}

buff.write_u8(18)?;

buff.write_i16(arr.len() as i16)?;

buff.write_f32(x)?;

buff.write_f32(y)?;

}

pub type EntityMapping = HashMap<u8, Box<dyn Content>>;

impl<'l> Tile<'l> {

pub fn new(floor: BlockEnum, ore: BlockEnum) -> Self {

Self {

floor,

});

}

self.build.as_ref()

}

/// ._.

///

/// dont think about it too much

pub fn size(&self) -> u8 {

if let Some(b) = &self.build {

return b.block.get_size();

1

}

pub unsafe fn floor_image(&self, s: Scale) -> ImageHolder {

macro_rules! lo {

($v:expr => [$(|)? $($k:literal $(|)?)+], $scale: ident) => { paste::paste! {

floor()

}

/// # Safety

pub unsafe fn build_image(&self, context: Option<&RenderingContext>, s: Scale) -> ImageHolder {

// building covers floore

let Some(b) = &self.build else {

if self.ore != BlockEnum::Air {

format!("+{}", self.ore.get_name())

} else {

},

if let Some(build) = &self.build {

format!(":{}", build.block.name())

} else {

}

)

}

block: self.block,

items: self.items.clone(),

liquids: self.liquids.clone(),

rotation: self.rotation,

team: self.team,

data: self.data,

}

impl<'l> Build<'l> {

pub fn new(block: &'l Block) -> Build<'l> {

Self {

block,

rotation: Rotation::Up,

team: team::SHARDED,

data: 0,

}

}

self.block

.image(self.state.as_ref(), context, self.rotation, s)

}

pub fn name(&self) -> &str {

self.block.name()

}

mask = buff.read_u8()?;

}

read_items(buff, &mut self.items)?;

}

read_power(buff)?;

}

read_liquids(buff, &mut self.liquids)?;

}

// "efficiency"?

}

impl<'l> Map<'l> {

pub fn new(width: usize, height: usize, tags: HashMap<String, String>) -> Self {

Self {

tiles: vec![Tile::new(BlockEnum::Stone, BlockEnum::Air); width * height],

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

if consecutives > 0 {

for i in (i + 1)..(i + 1 + consecutives) {

}

i += consecutives;

}

let central = if entity { buff.read_bool()? } else { false };

let block = BlockEnum::try_from(block_id)

.map_err(|_| ReadError::NoSuchBlock(block_id.to_string()))?;

Some(

self.0

.get(block.get_name())

.ok_or_else(|| ReadError::NoSuchBlock(block.to_string()))?,

)

};

if central {

if let Some(block) = block {

}

i += consecutives;

}

}

m = Some(map);

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

impl<'d> DataRead<'d> {

#[must_use]

Self { data, read: 0 }

}

match r {

Err(e) => {

// skip this chunk

let n = len - self.read;

if n != 0 {

#[cfg(debug_assertions)]

}

#[must_use]

matches!(self.data, WriteBuff::Vec(..))

}

/// eat this datawrite

///

/// panics if ref write buffer

pub fn consume(self) -> Vec<u8> {

match self.data {

WriteBuff::Vec(v) => v,

fn try_from(value: DataWrite<'d>) -> Result<Self, Self::Error> {

match value.data {

WriteBuff::Vec(v) => Ok(v),

}

}

}

}

impl ImageHolder {

pub fn own(self) -> RgbaImage {

match self {

Self::Own(x) => x,

}

impl Scale {

match self {

Self::Full => 32,

Self::Quarter => 32 / 4,

/// trait for renderable objects

pub trait Renderable {

/// create a picture

unsafe fn render(&self) -> RgbImage;

}

/// // this is now safe, because we have warmed up

/// let output /*: RgbImage */ = unsafe { s.render() };

/// ```

unsafe fn render(&self) -> RgbImage {

// fill background

let mut bg = RgbImage::repeated(

}

impl Renderable for Map<'_> {

unsafe fn render(&self) -> RgbImage {

let scale = if self.width + self.height < 2000 {

Scale::Quarter

}

}

/// Loads all the images into memory (about 300mb)

pub unsafe fn warmup() {

full::warmup();

quar::warmup();

}

let name = dbg!(t.get_name());

let t = reg.get(name).unwrap();

t.image(

None,

Some(&RenderingContext {

impl<'l> Placement<'l> {

/// make a placement from a block

pub fn new(block: &'l Block) -> Self {

Self {

block,

}

/// draws this placement in particular

pub unsafe fn image(

&self,

context: Option<&RenderingContext>,

fn clone(&self) -> Self {

Self {

block: self.block,

rot: self.rot,

}

}

h: self.height,

});

}

}

/// gets a block, mutably

h: self.height,

});

}

}

/// ```

/// # use mindus::Schematic;

///

});

}

let state = block.deserialize_state(data)?;

self.blocks[x][y] = Some(p);

Ok(())

}

#[must_use]

/// see how much this schematic costs.

/// ```

/// # use mindus::Schematic;

/// # use mindus::DynData;

const SCHEMATIC_HEADER: u32 =

((b'm' as u32) << 24) | ((b's' as u32) << 16) | ((b'c' as u32) << 8) | (b'h' as u32);

pub struct SchematicSerializer<'l>(pub &'l BlockRegistry<'l>);

impl<'l> Serializer<Schematic<'l>> for SchematicSerializer<'l> {

Self {

base: Vec::default(),

total: 0,

}

}

}

#[must_use]

/// total items

self.total

}

/// s.sub(item::Type::Copper, 500, 0);

/// assert!(s.is_empty());

/// ```

self.total == 0

}

/// ```

#[must_use]

pub fn get(&self, ty: T) -> u32 {

}

/// set item count of certain element

///

}

}

impl LogicField {

#[must_use]

self,

)

}

#[must_use]

}

}

impl Team {

#[must_use]

Self(id)

}

#[must_use]

}

}

5 => "blue",

6 => "neoplastic",

// dark magic: offsets manually computed, then rely on the format "...|team#{i}|..."

// length: 7 ("team#" (5) + 1 digit + "|" (1))

let s = ((i - 6) as usize) * 7;

&TEAM_NAMES[s..s + 6] // exclude the trailing "|"

}

impl Team {

macro_rules! h {

($x:literal) => {

Rgb(color_hex::color_from_hex!($x))

};

}

SHARDED => h!("ffd37f"),

DERELICT => h!("4d4e58"),

CRUX => h!("f25555"),

use std::cell::UnsafeCell;

use std::mem::ManuallyDrop;

use std::panic::{RefUnwindSafe, UnwindSafe};

}

#[inline]

pub unsafe fn load(this: &Lock<T, F>) {

let data = &mut *this.data.get();

let f = ManuallyDrop::take(&mut data.f);

impl<T, F> Lock<T, F> {

#[inline]

pub unsafe fn get(&self) -> &T {

&(*self.data.get()).value

}