-//! deal with blocks.

-//!

-//! categorized as mindustry categorizes them in its assets folder, for easy drawing.

-//!

-//! with the exception of sandbox, that is.

-use bobbin_bits::U4::{self, B0000, B0001, B0010, B0100, B1000};

-use std::error::Error;

-use std::fmt;

-

-use crate::data::dynamic::{DynData, DynType};

-use crate::data::map::{Build, EntityMapping};

-use crate::data::{self, renderer::*, CompressError};

-use crate::data::{DataRead, GridPos, ReadError as DataReadError};

-use crate::item::storage::ItemStorage;

-use crate::registry::RegistryEntry;

-

-macro_rules! mods {

- ($($mod:ident)*) => {

- $(pub mod $mod;)*

-

- pub mod all {

- $(pub use crate::block::$mod::*;)*

- pub use super::simple::BasicBlock;

- }

- }

-}

-

-mods! {

- campaign content defense distribution drills environment liquid logic payload power production storage turrets walls units

-}

-

-mod simple;

-

-macro_rules! disp {

- ($($k:ident,)+) => {

- use all::{$($k,)+};

- #[enum_dispatch::enum_dispatch]

- pub(crate) enum BlockLogicEnum {

- $($k,)+

- }

- #[const_trait]

- pub trait ConstFrom<T>: Sized {

- fn fro(value: T) -> Self;

- }

- $(

- impl const ConstFrom<$k> for BlockLogicEnum {

- fn fro(v: $k) -> Self {

- BlockLogicEnum::$k(v)

- }

- }

- )+

-

- /*impl std::fmt::Debug for BlockLogicEnum {

- fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {

- match self {

- $(BlockLogicEnum::$k { .. } => write!(w, stringify!($k)),)+

- }

- }

- }*/

- }

-}

-

-disp! {

- BasicBlock,

- WallBlock,

- DuctBlock,

- BridgeBlock,

- ItemBlock,

- ProductionBlock,

- SeparatorBlock,

- StackConveyor,

- HeatCrafter,

- ConnectorBlock,

- ItemTurret,

- ConveyorBlock,

- WallDrillBlock,

- DrillBlock,

- NuclearGeneratorBlock,

- GeneratorBlock,

- ConduitBlock,

- HeatedBlock,

- RadarBlock,

- ShieldBlock,

- PointDefenseTurret,

- JunctionBlock,

- Turret,

- MemoryBlock,

- MessageLogic,

- ConstructorBlock,

- AssemblerBlock,

- UnitFactory,

- SimpleDuctBlock,

- SurgeRouter,

- SimplePayloadBlock,

- PayloadConveyor,

- ImpactReactorBlock,

- Neoplasia,

- DiodeBlock,

- HeatConduit,

- ContinousTurret,

- TractorBeamTurret,

- AssemblerModule,

- RepairTurret,

- FluidBlock,

- CanvasBlock,

- SwitchLogic,

- ProcessorLogic,

- PayloadBlock,

- LampBlock,

- DoorBlock,

-}

-

-pub trait Cast {

- fn downcast_ref(state: &State) -> Option<&Self>;

- fn downcast_mut(state: &mut State) -> Option<&mut Self>;

-}

-

-macro_rules! stater {

- ($($k: ident($v: ty),)+) => {

- #[derive(Debug, Clone)]

- pub enum State {

- $($k($v),)+

- }

-

- $(

- impl From<$v> for State {

- fn from(v: $v) -> State { State::$k(v) }

- }

-

- impl Cast for $v {

- fn downcast_ref(state: &State) -> Option<&Self> {

- match state {

- State::$k(v) => Some(v),

- _ => None,

- }

- }

- fn downcast_mut(state: &mut State) -> Option<&mut Self> {

- match state {

- State::$k(v) => Some(v),

- _ => None,

- }

- }

- }

- )+

- }

-}

-

-stater! {

- // TODO deoptionize

- String(String),

- Item(Option<crate::item::Type>),

- Fluid(Option<crate::fluid::Type>),

- Image(Image<Vec<u8>, 1>),

- Point(Option<(i32, i32)>),

- Bool(bool),

- Processor(logic::ProcessorState),

- Payload(payload::Payload),

- Power(Vec<(i16, i16)>),

- Color(power::Rgba),

- Command(Option<crate::data::command::UnitCommand>),

- Unit(Option<crate::unit::Type>),

-}

-

-impl State {

- pub fn downcast_ref<T: Cast>(&self) -> Option<&T> {

- T::downcast_ref(self)

- }

-

- pub fn downcast_mut<T: Cast>(&mut self) -> Option<&mut T> {

- T::downcast_mut(self)

- }

-

- pub fn new<T: Into<Self>>(from: T) -> Self {

- from.into()

- }

-}

-

-#[enum_dispatch::enum_dispatch(BlockLogicEnum)]

-pub trait BlockLogic {

- /// mindustry blocks are the same width and height

- fn get_size(&self) -> u8;

-

- fn is_symmetric(&self) -> bool;

-

- fn create_build_cost(&self) -> Option<ItemStorage>;

-

- fn data_from_i32(&self, config: i32, pos: GridPos) -> Result<DynData, DataConvertError>;

-

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

-

- #[allow(unused_variables)]

- fn mirror_state(&self, state: &mut State, horizontally: bool, vertically: bool) {}

-

- #[allow(unused_variables)]

- fn rotate_state(&self, state: &mut State, clockwise: bool) {}

-

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

-

- #[allow(unused_variables)]

- fn draw(

- &self,

- name: &str,

- state: Option<&State>,

- context: Option<&RenderingContext>,

- rot: Rotation,

- scale: Scale,

- ) -> ImageHolder<4> {

- unimplemented!("{name}")

- }

-

- #[allow(unused_variables)]

- fn read(

- &self,

- build: &mut Build,

- reg: &BlockRegistry,

- mapping: &EntityMapping,

- buff: &mut DataRead,

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

- Ok(())

- }

-}

-

-// i wish i could derive

-macro_rules! impl_block {

- () => {

- fn get_size(&self) -> u8 {

- self.size

- }

-

- fn is_symmetric(&self) -> bool {

- self.symmetric

- }

-

- fn create_build_cost(&self) -> Option<$crate::item::storage::ItemStorage> {

- if self.build_cost.is_empty() {

- None

- } else {

- let mut storage = crate::item::storage::Storage::new();

- for (ty, cnt) in self.build_cost {

- storage.add(*ty, *cnt, u32::MAX);

- }

- Some(storage)

- }

- }

- };

-}

-pub(crate) use impl_block;

-

-#[derive(Debug, thiserror::Error)]

-pub enum DataConvertError {

- #[error(transparent)]

- Custom(#[from] Box<dyn Error + Sync + Send>),

-}

-

-impl DataConvertError {

- pub fn forward<T, E: Error + Sync + Send + 'static>(result: Result<T, E>) -> Result<T, Self> {

- match result {

- Ok(v) => Ok(v),

- Err(e) => Err(Self::Custom(Box::new(e))),

- }

- }

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum DeserializeError {

- #[error(transparent)]

- DecompressError(#[from] data::DecompressError),

- #[error("expected type {expect:?} but got {have:?}")]

- InvalidType { have: DynType, expect: DynType },

- #[error(transparent)]

- Custom(#[from] Box<dyn Error + Sync + Send>),

-}

-

-impl DeserializeError {

- pub fn forward<T, E: Error + Sync + Send + 'static>(result: Result<T, E>) -> Result<T, Self> {

- match result {

- Ok(v) => Ok(v),

- Err(e) => Err(Self::Custom(Box::new(e))),

- }

- }

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum SerializeError {

- #[error(transparent)]

- Custom(#[from] Box<dyn Error + Sync + Send>),

- #[error(transparent)]

- Compress(#[from] CompressError),

-}

-

-impl SerializeError {

- pub fn forward<T, E: Error + Sync + Send + 'static>(result: Result<T, E>) -> Result<T, Self> {

- match result {

- Ok(v) => Ok(v),

- Err(e) => Err(Self::Custom(Box::new(e))),

- }

- }

-}

-

-/// a block. put it in stuff!

-pub struct Block {

- image: Option<[Image<&'static [u8], 4>; 3]>,

- name: &'static str,

- logic: BlockLogicEnum,

-}

-

-impl PartialEq for Block {

- fn eq(&self, rhs: &Block) -> bool {

- self.name == rhs.name

- }

-}

-

-impl Block {

- /// create a new block

- #[must_use]

- #[inline]

- pub(crate) const fn new(

- name: &'static str,

- logic: BlockLogicEnum,

- image: Option<[Image<&'static [u8], 4>; 3]>,

- ) -> Self {

- Self { image, name, logic }

- }

-

- /// this blocks name

- /// ```

- /// assert!(mindus::block::distribution::DISTRIBUTOR.name() == "distributor")

- /// ```

- #[must_use]

- #[inline]

- pub const fn name(&self) -> &'static str {

- self.name

- }

-

- /// should you send context to [`image`]?

- #[must_use]

- #[inline]

- pub fn wants_context(&self) -> bool {

- use BlockLogicEnum::*;

- matches!(

- self.logic,

- ConveyorBlock(..) | DuctBlock(..) | StackConveyor(..) | ConduitBlock(..)

- )

- }

-

- /// draw this block, with this state

- #[must_use]

- #[inline]

- pub fn image(

- &self,

- state: Option<&State>,

- context: Option<&RenderingContext>,

- rot: Rotation,

- scale: Scale,

- ) -> ImageHolder<4> {

- if let Some(imgs) = &self.image {

- return ImageHolder::from((imgs[scale as usize]).copy());

- }

- self.logic.draw(self.name, state, context, rot, scale)

- }

-

- /// size.

- #[must_use]

- #[inline]

- pub fn get_size(&self) -> u8 {

- self.logic.get_size()

- }

-

- /// does it matter if its rotated

- #[must_use]

- #[inline]

- pub fn is_symmetric(&self) -> bool {

- self.logic.is_symmetric()

- }

-

- /// cost

- #[must_use]

- #[inline]

- pub fn get_build_cost(&self) -> Option<ItemStorage> {

- self.logic.create_build_cost()

- }

-

- pub(crate) fn data_from_i32(

- &self,

- config: i32,

- pos: GridPos,

- ) -> Result<DynData, DataConvertError> {

- self.logic.data_from_i32(config, pos)

- }

-

- pub(crate) fn deserialize_state(

- &self,

- data: DynData,

- ) -> Result<Option<State>, DeserializeError> {

- self.logic.deserialize_state(data)

- }

-

- pub(crate) fn mirror_state(&self, state: &mut State, horizontally: bool, vertically: bool) {

- self.logic.mirror_state(state, horizontally, vertically);

- }

-

- pub(crate) fn rotate_state(&self, state: &mut State, clockwise: bool) {

- self.logic.rotate_state(state, clockwise);

- }

-

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

- self.logic.serialize_state(state)

- }

-

- #[inline]

- pub(crate) fn read(

- &self,

- build: &mut Build,

- reg: &BlockRegistry,

- mapping: &EntityMapping,

- buff: &mut DataRead,

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

- self.logic.read(build, reg, mapping, buff)

- }

-}

-

-impl fmt::Debug for Block {

- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

- write!(f, "Block<{:?}>", self.name)

- }

-}

-

-impl RegistryEntry for Block {

- fn get_name(&self) -> &str {

- self.name

- }

-}

-

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

-/// the possible rotation states of a object

-#[repr(u8)]

-pub enum Rotation {

- Up,

- Right,

- Down,

- Left,

-}

-

-impl Rotation {

- #[must_use]

- /// count rotations

- pub const fn count(self) -> u8 {

- self as u8

- }

-

- #[must_use]

- /// mask

- pub const fn mask(self) -> U4 {

- match self {

- Rotation::Up => B1000,

- Rotation::Right => B0100,

- Rotation::Down => B0010,

- Rotation::Left => B0001,

- }

- }

-

- #[must_use]

- /// character of this rot (Right => >, Up => ^, Left => <, Down => v)

- pub const fn ch(self) -> char {

- match self {

- Rotation::Right => '>',

- Rotation::Up => '^',

- Rotation::Left => '<',

- Rotation::Down => 'v',

- }

- }

-

- #[must_use]

- /// mirror the directions.

- pub const fn mirrored(self, horizontally: bool, vertically: bool) -> Self {

- match self {

- Self::Right => {

- if horizontally {

- Self::Left

- } else {

- Self::Right

- }

- }

- Self::Up => {

- if vertically {

- Self::Down

- } else {

- Self::Up

- }

- }

- Self::Left => {

- if horizontally {

- Self::Right

- } else {

- Self::Left

- }

- }

- Self::Down => {

- if vertically {

- Self::Up

- } else {

- Self::Down

- }

- }

- }

- }

-

- /// mirror in place

- pub fn mirror(&mut self, horizontally: bool, vertically: bool) {

- *self = self.mirrored(horizontally, vertically);

- }

-

- #[must_use]

- /// rotate the rotation

- pub const fn rotated(self, clockwise: bool) -> Self {

- match self {

- Self::Right => {

- if clockwise {

- Self::Down

- } else {

- Self::Up

- }

- }

- Self::Up => {

- if clockwise {

- Self::Right

- } else {

- Self::Left

- }

- }

- Self::Left => {

- if clockwise {

- Self::Up

- } else {

- Self::Down

- }

- }

- Self::Down => {

- if clockwise {

- Self::Left

- } else {

- Self::Right

- }

- }

- }

- }

-

- /// rotate the rotation in place

- pub fn rotate(&mut self, clockwise: bool) {

- *self = self.rotated(clockwise);

- }

-

- #[must_use]

- /// rotate 180

- pub const fn rotated_180(self) -> Self {

- match self {

- Self::Right => Self::Left,

- Self::Up => Self::Down,

- Self::Left => Self::Right,

- Self::Down => Self::Up,

- }

- }

-

- /// rotate 180 in place

- pub fn rotate_180(&mut self) {

- *self = self.rotated_180();

- }

-}

-

-impl From<u8> for Rotation {

- fn from(val: u8) -> Self {

- match val & 3 {

- 0 => Self::Right,

- 1 => Self::Up,

- 2 => Self::Left,

- _ => Self::Down,

- }

- }

-}

-

-impl From<Rotation> for u8 {

- fn from(rot: Rotation) -> Self {

- match rot {

- Rotation::Right => 0,

- Rotation::Up => 1,

- Rotation::Left => 2,

- Rotation::Down => 3,

- }

- }

-}

-

-pub type BlockRegistry<'l> = crate::registry::Registry<'l, Block>;

-pub type RegisterError<'l> = crate::registry::RegisterError<'l, Block>;

-

-macro_rules! make_register {

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

- $(

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

- )+

-

- pub(crate) fn register(reg: &mut $crate::block::BlockRegistry<'_>) {

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

- $field, <crate::block::BlockLogicEnum as crate::block::ConstFrom<_>>::fro($logic), None

- ); }

- };

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

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

- $field, <crate::block::BlockLogicEnum as crate::block::ConstFrom<_>>::fro($logic), Some(crate::data::renderer::load!($field))

- ); }

- }

-}

-pub(crate) use make_register;

-

-#[must_use]

-/// create a block registry

-pub fn build_registry() -> BlockRegistry<'static> {

- let mut reg = BlockRegistry::default();

- register(&mut reg);

- reg

-}

-

-fn register(reg: &mut BlockRegistry<'_>) {

- turrets::register(reg);

- drills::register(reg);

- distribution::register(reg);

- storage::register(reg);

- liquid::register(reg);

- power::register(reg);

- defense::register(reg);

- production::register(reg);

- payload::register(reg);

- campaign::register(reg);

- logic::register(reg);

- walls::register(reg);

- environment::register(reg);

- units::register(reg);

-}