mindustry logic execution, map- and schematic- parsing and rendering
Diffstat (limited to 'src/block/units.rs')
| -rw-r--r-- | src/block/units.rs | 380 |
1 files changed, 380 insertions, 0 deletions
diff --git a/src/block/units.rs b/src/block/units.rs new file mode 100644 index 0000000..83b39af --- /dev/null +++ b/src/block/units.rs @@ -0,0 +1,380 @@ +//! unit creation related blocks +use thiserror::Error; + +use super::payload::{read_payload_block, read_payload_seq}; +use crate::block::simple::*; +use crate::block::*; +use crate::data::command::UnitCommand; +use crate::data::dynamic::DynType; +use crate::unit; + +// fn is_pay(b: &str) -> bool { +// matches!( +// b, +// "ground-factory" +// | "air-factory" +// | "naval-factory" +// | "additive-reconstructor" +// | "multiplicative-reconstructor" +// | "exponential-reconstructor" +// | "tank-fabricator" +// | "ship-fabricator" +// | "mech-fabricator" +// | "tank-refabricator" +// | "ship-refabricator" +// | "payload-conveyor" +// | "payload-router" +// | "reinforced-payload-conveyor" +// | "reinforced-payload-router" +// | "payload-mass-driver" +// | "large-payload-mass-driver" +// | "constructor" +// | "large-constructor" +// | "payload-source" +// ) +// } + +make_simple!( + AssemblerBlock, + |_, name, _, _, rot: Rotation, s| { + let mut base = + load!(from name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s); + unsafe { + base.overlay( + 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.overlay(&load!(concat "top" => name which is ["tank-assembler" | "ship-assembler" | "mech-assembler"], s)) + }; + base + }, + |_, reg, map, buff| read_assembler(reg, map, buff) +); + +/// format: +/// - call [`read_payload_block`] +/// - progress: [`f32`] +/// - iterate [`u8`] +/// - read: [`i32`] +/// - call [`read_payload_seq`] +/// - point: ([`f32`], [`f32`]) (maybe [`NaN`](f32::NAN)) +fn read_assembler( + reg: &BlockRegistry, + map: &EntityMapping, + buff: &mut DataRead, +) -> Result<(), DataReadError> { + read_payload_block(reg, map, buff)?; + buff.skip(4)?; + let n = buff.read_u8()? as usize; + buff.skip(n * 4)?; + read_payload_seq(buff)?; + buff.skip(8) +} + +make_simple!( + AssemblerModule, + |_, _, _, _, rot: Rotation, scl| { + let mut base = load!("basic-assembler-module", scl); + unsafe { + base.overlay( + load!(scl -> match rot { + Rotation::Up | Rotation::Right => "basic-assembler-module-side1", + _ => "basic-assembler-module-side2", + }) + .rotate(rot.rotated(false).count()), + ) + }; + base + }, + |_, reg, map, buff| read_payload_block(reg, map, buff) +); + +make_simple!( + RepairTurret => |_, _, _, buff: &mut DataRead| { + buff.skip(4) // rotation: [`f32`] + } +); + +const GROUND_UNITS: &[unit::Type] = &[unit::Type::Dagger, unit::Type::Crawler, unit::Type::Nova]; +const AIR_UNITS: &[unit::Type] = &[unit::Type::Flare, unit::Type::Mono]; +const NAVAL_UNITS: &[unit::Type] = &[unit::Type::Risso, unit::Type::Retusa]; + +make_register! { + "ground-factory" => UnitFactory::new(3, false, cost!(Copper: 50, Lead: 120, Silicon: 80), GROUND_UNITS); + "air-factory" => UnitFactory::new(3, false, cost!(Copper: 60, Lead: 70), AIR_UNITS); + "naval-factory" => UnitFactory::new(3, false, cost!(Copper: 150, Lead: 130, Metaglass: 120), NAVAL_UNITS); + "additive-reconstructor" => ConstructorBlock::new(3, false, cost!(Copper: 200, Lead: 120, Silicon: 90)); + "multiplicative-reconstructor" => ConstructorBlock::new(5, false, cost!(Lead: 650, Titanium: 350, Thorium: 650, Silicon: 450)); + "exponential-reconstructor" => ConstructorBlock::new(7, false, + cost!(Lead: 2000, Titanium: 2000, Thorium: 750, Silicon: 1000, Plastanium: 450, PhaseFabric: 600)); + "tetrative-reconstructor" => ConstructorBlock::new(9, false, + cost!(Lead: 4000, Thorium: 1000, Silicon: 3000, Plastanium: 600, PhaseFabric: 600, SurgeAlloy: 800)); + "repair-point" -> RepairTurret::new(1, true, cost!(Copper: 30, Lead: 30, Silicon: 20)); + "repair-turret" -> RepairTurret::new(2, true, cost!(Thorium: 80, Silicon: 90, Plastanium: 60)); + "tank-fabricator" => UnitFactory::new(3, true, cost!(Silicon: 200, Beryllium: 150), &[unit::Type::Stell]); + "ship-fabricator" => UnitFactory::new(3, true, cost!(Silicon: 250, Beryllium: 200), &[unit::Type::Elude]); + "mech-fabricator" => UnitFactory::new(3, true, cost!(Silicon: 200, Graphite: 300, Tungsten: 60), &[unit::Type::Merui]); + "tank-refabricator" => ConstructorBlock::new(3, true, cost!(Beryllium: 200, Tungsten: 80, Silicon: 100)); + "mech-refabricator" => ConstructorBlock::new(3, true, cost!(Beryllium: 250, Tungsten: 120, Silicon: 150)); + "ship-refabricator" => ConstructorBlock::new(3, true, cost!(Beryllium: 200, Tungsten: 100, Silicon: 150, Oxide: 40)); + "prime-refabricator" => ConstructorBlock::new(5, true, cost!(Thorium: 250, Oxide: 200, Tungsten: 200, Silicon: 400)); + "tank-assembler" => AssemblerBlock::new(5, true, cost!(Thorium: 500, Oxide: 150, Carbide: 80, Silicon: 500)); + "ship-assembler" => AssemblerBlock::new(5, true, cost!(Carbide: 100, Oxide: 200, Tungsten: 500, Silicon: 800, Thorium: 400)); + "mech-assembler" => AssemblerBlock::new(5, true, cost!(Carbide: 200, Thorium: 600, Oxide: 200, Tungsten: 500, Silicon: 900)); // smh collaris + "basic-assembler-module" => AssemblerModule::new(5, true, cost!(Carbide: 300, Thorium: 500, Oxide: 200, PhaseFabric: 400)); // the dummy block + "unit-repair-tower" -> BasicBlock::new(2, true, cost!(Graphite: 90, Silicon: 90, Tungsten: 80)); + +} + +pub struct ConstructorBlock { + size: u8, + symmetric: bool, + build_cost: BuildCost, +} + +impl ConstructorBlock { + #[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 Option<UnitCommand>); +} + +impl BlockLogic for ConstructorBlock { + impl_block!(); + + fn data_from_i32(&self, _: i32, _: GridPos) -> Result<DynData, DataConvertError> { + Ok(DynData::Empty) + } + + fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> { + match data { + DynData::Empty => Ok(Some(Self::create_state(None))), + DynData::UnitCommand(u) => Ok(Some(Self::create_state(Some(u)))), + _ => Err(DeserializeError::InvalidType { + have: data.get_type(), + expect: DynType::UnitCommand, + }), + } + } + + fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> { + Ok(Self::get_state(state).map_or(DynData::Empty, DynData::UnitCommand)) + } + + fn draw( + &self, + name: &str, + _: Option<&State>, + _: Option<&RenderingContext>, + rot: Rotation, + s: Scale, + ) -> ImageHolder<4> { + let mut base = load!(from name which is ["additive-reconstructor" | "multiplicative-reconstructor" | "exponential-reconstructor" | "tetrative-reconstructor" | "tank-refabricator" | "mech-refabricator" | "ship-refabricator" | "prime-refabricator"], s); + let times = rot.rotated(false).count(); + 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" => "factory-out-5-dark", + "tetrative-reconstructor" => "factory-out-9", + }); + unsafe { 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" => "factory-in-5-dark", + "tetrative-reconstructor" => "factory-in-9", + }); + unsafe { base.overlay(r#in.rotate(times)) }; + + // TODO: the context cross is too small + // for i in 0..4u8 { + // if let Some((b, rot)) = dbg!(ctx.cross[i as usize]) { + // if rot.mirrored(true, true) != ctx.rotation && match rot { + // Rotation::Up => i == 3, + // Rotation::Right => i == 4, + // Rotation::Down => i == 0, + // Rotation::Left => i == 2, + // } && is_pay(b.name()) + // { + // let r = unsafe { std::mem::transmute::<u8, Rotation>(i) } + // .mirrored(true, true) + // .rotated(false); + // let mut input = input.clone(); + // input.rotate(r.count()); + // base.overlay(&input); + // } + // } + // } + + unsafe { + base.overlay(&load!(concat "top" => name which is ["additive-reconstructor" | "multiplicative-reconstructor" | "exponential-reconstructor" | "tetrative-reconstructor" | "tank-refabricator" | "mech-refabricator" | "ship-refabricator" | "prime-refabricator"], s)) + }; + base + } + + /// format: + /// - call [`read_payload_block`] + /// - progress: [`f32`] + /// - point: ([`f32`], [`f32`]) (maybe [`NaN`](f32::NAN)) + /// - command: [`DynData::UnitCommand`] + fn read( + &self, + _: &mut Build, + reg: &BlockRegistry, + map: &EntityMapping, + buff: &mut DataRead, + ) -> Result<(), DataReadError> { + read_payload_block(reg, map, buff)?; + buff.skip(12)?; + // TODO uncomment when read_payload_block impl finished + // b.state = self.deserialize_state(DynSerializer.deserialize(buff).unwrap()).unwrap(); + Ok(()) + } +} + +pub struct UnitFactory { + size: u8, + symmetric: bool, + build_cost: BuildCost, + valid: &'static [unit::Type], +} + +impl UnitFactory { + #[must_use] + pub const fn new( + size: u8, + symmetric: bool, + build_cost: BuildCost, + valid: &'static [unit::Type], + ) -> Self { + assert!(size != 0, "invalid size"); + assert!(!valid.is_empty(), "no valid units"); + assert!(valid.len() <= i32::MAX as usize, "too many valid units"); + Self { + size, + symmetric, + build_cost, + valid, + } + } + + state_impl!(pub Option<unit::Type>); +} + +impl BlockLogic for UnitFactory { + impl_block!(); + + fn data_from_i32(&self, _: i32, _: GridPos) -> Result<DynData, DataConvertError> { + Ok(DynData::Int(-1)) + } + + fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> { + match data { + DynData::Empty => Ok(Some(Self::create_state(None))), + DynData::Int(idx) => { + if idx == -1 { + Ok(Some(Self::create_state(None))) + } else if idx >= 0 && idx < self.valid.len() as i32 { + Ok(Some(Self::create_state(Some(self.valid[idx as usize])))) + } else { + Err(DeserializeError::Custom(Box::new( + AssemblerDeserializeError { + idx, + count: self.valid.len() as i32, + }, + ))) + } + } + _ => Err(DeserializeError::InvalidType { + have: data.get_type(), + expect: DynType::Int, + }), + } + } + + fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> { + if let Some(state) = Self::get_state(state) { + for (i, curr) in self.valid.iter().enumerate() { + if curr == state { + return Ok(DynData::Int(i as i32)); + } + } + Err(SerializeError::Custom(Box::new(AssemblerSerializeError( + *state, + )))) + } else { + Ok(DynData::Int(-1)) + } + } + + fn draw( + &self, + name: &str, + _: Option<&State>, + _: Option<&RenderingContext>, + rot: Rotation, + 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); + unsafe { + base.overlay( + load!(s -> match name { + "ground-factory" | "air-factory" | "naval-factory" => "factory-out-3", + _ => "factory-out-3-dark", + }) + .rotate(rot.rotated(false).count()), + ) + .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", + })) + }; + base + } + + /// format: + /// - call [`read_payload_block`] + /// - progress: [`f32`] + /// - plan: [`u16`] + /// - point: ([`f32`], [`f32`]) (maybe [`NaN`](f32::NAN)) + fn read( + &self, + _: &mut Build, + reg: &BlockRegistry, + mapping: &EntityMapping, + buff: &mut DataRead, + ) -> Result<(), DataReadError> { + read_payload_block(reg, mapping, buff)?; + buff.skip(14) + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)] +#[error("invalid unit index ({idx}, valid: {count})")] +pub struct AssemblerDeserializeError { + pub idx: i32, + pub count: i32, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)] +#[error("invalid unit {0:?}")] +pub struct AssemblerSerializeError(unit::Type); |