bendns' repos / mindus
mindustry logic execution, map- and schematic- parsing and rendering
Diffstat (limited to 'src/block/walls.rs')
-rw-r--r--src/block/walls.rs118
1 files changed, 118 insertions, 0 deletions
diff --git a/src/block/walls.rs b/src/block/walls.rs
new file mode 100644
index 0000000..4eaad5c
--- /dev/null
+++ b/src/block/walls.rs
@@ -0,0 +1,118 @@
+//! walls
+use crate::block::simple::*;
+use crate::block::*;
+use crate::data::dynamic::DynType;
+use crate::data::renderer::load;
+
+make_simple!(WallBlock, |_, _, _, _, _, s| {
+ let mut base = load!("thruster", s);
+ unsafe { base.overlay(&load!("thruster-top", s)) };
+ base
+});
+
+make_register! {
+ "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));
+ "door" => DoorBlock::new(1, true, cost!(Titanium: 6, Silicon: 4));
+ "door-large" => DoorBlock::new(2, true, cost!(Titanium: 6 * 4, Silicon: 4 * 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));
+ // sandbox only
+ "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));
+ "thruster" => WallBlock::new(4, false, cost!(Scrap: 96));
+}
+
+pub struct DoorBlock {
+ size: u8,
+ symmetric: bool,
+ build_cost: BuildCost,
+}
+
+impl DoorBlock {
+ #[must_use]
+ pub const fn new(size: u8, symmetric: bool, build_cost: BuildCost) -> Self {
+ assert!(size != 0, "invalid size");
+ Self {
+ size,
+ symmetric,
+ build_cost,
+ }
+ }
+
+ state_impl!(pub bool);
+}
+
+impl BlockLogic for DoorBlock {
+ impl_block!();
+
+ fn draw(
+ &self,
+ name: &str,
+ state: Option<&State>,
+ _: Option<&RenderingContext>,
+ _: Rotation,
+ s: Scale,
+ ) -> ImageHolder<4> {
+ if let Some(state) = state {
+ 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)
+ }
+
+ fn data_from_i32(&self, _: i32, _: GridPos) -> Result<DynData, DataConvertError> {
+ Ok(DynData::Boolean(false))
+ }
+
+ fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> {
+ match data {
+ DynData::Boolean(opened) => Ok(Some(Self::create_state(opened))),
+ _ => Err(DeserializeError::InvalidType {
+ have: data.get_type(),
+ expect: DynType::Boolean,
+ }),
+ }
+ }
+
+ fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> {
+ let state = Self::get_state(state);
+ Ok(DynData::Boolean(*state))
+ }
+
+ fn read(
+ &self,
+ build: &mut Build,
+ _: &BlockRegistry,
+ _: &EntityMapping,
+ buff: &mut DataRead,
+ ) -> Result<(), DataReadError> {
+ build.state = Some(Self::create_state(buff.read_bool()?));
+ Ok(())
+ }
+}