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.overlay(&top);

base

});

continue;

}

let mut edge = edge.clone();

to.overlay(&edge.borrow());

}

};

} else if mask == B0000 && empty {

// single

let mut base = gimme(0);

edgify(5, &mut base.borrow_mut());

base

} else if mask == B0000 {

// directional

let mut base = gimme(0);

let going = rot.rotated(false).count();

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

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

let mut edge = edge.clone();

base.overlay(&edge);

}

}

}

if name == "duct-router" {

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

p.overlay(&arrow);

p

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

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

p.overlay(&top);

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

p.overlay(&arrow);

p

} else {

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

}

);

base.overlay(&arrow);

base

}

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

let mut base =

load!(from name which is ["large-plasma-bore" | "plasma-bore" | "cliff-crusher"], s);

base

},

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

);

make_simple!(WallDrillBlock, |_, _, _, _, rot: Rotation, scl| {

let mut base = load!("cliff-crusher", scl);

base

});

}

let img = img.as_mut().scale((s * self.size as u32) - offset * 2);

let mut borders = load!("canvas", s);

return borders;

}

"small-deconstructor" => "factory-in-3",

_ => "factory-in-5",

});

base

}

// "payload-loader" | "payload-unloader"

let mut base = load!(from n which is ["payload-loader" | "payload-unloader"], scl);

let mut input = load!("factory-in-3-dark", scl);

let mut output = load!("factory-out-3-dark", scl);

.overlay(output.rotate(r.rotated(false).count()))

.overlay(

&load!(concat top => n which is ["payload-loader" | "payload-unloader"], scl),

base

}

}

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

let mut base =

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

base

},

read_payload_conveyor

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

let mut base =

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

let over = load!(concat over => name which is ["payload-router" | "reinforced-payload-router"], s);

base.overlay(&over);

base

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

_ => "factory-out-5",

});

base.overlay(&out);

base.overlay(&load!(concat top => name which is ["constructor" | "large-constructor" | "payload-source"], s));

base

Neoplasia,

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

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

load!(scl -> match rot {

Rotation::Up | Rotation::Right => "neoplasia-reactor-top1",

Rotation::Down | Rotation::Left => "neoplasia-reactor-top2",

})

base

},

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

return base;

}

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

base.overlay(&top);

base

});

// electrolyzer exclusive

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

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

load!(s -> match r {

Rotation::Up | Rotation::Left => "electrolyzer-hydrogen-output1"

Rotation::Down | Rotation::Right => "electrolyzer-hydrogen-output2"

})

load!(s -> match r {

Rotation::Down | Rotation::Right => "electrolyzer-ozone-output1"

Rotation::Up | Rotation::Left => "electrolyzer-ozone-output2"

})

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);

match r {

Rotation::Up | Rotation::Right => {

load!(concat top1 => n which is ["heat-router" | "heat-redirector"], s)

load!(concat top2 => 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);

base.overlay(&load!(concat top => name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s));

base

},

AssemblerModule,

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

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

load!(scl -> match rot {

Rotation::Up | Rotation::Right => "basic-assembler-module-side1",

_ => "basic-assembler-module-side2",

})

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 {

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);

load!(s -> match name {

"ground-factory" | "air-factory" | "naval-factory" => "factory-out-3",

_ => "factory-out-3-dark",

})

.overlay(&load!(s -> match name {

"ground-factory" | "air-factory" | "naval-factory" => "factory-top-3",

"tank-fabricator" => "tank-fabricator-top",

pub const FLIP_X: u8 = 1;

pub const FLIP_Y: u8 = 2;

if (flip & FLIP_X) != 0 {

with.flip_h();

}

load!(concat 4 => name which is ["reinforced-conduit" | "armored-duct" | "pulse-conduit" | "plated-conduit" | "conduit" | "conveyor" | "titanium-conveyor" | "armored-conveyor" | "duct"], scale)

}

};

p

}

/// ```

fn render(&self) -> Image<Vec<u8>, 3> {

// fill background

let mut canvas = Image::alloc(

((self.width + 2) * 32) as u32,

((self.height + 2) * 32) as u32,

};

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

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

}

canvas.as_mut().shadow();

for x in 0..canvas.width() {

}) {

// draw the floor first.

// println!("draw {tile:?} ({x}, {y}) + {scale:?}");

floor.as_mut().overlay_at(

scale * x as u32,

scale * y as u32,

}

if let Some(build) = tile.build() {

} else {

None

};

}

}

floor

}

}

slice_as_chunks,

slice_swap_unchecked

)]

pub mod block;

mod content;

pub mod data;

pub trait Overlay<W> {

/// Overlay with => self at coordinates x, y, without blending

}

pub trait RepeatNew {

type Output;

}

pub trait ImageUtils {

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

fn overlay(&mut self, with: Self::With<'_>) -> &mut Self;

/// rotate (squares only)

/// flip along the horizontal axis

fn flip_h(&mut self) -> &mut Self;

/// flip along the vertical axis

macro_rules! unsafe_assert {

($cond:expr) => {{

if !$cond {

}

}};

}

impl Overlay<Image<&[u8], 3>> for Image<&mut [u8], 3> {

for j in 0..with.height() {

for i in 0..with.width() {

}

}

self

}

impl Overlay<Image<&[u8], 4>> for Image<&mut [u8], 3> {

for j in 0..with.height() {

for i in 0..with.width() {

}

}

}

}

impl Overlay<Image<&[u8], 4>> for Image<&mut [u8], 4> {

for j in 0..with.height() {

for i in 0..with.width() {

.buffer

}

}

}

self

}

}

impl RepeatNew for Image<&[u8], 4> {

type Output = Image<Vec<u8>, 4>;

let mut img = Image::alloc(x, y); // could probably optimize this a ton but eh

for x in 0..(x / self.width()) {

for y in 0..(y / self.height()) {

}

}

for y in 0..img.height() / 2 {

for x in 0..img.width() {

}

}

}

for y in 0..img.height() {

for x in 0..img.width() / 2 {

}

}

}

for y in 0..img.height() / 2 {

for x in 0..img.width() {

}

}

let middle = img.height() / 2;

for x in 0..img.width() / 2 {

}

}

}

debug_assert_eq!(img.width(), img.height());

let size = img.width();

flip_v(img);

for i in 0..size {

for j in i..size {

for c in 0..CHANNELS {

(i * size + j) as usize * CHANNELS + c,

(j * size + i) as usize * CHANNELS + c,

);

}

}

debug_assert_eq!(img.width(), img.height());

flip_h(img);

let size = img.width();

for i in 0..size {

for j in i..size {

for c in 0..CHANNELS {

(i * size + j) as usize * CHANNELS + c,

(j * size + i) as usize * CHANNELS + c,

);

}

}

}

impl ImageUtils for Image<&mut [u8], 4> {

}

self

}

}

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

fn overlay(&mut self, with: &Image<&[u8], 4>) -> &mut Self {

unsafe_assert!(self.buffer.len() % 4 == 0);

unsafe_assert!(with.buffer.len() % 4 == 0);

for (i, other_pixels) in with.buffer.array_chunks::<4>().enumerate() {

#[inline]

fn flip_h(&mut self) -> &mut Self {

self

}

#[inline(always)]

fn flip_v(&mut self) -> &mut Self {

self

}

}

unsafe fn really_unsafe_index(x: u32, y: u32, w: u32) -> usize {

// y * w + x

(y as usize)

///

/// - UB if x, y is out of bounds

/// - UB if buffer is too small

pub unsafe fn slice(&self, x: u32, y: u32) -> impl SliceIndex<[u8], Output = [u8]> {

debug_assert!(x < self.width(), "x out of bounds");

debug_assert!(y < self.height(), "y out of bounds");

}

impl Overlay<ImageHolder<4>> for ImageHolder<4> {

self.borrow_mut().overlay_at(&with.borrow(), x, y);

self

}

self

}

if times == 0 {

return self;

}

[00, 01]

[02, 10]

];

assert_eq!(

from,

img![

[90, 01]

[21, 42]

];

assert_eq!(

from,

img![

[90, 01]

[21, 42]

];

assert_eq!(

from,

img![