+version = "2.0.1"

+macro_rules! wr {

+ ($dst:expr => $($arg:tt)*) => { writeln!($dst, $($arg)*).unwrap() };

+}

+

+fn kebab2bigsnek(kebab: &str) -> String {

+ let mut n = String::new();

+ n.reserve(kebab.len());

+ for c in kebab.chars() {

+ if c == '-' {

+ n.push('_');

+ } else {

+ n.push(c.to_ascii_uppercase());

+ }

+ }

+ n

+}

+

+ let mut n = 4usize;

+

+ wr!(full => "pub mod full {{");

+ wr!(full => "pub static EMPTY: LazyLock<RgbaImage> = LazyLock::new(|| RgbaImage::new(32, 32));");

+

+ wr!(quar => "pub mod quar {{");

+ wr!(quar => "pub static EMPTY: LazyLock<RgbaImage> = LazyLock::new(|| RgbaImage::new(8, 8));");

+

+ wr!(eigh => "pub mod eigh {{");

+ wr!(eigh => "pub static EMPTY: LazyLock<RgbaImage> = LazyLock::new(|| RgbaImage::new(4, 4));");

+

+ for mut file in [&full, &quar, &eigh] {

+ file.write_all(b"macro_rules!img{($v:expr)=>{{static TMP:LazyLock<RgbaImage>=LazyLock::new(||$v);&TMP}};}\n").unwrap();

+ wr!(file => "use ::{{image::RgbaImage, std::sync::LazyLock}};");

+ wr!(full => "pub static BUILD{}: &LazyLock<RgbaImage> = &EMPTY;", i);

+ wr!(quar => "pub static BUILD{}: &LazyLock<RgbaImage> = &EMPTY;", i);

+ wr!(eigh => "pub static BUILD{}: &LazyLock<RgbaImage> = &EMPTY;", i);

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

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

+ let path = kebab2bigsnek(path.file_name().unwrap().to_str().unwrap());

+ wr!($ext =>

+ r#"pub static {path}: &LazyLock<RgbaImage> = img!(unsafe {{ RgbaImage::from_vec({x}, {y}, include_bytes!(concat!(env!("OUT_DIR"), "/{n}-{}")).to_vec()).unwrap_unchecked() }});"#,

+ );

+ wr!(warmup => "LazyLock::force({path});");

+ warmup.write_all(b"}").unwrap();

+ // brazillian literal

+ f.write_all(br#"include!(concat!(env!("OUT_DIR"), "/warmup.rs"));"#)

+ .unwrap();

+ "launch-pad" -> CampaignBlock::new(3, true, cost!(Copper: 350, Lead: 200, Titanium: 150, Silicon: 140));

+ "interplanetary-accelerator" -> CampaignBlock::new(7, true, cost!(Copper: 16000, Silicon: 11000, Thorium: 13000, Titanium: 12000, SurgeAlloy: 6000, PhaseFabric: 5000));

+ "mender" -> HeatedBlock::new(1, true, cost!(Copper: 25, Lead: 30));

+ "mend-projector" -> HeatedBlock::new(2, true, cost!(Copper: 50, Lead: 100, Titanium: 25, Silicon: 40));

+ "overdrive-projector" -> HeatedBlock::new(2, true, cost!(Lead: 100, Titanium: 75, Silicon: 75, Plastanium: 30));

+ "overdrive-dome" -> HeatedBlock::new(3, true, cost!(Lead: 200, Titanium: 130, Silicon: 130, Plastanium: 80, SurgeAlloy: 120));

+ "force-projector" -> DefenseBlock::new(3, true, cost!(Lead: 100, Titanium: 75, Silicon: 125));

+ "regen-projector" -> DefenseBlock::new(3, true, cost!(Silicon: 80, Tungsten: 60, Oxide: 40, Beryllium: 80));

+ "shock-mine" -> DefenseBlock::new(1, true, cost!(Lead: 25, Silicon: 12));

+ "radar" -> DefenseBlock::new(1, true, cost!(Silicon: 60, Graphite: 50, Beryllium: 10));

+ "build-tower" -> DefenseBlock::new(3, true, cost!(Silicon: 150, Oxide: 40, Thorium: 60));

+ "shockwave-tower" -> DefenseBlock::new(3, true, cost!(SurgeAlloy: 50, Silicon: 150, Oxide: 30, Tungsten: 100));

+ "barrier-projector" -> DefenseBlock::new(3, true, &[]);

+ "shield-projector" -> DefenseBlock::new(3, true, &[]);

+ "large-shield-projector" -> DefenseBlock::new(4, true, &[]);

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

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

+ let edge = load!(concat edge => name which is ["surge-conveyor" | "plastanium-conveyor"], s);

+ let gimme = |n: u8| match n {

+ 0 => load!(concat 0 => name which is ["surge-conveyor" | "plastanium-conveyor"], s),

+ 1 => load!(concat 1 => name which is ["surge-conveyor" | "plastanium-conveyor"], s),

+ _ => load!("plastanium-conveyor-2", s),

+ };

+ let mut base = load!("surge-router", s);

+ base.overlay(&load!("top", s));

+ "junction" -> JunctionBlock::new(1, true, cost!(Copper: 2));

+ "bridge-conveyor" -> BridgeBlock::new(1, false, cost!(Copper: 6, Lead: 6), 4, true);

+ "phase-conveyor" -> BridgeBlock::new(1, false, cost!(Lead: 10, Graphite: 10, Silicon: 7, PhaseFabric: 5), 12, true);

+ "router" -> ControlBlock::new(1, true, cost!(Copper: 3));

+ "distributor" -> ControlBlock::new(2, true, cost!(Copper: 4, Lead: 4));

+ "overflow-gate" -> ControlBlock::new(1, true, cost!(Copper: 4, Lead: 2));

+ "underflow-gate" -> ControlBlock::new(1, true, cost!(Copper: 4, Lead: 2));

+ "unit-cargo-loader" -> UnitCargoLoader::new(3, true, cost!(Silicon: 80, SurgeAlloy: 50, Oxide: 20));

+ "item-source" -> ItemBlock::new(1, true, &[]);

+ "item-void" -> ControlBlock::new(1, true, &[]);

+ let mut p = load!(from name which is ["sorter" | "inverted-sorter" | "duct-router" | "duct-unloader" | "unit-cargo-unload-point" | "unloader" | "item-source"], s);

+ let mut top = load!(s -> match name {

+ "unit-cargo-unload-point" => "unit-cargo-unload-point-top",

+ "unloader" => "unloader-center",

+ _ => "center",

+ });

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

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

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

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

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

+ base.overlay(&load!("mass-driver", s));

+ let mut base =

+ load!(from name which is ["duct-bridge" | "reinforced-bridge-conduit"], s);

+ let mut arrow = load!(

+ s -> match name {

+ }

+ _ => unreachable!(),

+ let mut base =

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

+ let mut top = load!(concat top => name which is ["large-plasma-bore" | "plasma-bore" | "cliff-crusher"], s);

+ top.rotate(rot.rotated(false).count());

+ base.overlay(&top);

+ return base;

+ "mechanical-drill" -> DrillBlock::new(2, true, cost!(Copper: 12));

+ "pneumatic-drill" -> DrillBlock::new(2, true, cost!(Copper: 18, Graphite: 10));

+ "laser-drill" -> DrillBlock::new(3, true, cost!(Copper: 35, Graphite: 30, Titanium: 20, Silicon: 30));

+ "blast-drill" -> DrillBlock::new(4, true, cost!(Copper: 65, Titanium: 50, Thorium: 75, Silicon: 60));

+ "water-extractor" -> ExtractorBlock::new(2, true, cost!(Copper: 30, Lead: 30, Metaglass: 30, Graphite: 30));

+ "oil-extractor" -> ExtractorBlock::new(3, true, cost!(Copper: 150, Lead: 115, Graphite: 175, Thorium: 115, Silicon: 75));

+ "vent-condenser" -> ProductionBlock::new(3, true, cost!(Graphite: 20, Beryllium: 60));

+ "cliff-crusher" -> DrillBlock::new(2, false, cost!(Beryllium: 100, Graphite: 40));

+ "impact-drill" -> DrillBlock::new(4, true, cost!(Silicon: 70, Beryllium: 90, Graphite: 60));

+ "eruption-drill" -> DrillBlock::new(5, true, cost!(Silicon: 200, Oxide: 20, Tungsten: 200, Thorium: 120));

+ $($field -> EnvironmentBlock::new($size, true, &[]);)*

+make_simple!(EnvironmentBlock);

+ let tile = rotations2tile((index, rot, flip), "conduit", s);

+ "reinforced-pump" -> LiquidBlock::new(2, true, cost!(Beryllium: 40, Tungsten: 30, Silicon: 20));

+ "mechanical-pump" -> LiquidBlock::new(1, true, cost!(Copper: 15, Metaglass: 10));

+ "rotary-pump" -> LiquidBlock::new(2, true, cost!(Copper: 70, Metaglass: 50, Titanium: 35, Silicon: 20));

+ "impulse-pump" -> LiquidBlock::new(3, true, cost!(Copper: 80, Metaglass: 90, Titanium: 40, Thorium: 35, Silicon: 30));

+ "liquid-router" -> LiquidBlock::new(1, true, cost!(Metaglass: 2, Graphite: 4));

+ "liquid-container" -> LiquidBlock::new(2, true, cost!(Metaglass: 15, Titanium: 10));

+ "liquid-tank" -> LiquidBlock::new(3, true, cost!(Metaglass: 40, Titanium: 30));

+ "liquid-junction" -> LiquidBlock::new(1, true, cost!(Metaglass: 8, Graphite: 4));

+ "bridge-conduit" -> BridgeBlock::new(1, true, cost!(Metaglass: 8, Graphite: 4), 4, true);

+ "phase-conduit" -> BridgeBlock::new(1, true, cost!(Metaglass: 20, Titanium: 10, Silicon: 7, PhaseFabric: 5), 12, true);

+ "reinforced-liquid-junction" -> LiquidBlock::new(1, true, cost!(Graphite: 4, Beryllium: 8));

+ "reinforced-liquid-router" -> LiquidBlock::new(1, true, cost!(Graphite: 8, Beryllium: 4));

+ "reinforced-liquid-container" -> LiquidBlock::new(2, true, cost!(Tungsten: 10, Beryllium: 16));

+ "reinforced-liquid-tank" -> LiquidBlock::new(3, true, cost!(Tungsten: 40, Beryllium: 50));

+ "liquid-void" -> LiquidBlock::new(1, true, &[]);

+ _: &str,

+ let mut p = load!("liquid-source", s);

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

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

+ "reinforced-message" -> MessageLogic::new(1, true, cost!(Graphite: 10, Beryllium: 5));

+ "message" -> MessageLogic::new(1, true, cost!(Copper: 5, Graphite: 5));

+ "micro-processor" -> ProcessorLogic::new(1, true, cost!(Copper: 90, Lead: 50, Silicon: 50));

+ "logic-processor" -> ProcessorLogic::new(2, true, cost!(Lead: 320, Graphite: 60, Thorium: 50, Silicon: 80));

+ "hyper-processor" -> ProcessorLogic::new(3, true, cost!(Lead: 450, Thorium: 75, Silicon: 150, SurgeAlloy: 50));

+ "memory-cell" -> MemoryBlock::new(1, true, cost!(Copper: 30, Graphite: 30, Silicon: 30));

+ "memory-bank" -> MemoryBlock::new(2, true, cost!(Copper: 30, Graphite: 80, Silicon: 80, PhaseFabric: 30));

+ "logic-display" -> LogicBlock::new(3, true, cost!(Lead: 100, Metaglass: 50, Silicon: 50));

+ "large-logic-display" -> LogicBlock::new(6, true, cost!(Lead: 200, Metaglass: 100, Silicon: 150, PhaseFabric: 75));

+ "world-processor" -> LogicBlock::new(1, true, &[]);

+ "world-message" -> MessageLogic::new(1, true, &[]);

+ "world-cell" -> MemoryBlock::new(1, true, &[]);

+ _: &str,

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

+ _: &str,

+ _: Scale,

+ unreachable!()

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

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

+use std::sync::LazyLock;

+ ) -> ImageHolder {

+ unimplemented!("{name}")

+ }

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

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

+ Self { name, logic, image }

+ if let Some(imgs) = self.image {

+ return ImageHolder::from(LazyLock::force(unsafe {

+ imgs.get_unchecked(scale as usize)

+ }));

+ }

+ ($($field:literal $op:tt $logic:expr;)+) => { paste::paste! {

+ $crate::block::make_register!(impl $field $op $logic);

+ )+

+ // get the static we make

+ $(assert!(reg.register(&[<$field:snake:upper>]).is_ok());)+

+ (impl $field: literal => $logic: expr) => {

+ paste::paste! { pub static [<$field:snake:upper>]: $crate::block::Block = $crate::block::Block::new(

+ std::borrow::Cow::Borrowed($field), $crate::access::Access::Borrowed(&$logic), None

+ ); }

+ };

+ (impl $field: literal -> $logic: expr) => {

+ paste::paste! { pub static [<$field:snake:upper>]: $crate::block::Block = $crate::block::Block::new(

+ std::borrow::Cow::Borrowed($field), $crate::access::Access::Borrowed(&$logic), Some(crate::data::renderer::load!($field))

+ ); }

+ }

+ let mut base = load!(from n which is ["deconstructor" | "small-deconstructor" | "payload-void"], scl);

+ let mut r#in = load!(scl -> match n {

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

+ _ => "factory-in-5",

+ });

+ base.overlay(r#in.rotate(r.rotated(false).count())).overlay(

+ load!(scl -> match n {

+ "small-deconstructor" => "small-deconstructor-top",

+ "deconstructor" => "deconstructor-top",

+ _ => "payload-void-top",

+ })

+ .borrow(),

+ 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(

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

+ .borrow(),

+ );

+ let mut base =

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

+ "payload-mass-driver" -> BridgeBlock::new(3, true, cost!(Tungsten: 120, Silicon: 120, Graphite: 50), 700, false);

+ "large-payload-mass-driver" -> BridgeBlock::new(5, true, cost!(Thorium: 200, Tungsten: 200, Silicon: 200, Graphite: 100, Oxide: 30), 1100, false);

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

+ let mut base = load!(from name which is ["constructor" | "large-constructor" | "payload-source"], s);

+ let mut out = load!(s -> match name {

+ "constructor" => "factory-out-3",

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

+ _ => "factory-out-5",

+ });

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

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

+ // TODO 2 tops

+ base.overlay(load!("neoplasia-reactor-top", scl).rotate(rot.rotated(false).count()));

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

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

+ "illuminator" -> LampBlock::new(1, true, cost!(Lead: 8, Graphite: 12, Silicon: 8));

+ "power-node" -> ConnectorBlock::new(1, true, cost!(Copper: 1, Lead: 3), 10);

+ "power-node-large" -> ConnectorBlock::new(2, true, cost!(Lead: 10, Titanium: 5, Silicon: 3), 15);

+ "surge-tower" -> ConnectorBlock::new(2, true, cost!(Lead: 10, Titanium: 7, Silicon: 15, SurgeAlloy: 15), 2);

+ "battery" -> BatteryBlock::new(1, true, cost!(Copper: 5, Lead: 20));

+ "battery-large" -> BatteryBlock::new(3, true, cost!(Lead: 50, Titanium: 20, Silicon: 30));

+ "combustion-generator" -> GeneratorBlock::new(1, true, cost!(Copper: 25, Lead: 15));

+ "thermal-generator" -> GeneratorBlock::new(2, true, cost!(Copper: 40, Lead: 50, Metaglass: 40, Graphite: 35, Silicon: 35));

+ "steam-generator" -> GeneratorBlock::new(2, true, cost!(Copper: 35, Lead: 40, Graphite: 25, Silicon: 30));

+ "differential-generator" -> GeneratorBlock::new(3, true, cost!(Copper: 70, Lead: 100, Metaglass: 50, Titanium: 50, Silicon: 65));

+ "rtg-generator" -> GeneratorBlock::new(2, true, cost!(Lead: 100, Thorium: 50, Silicon: 75, Plastanium: 75, PhaseFabric: 25));

+ "solar-panel" -> GeneratorBlock::new(1, true, cost!(Lead: 10, Silicon: 15));

+ "solar-panel-large" -> GeneratorBlock::new(3, true, cost!(Lead: 80, Silicon: 110, PhaseFabric: 15));

+ "thorium-reactor" -> NuclearGeneratorBlock::new(3, true, cost!(Lead: 300, Metaglass: 50, Graphite: 150, Thorium: 150, Silicon: 200));

+ "impact-reactor" -> ImpactReactorBlock::new(4, true,

+ "beam-node" -> ConnectorBlock::new(1, true, cost!(Beryllium: 8), 4);

+ "beam-tower" -> ConnectorBlock::new(3, true, cost!(Beryllium: 30, Oxide: 10, Silicon: 10), 12);

+ "turbine-condenser" -> GeneratorBlock::new(3, true, cost!(Beryllium: 60));

+ "chemical-combustion-chamber" -> GeneratorBlock::new(3, true, cost!(Graphite: 40, Tungsten: 40, Oxide: 40, Silicon: 30));

+ "pyrolysis-generator" -> GeneratorBlock::new(3, true, cost!(Graphite: 50, Carbide: 50, Oxide: 60, Silicon: 50));

+ "flux-reactor" -> GeneratorBlock::new(5, true, cost!(Graphite: 300, Carbide: 200, Oxide: 100, Silicon: 600, SurgeAlloy: 300));

+ "beam-link" -> ConnectorBlock::new(3, true, &[], 12);

+ "power-source" -> ConnectorBlock::new(1, true, &[], 100);

+ "power-void" -> GeneratorBlock::new(1, true, &[]);

+ "cultivator" -> ProductionBlock::new(2, true, cost!(Copper: 25, Lead: 25, Silicon: 10));

+ "graphite-press" -> ProductionBlock::new(2, true, cost!(Copper: 75, Lead: 30));

+ "multi-press" -> ProductionBlock::new(3, true, cost!(Lead: 100, Graphite: 50, Titanium: 100, Silicon: 25));

+ "silicon-smelter" -> ProductionBlock::new(2, true, cost!(Copper: 30, Lead: 25));

+ "silicon-crucible" -> ProductionBlock::new(3, true, cost!(Metaglass: 80, Titanium: 120, Silicon: 60, Plastanium: 35));

+ "kiln" -> ProductionBlock::new(2, true, cost!(Copper: 60, Lead: 30, Graphite: 30));

+ "plastanium-compressor" -> ProductionBlock::new(2, true, cost!(Lead: 115, Graphite: 60, Titanium: 80, Silicon: 80));

+ "phase-weaver" -> ProductionBlock::new(2, true, cost!(Lead: 120, Thorium: 75, Silicon: 130));

+ "surge-smelter" -> ProductionBlock::new(3, true, cost!(Lead: 80, Thorium: 70, Silicon: 80));

+ "cryofluid-mixer" -> ProductionBlock::new(2, true, cost!(Lead: 65, Thorium: 60, Silicon: 40));

+ "pyratite-mixer" -> ProductionBlock::new(2, true, cost!(Copper: 50, Lead: 25));

+ "blast-mixer" -> ProductionBlock::new(2, true, cost!(Lead: 30, Thorium: 20));

+ "melter" -> ProductionBlock::new(1, true, cost!(Copper: 30, Lead: 35, Graphite: 45));

+ "separator" -> ProductionBlock::new(2, true, cost!(Copper: 30, Titanium: 25));

+ "disassembler" -> ProductionBlock::new(3, true, cost!(Titanium: 100, Thorium: 80, Silicon: 150, Plastanium: 40));

+ "spore-press" -> ProductionBlock::new(2, true, cost!(Lead: 35, Silicon: 30));

+ "pulverizer" -> ProductionBlock::new(1, true, cost!(Copper: 30, Lead: 25));

+ "coal-centrifuge" -> ProductionBlock::new(2, true, cost!(Lead: 30, Graphite: 40, Titanium: 20));

+ "incinerator" -> Incinerator::new(1, true, cost!(Lead: 15, Graphite: 5));

+ "silicon-arc-furnace" -> ProductionBlock::new(3, true, cost!(Beryllium: 70, Graphite: 80));

+ "atmospheric-concentrator" -> ProductionBlock::new(3, true, cost!(Oxide: 60, Beryllium: 180, Silicon: 150));

+ "slag-incinerator" -> Incinerator::new(1, true, cost!(Tungsten: 15));

+ "carbide-crucible" -> ProductionBlock::new(3, true, cost!(Tungsten: 110, Thorium: 150, Oxide: 60));

+ "surge-crucible" -> ProductionBlock::new(3, true, cost!(Silicon: 100, Graphite: 80, Tungsten: 80, Oxide: 80));

+ "cyanogen-synthesizer" -> ProductionBlock::new(3, true, cost!(Carbide: 50, Silicon: 80, Beryllium: 90));

+ "phase-synthesizer" -> ProductionBlock::new(3, true, cost!(Carbide: 90, Silicon: 100, Thorium: 100, Tungsten: 200));

+ "heat-source" -> HeatCrafter::new(1, false, &[]);

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

+ match r {

+ Rotation::Up | Rotation::Right =>

+ load!(concat top1 => n which is ["phase-heater" | "electric-heater" | "oxidation-chamber" | "slag-heater"], s),

+ _ => load!(concat top2 => n which is ["phase-heater" | "electric-heater" | "oxidation-chamber" | "slag-heater"], s)

+ }

+ n => unimplemented!("{n}"),

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

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

+ base.overlay(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),

+ }.rotate(r.rotated(false).count()));

+ base

+});

+ crate::block::simple::make_simple!($name, |_, n, _, _, _, _| unimplemented!("{n}"), $read);

+ ($name: ident) => {

+ crate::block::simple::make_simple!($name, |_, n, _, _, _, _| unimplemented!("{n}"));

+ };

+ "core-shard" -> StorageBlock::new(3, true, cost!(Copper: 1000, Lead: 800));

+ "core-foundation" -> StorageBlock::new(4, true, cost!(Copper: 3000, Lead: 3000, Silicon: 2000));

+ "core-nucleus" -> StorageBlock::new(5, true, cost!(Copper: 8000, Lead: 8000, Thorium: 4000, Silicon: 5000));

+ "core-bastion" -> StorageBlock::new(4, true, cost!(Graphite: 1000, Silicon: 1000, Beryllium: 800));

+ "core-citadel" -> StorageBlock::new(5, true, cost!(Silicon: 4000, Beryllium: 4000, Tungsten: 3000, Oxide: 1000));

+ "core-acropolis" -> StorageBlock::new(6, true, cost!(Beryllium: 6000, Silicon: 5000, Tungsten: 5000, Carbide: 3000, Oxide: 3000));

+ "container" -> StorageBlock::new(2, true, cost!(Titanium: 100));

+ "vault" -> StorageBlock::new(3, true, cost!(Titanium: 250, Thorium: 125));

+ "unloader" -> ItemBlock::new(1, true, cost!(Titanium: 25, Silicon: 30));

+ "reinforced-container" -> StorageBlock::new(2, true, cost!(Tungsten: 30, Graphite: 40));

+ "reinforced-vault" -> StorageBlock::new(3, true, cost!(Tungsten: 125, Thorium: 70, Beryllium: 100));

+ let size = me.get_size();

+ let mut base = match name {

+ | "scathe" | "malign" | "smite" => load!(s -> match size {

+ 3 => "reinforced-block-3",

+ 4 => "reinforced-block-4",

+ 5 => "reinforced-block-5",

+ }),

+ _ => load!(s -> match size {

+ 1 => "block-1",

+ 2 => "block-2",

+ 3 => "block-3",

+ 4 => "block-4",

+ }),

+ base.overlay(load!(from name which is ["duo" | "scatter" | "scorch" | "hail" | "wave" | "tsunami" | "lancer" | "arc" | "parallax" | "swarmer" | "salvo" | "segment" | "fuse" | "ripple" | "cyclone" | "foreshadow" | "spectre" | "meltdown" | "breach" | "diffuse" | "sublimate" | "titan" | "disperse" | "afflict" | "lustre" | "scathe" | "malign" | "smite"], s).borrow());

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

+ let mut base = load!(from name which is ["additive-reconstructor" | "multiplicative-reconstructor" | "exponential-reconstructor" | "tetrative-reconstructor" | "tank-refabricator" | "mech-refabricator" | "ship-refabricator" | "prime-refabricator" | "tank-assembler" | "ship-assembler" | "mech-assembler"], s);

+ let mut out = load!(s -> match name {

+ "additive-reconstructor" => "factory-out-3",

+ "multiplicative-reconstructor" => "factory-out-5",

+ "tank-refabricator" | "mech-refabricator" | "ship-refabricator" =>

+ "factory-out-3-dark",

+ "exponential-reconstructor" => "factory-out-7",

+ "prime-refabricator" | "tank-assembler" | "ship-assembler" | "mech-assembler" =>

+ "factory-out-5-dark",

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

+ });

+ base.overlay(out.rotate(times));

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

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

+ "multiplicative-reconstructor" => "factory-in-5",

+ "tank-refabricator" | "mech-refabricator" | "ship-refabricator" =>

+ "factory-in-3-dark",

+ "exponential-reconstructor" => "factory-in-7",

+ "prime-refabricator" | "tank-assembler" | "ship-assembler" | "mech-assembler" =>

+ "factory-in-5-dark",

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

+ });

+ base.overlay(r#in.rotate(times));

+ base.overlay(load!(concat top => name which is ["additive-reconstructor" | "multiplicative-reconstructor" | "exponential-reconstructor" | "tetrative-reconstructor" | "tank-refabricator" | "mech-refabricator" | "ship-refabricator" | "prime-refabricator" | "tank-assembler" | "ship-assembler" | "mech-assembler"], s).borrow());

+ match rot {

+ Rotation::Up | Rotation::Right => load!(s -> match name {

+ "mech-assembler" => "mech-assembler-side1",

+ "tank-assembler" => "tank-assembler-side1",

+ "ship-assembler" => "ship-assembler-side1",

+ }),

+ _ => load!(s -> match name {

+ "mech-assembler" => "mech-assembler-side2",

+ "tank-assembler" => "tank-assembler-side2",

+ "ship-assembler" => "ship-assembler-side2",

+ }),

+ }

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

+ load!(scl -> match rot {

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

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

+ })

+ let mut bot = load!("block-2", scl);

+ let top = load!("repair-turret", scl);

+ "unit-repair-tower" -> UnitRepairTower::new(2, true, cost!(Graphite: 90, Silicon: 90, Tungsten: 80));

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

+ let mut out = load!(s -> match name {

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

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

+ });

+ base.overlay(

+ load!(s -> match name {

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

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

+ "ship-fabricator" => "ship-fabricator-top",

+ "mech-fabricator" => "mech-fabricator-top",

+ })

+ .borrow(),

+ );

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

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

+ base.overlay(&load!("thruster-top", s));

+ base

+ "copper-wall" -> WallBlock::new(1, true, cost!(Copper: 6));

+ "copper-wall-large" -> WallBlock::new(2, true, cost!(Copper: 6 * 4));

+ "titanium-wall" -> WallBlock::new(1, true, cost!(Titanium: 6));

+ "titanium-wall-large" -> WallBlock::new(2, true, cost!(Titanium: 6 * 4));

+ "plastanium-wall" -> WallBlock::new(1, true, cost!(Metaglass: 2, Plastanium: 5));

+ "plastanium-wall-large" -> WallBlock::new(2, true, cost!(Metaglass: 2 * 4, Plastanium: 5 * 4));

+ "thorium-wall" -> WallBlock::new(1, true, cost!(Thorium: 6));

+ "thorium-wall-large" -> WallBlock::new(2, true, cost!(Thorium: 6 * 4));

+ "phase-wall" -> WallBlock::new(1, true, cost!(PhaseFabric: 6));

+ "phase-wall-large" -> WallBlock::new(2, true, cost!(PhaseFabric: 6 * 4));

+ "surge-wall" -> WallBlock::new(1, true, cost!(SurgeAlloy: 6));

+ "surge-wall-large" -> WallBlock::new(2, true, cost!(SurgeAlloy: 6 * 4));

+ "tungsten-wall" -> WallBlock::new(1, true, cost!(Tungsten: 6));

+ "tungsten-wall-large" -> WallBlock::new(2, true, cost!(Tungsten: 6 * 4));

+ "blast-door" -> DoorBlock::new(2, true, cost!(Tungsten: 24, Silicon: 24));

+ "reinforced-surge-wall" -> WallBlock::new(1, true, cost!(SurgeAlloy: 6, Tungsten: 2));

+ "reinforced-surge-wall-large" -> WallBlock::new(2, true, cost!(SurgeAlloy: 6 * 4, Tungsten: 2 * 4));

+ "carbide-wall" -> WallBlock::new(1, true, cost!(Thorium: 6, Carbide: 6));

+ "carbide-wall-large" -> WallBlock::new(2, true, cost!(Thorium: 6 * 4, Carbide: 6 * 4));

+ "shielded-wall" -> WallBlock::new(2, true, cost!(PhaseFabric: 20, SurgeAlloy: 12, Beryllium: 12));

+ "beryllium-wall" -> WallBlock::new(1, true, cost!(Beryllium: 6));

+ "beryllium-wall-large" -> WallBlock::new(2, true, cost!(Beryllium: 6 * 4));

+ "scrap-wall" -> WallBlock::new(1, true, cost!(Scrap: 6));

+ "scrap-wall-large" -> WallBlock::new(2, true, cost!(Scrap: 24));

+ "scrap-wall-huge" -> WallBlock::new(3, true, cost!(Scrap: 54));

+ "scrap-wall-gigantic" -> WallBlock::new(4, true, cost!(Scrap: 96));

+ if *Self::get_state(state) {

+ return load!(s -> match name {

+ "door" => "door-open",

+ "blast-door" => "blast-door-open",

+ _ => "door-large-open",

+ });

+ load!(from name which is ["door" | "blast-door" | "door-large"], s)

+ let mut p = match index {

+ 0 => {

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

+ }

+ 1 => {

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

+ }

+ 2 => {

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

+ }

+ 3 => {

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

+ }

+ _ => {

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

+ }

+ };

+use super::schematic::Schematic;

+use super::GridPos;

+include!(concat!(env!("OUT_DIR"), "/full.rs"));

+include!(concat!(env!("OUT_DIR"), "/quar.rs"));

+include!(concat!(env!("OUT_DIR"), "/eigh.rs"));

+#[repr(u8)]

+#[macro_export]

+macro_rules! load {

+ ($name:literal, $scale:ident) => { paste::paste! {

+ ImageHolder::from(std::sync::LazyLock::force(match $scale {

+ crate::data::renderer::Scale::Quarter => crate::data::renderer::quar::[<$name:snake:upper>],

+ crate::data::renderer::Scale::Eigth => crate::data::renderer::eigh::[<$name:snake:upper>],

+ crate::data::renderer::Scale::Full => crate::data::renderer::full::[<$name:snake:upper>],

+ }))

+ } };

+ ($name: literal) => { paste::paste! {

+ [crate::data::renderer::full::[<$name:snake:upper>], crate::data::renderer::quar::[<$name:snake:upper>], crate::data::renderer::eigh::[<$name:snake:upper>]]

+ } };

+ (from $v:ident which is [$($k:literal $(|)?)+], $scale: ident) => {

+ crate::data::renderer::load!($scale -> match $v {

+ $($k => $k,)+

+ })

+ };

+ // turn load!(s -> match x { "v" => "y" }) into match x { "v" => load!("y", s) }

+ ($scale:ident -> match $v:ident { $($k:pat => $nam:literal $(,)?)+ }) => {

+ match $v {

+ $($k => crate::data::renderer::load!($nam, $scale),)+

+ #[allow(unreachable_patterns)]

+ n => unreachable!("{n:?}"),

+ }

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

+ match $v {

+ $($k =>

+ ImageHolder::from(std::sync::LazyLock::force(match $scale {

+ crate::data::renderer::Scale::Quarter => crate::data::renderer::quar::[<$k:snake:upper _ $x:snake:upper>],

+ crate::data::renderer::Scale::Eigth => crate::data::renderer::eigh::[<$k:snake:upper _ $x:snake:upper>],

+ crate::data::renderer::Scale::Full => crate::data::renderer::full::[<$k:snake:upper _ $x:snake:upper>],

+ })),

+ )+

+ #[allow(unreachable_patterns)]

+ n => unreachable!("{n:?}"),

+ }

+ } };

+ // (concat $x:expr, to $v:ident which is [$($k:literal $(|)?)+], $scale: ident) => { paste::paste! {

+ // match $v {

+ // $($k =>

+ // ImageHolder::from(**match $scale {

+ // crate::data::renderer::Scale::Quarter => crate::data::renderer::quar::[<$k:snake:upper $x:snake:upper>],

+ // crate::data::renderer::Scale::Eigth => crate::data::renderer::eigh::[<$k:snake:upper $x:snake:upper>],

+ // crate::data::renderer::Scale::Full => crate::data::renderer::full::[<$k:snake:upper $x:snake:upper>],

+ // }),

+ // )+

+ // }

+ // } }

+pub(crate) use load;

+ full::warmup();

+ quar::warmup();

+ eigh::warmup();

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

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