make_simple!(SimpleDuctBlock, |_, name, _, _, rot: Rotation, s| {

let mut base = load!("duct-base", s);

let mut top = load!(from name which is ["overflow-duct" "underflow-duct"], s);

base

});

if i == skip {

continue;

}

}

};

let gimme = |n: u8| match n {

unsafe { base.rotate(going) };

for [r, i] in [[3, 0b1000], [0, 0b0100], [1, 0b0010], [2, 0b0001]] {

if (mask.into_u8() & i) == 0 && (going != r || empty) {

}

}

base

|_, _, _, buff: &mut DataRead| buff.skip(8),

true

);

// format: id: [`i32`]

make_simple!(UnitCargoLoader => |_, _, _, buff: &mut DataRead| buff.skip(4));

"unloader" => "unloader-center",

_ => "center",

});

return p;

}

}

}

if name == "duct-router" {

let mut arrow = load!("top", s);

p

} else if name == "duct-unloader" {

let mut top = load!("duct-unloader-top", s);

let mut arrow = load!("duct-unloader-arrow", s);

p

} else {

let mut null = load!("cross-full", s);

null

}

}

match name {

"mass-driver" => {

let mut base = load!("mass-driver-base", s);

base

}

"duct-bridge" | "reinforced-bridge-conduit" => {

_ => "reinforced-bridge-conduit-dir",

}

);

base

}

// "bridge-conveyor" | "phase-conveyor" | "bridge-conduit" | "phase-conduit" | "payload-mass-driver" | "large-payload-mass-driver"

if let Some(state) = state {

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

let mut top = load!("center", s);

return p;

}

}

let mut null = load!("cross-full", s);

null

}

if let Some(state) = state {

if *Self::get_state(state) {

let on = load!("switch-on", s);

return base;

}

}

"payload-router" | "reinforced-payload-router" => {

let mut base =

load!(from name which is ["payload-router" | "reinforced-payload-router"], s);

base

}

_ => {

"large-constructor" => "factory-out-5-dark",

_ => "factory-out-5",

});

base

}

}

Neoplasia,

|_, _, _, _, rot: Rotation, scl| {

let mut base = load!("neoplasia-reactor", scl);

base

},

|_, _, _, buff: &mut DataRead| read_heater(buff)

return base;

}

let mut top = load!("diode-arrow", s);

base

});

// electrolyzer exclusive

// ozone <- e(^) -> hydrogen

let mut base = load!("electrolyzer", s);

base

},

|b: &mut Build<'_>, _, _, buff: &mut DataRead| {

HeatCrafter,

|_, n, _, _, r: Rotation, s| {

let mut base = load!(from n which is ["phase-heater" | "electric-heater" | "oxidation-chamber" | "slag-heater" | "heat-source"], s);

Rotation::Up | Rotation::Right => load!(concat "top1" => n which is ["phase-heater" | "electric-heater" | "oxidation-chamber" | "slag-heater" | "heat-source"], s),

Rotation::Down | Rotation::Left => load!(concat "top2" => n which is ["phase-heater" | "electric-heater" | "oxidation-chamber" | "slag-heater" | "heat-source"], s)

base

},

|_, _, _, buff: &mut DataRead| {

);

make_simple!(HeatConduit, |_, n, _, _, r: Rotation, s| {

let mut base = load!(from n which is ["heat-router" | "heat-redirector"], s);

}

base

});

|_, name, _, _, rot: Rotation, s| {

let mut base =

load!(from name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s);

match rot {

Rotation::Up | Rotation::Right => load!(concat "side1" => name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s),

Rotation::Down | Rotation::Left => load!(concat "side2" => name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s)

.rotate(rot.rotated(false).count())

base

},

|_, reg, map, buff| read_assembler(reg, map, buff)

AssemblerModule,

|_, _, _, _, rot: Rotation, scl| {

let mut base = load!("basic-assembler-module", scl);

base

},

|_, reg, map, buff| read_payload_block(reg, map, buff)

"prime-refabricator" => "factory-out-5-dark",

"tetrative-reconstructor" => "factory-out-9",

});

let mut r#in = load!(s -> match name {

"additive-reconstructor" => "factory-in-3",

"prime-refabricator" => "factory-in-5-dark",

"tetrative-reconstructor" => "factory-in-9",

});

// TODO: the context cross is too small

// for i in 0..4u8 {

// }

// }

base

}

s: Scale,

) -> ImageHolder<4> {

let mut base = load!(from name which is ["ground-factory" | "air-factory" | "naval-factory" | "tank-fabricator" | "ship-fabricator" | "mech-fabricator"], s);

base

}

make_simple!(WallBlock, |_, _, _, _, _, s| {

let mut base = load!("thruster", s);

base

});

// from bottom + left

B0011 => match rot {

Rotation::Right => p!("2-0"), // ┬

_ => unreachable!(),

},

// from right

///

/// dont think about it too much

#[must_use]

pub fn size(&self) -> u8 {

}

pub(crate) fn floor(&self, s: Scale) -> ImageHolder<4> {

lo!(self.floor => [

| "darksand"

}

#[must_use]

pub(crate) fn ore(&self, s: Scale) -> ImageHolder<4> {

lo!(self.ore => ["ore-copper" | "ore-beryllium" | "ore-lead" | "ore-scrap" | "ore-coal" | "ore-thorium" | "ore-titanium" | "ore-tungsten" | "pebbles" | "tendrils" | "ore-wall-tungsten" | "ore-wall-beryllium" | "ore-wall-thorium" | "spawn" | "ore-crystal-thorium"], s)

}

#[must_use]

pub fn has_ore(&self) -> bool {

self.ore != BlockEnum::Air

}

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

let mut floor = self.floor(s);

if self.has_ore() {

}

floor

}

/// Draw this tiles build.

#[must_use]

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

// building covers floore

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

/// Tint this image with the color

fn tint(&mut self, color: (u8, u8, u8)) -> &mut Self;

/// Overlay with => self (does not blend)

/// rotate (squares only)

/// # Safety

///

self

}

type With<'a> = &'a Image<&'a [u8], 4>;

unsafe_assert!(self.width() == with.width());

unsafe_assert!(self.height() == with.height());

unsafe_assert!(with.buffer.len() > 4);

self

}

type With<'a> = &'a Self;

self.borrow_mut().overlay(&with.borrow());

self

}