+//! payload related bits and bobs

+use thiserror::Error;

+

+use crate::block::content::Type as BlockEnum;

+use crate::block::distribution::BridgeBlock;

+use crate::block::simple::*;

+use crate::block::{self, *};

+use crate::content::{self, Content};

+use crate::data::dynamic::DynType;

+use crate::data::ReadError;

+use crate::unit;

+

+use super::BlockRegistry;

+

+make_simple!(SimplePayloadBlock, |_, n, _, _, r: Rotation, scl| {

+ match n {

+ "deconstructor" | "small-deconstructor" | "payload-void" => {

+ 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",

+ });

+ unsafe {

+ 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",

+ }))

+ };

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

+ unsafe {

+ base.overlay(input.rotate(r.rotated(false).count()))

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

+ .overlay(

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

+ )

+ };

+ base

+ }

+ }

+});

+make_simple!(

+ PayloadConveyor,

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

+ let mut base =

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

+ unsafe { base.rotate(r.rotated(false).count()) };

+ base

+ },

+ read_payload_conveyor

+);

+// make_simple!(PayloadRouter => read_payload_router);

+

+make_register! {

+ "payload-conveyor" => PayloadConveyor::new(3, false, cost!(Copper: 10, Graphite: 10));

+ "payload-router" => PayloadBlock::new(3, false, cost!(Copper: 10, Graphite: 15));

+ "reinforced-payload-conveyor" => PayloadConveyor::new(3, false, cost!(Tungsten: 10));

+ "reinforced-payload-router" => PayloadBlock::new(3, false, cost!(Tungsten: 15));

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

+ "small-deconstructor" => SimplePayloadBlock::new(3, true, cost!(Beryllium: 100, Silicon: 100, Oxide: 40, Graphite: 80));

+ "deconstructor" => SimplePayloadBlock::new(5, true, cost!(Beryllium: 250, Oxide: 100, Silicon: 250, Carbide: 250));

+ "constructor" => PayloadBlock::new(3, true, cost!(Silicon: 100, Beryllium: 150, Tungsten: 80));

+ "large-constructor" => PayloadBlock::new(5, true, cost!(Silicon: 150, Oxide: 150, Tungsten: 200, PhaseFabric: 40));

+ "payload-loader" => SimplePayloadBlock::new(3, false, cost!(Graphite: 50, Silicon: 50, Tungsten: 80));

+ "payload-unloader" => SimplePayloadBlock::new(3, false, cost!(Graphite: 50, Silicon: 50, Tungsten: 30));

+ // sandbox only

+ "payload-source" => PayloadBlock::new(5, false, &[]);

+ "payload-void" => SimplePayloadBlock::new(5, true, &[]);

+}

+

+#[derive(Clone, Copy, Debug, Eq, PartialEq)]

+/// payload item cfg

+pub enum Payload {

+ Empty,

+ Block(block::content::Type),

+ Unit(unit::Type),

+}

+

+/// a payload related block with [item cfg](Payload)

+pub struct PayloadBlock {

+ size: u8,

+ symmetric: bool,

+ build_cost: BuildCost,

+}

+

+impl PayloadBlock {

+ #[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 Payload);

+}

+

+impl BlockLogic for PayloadBlock {

+ impl_block!();

+

+ fn draw(

+ &self,

+ name: &str,

+ _: Option<&State>,

+ _: Option<&RenderingContext>,

+ r: Rotation,

+ s: Scale,

+ ) -> ImageHolder<4> {

+ match name {

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

+ let mut base =

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

+ unsafe {

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

+ base.overlay(& load!(concat "over" => name which is ["payload-router" | "reinforced-payload-router"], s));

+ }

+ base

+ }

+ _ => {

+ 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",

+ });

+ unsafe {

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

+ base.overlay(&out);

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

+ };

+ base

+ }

+ }

+ }

+

+ 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(Payload::Empty))),

+ DynData::Content(content::Type::Block, id) => {

+ let block = PayloadDeserializeError::forward(block::content::Type::try_from(id))?;

+ Ok(Some(Self::create_state(Payload::Block(block))))

+ }

+ DynData::Content(content::Type::Unit, id) => {

+ let unit = PayloadDeserializeError::forward(unit::Type::try_from(id))?;

+ Ok(Some(Self::create_state(Payload::Unit(unit))))

+ }

+ DynData::Content(have, ..) => Err(DeserializeError::Custom(Box::new(

+ PayloadDeserializeError::ContentType(have),

+ ))),

+ _ => Err(DeserializeError::InvalidType {

+ have: data.get_type(),

+ expect: DynType::Content,

+ }),

+ }

+ }

+

+ fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> {

+ match Self::get_state(state) {

+ Payload::Empty => Ok(DynData::Empty),

+ Payload::Block(block) => Ok(DynData::Content(content::Type::Block, (*block).into())),

+ Payload::Unit(unit) => Ok(DynData::Content(content::Type::Unit, (*unit).into())),

+ }

+ }

+}

+

+/// format:

+/// - call [`read_payload_conveyor`]

+/// - t: [`u8`]

+/// - sort: [`u16`]

+/// - recdir: [`u8`]

+fn read_payload_router(

+ b: &mut Build,

+ reg: &BlockRegistry,

+ entity_mapping: &EntityMapping,

+ buff: &mut DataRead,

+) -> Result<(), DataReadError> {

+ read_payload_conveyor(b, reg, entity_mapping, buff)?;

+ buff.skip(4)

+}

+

+/// format:

+/// - [skip(4)](`DataRead::skip`)

+/// - rot: [`f32`]

+/// - become [`read_payload`]

+fn read_payload_conveyor(

+ _: &mut Build,

+ reg: &BlockRegistry,

+ entity_mapping: &EntityMapping,

+ buff: &mut DataRead,

+) -> Result<(), DataReadError> {

+ buff.skip(8)?;

+ read_payload(reg, entity_mapping, buff)

+}

+

+/// format:

+/// - iterate [`i16`]..0

+/// - [`u8`], [`i16`], [`i32`]

+pub(crate) fn read_payload_seq(buff: &mut DataRead) -> Result<(), DataReadError> {

+ let amount = (-buff.read_i16()?) as usize;

+ buff.skip(amount * 7)

+}

+

+/// format:

+/// - vector: ([`f32`], [`f32`])

+/// - rotation: [`f32`]

+/// - become [`read_payload`]

+pub(crate) fn read_payload_block(

+ reg: &BlockRegistry,

+ entity_mapping: &EntityMapping,

+ buff: &mut DataRead,

+) -> Result<(), DataReadError> {

+ buff.skip(12)?;

+ read_payload(reg, entity_mapping, buff)

+}

+

+/// format:

+/// - exists: [`bool`]

+/// - if !exists: ok

+/// - type: [`u8`]

+/// - if type == `1` (payload block):

+/// - block: [`u16`]

+/// - version: [`u8`]

+/// - [`BlockLogic::read`] (recursion :ferrisHmm:),

+/// - if type == 2 (paylood unit):

+/// - id: [`u8`]

+/// - unit read???????? TODO

+fn read_payload(

+ reg: &BlockRegistry,

+ entity_mapping: &crate::data::map::EntityMapping,

+ buff: &mut DataRead,

+) -> Result<(), DataReadError> {

+ if !buff.read_bool()? {

+ return Ok(());

+ }

+ let t = buff.read_u8()?;

+ const BLOCK: u8 = 1;

+ const UNIT: u8 = 0;

+ match t {

+ BLOCK => {

+ let b = buff.read_u16()?;

+ let b = BlockEnum::try_from(b).unwrap_or(BlockEnum::Router);

+ let block = reg.get(b.get_name()).unwrap();

+ block

+ .logic

+ .read(&mut Build::new(block), reg, entity_mapping, buff)?;

+ }

+ UNIT => {

+ let u = buff.read_u8()?;

+ let Some(_u) = entity_mapping.get(&u) else {

+ return Err(ReadError::Expected("map entry"));

+ };

+ // unit::Type::try_from(u).unwrap_or(unit::Type::Alpha).read(todo!());

+ }

+ _ => return Err(ReadError::Expected("0 | 1")),

+ }

+ Ok(())

+}

+

+#[cfg(test)]

+mod tests {

+ use std::collections::HashMap;

+

+ use crate::registry::Registry;

+

+ use super::*;

+ #[test]

+ fn payload_conv() {

+ let mut reg = Registry::default();

+ register(&mut reg);

+ let mut r = DataRead::new(&[0, 0, 0, 0, 0, 0, 0, 0, 0]);

+ read_payload_conveyor(

+ &mut Build::new(&PAYLOAD_CONVEYOR),

+ &reg,

+ &HashMap::default(),

+ &mut r,

+ )

+ .unwrap();

+ assert!(r.read_bool().is_err());

+ let mut r = DataRead::new(&[

+ 65, 198, 232, 0, 67, 51, 255, 249, 1, 1, 0, 157, 0, 67, 197, 128, 0, 128, 1, 3,

+ ]);

+ read_payload_conveyor(

+ &mut Build::new(&PAYLOAD_CONVEYOR),

+ &reg,

+ &HashMap::default(),

+ &mut r,

+ )

+ .unwrap();

+ assert!(r.read_bool().is_err());

+ }

+}

+

+#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)]

+pub enum PayloadDeserializeError {

+ #[error("expected Unit or Block but got {0:?}")]

+ ContentType(content::Type),

+ #[error("payload block not found")]

+ BlockNotFound(#[from] block::content::TryFromU16Error),

+ #[error("payload unit not found")]

+ UnitNotFound(#[from] unit::TryFromU16Error),

+}

+

+impl PayloadDeserializeError {

+ pub fn forward<T, E: Into<Self>>(result: Result<T, E>) -> Result<T, DeserializeError> {

+ match result {

+ Ok(v) => Ok(v),

+ Err(e) => Err(DeserializeError::Custom(Box::new(e.into()))),

+ }

+ }

+}