+//! liquid related things

+use thiserror::Error;

+

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

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

+use crate::block::*;

+use crate::content;

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

+use crate::data::renderer::load;

+use crate::fluid;

+use crate::utils::ImageUtils;

+

+make_simple!(ConduitBlock, |_,

+ name,

+ _,

+ ctx: Option<&RenderingContext>,

+ rot,

+ s| {

+ let ctx = ctx.unwrap();

+

+ let mask = mask(ctx, rot, name);

+ // TODO caps. stopped trying bcz too complex

+ mask2tile(mask, rot, name, s)

+});

+

+make_register! {

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

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

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

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

+ "conduit" => ConduitBlock::new(1, false, cost!(Metaglass: 1));

+ "pulse-conduit" => ConduitBlock::new(1, false, cost!(Metaglass: 1, Titanium: 2));

+ "plated-conduit" => ConduitBlock::new(1, false, cost!(Metaglass: 1, Thorium: 2, Plastanium: 1));

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

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

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

+ "liquid-junction" -> BasicBlock::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-conduit" => ConduitBlock::new(1, false, cost!(Beryllium: 2));

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

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

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

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

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

+ // sandbox only

+ "liquid-source" => FluidBlock::new(1, true, &[]);

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

+}

+

+pub struct FluidBlock {

+ size: u8,

+ symmetric: bool,

+ build_cost: BuildCost,

+}

+

+impl FluidBlock {

+ #[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<fluid::Type>);

+}

+

+impl BlockLogic for FluidBlock {

+ impl_block!();

+

+ fn data_from_i32(&self, config: i32, _: GridPos) -> Result<DynData, DataConvertError> {

+ if config < 0 || config > i32::from(u16::MAX) {

+ return Err(DataConvertError::Custom(Box::new(FluidConvertError(

+ config,

+ ))));

+ }

+ Ok(DynData::Content(content::Type::Fluid, config as u16))

+ }

+

+ fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> {

+ match data {

+ DynData::Empty => Ok(Some(Self::create_state(None))),

+ DynData::Content(content::Type::Fluid, id) => Ok(Some(Self::create_state(Some(

+ FluidDeserializeError::forward(fluid::Type::try_from(id))?,

+ )))),

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

+ FluidDeserializeError::ContentType(have),

+ ))),

+ _ => Err(DeserializeError::InvalidType {

+ have: data.get_type(),

+ expect: DynType::Content,

+ }),

+ }

+ }

+

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

+ Ok(Self::get_state(state)

+ .as_ref()

+ .map_or(DynData::Empty, |&fluid| {

+ DynData::Content(content::Type::Fluid, fluid.into())

+ }))

+ }

+

+ fn draw(

+ &self,

+ _: &str,

+ state: Option<&State>,

+ _: Option<&RenderingContext>,

+ _: Rotation,

+ s: Scale,

+ ) -> ImageHolder<4> {

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

+ if let Some(state) = state && let Some(liq) = Self::get_state(state) {

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

+ unsafe { p.overlay(top.tint(liq.color())) };

+ return p;

+ }

+ p

+ }

+

+ /// format:

+ /// - fluid: [`u16`] as [`Fluid`](fluid::Type)

+ fn read(

+ &self,

+ b: &mut Build,

+ _: &BlockRegistry,

+ _: &EntityMapping,

+ buff: &mut DataRead,

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

+ let f = buff.read_u16()?;

+ b.state = Some(Self::create_state(fluid::Type::try_from(f).ok()));

+ Ok(())

+ }

+}

+

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

+#[error("invalid config ({0}) for fluid")]

+pub struct FluidConvertError(pub i32);

+

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

+pub enum FluidDeserializeError {

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

+ ContentType(content::Type),

+ #[error("fluid not found")]

+ NotFound(#[from] fluid::TryFromU16Error),

+}

+

+impl FluidDeserializeError {

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

+ }

+ }

+}