pipe locking and fluid tanks

src/main/java/com/drmangotea/tfmg/base/TFMGBlockStateGen.java

@@ -0,0 +1,27 @@
+package com.drmangotea.tfmg.base;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlock;
+import com.simibubi.create.foundation.utility.Iterate;
+import com.simibubi.create.foundation.utility.Pointing;
+import com.tterrag.registrate.providers.DataGenContext;
+import com.tterrag.registrate.providers.RegistrateBlockstateProvider;
+import com.tterrag.registrate.util.nullness.NonNullBiConsumer;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraftforge.client.model.generators.ModelFile;
+import net.minecraftforge.client.model.generators.MultiPartBlockStateBuilder;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TFMGBlockStateGen {
+
+
+}

src/main/java/com/drmangotea/tfmg/base/creative_mode_tabs/BuldingCreativeModeTab.java

@@ -1,15 +1,14 @@
 package com.drmangotea.tfmg.base.creative_mode_tabs;
 
+import com.drmangotea.tfmg.registry.TFMGBlocks;
 import com.drmangotea.tfmg.registry.TFMGItems;
-import com.simibubi.create.content.decoration.palettes.AllPaletteBlocks;
-import com.simibubi.create.infrastructure.item.CreateCreativeModeTab;
 
 import net.minecraft.core.NonNullList;
 import net.minecraft.world.item.ItemStack;
 
-public class ConcreteCreativeModeTab extends TFMGCreativeModeTab {
-    public ConcreteCreativeModeTab() {
-        super("concrete");
+public class BuldingCreativeModeTab extends TFMGCreativeModeTab {
+    public BuldingCreativeModeTab() {
+        super("building");
     }
 
     @Override
@@ -18,6 +17,6 @@ public class ConcreteCreativeModeTab extends TFMGCreativeModeTab {
 
     @Override
     public ItemStack makeIcon() {
-        return TFMGItems.COPPER_GRENADE.asStack();
+        return TFMGBlocks.CONCRETE.asStack();
     }
 }

src/main/java/com/drmangotea/tfmg/content/fluids/BurnableFluid.java

@@ -9,6 +9,10 @@ import net.minecraft.world.level.material.Fluid;
 import net.minecraft.world.level.material.FluidState;
 import net.minecraftforge.fluids.ForgeFlowingFluid;
 
+/**
+ * makes fluid burn when close to fire,
+ * not working for now
+ */
 public class BurnableFluid extends ForgeFlowingFluid {
 
 

src/main/java/com/drmangotea/tfmg/content/gadgets/explosives/thermite_grenades/fire/TFMGColoredFires.java

@@ -9,6 +9,10 @@ import net.minecraftforge.registries.DeferredRegister;
 import net.minecraftforge.registries.ForgeRegistries;
 import net.minecraftforge.registries.RegistryObject;
 
+/**
+ * making blockstate for fire in registrate is pain/idk how to do it
+ * so no registrate for those :skull:
+ */
 public class TFMGColoredFires {
 
     public static final DeferredRegister<Block> BLOCKS =

src/main/java/com/drmangotea/tfmg/content/items/CoalCokeBlockItem.java

@@ -0,0 +1,25 @@
+package com.drmangotea.tfmg.content.items;
+
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.block.Block;
+import org.jetbrains.annotations.Nullable;
+
+public class CoalCokeBlockItem extends BlockItem {
+
+
+
+
+    public CoalCokeBlockItem(Block p_40565_, Properties p_40566_) {
+        super(p_40565_, p_40566_);
+
+    }
+
+
+
+    @Override
+    public int getBurnTime(ItemStack itemStack, @Nullable RecipeType<?> recipeType) {
+        return 28800;
+    }
+}

src/main/java/com/drmangotea/tfmg/content/items/CoalCokeItem.java

@@ -0,0 +1,27 @@
+package com.drmangotea.tfmg.content.items;
+
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.block.Block;
+import net.minecraftforge.common.property.Properties;
+import org.jetbrains.annotations.Nullable;
+
+public class CoalCokeItem extends Item {
+
+
+
+
+    public CoalCokeItem(Properties p_40566_) {
+        super( p_40566_);
+
+    }
+
+
+
+    @Override
+    public int getBurnTime(ItemStack itemStack, @Nullable RecipeType<?> recipeType) {
+        return 3200;
+    }
+}

src/main/java/com/drmangotea/tfmg/content/items/FossilstoneItem.java

@@ -0,0 +1,25 @@
+package com.drmangotea.tfmg.content.items;
+
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.block.Block;
+import org.jetbrains.annotations.Nullable;
+
+public class FossilstoneItem extends BlockItem {
+
+
+
+
+    public FossilstoneItem(Block p_40565_, Properties p_40566_) {
+        super(p_40565_, p_40566_);
+
+    }
+
+
+
+    @Override
+    public int getBurnTime(ItemStack itemStack, @Nullable RecipeType<?> recipeType) {
+        return 4000;
+    }
+}

src/main/java/com/drmangotea/tfmg/content/items/ScrewdriverItem.java

@@ -0,0 +1,53 @@
+package com.drmangotea.tfmg.content.items;
+
+import com.drmangotea.tfmg.content.machines.pipes.normal.LockablePipeBlockEntity;
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.SteelPipeBlock;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.Level;
+
+
+public class ScrewdriverItem extends Item {
+
+
+
+
+    public ScrewdriverItem(Properties p_40566_) {
+        super( p_40566_);
+
+    }
+
+    @Override
+    public InteractionResult useOn(UseOnContext pContext) {
+        Player player = pContext.getPlayer();
+
+        BlockPos positionClicked = pContext.getClickedPos();
+
+        Level level = pContext.getLevel();
+
+
+
+
+        if(level.getBlockState(positionClicked).is(TFMGBlocks.STEEL_PIPE.get())) {
+            level.playSound(player, positionClicked, SoundEvents.ANVIL_PLACE, SoundSource.BLOCKS, 0.3f,0.5f);
+            ((LockablePipeBlockEntity)level.getBlockEntity(positionClicked)).toggleLock(player);
+
+        }
+
+
+
+        pContext.getItemInHand().hurtAndBreak(1, pContext.getPlayer(),
+                (playerr) -> playerr.broadcastBreakEvent(playerr.getUsedItemHand()));
+
+
+        return InteractionResult.SUCCESS;
+
+    }
+}

src/main/java/com/drmangotea/tfmg/content/items/TFMGFuelItem.java

@@ -1,32 +0,0 @@
-package com.drmangotea.tfmg.content.items;
-
-import net.minecraft.world.item.BlockItem;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.RecipeType;
-import net.minecraft.world.level.block.Block;
-import org.jetbrains.annotations.Nullable;
-
-public class TFMGFuelItem extends BlockItem {
-
-    private final int burnTicks;
-
-
-    public static TFMGFuelItem fossilstone(Block block,Properties properties) {
-        return new TFMGFuelItem(block,properties, 4000);
-    }
-        public static TFMGFuelItem coal_coke(Block block,Properties properties){
-            return new TFMGFuelItem(block,properties,3200);
-    }
-    public TFMGFuelItem(Block p_40565_, Properties p_40566_,int burnTime) {
-        super(p_40565_, p_40566_);
-        this.burnTicks = burnTime;
-    }
-
-
-
-    @Override
-    public int getBurnTime(ItemStack itemStack, @Nullable RecipeType<?> recipeType) {
-        return burnTicks;
-    }
-}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/LockablePipeBlockEntity.java

@@ -0,0 +1,44 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal;
+
+
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlockEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class LockablePipeBlockEntity extends FluidPipeBlockEntity {
+
+    public boolean locked = false;
+
+    public LockablePipeBlockEntity(BlockEntityType<?> type, BlockPos pos, BlockState state) {
+        super(type, pos, state);
+    }
+
+    public void toggleLock(Player player){
+        level.playSound(player, getBlockPos(), SoundEvents.ANVIL_PLACE, SoundSource.BLOCKS, 0.3f,0.5f);
+        locked = !locked;
+
+    }
+
+    @Override
+    public void write(CompoundTag compound, boolean clientPacket) {
+
+        compound.putBoolean("Locked", locked);
+
+        super.write(compound, clientPacket);
+
+    }
+    @Override
+    protected void read(CompoundTag compound, boolean clientPacket) {
+        super.read(compound, clientPacket);
+
+
+        locked = compound.getBoolean("Locked");
+
+    }
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/TFMGPipeBlockEntity.java

@@ -0,0 +1,19 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal;
+
+
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlockEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class TFMGPipeBlockEntity extends FluidPipeBlockEntity {
+
+
+
+    public TFMGPipeBlockEntity(BlockEntityType<?> type, BlockPos pos, BlockState state) {
+        super(type, pos, state);
+    }
+
+
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/steel/EncasedSteelPipeBlock.java

@@ -0,0 +1,70 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal.steel;
+
+
+import com.drmangotea.tfmg.registry.TFMGBlockEntities;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.EncasedPipeBlock;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlockEntity;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.HitResult;
+
+import java.util.function.Supplier;
+
+public class EncasedSteelPipeBlock extends EncasedPipeBlock {
+
+    public EncasedSteelPipeBlock(Properties p_i48339_1_, Supplier<Block> casing) {
+        super(p_i48339_1_, casing);
+    }
+
+    @Override
+    public ItemStack getCloneItemStack(BlockState state, HitResult target, BlockGetter world, BlockPos pos, Player player) {
+        return TFMGBlocks.STEEL_PIPE.asStack();
+    }
+
+    @Override
+    public InteractionResult onWrenched(BlockState state, UseOnContext context) {
+        Level world = context.getLevel();
+        BlockPos pos = context.getClickedPos();
+
+        if (world.isClientSide)
+            return InteractionResult.SUCCESS;
+
+        context.getLevel()
+                .levelEvent(2001, context.getClickedPos(), Block.getId(state));
+        BlockState equivalentPipe = transferSixWayProperties(state, TFMGBlocks.STEEL_PIPE.getDefaultState());
+
+        Direction firstFound = Direction.UP;
+        for (Direction d : Iterate.directions)
+            if (state.getValue(FACING_TO_PROPERTY_MAP.get(d))) {
+                firstFound = d;
+                break;
+            }
+
+        FluidTransportBehaviour.cacheFlows(world, pos);
+        world.setBlockAndUpdate(pos, TFMGBlocks.STEEL_PIPE.get()
+                .updateBlockState(equivalentPipe, firstFound, null, world, pos));
+        FluidTransportBehaviour.loadFlows(world, pos);
+        return InteractionResult.SUCCESS;
+    }
+    @Override
+    public Class<FluidPipeBlockEntity> getBlockEntityClass() {
+        return FluidPipeBlockEntity.class;
+    }
+
+    @Override
+    public BlockEntityType<? extends FluidPipeBlockEntity> getBlockEntityType() {
+        return TFMGBlockEntities.ENCASED_STEEL_PIPE.get();
+    }
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/steel/GlassSteelPipeBlock.java

@@ -0,0 +1,80 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal.steel;
+
+
+import com.drmangotea.tfmg.registry.TFMGBlockEntities;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.simibubi.create.AllBlocks;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.EncasedPipeBlock;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlock;
+import com.simibubi.create.content.fluids.pipes.GlassFluidPipeBlock;
+import com.simibubi.create.content.fluids.pipes.StraightPipeBlockEntity;
+import com.simibubi.create.content.schematics.requirement.ItemRequirement;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+
+import java.util.Map;
+
+public class GlassSteelPipeBlock extends GlassFluidPipeBlock {
+    public GlassSteelPipeBlock(Properties p_i48339_1_) {
+        super(p_i48339_1_);
+    }
+
+    @Override
+    public ItemRequirement getRequiredItems(BlockState state, BlockEntity te) {
+        return ItemRequirement.of(TFMGBlocks.STEEL_PIPE.getDefaultState(), te);
+    }
+    @Override
+    public ItemStack getCloneItemStack(BlockState state, HitResult target, BlockGetter world, BlockPos pos,
+                                       Player player) {
+        return TFMGBlocks.STEEL_PIPE.asStack();
+    }
+    @Override
+    public BlockState toRegularPipe(LevelAccessor world, BlockPos pos, BlockState state) {
+        Direction side = Direction.get(Direction.AxisDirection.POSITIVE, state.getValue(AXIS));
+        Map<Direction, BooleanProperty> facingToPropertyMap = FluidPipeBlock.PROPERTY_BY_DIRECTION;
+        return TFMGBlocks.STEEL_PIPE.get()
+                .updateBlockState(TFMGBlocks.STEEL_PIPE.getDefaultState()
+                        .setValue(facingToPropertyMap.get(side), true)
+                        .setValue(facingToPropertyMap.get(side.getOpposite()), true), side, null, world, pos);
+    }
+    @Override
+    public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand,
+                                 BlockHitResult hit) {
+        if (!AllBlocks.COPPER_CASING.isIn(player.getItemInHand(hand)))
+            return InteractionResult.PASS;
+        if (world.isClientSide)
+            return InteractionResult.SUCCESS;
+        BlockState newState = TFMGBlocks.COPPER_ENCASED_STEEL_PIPE.getDefaultState();
+        for (Direction d : Iterate.directionsInAxis(getAxis(state)))
+            newState = newState.setValue(EncasedPipeBlock.FACING_TO_PROPERTY_MAP.get(d), true);
+        FluidTransportBehaviour.cacheFlows(world, pos);
+        world.setBlockAndUpdate(pos, newState);
+        FluidTransportBehaviour.loadFlows(world, pos);
+        return InteractionResult.SUCCESS;
+    }
+
+    @Override
+    public Class<StraightPipeBlockEntity> getBlockEntityClass() {
+        return StraightPipeBlockEntity.class;
+    }
+
+    @Override
+    public BlockEntityType<? extends StraightPipeBlockEntity> getBlockEntityType() {
+        return TFMGBlockEntities.GLASS_STEEL_PIPE.get();
+    }
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/steel/SteelPipeAttachmentModel.java

@@ -0,0 +1,134 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal.steel;
+
+import com.drmangotea.tfmg.registry.TFMGPartialModels;
+import com.simibubi.create.content.decoration.bracket.BracketedBlockEntityBehaviour;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlock;
+import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
+import com.simibubi.create.foundation.model.BakedModelWrapperWithData;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.ChunkRenderTypeSet;
+import net.minecraftforge.client.model.data.ModelData;
+import net.minecraftforge.client.model.data.ModelProperty;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SteelPipeAttachmentModel extends BakedModelWrapperWithData {
+
+    private static final ModelProperty<PipeModelData> PIPE_PROPERTY = new ModelProperty<>();
+
+    public SteelPipeAttachmentModel(BakedModel template) {
+        super(template);
+    }
+
+    @Override
+    protected ModelData.Builder gatherModelData(ModelData.Builder builder, BlockAndTintGetter world, BlockPos pos, BlockState state,
+                                                ModelData blockEntityData) {
+        PipeModelData data = new PipeModelData();
+        FluidTransportBehaviour transport = BlockEntityBehaviour.get(world, pos, FluidTransportBehaviour.TYPE);
+        BracketedBlockEntityBehaviour bracket = BlockEntityBehaviour.get(world, pos, BracketedBlockEntityBehaviour.TYPE);
+
+        if (transport != null)
+            for (Direction d : Iterate.directions)
+                data.putAttachment(d, transport.getRenderedRimAttachment(world, pos, state, d));
+        if (bracket != null)
+            data.putBracket(bracket.getBracket());
+
+        data.setEncased(FluidPipeBlock.shouldDrawCasing(world, pos, state));
+        return builder.with(PIPE_PROPERTY, data);
+    }
+
+
+    @SuppressWarnings("removal")
+    @Override
+    public ChunkRenderTypeSet getRenderTypes(@NotNull BlockState state, @NotNull RandomSource rand, @NotNull ModelData data) {
+        ChunkRenderTypeSet set = super.getRenderTypes(state, rand, data);
+        if (set.isEmpty()) {
+            return ItemBlockRenderTypes.getRenderLayers(state);
+        }
+        return set;
+    }
+
+    @Override
+    public List<BakedQuad> getQuads(BlockState state, Direction side, RandomSource rand, ModelData data, RenderType renderType) {
+        List<BakedQuad> quads = super.getQuads(state, side, rand, data, renderType);
+        if (data.has(PIPE_PROPERTY)) {
+            PipeModelData pipeData = data.get(PIPE_PROPERTY);
+            quads = new ArrayList<>(quads);
+            addQuads(quads, state, side, rand, data, pipeData, renderType);
+        }
+        return quads;
+    }
+
+    private void addQuads(List<BakedQuad> quads, BlockState state, Direction side, RandomSource rand, ModelData data,
+                          PipeModelData pipeData, RenderType renderType) {
+        BakedModel bracket = pipeData.getBracket();
+        if (bracket != null)
+            quads.addAll(bracket.getQuads(state, side, rand, data, renderType));
+        for (Direction d : Iterate.directions) {
+            FluidTransportBehaviour.AttachmentTypes type = pipeData.getAttachment(d);
+            for (FluidTransportBehaviour.AttachmentTypes.ComponentPartials partial : type.partials) {
+                quads.addAll(TFMGPartialModels.STEEL_PIPE_ATTACHMENTS.get(partial)
+                        .get(d)
+                        .get()
+                        .getQuads(state, side, rand, data, renderType));
+            }
+        }
+        if (pipeData.isEncased())
+            quads.addAll(TFMGPartialModels.STEEL_FLUID_PIPE_CASING.get()
+                    .getQuads(state, side, rand, data, renderType));
+    }
+
+    private static class PipeModelData {
+        private FluidTransportBehaviour.AttachmentTypes[] attachments;
+        private boolean encased;
+        private BakedModel bracket;
+
+        public PipeModelData() {
+            attachments = new FluidTransportBehaviour.AttachmentTypes[6];
+            Arrays.fill(attachments, FluidTransportBehaviour.AttachmentTypes.NONE);
+        }
+
+        public void putBracket(BlockState state) {
+            if (state != null) {
+                this.bracket = Minecraft.getInstance()
+                        .getBlockRenderer()
+                        .getBlockModel(state);
+            }
+        }
+
+        public BakedModel getBracket() {
+            return bracket;
+        }
+
+        public void putAttachment(Direction face, FluidTransportBehaviour.AttachmentTypes rim) {
+            attachments[face.get3DDataValue()] = rim;
+        }
+
+        public FluidTransportBehaviour.AttachmentTypes getAttachment(Direction face) {
+            return attachments[face.get3DDataValue()];
+        }
+
+        public void setEncased(boolean encased) {
+            this.encased = encased;
+        }
+
+        public boolean isEncased() {
+            return encased;
+        }
+    }
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/normal/steel/SteelPipeBlock.java

@@ -0,0 +1,207 @@
+package com.drmangotea.tfmg.content.machines.pipes.normal.steel;
+
+
+import com.drmangotea.tfmg.CreateTFMG;
+import com.drmangotea.tfmg.content.machines.pipes.normal.LockablePipeBlockEntity;
+import com.drmangotea.tfmg.registry.TFMGBlockEntities;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.simibubi.create.AllBlocks;
+import com.simibubi.create.content.decoration.bracket.BracketedBlockEntityBehaviour;
+import com.simibubi.create.content.fluids.FluidPropagator;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.EncasedPipeBlock;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlock;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlockEntity;
+import com.simibubi.create.content.fluids.pipes.GlassFluidPipeBlock;
+import com.simibubi.create.foundation.advancement.AllAdvancements;
+import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.concurrent.locks.Lock;
+
+public class SteelPipeBlock extends FluidPipeBlock {
+//    public static final BooleanProperty LOCKEDDDD = BlockStateProperties.LOCKED;
+
+    public SteelPipeBlock(Properties properties) {
+        super(properties);
+        // this.registerDefaultState(super.defaultBlockState().setValue(LOCKEDDDD, false));
+
+    }
+
+    public BlockState updateBlockState(BlockState state, Direction preferredDirection, @Nullable Direction ignore,
+                                       BlockAndTintGetter world, BlockPos pos) {
+        if(world.getBlockEntity(pos) instanceof LockablePipeBlockEntity)
+            if(((LockablePipeBlockEntity)world.getBlockEntity(pos)).locked){
+                    return state;
+          }
+
+        BracketedBlockEntityBehaviour bracket = BlockEntityBehaviour.get(world, pos, BracketedBlockEntityBehaviour.TYPE);
+        if (bracket != null && bracket.isBracketPresent())
+            return state;
+
+        BlockState prevState = state;
+        int prevStateSides = (int) Arrays.stream(Iterate.directions)
+                .map(PROPERTY_BY_DIRECTION::get)
+                .filter(prevState::getValue)
+                .count();
+
+        // Update sides that are not ignored
+        for (Direction d : Iterate.directions)
+            if (d != ignore) {
+                boolean shouldConnect = canConnectTo(world, pos.relative(d), world.getBlockState(pos.relative(d)), d);
+
+                if(world.getBlockEntity(pos.relative(d)) instanceof LockablePipeBlockEntity) {
+                    if (((LockablePipeBlockEntity) world.getBlockEntity(pos.relative(d))).locked) {
+                        shouldConnect = false;
+
+
+                        if(world.getBlockState(pos.relative(d)).getValue(PROPERTY_BY_DIRECTION.get(d.getOpposite()))){
+                            shouldConnect =true;
+                        }
+                    }
+
+
+                }
+                state = state.setValue(PROPERTY_BY_DIRECTION.get(d), shouldConnect);
+            }
+
+        // See if it has enough connections
+        Direction connectedDirection = null;
+        for (Direction d : Iterate.directions) {
+            if (isOpenAt(state, d)) {
+                if (connectedDirection != null)
+                    return state;
+                connectedDirection = d;
+            }
+        }
+
+        // Add opposite end if only one connection
+        if (connectedDirection != null)
+            return state.setValue(PROPERTY_BY_DIRECTION.get(connectedDirection.getOpposite()), true);
+
+        // If we can't connect to anything and weren't connected before, do nothing
+        if (prevStateSides == 2)
+            return prevState;
+
+        // Use preferred
+        return state.setValue(PROPERTY_BY_DIRECTION.get(preferredDirection), true)
+                .setValue(PROPERTY_BY_DIRECTION.get(preferredDirection.getOpposite()), true);
+    }
+    @Override
+    public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource r) {
+        super.tick(state,world,pos,r);
+
+
+    }
+    @Override
+    public InteractionResult onWrenched(BlockState state, UseOnContext context) {
+
+
+
+        if (tryRemoveBracket(context))
+            return InteractionResult.SUCCESS;
+        Level world = context.getLevel();
+        BlockPos pos = context.getClickedPos();
+        Direction clickedFace = context.getClickedFace();
+
+        Direction.Axis axis = getAxis(world, pos, state);
+        if (axis == null) {
+            Vec3 clickLocation = context.getClickLocation()
+                    .subtract(pos.getX(), pos.getY(), pos.getZ());
+            double closest = Float.MAX_VALUE;
+            Direction argClosest = Direction.UP;
+            for (Direction direction : Iterate.directions) {
+                if (clickedFace.getAxis() == direction.getAxis())
+                    continue;
+                Vec3 centerOf = Vec3.atCenterOf(direction.getNormal());
+                double distance = centerOf.distanceToSqr(clickLocation);
+                if (distance < closest) {
+                    closest = distance;
+                    argClosest = direction;
+                }
+            }
+            axis = argClosest.getAxis();
+        }
+
+        if (clickedFace.getAxis() == axis)
+            return InteractionResult.PASS;
+        if (!world.isClientSide) {
+            withBlockEntityDo(world, pos, fpte -> fpte.getBehaviour(FluidTransportBehaviour.TYPE).interfaces.values()
+                    .stream()
+                    .filter(pc -> pc != null && pc.hasFlow())
+                    .findAny()
+                    .ifPresent($ -> AllAdvancements.GLASS_PIPE.awardTo(context.getPlayer())));
+
+            FluidTransportBehaviour.cacheFlows(world, pos);
+            world.setBlockAndUpdate(pos, TFMGBlocks.GLASS_STEEL_PIPE.getDefaultState()
+                    .setValue(GlassFluidPipeBlock.AXIS, axis)
+                    .setValue(BlockStateProperties.WATERLOGGED, state.getValue(BlockStateProperties.WATERLOGGED)));
+            FluidTransportBehaviour.loadFlows(world, pos);
+        }
+        return InteractionResult.SUCCESS;
+    }
+    @Nullable
+    private Direction.Axis getAxis(BlockGetter world, BlockPos pos, BlockState state) {
+        return FluidPropagator.getStraightPipeAxis(state);
+    }
+    @Override
+    public ItemStack getCloneItemStack(BlockState state, HitResult target, BlockGetter world, BlockPos pos,
+                                       Player player) {
+        return TFMGBlocks.STEEL_PIPE.asStack();
+    }
+    @Override
+    public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand,
+                                 BlockHitResult hit) {
+        if (!AllBlocks.COPPER_CASING.isIn(player.getItemInHand(hand)))
+            return InteractionResult.PASS;
+        if (world.isClientSide)
+            return InteractionResult.SUCCESS;
+
+        FluidTransportBehaviour.cacheFlows(world, pos);
+        world.setBlockAndUpdate(pos,
+                EncasedPipeBlock.transferSixWayProperties(state, TFMGBlocks.COPPER_ENCASED_STEEL_PIPE.getDefaultState()));
+        FluidTransportBehaviour.loadFlows(world, pos);
+        return InteractionResult.SUCCESS;
+
+    }
+ //  @Override
+ //  protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+ //      super.createBlockStateDefinition(builder);
+ //      builder.add(LOCKEDDDD);
+
+ //  }
+    @Override
+    public Class<FluidPipeBlockEntity> getBlockEntityClass() {
+        return FluidPipeBlockEntity.class;
+    }
+
+    @Override
+    public BlockEntityType<? extends FluidPipeBlockEntity> getBlockEntityType() {
+        return TFMGBlockEntities.STEEL_PIPE.get();
+    }
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/pipes/pumps/SteelPumpBlock.java

@@ -0,0 +1,37 @@
+/*
+package com.drmangotea.tfmg.content.machines.pipes.pumps;
+
+import com.drmangotea.createindustry.registry.CIBlockEntities;
+import com.simibubi.create.content.fluids.pump.PumpBlock;
+import com.simibubi.create.content.fluids.pump.PumpBlockEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class SteelPumpBlock extends PumpBlock {
+    public SteelPumpBlock(Properties p_i48415_1_) {
+        super(p_i48415_1_);
+    }
+
+
+    @Override
+    public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource r) {
+        super.tick(state,world,pos,r);
+        this.getBlockEntity(world,pos).updatePressureChange();
+
+    }
+
+    @Override
+    public Class<PumpBlockEntity> getBlockEntityClass() {
+        return PumpBlockEntity.class;
+    }
+
+    @Override
+    public BlockEntityType<? extends PumpBlockEntity> getBlockEntityType() {
+        return CIBlockEntities.STEEL_PUMP.get();
+    }
+}
+
+ */

src/main/java/com/drmangotea/tfmg/content/machines/pipes/pumps/SteelPumpTileEntity.java

@@ -0,0 +1,13 @@
+package com.drmangotea.tfmg.content.machines.pipes.pumps;
+
+
+import com.simibubi.create.content.fluids.pump.PumpBlockEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class SteelPumpTileEntity extends PumpBlockEntity {
+    public SteelPumpTileEntity(BlockEntityType<?> typeIn, BlockPos pos, BlockState state) {
+        super(typeIn, pos, state);
+    }
+}

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelFluidTankModel.java

@@ -0,0 +1,89 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+
+import com.drmangotea.tfmg.base.TFMGSpriteShifts;
+import com.simibubi.create.api.connectivity.ConnectivityHandler;
+import com.simibubi.create.content.fluids.tank.FluidTankCTBehaviour;
+import com.simibubi.create.foundation.block.connected.CTModel;
+import com.simibubi.create.foundation.block.connected.CTSpriteShiftEntry;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.model.data.ModelData;
+import net.minecraftforge.client.model.data.ModelProperty;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class SteelFluidTankModel extends CTModel {
+
+    protected static final ModelProperty<CullData> CULL_PROPERTY = new ModelProperty<>();
+
+    public static SteelFluidTankModel standard(BakedModel originalModel) {
+        return new SteelFluidTankModel(originalModel, TFMGSpriteShifts.STEEL_FLUID_TANK, TFMGSpriteShifts.STEEL_FLUID_TANK_TOP,
+                TFMGSpriteShifts.STEEL_FLUID_TANK_INNER);
+    }
+
+
+    private SteelFluidTankModel(BakedModel originalModel, CTSpriteShiftEntry side, CTSpriteShiftEntry top,
+                           CTSpriteShiftEntry inner) {
+        super(originalModel, new FluidTankCTBehaviour(side, top, inner));
+    }
+
+    @Override
+    protected ModelData.Builder gatherModelData(ModelData.Builder builder, BlockAndTintGetter world, BlockPos pos, BlockState state,
+                                                ModelData blockEntityData) {
+        super.gatherModelData(builder, world, pos, state, blockEntityData);
+        CullData cullData = new CullData();
+        for (Direction d : Iterate.horizontalDirections)
+            cullData.setCulled(d, ConnectivityHandler.isConnected(world, pos, pos.relative(d)));
+        return builder.with(CULL_PROPERTY, cullData);
+    }
+
+    @Override
+    public List<BakedQuad> getQuads(BlockState state, Direction side, RandomSource rand, ModelData extraData, RenderType renderType) {
+        if (side != null)
+            return Collections.emptyList();
+
+        List<BakedQuad> quads = new ArrayList<>();
+        for (Direction d : Iterate.directions) {
+            if (extraData.has(CULL_PROPERTY) && extraData.get(CULL_PROPERTY)
+                    .isCulled(d))
+                continue;
+            quads.addAll(super.getQuads(state, d, rand, extraData, renderType));
+        }
+        quads.addAll(super.getQuads(state, null, rand, extraData, renderType));
+        return quads;
+    }
+    private class CullData {
+        boolean[] culledFaces;
+
+        public CullData() {
+            culledFaces = new boolean[4];
+            Arrays.fill(culledFaces, false);
+        }
+
+        void setCulled(Direction face, boolean cull) {
+            if (face.getAxis()
+                    .isVertical())
+                return;
+            culledFaces[face.get2DDataValue()] = cull;
+        }
+
+        boolean isCulled(Direction face) {
+            if (face.getAxis()
+                    .isVertical())
+                return false;
+            return culledFaces[face.get2DDataValue()];
+        }
+    }
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelFluidTankRenderer.java

@@ -0,0 +1,119 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+
+import com.jozufozu.flywheel.util.transform.TransformStack;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.simibubi.create.AllPartialModels;
+import com.simibubi.create.foundation.blockEntity.renderer.SafeBlockEntityRenderer;
+import com.simibubi.create.foundation.fluid.FluidRenderer;
+import com.simibubi.create.foundation.render.CachedBufferer;
+import com.simibubi.create.foundation.utility.Iterate;
+import com.simibubi.create.foundation.utility.animation.LerpedFloat;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
+import net.minecraft.core.Direction;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+
+public class SteelFluidTankRenderer extends SafeBlockEntityRenderer<SteelTankBlockEntity> {
+
+    public SteelFluidTankRenderer(BlockEntityRendererProvider.Context context) {}
+
+    @Override
+    protected void renderSafe(SteelTankBlockEntity te, float partialTicks, PoseStack ms, MultiBufferSource buffer,
+                              int light, int overlay) {
+        if (!te.isController())
+            return;
+        if (!te.window) {
+            ////  if (te.tower.isActive())
+            ////    renderAsBoiler(te, partialTicks, ms, buffer, light, overlay);
+            return;
+        }
+
+        LerpedFloat fluidLevel = te.getFluidLevel();
+        if (fluidLevel == null)
+            return;
+
+        float capHeight = 1 / 4f;
+        float tankHullWidth = 1 / 16f + 1 / 128f;
+        float minPuddleHeight = 1 / 16f;
+        float totalHeight = te.height - 2 * capHeight - minPuddleHeight;
+
+        float level = fluidLevel.getValue(partialTicks);
+        if (level < 1 / (512f * totalHeight))
+            return;
+        float clampedLevel = Mth.clamp(level * totalHeight, 0, totalHeight);
+
+        FluidTank tank = te.tankInventory;
+        FluidStack fluidStack = tank.getFluid();
+
+        if (fluidStack.isEmpty())
+            return;
+
+        boolean top = fluidStack.getFluid()
+                .getFluidType()
+                .isLighterThanAir();
+
+        float xMin = tankHullWidth;
+        float xMax = xMin + te.width - 2 * tankHullWidth;
+        float yMin = totalHeight + capHeight + minPuddleHeight - clampedLevel;
+        float yMax = yMin + clampedLevel;
+
+        if (top) {
+            yMin += totalHeight - clampedLevel;
+            yMax += totalHeight - clampedLevel;
+        }
+
+        float zMin = tankHullWidth;
+        float zMax = zMin + te.width - 2 * tankHullWidth;
+
+        ms.pushPose();
+        ms.translate(0, clampedLevel - totalHeight, 0);
+        FluidRenderer.renderFluidBox(fluidStack, xMin, yMin, zMin, xMax, yMax, zMax, buffer, ms, light, false);
+        ms.popPose();
+    }
+
+    protected void renderAsBoiler(SteelTankBlockEntity te, float partialTicks, PoseStack ms, MultiBufferSource buffer,
+                                  int light, int overlay) {
+        BlockState blockState = te.getBlockState();
+        VertexConsumer vb = buffer.getBuffer(RenderType.solid());
+        ms.pushPose();
+        TransformStack msr = TransformStack.cast(ms);
+        msr.translate(te.width / 2f, 0.5, te.width / 2f);
+
+        float dialPivot = 5.75f / 16;
+        //// float progress = te.tower.gauge.getValue(partialTicks);
+
+        for (Direction d : Iterate.horizontalDirections) {
+            ms.pushPose();
+         ////   CachedBufferer.partial(CIPartialModels.TOWER_GAUGE, blockState)
+         ////           .rotateY(d.toYRot())
+         ////           .unCentre()
+         ////           .translate(te.width / 2f - 6 / 16f, 0, 0)
+         ////           .light(light)
+         ////           .renderInto(ms, vb);
+            CachedBufferer.partial(AllPartialModels.BOILER_GAUGE_DIAL, blockState)
+                    .rotateY(d.toYRot())
+                    .unCentre()
+                    .translate(te.width / 2f - 6 / 16f, 0, 0)
+                    .translate(0, dialPivot, dialPivot)
+                    .rotateX(-te.visualGaugeRotation.getValue(partialTicks))
+                    .translate(0, -dialPivot, -dialPivot)
+                    .light(light)
+                    .renderInto(ms, vb);
+            ms.popPose();
+        }
+
+        ms.popPose();
+    }
+
+    @Override
+    public boolean shouldRenderOffScreen(SteelTankBlockEntity te) {
+        return te.isController();
+    }
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelTankBlock.java

@@ -0,0 +1,351 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+
+import com.drmangotea.tfmg.registry.TFMGBlockEntities;
+import com.simibubi.create.api.connectivity.ConnectivityHandler;
+import com.simibubi.create.content.equipment.wrench.IWrenchable;
+import com.simibubi.create.content.fluids.transfer.GenericItemEmptying;
+import com.simibubi.create.content.fluids.transfer.GenericItemFilling;
+import com.simibubi.create.foundation.block.IBE;
+import com.simibubi.create.foundation.blockEntity.ComparatorUtil;
+import com.simibubi.create.foundation.fluid.FluidHelper;
+import com.simibubi.create.foundation.fluid.FluidHelper.FluidExchange;
+import com.simibubi.create.foundation.utility.Lang;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.particles.BlockParticleOption;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.Mth;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Mirror;
+import net.minecraft.world.level.block.Rotation;
+import net.minecraft.world.level.block.SoundType;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition.Builder;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+import net.minecraftforge.common.util.ForgeSoundType;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+
+public class SteelTankBlock extends Block implements IWrenchable, IBE<SteelTankBlockEntity> {
+
+        public static final BooleanProperty TOP = BooleanProperty.create("top");
+        public static final BooleanProperty BOTTOM = BooleanProperty.create("bottom");
+        public static final EnumProperty<Shape> SHAPE = EnumProperty.create("shape", Shape.class);
+
+        private boolean creative;
+
+        public static SteelTankBlock regular(Properties p_i48440_1_) {
+            return new SteelTankBlock(p_i48440_1_, false);
+        }
+
+        public static SteelTankBlock creative(Properties p_i48440_1_) {
+            return new SteelTankBlock(p_i48440_1_, true);
+        }
+
+
+
+        protected SteelTankBlock(Properties p_i48440_1_, boolean creative) {
+            super(p_i48440_1_);
+            this.creative = creative;
+            registerDefaultState(defaultBlockState().setValue(TOP, true)
+                    .setValue(BOTTOM, true)
+                    .setValue(SHAPE, Shape.WINDOW));
+        }
+
+        public static boolean isTank(BlockState state) {
+            return state.getBlock() instanceof SteelTankBlock;
+        }
+
+        @Override
+        public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean moved) {
+            if (oldState.getBlock() == state.getBlock())
+                return;
+            if (moved)
+                return;
+            withBlockEntityDo(world, pos, SteelTankBlockEntity::updateConnectivity);
+        }
+
+        @Override
+        protected void createBlockStateDefinition(Builder<Block, BlockState> p_206840_1_) {
+            p_206840_1_.add(TOP, BOTTOM, SHAPE);
+        }
+
+        @Override
+        public int getLightEmission(BlockState state, BlockGetter world, BlockPos pos) {
+            SteelTankBlockEntity tankAt = ConnectivityHandler.partAt(getBlockEntityType(), world, pos);
+            if (tankAt == null)
+                return 0;
+            SteelTankBlockEntity controllerTE = (SteelTankBlockEntity) tankAt.getControllerBE();
+            if (controllerTE == null || !controllerTE.window)
+                return 0;
+            return tankAt.luminosity;
+        }
+
+        @Override
+        public InteractionResult onWrenched(BlockState state, UseOnContext context) {
+            withBlockEntityDo(context.getLevel(), context.getClickedPos(), SteelTankBlockEntity::toggleWindows);
+            return InteractionResult.SUCCESS;
+        }
+
+        static final VoxelShape CAMPFIRE_SMOKE_CLIP = Block.box(0, 4, 0, 16, 16, 16);
+
+        @Override
+        public VoxelShape getCollisionShape(BlockState pState, BlockGetter pLevel, BlockPos pPos,
+                                            CollisionContext pContext) {
+            if (pContext == CollisionContext.empty())
+                return CAMPFIRE_SMOKE_CLIP;
+            return pState.getShape(pLevel, pPos);
+        }
+
+        @Override
+        public VoxelShape getBlockSupportShape(BlockState pState, BlockGetter pReader, BlockPos pPos) {
+            return Shapes.block();
+        }
+
+        @Override
+        public BlockState updateShape(BlockState pState, Direction pDirection, BlockState pNeighborState,
+                                      LevelAccessor pLevel, BlockPos pCurrentPos, BlockPos pNeighborPos) {
+            if (pDirection == Direction.DOWN && pNeighborState.getBlock() != this)
+                withBlockEntityDo(pLevel, pCurrentPos, SteelTankBlockEntity::updateBoilerTemperature);
+            return pState;
+        }
+
+        @Override
+        public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand,
+                                     BlockHitResult ray) {
+            ItemStack heldItem = player.getItemInHand(hand);
+            boolean onClient = world.isClientSide;
+
+            if (heldItem.isEmpty())
+                return InteractionResult.PASS;
+            if (!player.isCreative() && !creative)
+                return InteractionResult.PASS;
+
+            FluidExchange exchange = null;
+            SteelTankBlockEntity te = ConnectivityHandler.partAt(getBlockEntityType(), world, pos);
+            if (te == null)
+                return InteractionResult.FAIL;
+
+            LazyOptional<IFluidHandler> tankCapability = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY);
+            if (!tankCapability.isPresent())
+                return InteractionResult.PASS;
+            IFluidHandler fluidTank = tankCapability.orElse(null);
+            FluidStack prevFluidInTank = fluidTank.getFluidInTank(0)
+                    .copy();
+
+            if (FluidHelper.tryEmptyItemIntoBE(world, player, hand, heldItem, te))
+                exchange = FluidExchange.ITEM_TO_TANK;
+            else if (FluidHelper.tryFillItemFromBE(world, player, hand, heldItem, te))
+                exchange = FluidExchange.TANK_TO_ITEM;
+
+            if (exchange == null) {
+                if (GenericItemEmptying.canItemBeEmptied(world, heldItem)
+                        || GenericItemFilling.canItemBeFilled(world, heldItem))
+                    return InteractionResult.SUCCESS;
+                return InteractionResult.PASS;
+            }
+
+            SoundEvent soundevent = null;
+            BlockState fluidState = null;
+            FluidStack fluidInTank = tankCapability.map(fh -> fh.getFluidInTank(0))
+                    .orElse(FluidStack.EMPTY);
+
+            if (exchange == FluidExchange.ITEM_TO_TANK) {
+
+
+                Fluid fluid = fluidInTank.getFluid();
+                fluidState = fluid.defaultFluidState()
+                        .createLegacyBlock();
+                soundevent = FluidHelper.getEmptySound(fluidInTank);
+            }
+
+            if (exchange == FluidExchange.TANK_TO_ITEM) {
+
+                Fluid fluid = prevFluidInTank.getFluid();
+                fluidState = fluid.defaultFluidState()
+                        .createLegacyBlock();
+                soundevent = FluidHelper.getFillSound(prevFluidInTank);
+            }
+
+            if (soundevent != null && !onClient) {
+                float pitch = Mth
+                        .clamp(1 - (1f * fluidInTank.getAmount() / (SteelTankBlockEntity.getCapacityMultiplier() * 16)), 0, 1);
+                pitch /= 1.5f;
+                pitch += .5f;
+                pitch += (world.random.nextFloat() - .5f) / 4f;
+                world.playSound(null, pos, soundevent, SoundSource.BLOCKS, .5f, pitch);
+            }
+
+            if (!fluidInTank.isFluidStackIdentical(prevFluidInTank)) {
+                if (te instanceof SteelTankBlockEntity) {
+                    SteelTankBlockEntity controllerTE = (SteelTankBlockEntity) ((SteelTankBlockEntity) te).getControllerBE();
+                    if (controllerTE != null) {
+                        if (fluidState != null && onClient) {
+                            BlockParticleOption blockParticleData =
+                                    new BlockParticleOption(ParticleTypes.BLOCK, fluidState);
+                            float level = (float) fluidInTank.getAmount() / fluidTank.getTankCapacity(0);
+
+                            boolean reversed = fluidInTank.getFluid()
+                                    .getFluidType()
+                                    .isLighterThanAir();
+                            if (reversed)
+                                level = 1 - level;
+
+                            Vec3 vec = ray.getLocation();
+                            vec = new Vec3(vec.x, controllerTE.getBlockPos()
+                                    .getY() + level * (controllerTE.height - .5f) + .25f, vec.z);
+                            Vec3 motion = player.position()
+                                    .subtract(vec)
+                                    .scale(1 / 20f);
+                            vec = vec.add(motion);
+                            world.addParticle(blockParticleData, vec.x, vec.y, vec.z, motion.x, motion.y, motion.z);
+                            return InteractionResult.SUCCESS;
+                        }
+
+                        controllerTE.sendDataImmediately();
+                        controllerTE.setChanged();
+                    }
+                }
+            }
+
+            return InteractionResult.SUCCESS;
+        }
+
+        @Override
+        public void onRemove(BlockState state, Level world, BlockPos pos, BlockState newState, boolean isMoving) {
+            if (state.hasBlockEntity() && (state.getBlock() != newState.getBlock() || !newState.hasBlockEntity())) {
+                BlockEntity te = world.getBlockEntity(pos);
+                if (!(te instanceof SteelTankBlockEntity))
+                    return;
+                SteelTankBlockEntity tankTE = (SteelTankBlockEntity) te;
+                world.removeBlockEntity(pos);
+                ConnectivityHandler.splitMulti(tankTE);
+            }
+        }
+
+        @Override
+        public Class<SteelTankBlockEntity> getBlockEntityClass() {
+            return SteelTankBlockEntity.class;
+        }
+
+        @Override
+        public BlockEntityType<? extends SteelTankBlockEntity> getBlockEntityType() {
+            return creative ? TFMGBlockEntities.STEEL_FLUID_TANK.get() : TFMGBlockEntities.STEEL_FLUID_TANK.get();
+        }
+
+        @Override
+        public BlockState mirror(BlockState state, Mirror mirror) {
+            if (mirror == Mirror.NONE)
+                return state;
+            boolean x = mirror == Mirror.FRONT_BACK;
+            switch (state.getValue(SHAPE)) {
+                case WINDOW_NE:
+                    return state.setValue(SHAPE, x ? Shape.WINDOW_NW : Shape.WINDOW_SE);
+                case WINDOW_NW:
+                    return state.setValue(SHAPE, x ? Shape.WINDOW_NE : Shape.WINDOW_SW);
+                case WINDOW_SE:
+                    return state.setValue(SHAPE, x ? Shape.WINDOW_SW : Shape.WINDOW_NE);
+                case WINDOW_SW:
+                    return state.setValue(SHAPE, x ? Shape.WINDOW_SE : Shape.WINDOW_NW);
+                default:
+                    return state;
+            }
+        }
+
+        @Override
+        public BlockState rotate(BlockState state, Rotation rotation) {
+            for (int i = 0; i < rotation.ordinal(); i++)
+                state = rotateOnce(state);
+            return state;
+        }
+
+        private BlockState rotateOnce(BlockState state) {
+            switch (state.getValue(SHAPE)) {
+                case WINDOW_NE:
+                    return state.setValue(SHAPE, Shape.WINDOW_SE);
+                case WINDOW_NW:
+                    return state.setValue(SHAPE, Shape.WINDOW_NE);
+                case WINDOW_SE:
+                    return state.setValue(SHAPE, Shape.WINDOW_SW);
+                case WINDOW_SW:
+                    return state.setValue(SHAPE, Shape.WINDOW_NW);
+                default:
+                    return state;
+            }
+        }
+
+        public enum Shape implements StringRepresentable {
+            PLAIN, WINDOW, WINDOW_NW, WINDOW_SW, WINDOW_NE, WINDOW_SE;
+
+            @Override
+            public String getSerializedName() {
+                return Lang.asId(name());
+            }
+        }
+
+        // Tanks are less noisy when placed in batch
+        public static final SoundType SILENCED_METAL =
+                new ForgeSoundType(0.1F, 1.5F, () -> SoundEvents.METAL_BREAK, () -> SoundEvents.METAL_STEP,
+                        () -> SoundEvents.METAL_PLACE, () -> SoundEvents.METAL_HIT, () -> SoundEvents.METAL_FALL);
+
+        @Override
+        public SoundType getSoundType(BlockState state, LevelReader world, BlockPos pos, Entity entity) {
+            SoundType soundType = super.getSoundType(state, world, pos, entity);
+            if (entity != null && entity.getPersistentData()
+                    .contains("SilenceTankSound"))
+                return SILENCED_METAL;
+            return soundType;
+        }
+
+        @Override
+        public boolean hasAnalogOutputSignal(BlockState state) {
+            return true;
+        }
+
+        @Override
+        public int getAnalogOutputSignal(BlockState blockState, Level worldIn, BlockPos pos) {
+            return getBlockEntityOptional(worldIn, pos).map(SteelTankBlockEntity::getControllerBE)
+                    .map(te -> ComparatorUtil.fractionToRedstoneLevel(te.getFillState()))
+                    .orElse(0);
+        }
+
+        public static void updateTowerState(BlockState pState, Level pLevel, BlockPos tankPos) {
+            BlockState tankState = pLevel.getBlockState(tankPos);
+            if (!(tankState.getBlock()instanceof SteelTankBlock tank))
+                return;
+            SteelTankBlockEntity tankTE = tank.getBlockEntity(pLevel, tankPos);
+            if (tankTE == null)
+                return;
+            SteelTankBlockEntity controllerTE = (SteelTankBlockEntity) tankTE.getControllerBE();
+            if (controllerTE == null)
+                return;
+            controllerTE.updateBoilerState();
+        }
+
+    }

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelTankBlockEntity.java

@@ -0,0 +1,656 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+
+import com.simibubi.create.api.connectivity.ConnectivityHandler;
+import com.simibubi.create.content.equipment.goggles.IHaveGoggleInformation;
+import com.simibubi.create.content.fluids.tank.FluidTankBlockEntity;
+import com.simibubi.create.foundation.blockEntity.IMultiBlockEntityContainer;
+import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
+import com.simibubi.create.foundation.fluid.SmartFluidTank;
+import com.simibubi.create.foundation.utility.animation.LerpedFloat;
+import com.simibubi.create.foundation.utility.animation.LerpedFloat.Chaser;
+import com.simibubi.create.infrastructure.config.AllConfigs;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
+import com.drmangotea.tfmg.content.machines.tanks.SteelTankBlock.Shape;
+import net.minecraft.nbt.NbtUtils;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidType;
+import net.minecraftforge.fluids.IFluidTank;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+
+import static java.lang.Math.abs;
+
+public class SteelTankBlockEntity extends FluidTankBlockEntity implements IHaveGoggleInformation, IMultiBlockEntityContainer.Fluid {
+
+    private static final int MAX_SIZE = 3;
+
+    protected LazyOptional<IFluidHandler> fluidCapability;
+    protected boolean forceFluidLevelUpdate;
+    public FluidTank tankInventory;
+    protected BlockPos controller;
+    protected BlockPos lastKnownPos;
+    protected boolean updateConnectivity;
+    public boolean window;
+    public int luminosity;
+    public int width;
+    public int height;
+    public int gaugeRotation=0;
+
+
+    ////public DistillationTowerData tower;
+
+    private static final int SYNC_RATE = 8;
+    protected int syncCooldown;
+    protected boolean queuedSync;
+
+    // For rendering purposes only
+    private LerpedFloat fluidLevel;
+    public LerpedFloat visualGaugeRotation =LerpedFloat.angular();;
+
+    public SteelTankBlockEntity(BlockEntityType<?> type, BlockPos pos, BlockState state) {
+        super(type, pos, state);
+        tankInventory = createInventory();
+        fluidCapability = LazyOptional.of(() -> tankInventory);
+        forceFluidLevelUpdate = true;
+        updateConnectivity = false;
+        window = true;
+        height = 1;
+        width = 1;
+        ////// tower = new DistillationTowerData();
+        refreshCapability();
+    }
+
+
+
+    protected SmartFluidTank createInventory() {
+        return new SmartFluidTank(getCapacityMultiplier(), this::onFluidStackChanged);
+    }
+
+    public void updateConnectivity() {
+        updateConnectivity = false;
+        if (level.isClientSide)
+            return;
+        if (!isController())
+            return;
+        ConnectivityHandler.formMulti(this);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        getGaugeRotation();
+
+        visualGaugeRotation.chase(gaugeRotation, 0.2f, Chaser.EXP);
+        visualGaugeRotation.tickChaser();
+        if (syncCooldown > 0) {
+            syncCooldown--;
+            if (syncCooldown == 0 && queuedSync)
+                sendData();
+        }
+
+        if (lastKnownPos == null)
+            lastKnownPos = getBlockPos();
+        else if (!lastKnownPos.equals(worldPosition) && worldPosition != null) {
+            onPositionChanged();
+            return;
+        }
+
+        if (updateConnectivity)
+            updateConnectivity();
+        if (fluidLevel != null)
+            fluidLevel.tickChaser();
+       //// if (isController())
+       ////     tower.tick(this);
+    }
+
+    @Override
+    public BlockPos getLastKnownPos() {
+        return lastKnownPos;
+    }
+
+    @Override
+    public boolean isController() {
+        return controller == null || worldPosition.getX() == controller.getX()
+                && worldPosition.getY() == controller.getY() && worldPosition.getZ() == controller.getZ();
+    }
+
+    @Override
+    public void initialize() {
+        super.initialize();
+        sendData();
+        if (level.isClientSide)
+            invalidateRenderBoundingBox();
+    }
+
+    private void onPositionChanged() {
+        removeController(true);
+        lastKnownPos = worldPosition;
+    }
+
+    protected void onFluidStackChanged(FluidStack newFluidStack) {
+        if (!hasLevel())
+            return;
+
+        FluidType attributes = newFluidStack.getFluid()
+                .getFluidType();
+        int luminosity = (int) (attributes.getLightLevel(newFluidStack) / 1.2f);
+        boolean reversed = attributes.isLighterThanAir();
+        int maxY = (int) ((getFillState() * height) + 1);
+
+        for (int yOffset = 0; yOffset < height; yOffset++) {
+            boolean isBright = reversed ? (height - yOffset <= maxY) : (yOffset < maxY);
+            int actualLuminosity = isBright ? luminosity : luminosity > 0 ? 1 : 0;
+
+            for (int xOffset = 0; xOffset < width; xOffset++) {
+                for (int zOffset = 0; zOffset < width; zOffset++) {
+                    BlockPos pos = this.worldPosition.offset(xOffset, yOffset, zOffset);
+                    SteelTankBlockEntity tankAt = ConnectivityHandler.partAt(getType(), level, pos);
+                    if (tankAt == null)
+                        continue;
+                    level.updateNeighbourForOutputSignal(pos, tankAt.getBlockState()
+                            .getBlock());
+                    if (tankAt.luminosity == actualLuminosity)
+                        continue;
+                    tankAt.setLuminosity(actualLuminosity);
+                }
+            }
+        }
+
+        if (!level.isClientSide) {
+            setChanged();
+            sendData();
+        }
+
+        if (isVirtual()) {
+            if (fluidLevel == null)
+                fluidLevel = LerpedFloat.linear()
+                        .startWithValue(getFillState());
+            fluidLevel.chase(getFillState(), .5f, Chaser.EXP);
+        }
+    }
+
+    protected void setLuminosity(int luminosity) {
+        if (level.isClientSide)
+            return;
+        if (this.luminosity == luminosity)
+            return;
+        this.luminosity = luminosity;
+        sendData();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public SteelTankBlockEntity getControllerBE() {
+        if (isController())
+            return this;
+        BlockEntity tileEntity = level.getBlockEntity(controller);
+        if (tileEntity instanceof SteelTankBlockEntity)
+            return (SteelTankBlockEntity) tileEntity;
+        return null;
+    }
+
+    public void applyFluidTankSize(int blocks) {
+        tankInventory.setCapacity(blocks * getCapacityMultiplier());
+        int overflow = tankInventory.getFluidAmount() - tankInventory.getCapacity();
+        if (overflow > 0)
+            tankInventory.drain(overflow, FluidAction.EXECUTE);
+        forceFluidLevelUpdate = true;
+    }
+
+    public void removeController(boolean keepFluids) {
+        if (level.isClientSide)
+            return;
+        updateConnectivity = true;
+        if (!keepFluids)
+            applyFluidTankSize(1);
+        controller = null;
+        width = 1;
+        height = 1;
+        ////    tower.clear();
+        onFluidStackChanged(tankInventory.getFluid());
+
+        BlockState state = getBlockState();
+        if (SteelTankBlock.isTank(state)) {
+            state = state.setValue(SteelTankBlock.BOTTOM, true);
+            state = state.setValue(SteelTankBlock.TOP, true);
+            state = state.setValue(SteelTankBlock.SHAPE, window ? SteelTankBlock.Shape.WINDOW : SteelTankBlock.Shape.PLAIN);
+            getLevel().setBlock(worldPosition, state, 22);
+        }
+
+        refreshCapability();
+        setChanged();
+        sendData();
+    }
+
+    public void toggleWindows() {
+        SteelTankBlockEntity te = getControllerBE();
+        if (te == null)
+            return;
+       //// if (te.tower.isActive())
+       ////     return;
+        te.setWindows(!te.window);
+    }
+
+    public void updateBoilerTemperature() {
+        SteelTankBlockEntity te = getControllerBE();
+        if (te == null)
+            return;
+     ////   if (!te.tower.isActive())
+     ////       return;
+        //// te.tower.needsHeatLevelUpdate = true;
+    }
+
+    public void sendDataImmediately() {
+        syncCooldown = 0;
+        queuedSync = false;
+        sendData();
+    }
+
+    @Override
+    public void sendData() {
+        if (syncCooldown > 0) {
+            queuedSync = true;
+            return;
+        }
+        super.sendData();
+        queuedSync = false;
+        syncCooldown = SYNC_RATE;
+    }
+
+    public void setWindows(boolean window) {
+        this.window = window;
+        for (int yOffset = 0; yOffset < height; yOffset++) {
+            for (int xOffset = 0; xOffset < width; xOffset++) {
+                for (int zOffset = 0; zOffset < width; zOffset++) {
+
+                    BlockPos pos = this.worldPosition.offset(xOffset, yOffset, zOffset);
+                    BlockState blockState = level.getBlockState(pos);
+                    if (!SteelTankBlock.isTank(blockState))
+                        continue;
+
+                    Shape shape = Shape.PLAIN;
+                    if (window) {
+                        // SIZE 1: Every tank has a window
+                        if (width == 1)
+                            shape = Shape.WINDOW;
+                        // SIZE 2: Every tank has a corner window
+                        if (width == 2)
+                            shape = xOffset == 0 ? zOffset == 0 ? Shape.WINDOW_NW : Shape.WINDOW_SW
+                                    : zOffset == 0 ? Shape.WINDOW_NE : Shape.WINDOW_SE;
+                        // SIZE 3: Tanks in the center have a window
+                        if (width == 3 && abs(abs(xOffset) - abs(zOffset)) == 1)
+                            shape = Shape.WINDOW;
+                    }
+
+                    level.setBlock(pos, blockState.setValue(SteelTankBlock.SHAPE, shape), 22);
+                    level.getChunkSource()
+                            .getLightEngine()
+                            .checkBlock(pos);
+                }
+            }
+        }
+    }
+
+    public void updateBoilerState() {
+        if (!isController())
+            return;
+
+      ////  boolean wasBoiler = tower.isActive();
+      ////  boolean changed = tower.evaluate(this);
+
+    ////   if (wasBoiler != tower.isActive()) {
+    ////     ////  if (tower.isActive())
+    ////     ////      setWindows(false);
+
+    ////       for (int yOffset = 0; yOffset < height; yOffset++)
+    ////           for (int xOffset = 0; xOffset < width; xOffset++)
+    ////               for (int zOffset = 0; zOffset < width; zOffset++)
+    ////                   if (level.getBlockEntity(
+    ////                           worldPosition.offset(xOffset, yOffset, zOffset))instanceof SteelTankBlockEntity fte)
+    ////                       fte.refreshCapability();
+    ////   }
+
+   ///    if (changed) {
+   ///        notifyUpdate();
+
+   ///    }
+    }
+
+    @Override
+    public void setController(BlockPos controller) {
+        if (level.isClientSide && !isVirtual())
+            return;
+        if (controller.equals(this.controller))
+            return;
+        this.controller = controller;
+        refreshCapability();
+        setChanged();
+        sendData();
+    }
+
+    private void refreshCapability() {
+        LazyOptional<IFluidHandler> oldCap = fluidCapability;
+        fluidCapability = LazyOptional.of(() -> handlerForCapability());
+        oldCap.invalidate();
+    }
+
+    private IFluidHandler handlerForCapability() {
+
+        return tankInventory;////isController()
+               ////? tower.isActive()
+               ////? tower.createHandler()
+
+               ////: tankInventory
+               ////: getControllerBE() != null ? getControllerBE().handlerForCapability()
+               ////: new FluidTank(0);
+    }
+
+    @Override
+    public BlockPos getController() {
+        return isController() ? worldPosition : controller;
+    }
+
+    @Override
+    protected AABB createRenderBoundingBox() {
+        if (isController())
+            return super.createRenderBoundingBox().expandTowards(width - 1, height - 1, width - 1);
+        else
+            return super.createRenderBoundingBox();
+    }
+
+    @Nullable
+    public SteelTankBlockEntity getOtherFluidTankTileEntity(Direction direction) {
+        BlockEntity otherTE = level.getBlockEntity(worldPosition.relative(direction));
+        if (otherTE instanceof SteelTankBlockEntity)
+            return (SteelTankBlockEntity) otherTE;
+        return null;
+    }
+
+    @Override
+    public boolean addToGoggleTooltip(List<Component> tooltip, boolean isPlayerSneaking) {
+        SteelTankBlockEntity controllerTE = getControllerBE();
+        if (controllerTE == null)
+            return false;
+       /////// if (controllerTE.tower.addToGoggleTooltip(tooltip, isPlayerSneaking, controllerTE.getTotalTankSize()))
+       ///////     return true;
+        return containedFluidTooltip(tooltip, isPlayerSneaking,
+                controllerTE.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY));
+    }
+
+    @Override
+    protected void read(CompoundTag compound, boolean clientPacket) {
+        super.read(compound, clientPacket);
+
+        BlockPos controllerBefore = controller;
+        int prevSize = width;
+        int prevHeight = height;
+        int prevLum = luminosity;
+
+        updateConnectivity = compound.contains("Uninitialized");
+        luminosity = compound.getInt("Luminosity");
+        controller = null;
+        lastKnownPos = null;
+
+        if (compound.contains("LastKnownPos"))
+            lastKnownPos = NbtUtils.readBlockPos(compound.getCompound("LastKnownPos"));
+        if (compound.contains("Controller"))
+            controller = NbtUtils.readBlockPos(compound.getCompound("Controller"));
+
+        if (isController()) {
+            window = compound.getBoolean("Window");
+            width = compound.getInt("Size");
+            height = compound.getInt("Height");
+            tankInventory.setCapacity(getTotalTankSize() * getCapacityMultiplier());
+            tankInventory.readFromNBT(compound.getCompound("TankContent"));
+            if (tankInventory.getSpace() < 0)
+                tankInventory.drain(-tankInventory.getSpace(), FluidAction.EXECUTE);
+        }
+
+      ///// tower.read(compound.getCompound("Boiler"), width * width * height);
+
+        if (compound.contains("ForceFluidLevel") || fluidLevel == null)
+            fluidLevel = LerpedFloat.linear()
+                    .startWithValue(getFillState());
+
+        if (!clientPacket)
+            return;
+
+        boolean changeOfController =
+                controllerBefore == null ? controller != null : !controllerBefore.equals(controller);
+        if (changeOfController || prevSize != width || prevHeight != height) {
+            if (hasLevel())
+                level.sendBlockUpdated(getBlockPos(), getBlockState(), getBlockState(), 16);
+            if (isController())
+                tankInventory.setCapacity(getCapacityMultiplier() * getTotalTankSize());
+            invalidateRenderBoundingBox();
+        }
+        if (isController()) {
+            float fillState = getFillState();
+            if (compound.contains("ForceFluidLevel") || fluidLevel == null)
+                fluidLevel = LerpedFloat.linear()
+                        .startWithValue(fillState);
+            fluidLevel.chase(fillState, 0.5f, Chaser.EXP);
+        }
+        if (luminosity != prevLum && hasLevel())
+            level.getChunkSource()
+                    .getLightEngine()
+                    .checkBlock(worldPosition);
+
+        if (compound.contains("LazySync"))
+            fluidLevel.chase(fluidLevel.getChaseTarget(), 0.125f, Chaser.EXP);
+    }
+    public void getGaugeRotation(){
+      ////// int level=tower.towerLevel;
+
+      ////// if(level>=13){
+      //////     gaugeRotation=90;
+      ////// } else
+      ////// if(level>=4){
+      //////     gaugeRotation=45;
+      ////// } else{
+      //////     gaugeRotation=0;
+      ////// }
+
+
+    }
+    public float getFillState() {
+        return (float) tankInventory.getFluidAmount() / tankInventory.getCapacity();
+    }
+
+    @Override
+    public void write(CompoundTag compound, boolean clientPacket) {
+
+        if (updateConnectivity)
+            compound.putBoolean("Uninitialized", true);
+      ///////  compound.put("Boiler", tower.write());
+        if (lastKnownPos != null)
+            compound.put("LastKnownPos", NbtUtils.writeBlockPos(lastKnownPos));
+        if (!isController())
+            compound.put("Controller", NbtUtils.writeBlockPos(controller));
+        if (isController()) {
+            compound.putBoolean("Window", window);
+            compound.put("TankContent", tankInventory.writeToNBT(new CompoundTag()));
+            compound.putInt("Size", width);
+            compound.putInt("Height", height);
+        }
+        compound.putInt("Luminosity", luminosity);
+       // super.write(compound, clientPacket);
+        //super.saveAdditional(compound);
+
+        forEachBehaviour(tb -> tb.write(compound, clientPacket));
+
+        if (!clientPacket)
+            return;
+        if (forceFluidLevelUpdate)
+            compound.putBoolean("ForceFluidLevel", true);
+        if (queuedSync)
+            compound.putBoolean("LazySync", true);
+        forceFluidLevelUpdate = false;
+    }
+
+    @Nonnull
+    @Override
+    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
+        if (!fluidCapability.isPresent())
+            refreshCapability();
+        if (cap == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
+            return fluidCapability.cast();
+        return super.getCapability(cap, side);
+    }
+
+
+
+    @Override
+    public void addBehaviours(List<BlockEntityBehaviour> behaviours) {
+        //registerAwardables(behaviours, AllAdvancements.STEAM_ENGINE_MAXED, AllAdvancements.PIPE_ORGAN);
+    }
+
+    public IFluidTank getTankInventory() {
+        return tankInventory;
+    }
+
+    public int getTotalTankSize() {
+        return width * width * height;
+    }
+
+    public static int getMaxSize() {
+        return MAX_SIZE;
+    }
+
+    public static int getCapacityMultiplier() {
+        return AllConfigs.server().fluids.fluidTankCapacity.get() * 1000;
+    }
+
+    public static int getMaxHeight() {
+        return AllConfigs.server().fluids.fluidTankMaxHeight.get();
+    }
+
+    public LerpedFloat getFluidLevel() {
+        return fluidLevel;
+    }
+
+    public void setFluidLevel(LerpedFloat fluidLevel) {
+        this.fluidLevel = fluidLevel;
+    }
+
+    @Override
+    public void preventConnectivityUpdate() {
+        updateConnectivity = false;
+    }
+
+    @Override
+    public void notifyMultiUpdated() {
+        BlockState state = this.getBlockState();
+        if (SteelTankBlock.isTank(state)) { // safety
+            state = state.setValue(SteelTankBlock.BOTTOM, getController().getY() == getBlockPos().getY());
+            state = state.setValue(SteelTankBlock.TOP, getController().getY() + height - 1 == getBlockPos().getY());
+            level.setBlock(getBlockPos(), state, 6);
+        }
+        if (isController())
+            setWindows(window);
+        onFluidStackChanged(tankInventory.getFluid());
+        updateBoilerState();
+        setChanged();
+    }
+
+    @Override
+    public void setExtraData(@Nullable Object data) {
+        if (data instanceof Boolean)
+            window = (boolean) data;
+    }
+
+    @Override
+    @Nullable
+    public Object getExtraData() {
+        return window;
+    }
+
+    @Override
+    public Object modifyExtraData(Object data) {
+        if (data instanceof Boolean windows) {
+            windows |= window;
+            return windows;
+        }
+        return data;
+    }
+
+    @Override
+    public Direction.Axis getMainConnectionAxis() {
+        return Direction.Axis.Y;
+    }
+
+    @Override
+    public int getMaxLength(Direction.Axis longAxis, int width) {
+        if (longAxis == Direction.Axis.Y)
+            return getMaxHeight();
+        return getMaxWidth();
+    }
+
+    @Override
+    public int getMaxWidth() {
+        return MAX_SIZE;
+    }
+
+    @Override
+    public int getHeight() {
+        return height;
+    }
+
+    @Override
+    public void setHeight(int height) {
+        this.height = height;
+    }
+
+    @Override
+    public int getWidth() {
+        return width;
+    }
+
+    @Override
+    public void setWidth(int width) {
+        this.width = width;
+    }
+
+    @Override
+    public boolean hasTank() {
+        return true;
+    }
+
+    @Override
+    public int getTankSize(int tank) {
+        return getCapacityMultiplier();
+    }
+
+    @Override
+    public void setTankSize(int tank, int blocks) {
+        applyFluidTankSize(blocks);
+    }
+
+    @Override
+    public IFluidTank getTank(int tank) {
+        return tankInventory;
+    }
+
+    @Override
+    public FluidStack getFluid(int tank) {
+        return tankInventory.getFluid()
+                .copy();
+    }
+}
+

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelTankGenerator.java

@@ -0,0 +1,63 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+import com.simibubi.create.foundation.data.AssetLookup;
+import com.simibubi.create.foundation.data.SpecialBlockStateGen;
+import com.tterrag.registrate.providers.DataGenContext;
+import com.tterrag.registrate.providers.RegistrateBlockstateProvider;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.model.generators.ModelFile;
+
+public class SteelTankGenerator extends SpecialBlockStateGen {
+
+    private String prefix;
+
+    public SteelTankGenerator() {
+        this("");
+    }
+
+    public SteelTankGenerator(String prefix) {
+        this.prefix = prefix;
+    }
+
+    @Override
+    protected int getXRotation(BlockState state) {
+        return 0;
+    }
+
+    @Override
+    protected int getYRotation(BlockState state) {
+        return 0;
+    }
+
+    @Override
+    public <T extends Block> ModelFile getModel(DataGenContext<Block, T> ctx, RegistrateBlockstateProvider prov,
+                                                BlockState state) {
+        Boolean top = state.getValue(SteelTankBlock.TOP);
+        Boolean bottom = state.getValue(SteelTankBlock.BOTTOM);
+        SteelTankBlock.Shape shape = state.getValue(SteelTankBlock.SHAPE);
+
+        String shapeName = "middle";
+        if (top && bottom)
+            shapeName = "single";
+        else if (top)
+            shapeName = "top";
+        else if (bottom)
+            shapeName = "bottom";
+
+        String modelName = shapeName + (shape == SteelTankBlock.Shape.PLAIN ? "" : "_" + shape.getSerializedName());
+
+        if (!prefix.isEmpty())
+            return prov.models()
+                    .withExistingParent(prefix + modelName, prov.modLoc("block/fluid_tank/block_" + modelName))
+                    .texture("0", prov.modLoc("block/" + prefix + "casing"))
+                    .texture("1", prov.modLoc("block/" + prefix + "fluid_tank"))
+                    .texture("3", prov.modLoc("block/" + prefix + "fluid_tank_window"))
+                    .texture("4", prov.modLoc("block/" + prefix + "casing"))
+                    .texture("5", prov.modLoc("block/" + prefix + "fluid_tank_window_single"))
+                    .texture("particle", prov.modLoc("block/" + prefix + "steel_fluid_tank"));
+
+        return AssetLookup.partialBaseModel(ctx, prov, modelName);
+    }
+
+}

src/main/java/com/drmangotea/tfmg/content/machines/tanks/SteelTankItem.java

@@ -0,0 +1,133 @@
+package com.drmangotea.tfmg.content.machines.tanks;
+
+
+import com.drmangotea.tfmg.registry.TFMGBlockEntities;
+import com.simibubi.create.api.connectivity.ConnectivityHandler;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.fluids.FluidStack;
+
+public class SteelTankItem extends BlockItem {
+
+    public SteelTankItem(Block p_i48527_1_, Properties p_i48527_2_) {
+        super(p_i48527_1_, p_i48527_2_);
+    }
+
+    @Override
+    public InteractionResult place(BlockPlaceContext ctx) {
+        InteractionResult initialResult = super.place(ctx);
+        if (!initialResult.consumesAction())
+            return initialResult;
+        tryMultiPlace(ctx);
+        return initialResult;
+    }
+
+    @Override
+    protected boolean updateCustomBlockEntityTag(BlockPos p_195943_1_, Level p_195943_2_, Player p_195943_3_,
+                                                 ItemStack p_195943_4_, BlockState p_195943_5_) {
+        MinecraftServer minecraftserver = p_195943_2_.getServer();
+        if (minecraftserver == null)
+            return false;
+        CompoundTag nbt = p_195943_4_.getTagElement("BlockEntityTag");
+        if (nbt != null) {
+            nbt.remove("Luminosity");
+            nbt.remove("Size");
+            nbt.remove("Height");
+            nbt.remove("Controller");
+            nbt.remove("LastKnownPos");
+            if (nbt.contains("TankContent")) {
+                FluidStack fluid = FluidStack.loadFluidStackFromNBT(nbt.getCompound("TankContent"));
+                if (!fluid.isEmpty()) {
+                    fluid.setAmount(Math.min(SteelTankBlockEntity.getCapacityMultiplier(), fluid.getAmount()));
+                    nbt.put("TankContent", fluid.writeToNBT(new CompoundTag()));
+                }
+            }
+        }
+        return super.updateCustomBlockEntityTag(p_195943_1_, p_195943_2_, p_195943_3_, p_195943_4_, p_195943_5_);
+    }
+
+    private void tryMultiPlace(BlockPlaceContext ctx) {
+
+        Player player = ctx.getPlayer();
+        if (player == null)
+            return;
+        if (player.isShiftKeyDown())
+            return;
+        Direction face = ctx.getClickedFace();
+        if (!face.getAxis()
+                .isVertical())
+            return;
+        ItemStack stack = ctx.getItemInHand();
+        Level world = ctx.getLevel();
+        BlockPos pos = ctx.getClickedPos();
+        BlockPos placedOnPos = pos.relative(face.getOpposite());
+        BlockState placedOnState = world.getBlockState(placedOnPos);
+
+        if (!SteelTankBlock.isTank(placedOnState))
+            return;
+
+        SteelTankBlockEntity tankAt = ConnectivityHandler.partAt(
+                TFMGBlockEntities.STEEL_FLUID_TANK.get(), world, placedOnPos
+        );
+        if (tankAt == null)
+            return;
+        SteelTankBlockEntity controllerTE = (SteelTankBlockEntity) tankAt.getControllerBE();
+        if (controllerTE == null)
+            return;
+
+        int width = controllerTE.width;
+        if (width == 1)
+            return;
+
+        int tanksToPlace = 0;
+        BlockPos startPos = face == Direction.DOWN ? controllerTE.getBlockPos()
+                .below()
+                : controllerTE.getBlockPos()
+                .above(controllerTE.height);
+
+        if (startPos.getY() != pos.getY())
+            return;
+
+        for (int xOffset = 0; xOffset < width; xOffset++) {
+            for (int zOffset = 0; zOffset < width; zOffset++) {
+                BlockPos offsetPos = startPos.offset(xOffset, 0, zOffset);
+                BlockState blockState = world.getBlockState(offsetPos);
+                if (SteelTankBlock.isTank(blockState))
+                    continue;
+                if (!blockState.getMaterial()
+                        .isReplaceable())
+                    return;
+                tanksToPlace++;
+            }
+        }
+
+        if (!player.isCreative() && stack.getCount() < tanksToPlace)
+            return;
+
+        for (int xOffset = 0; xOffset < width; xOffset++) {
+            for (int zOffset = 0; zOffset < width; zOffset++) {
+                BlockPos offsetPos = startPos.offset(xOffset, 0, zOffset);
+                BlockState blockState = world.getBlockState(offsetPos);
+                if (SteelTankBlock.isTank(blockState))
+                    continue;
+                BlockPlaceContext context = BlockPlaceContext.at(ctx, offsetPos, face);
+                player.getPersistentData()
+                        .putBoolean("SilenceTankSound", true);
+                super.place(context);
+                player.getPersistentData()
+                        .remove("SilenceTankSound");
+            }
+        }
+    }
+
+}

src/main/java/com/drmangotea/tfmg/mixins/AllOreFeatureConfigEntriesMixin.java

@@ -24,6 +24,9 @@ import org.spongepowered.asm.mixin.Shadow;
 import java.util.HashMap;
 import java.util.Map;
 
+ /**
+ * really goofy way to do worldgen but it works
+ */
 @Mixin(AllOreFeatureConfigEntries.class)
 public class AllOreFeatureConfigEntriesMixin {
 

src/main/java/com/drmangotea/tfmg/mixins/FluidPipeBlockMixin.java

@@ -0,0 +1,371 @@
+package com.drmangotea.tfmg.mixins;
+
+import com.drmangotea.tfmg.CreateTFMG;
+import com.drmangotea.tfmg.content.machines.pipes.normal.LockablePipeBlockEntity;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.simibubi.create.AllBlockEntityTypes;
+import com.simibubi.create.AllBlocks;
+import com.simibubi.create.content.contraptions.ITransformableBlock;
+import com.simibubi.create.content.contraptions.StructureTransform;
+import com.simibubi.create.content.decoration.bracket.BracketedBlockEntityBehaviour;
+import com.simibubi.create.content.decoration.encasing.EncasableBlock;
+import com.simibubi.create.content.equipment.wrench.IWrenchableWithBracket;
+import com.simibubi.create.content.fluids.FluidPropagator;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.*;
+import com.simibubi.create.foundation.advancement.AdvancementBehaviour;
+import com.simibubi.create.foundation.advancement.AllAdvancements;
+import com.simibubi.create.foundation.block.IBE;
+import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
+import com.simibubi.create.foundation.utility.Iterate;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Direction.Axis;
+import net.minecraft.network.protocol.game.DebugPackets;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.BlockAndTintGetter;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition.Builder;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.Fluids;
+import net.minecraft.world.level.pathfinder.PathComputationType;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.VoxelShape;
+import net.minecraft.world.ticks.TickPriority;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Optional;
+@Mixin(FluidPipeBlock.class)
+public class FluidPipeBlockMixin extends PipeBlock implements SimpleWaterloggedBlock, IWrenchableWithBracket,
+	IBE<FluidPipeBlockEntity>, EncasableBlock, ITransformableBlock {
+
+	private static final VoxelShape OCCLUSION_BOX = Block.box(4, 4, 4, 12, 12, 12);
+
+	public FluidPipeBlockMixin(Properties properties) {
+		super(4 / 16f, properties);
+		this.registerDefaultState(super.defaultBlockState().setValue(BlockStateProperties.WATERLOGGED, false));
+	}
+
+	@Override
+	public InteractionResult onWrenched(BlockState state, UseOnContext context) {
+		if (tryRemoveBracket(context))
+			return InteractionResult.SUCCESS;
+
+		Level world = context.getLevel();
+		BlockPos pos = context.getClickedPos();
+		Direction clickedFace = context.getClickedFace();
+
+		Axis axis = getAxis(world, pos, state);
+		if (axis == null) {
+			Vec3 clickLocation = context.getClickLocation()
+				.subtract(pos.getX(), pos.getY(), pos.getZ());
+			double closest = Float.MAX_VALUE;
+			Direction argClosest = Direction.UP;
+			for (Direction direction : Iterate.directions) {
+				if (clickedFace.getAxis() == direction.getAxis())
+					continue;
+				Vec3 centerOf = Vec3.atCenterOf(direction.getNormal());
+				double distance = centerOf.distanceToSqr(clickLocation);
+				if (distance < closest) {
+					closest = distance;
+					argClosest = direction;
+				}
+			}
+			axis = argClosest.getAxis();
+		}
+
+		if (clickedFace.getAxis() == axis)
+			return InteractionResult.PASS;
+		if (!world.isClientSide) {
+			withBlockEntityDo(world, pos, fpte -> fpte.getBehaviour(FluidTransportBehaviour.TYPE).interfaces.values()
+				.stream()
+				.filter(pc -> pc != null && pc.hasFlow())
+				.findAny()
+				.ifPresent($ -> AllAdvancements.GLASS_PIPE.awardTo(context.getPlayer())));
+
+			FluidTransportBehaviour.cacheFlows(world, pos);
+			world.setBlockAndUpdate(pos, AllBlocks.GLASS_FLUID_PIPE.getDefaultState()
+				.setValue(GlassFluidPipeBlock.AXIS, axis)
+				.setValue(BlockStateProperties.WATERLOGGED, state.getValue(BlockStateProperties.WATERLOGGED)));
+			FluidTransportBehaviour.loadFlows(world, pos);
+		}
+		return InteractionResult.SUCCESS;
+	}
+
+	@Override
+	public void setPlacedBy(Level pLevel, BlockPos pPos, BlockState pState, LivingEntity pPlacer, ItemStack pStack) {
+		super.setPlacedBy(pLevel, pPos, pState, pPlacer, pStack);
+		AdvancementBehaviour.setPlacedBy(pLevel, pPos, pPlacer);
+	}
+
+	@Override
+	public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand,
+		BlockHitResult ray) {
+		ItemStack heldItem = player.getItemInHand(hand);
+		InteractionResult result = tryEncase(state, world, pos, heldItem, player, hand, ray);
+		if (result.consumesAction())
+			return result;
+
+		return InteractionResult.PASS;
+	}
+
+	public BlockState getAxisState(Axis axis) {
+		BlockState defaultState = defaultBlockState();
+		for (Direction d : Iterate.directions)
+			defaultState = defaultState.setValue(PROPERTY_BY_DIRECTION.get(d), d.getAxis() == axis);
+		return defaultState;
+	}
+
+	@Nullable
+	private Axis getAxis(BlockGetter world, BlockPos pos, BlockState state) {
+		return FluidPropagator.getStraightPipeAxis(state);
+	}
+
+	@Override
+	public void onRemove(BlockState state, Level world, BlockPos pos, BlockState newState, boolean isMoving) {
+		boolean blockTypeChanged = state.getBlock() != newState.getBlock();
+		if (blockTypeChanged && !world.isClientSide)
+			FluidPropagator.propagateChangedPipe(world, pos, state);
+		if (state != newState && !isMoving)
+			removeBracket(world, pos, true).ifPresent(stack -> Block.popResource(world, pos, stack));
+		if (state.hasBlockEntity() && (blockTypeChanged || !newState.hasBlockEntity()))
+			world.removeBlockEntity(pos);
+	}
+
+	@Override
+	public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean isMoving) {
+		if (world.isClientSide)
+			return;
+		if (state != oldState)
+			world.scheduleTick(pos, this, 1, TickPriority.HIGH);
+	}
+
+	@Override
+	public void neighborChanged(BlockState state, Level world, BlockPos pos, Block otherBlock, BlockPos neighborPos,
+		boolean isMoving) {
+		DebugPackets.sendNeighborsUpdatePacket(world, pos);
+		Direction d = FluidPropagator.validateNeighbourChange(state, world, pos, otherBlock, neighborPos, isMoving);
+		if (d == null)
+			return;
+		if (!isOpenAt(state, d))
+			return;
+		world.scheduleTick(pos, this, 1, TickPriority.HIGH);
+	}
+
+	@Override
+	public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource r) {
+		FluidPropagator.propagateChangedPipe(world, pos, state);
+	}
+	@Shadow
+	public static boolean isPipe(BlockState state) {
+		return state.getBlock() instanceof FluidPipeBlockMixin;
+	}
+	@Shadow
+	public static boolean canConnectTo(BlockAndTintGetter world, BlockPos neighbourPos, BlockState neighbour,
+		Direction direction) {
+		if (FluidPropagator.hasFluidCapability(world, neighbourPos, direction.getOpposite()))
+			return true;
+		if (VanillaFluidTargets.shouldPipesConnectTo(neighbour))
+			return true;
+		FluidTransportBehaviour transport = BlockEntityBehaviour.get(world, neighbourPos, FluidTransportBehaviour.TYPE);
+		BracketedBlockEntityBehaviour bracket =
+			BlockEntityBehaviour.get(world, neighbourPos, BracketedBlockEntityBehaviour.TYPE);
+		if (isPipe(neighbour))
+			return bracket == null || !bracket.isBracketPresent()
+				|| FluidPropagator.getStraightPipeAxis(neighbour) == direction.getAxis();
+		if (transport == null)
+			return false;
+		return transport.canHaveFlowToward(neighbour, direction.getOpposite());
+	}
+	@Shadow
+	public static boolean shouldDrawRim(BlockAndTintGetter world, BlockPos pos, BlockState state, Direction direction) {
+		BlockPos offsetPos = pos.relative(direction);
+		BlockState facingState = world.getBlockState(offsetPos);
+		if (facingState.getBlock() instanceof EncasedPipeBlock)
+			return true;
+		if (!isPipe(facingState))
+			return true;
+		if (!canConnectTo(world, offsetPos, facingState, direction))
+			return true;
+		return false;
+	}
+	@Shadow
+	public static boolean isOpenAt(BlockState state, Direction direction) {
+		return state.getValue(PROPERTY_BY_DIRECTION.get(direction));
+	}
+	@Shadow
+	public static boolean isCornerOrEndPipe(BlockAndTintGetter world, BlockPos pos, BlockState state) {
+		return isPipe(state) && FluidPropagator.getStraightPipeAxis(state) == null
+			&& !shouldDrawCasing(world, pos, state);
+	}
+	@Shadow
+	public static boolean shouldDrawCasing(BlockAndTintGetter world, BlockPos pos, BlockState state) {
+		if (!isPipe(state))
+			return false;
+		for (Axis axis : Iterate.axes) {
+			int connections = 0;
+			for (Direction direction : Iterate.directions)
+				if (direction.getAxis() != axis && isOpenAt(state, direction))
+					connections++;
+			if (connections > 2)
+				return true;
+		}
+		return false;
+	}
+
+	@Override
+	protected void createBlockStateDefinition(Builder<Block, BlockState> builder) {
+		builder.add(NORTH, EAST, SOUTH, WEST, UP, DOWN, BlockStateProperties.WATERLOGGED);
+		super.createBlockStateDefinition(builder);
+	}
+
+	@Override
+	public BlockState getStateForPlacement(BlockPlaceContext context) {
+		FluidState FluidState = context.getLevel()
+			.getFluidState(context.getClickedPos());
+		return updateBlockState(defaultBlockState(), context.getNearestLookingDirection(), null, context.getLevel(),
+			context.getClickedPos()).setValue(BlockStateProperties.WATERLOGGED,
+				Boolean.valueOf(FluidState.getType() == Fluids.WATER));
+	}
+
+	@Override
+	public BlockState updateShape(BlockState state, Direction direction, BlockState neighbourState, LevelAccessor world,
+		BlockPos pos, BlockPos neighbourPos) {
+		if (state.getValue(BlockStateProperties.WATERLOGGED))
+			world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world));
+		if (isOpenAt(state, direction) && neighbourState.hasProperty(BlockStateProperties.WATERLOGGED))
+			world.scheduleTick(pos, this, 1, TickPriority.HIGH);
+		return updateBlockState(state, direction, direction.getOpposite(), world, pos);
+	}
+	/**
+	 * @author DrMangoTea
+	 * @reason locked pipes
+	 */
+	@Overwrite( remap = false)
+	public BlockState updateBlockState(BlockState state, Direction preferredDirection, @Nullable Direction ignore,
+		BlockAndTintGetter world, BlockPos pos) {
+		CreateTFMG.LOGGER.debug("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+		BracketedBlockEntityBehaviour bracket = BlockEntityBehaviour.get(world, pos, BracketedBlockEntityBehaviour.TYPE);
+		if (bracket != null && bracket.isBracketPresent())
+			return state;
+
+		BlockState prevState = state;
+		int prevStateSides = (int) Arrays.stream(Iterate.directions)
+			.map(PROPERTY_BY_DIRECTION::get)
+			.filter(prevState::getValue)
+			.count();
+
+		// Update sides that are not ignored
+		for (Direction d : Iterate.directions)
+			if (d != ignore) {
+				boolean shouldConnect = canConnectTo(world, pos.relative(d), world.getBlockState(pos.relative(d)), d);
+				if(world.getBlockEntity(pos.relative(d)) instanceof LockablePipeBlockEntity)
+					if(((LockablePipeBlockEntity)world.getBlockEntity(pos.relative(d))).locked) {
+						shouldConnect = false;
+						CreateTFMG.LOGGER.debug("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+					}
+
+				state = state.setValue(PROPERTY_BY_DIRECTION.get(d), shouldConnect);
+			}
+
+		// See if it has enough connections
+		Direction connectedDirection = null;
+		for (Direction d : Iterate.directions) {
+			if (isOpenAt(state, d)) {
+				if (connectedDirection != null)
+					return state;
+				connectedDirection = d;
+			}
+		}
+
+		// Add opposite end if only one connection
+		if (connectedDirection != null)
+			return state.setValue(PROPERTY_BY_DIRECTION.get(connectedDirection.getOpposite()), true);
+
+		// If we can't connect to anything and weren't connected before, do nothing
+		if (prevStateSides == 2)
+			return prevState;
+
+		// Use preferred
+		return state.setValue(PROPERTY_BY_DIRECTION.get(preferredDirection), true)
+			.setValue(PROPERTY_BY_DIRECTION.get(preferredDirection.getOpposite()), true);
+	}
+
+	@Override
+	public FluidState getFluidState(BlockState state) {
+		return state.getValue(BlockStateProperties.WATERLOGGED) ? Fluids.WATER.getSource(false)
+			: Fluids.EMPTY.defaultFluidState();
+	}
+
+	@Override
+	public Optional<ItemStack> removeBracket(BlockGetter world, BlockPos pos, boolean inOnReplacedContext) {
+		BracketedBlockEntityBehaviour behaviour =
+			BracketedBlockEntityBehaviour.get(world, pos, BracketedBlockEntityBehaviour.TYPE);
+		if (behaviour == null)
+			return Optional.empty();
+		BlockState bracket = behaviour.removeBracket(inOnReplacedContext);
+		if (bracket == null)
+			return Optional.empty();
+		return Optional.of(new ItemStack(bracket.getBlock()));
+	}
+
+	@Override
+	public boolean isPathfindable(BlockState state, BlockGetter reader, BlockPos pos, PathComputationType type) {
+		return false;
+	}
+
+	@Override
+	public Class<FluidPipeBlockEntity> getBlockEntityClass() {
+		return FluidPipeBlockEntity.class;
+	}
+
+	@Override
+	public BlockEntityType<? extends FluidPipeBlockEntity> getBlockEntityType() {
+		return AllBlockEntityTypes.FLUID_PIPE.get();
+	}
+
+	@Override
+	public boolean supportsExternalFaceHiding(BlockState state) {
+		return false;
+	}
+
+	@Override
+	public VoxelShape getOcclusionShape(BlockState pState, BlockGetter pLevel, BlockPos pPos) {
+		return OCCLUSION_BOX;
+	}
+
+	@Override
+	public BlockState rotate(BlockState pState, Rotation pRotation) {
+		return FluidPipeBlockRotation.rotate(pState, pRotation);
+	}
+
+	@Override
+	public BlockState mirror(BlockState pState, Mirror pMirror) {
+		return FluidPipeBlockRotation.mirror(pState, pMirror);
+	}
+
+	@Override
+	public BlockState transform(BlockState state, StructureTransform transform) {
+		return FluidPipeBlockRotation.transform(state, transform);
+	}
+
+}

src/main/java/com/drmangotea/tfmg/mixins/FluidPropagatorMixin.java

@@ -0,0 +1,191 @@
+package com.drmangotea.tfmg.mixins;
+
+
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.SteelPipeBlock;
+import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.simibubi.create.AllBlocks;
+import com.simibubi.create.AllTags;
+import com.simibubi.create.content.fluids.FluidPropagator;
+import com.simibubi.create.content.fluids.FluidTransportBehaviour;
+import com.simibubi.create.content.fluids.pipes.AxisPipeBlock;
+import com.simibubi.create.content.fluids.pipes.FluidPipeBlock;
+import com.simibubi.create.content.fluids.pipes.VanillaFluidTargets;
+import com.simibubi.create.content.fluids.pump.PumpBlock;
+import com.simibubi.create.content.fluids.pump.PumpBlockEntity;
+import com.simibubi.create.foundation.advancement.AllAdvancements;
+import com.simibubi.create.foundation.advancement.CreateAdvancement;
+import com.simibubi.create.foundation.blockEntity.behaviour.BlockEntityBehaviour;
+import com.simibubi.create.foundation.utility.BlockHelper;
+import com.simibubi.create.foundation.utility.Iterate;
+import com.simibubi.create.foundation.utility.Pair;
+import com.simibubi.create.infrastructure.config.AllConfigs;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@Mixin(FluidPropagator.class)
+public class FluidPropagatorMixin {
+    @Shadow
+    public static CreateAdvancement[] getSharedTriggers() {
+        return new CreateAdvancement[] { AllAdvancements.WATER_SUPPLY, AllAdvancements.CROSS_STREAMS,
+                AllAdvancements.HONEY_DRAIN };
+    }
+
+    /**
+     * @author DrMangoTea
+     * @reason Custom Pipes
+     */
+    @Overwrite( remap = false)
+    public static void propagateChangedPipe(LevelAccessor world, BlockPos pipePos, BlockState pipeState) {
+        List<Pair<Integer, BlockPos>> frontier = new ArrayList<>();
+        Set<BlockPos> visited = new HashSet<>();
+        Set<Pair<PumpBlockEntity, Direction>> discoveredPumps = new HashSet<>();
+
+        frontier.add(Pair.of(0, pipePos));
+
+
+        // Visit all connected pumps to update their network
+        while (!frontier.isEmpty()) {
+
+            Pair<Integer, BlockPos> pair = frontier.remove(0);
+            BlockPos currentPos = pair.getSecond();
+            if (visited.contains(currentPos))
+                continue;
+            visited.add(currentPos);
+            BlockState currentState = currentPos.equals(pipePos) ? pipeState : world.getBlockState(currentPos);
+            FluidTransportBehaviour pipe = getPipe(world, currentPos);
+            if (pipe == null)
+                continue;
+            pipe.wipePressure();
+
+            for (Direction direction : getPipeConnections(currentState, pipe)) {
+                BlockPos target = currentPos.relative(direction);
+                if (world instanceof Level l && !l.isLoaded(target))
+                    continue;
+
+                BlockEntity tileEntity = world.getBlockEntity(target);
+                BlockState targetState = world.getBlockState(target);
+                if (tileEntity instanceof PumpBlockEntity) {
+                    if (
+                            //!TFMGBlocks.STEEL_PUMP.has(targetState)&&
+                                    !AllBlocks.MECHANICAL_PUMP.has(targetState) || targetState.getValue(PumpBlock.FACING)
+                            .getAxis() != direction.getAxis())
+                        continue;
+                    discoveredPumps.add(Pair.of((PumpBlockEntity) tileEntity, direction.getOpposite()));
+                    continue;
+                }
+                if (visited.contains(target))
+                    continue;
+                FluidTransportBehaviour targetPipe = getPipe(world, target);
+                if (targetPipe == null)
+                    continue;
+                Integer distance = pair.getFirst();
+                if (distance >= getPumpRange() && !targetPipe.hasAnyPressure())
+                    continue;
+                if (targetPipe.canHaveFlowToward(targetState, direction.getOpposite()))
+                    frontier.add(Pair.of(distance + 1, target));
+            }
+        }
+
+        discoveredPumps.forEach(pair -> pair.getFirst()
+                .updatePipesOnSide(pair.getSecond()));
+    }
+
+    @Shadow
+    public static FluidTransportBehaviour getPipe(BlockGetter reader, BlockPos pos) {
+        return BlockEntityBehaviour.get(reader, pos, FluidTransportBehaviour.TYPE);
+    }
+    @Shadow
+    public static boolean isOpenEnd(BlockGetter reader, BlockPos pos, Direction side) {
+        BlockPos connectedPos = pos.relative(side);
+        BlockState connectedState = reader.getBlockState(connectedPos);
+        FluidTransportBehaviour pipe = FluidPropagator.getPipe(reader, connectedPos);
+        if (pipe != null && pipe.canHaveFlowToward(connectedState, side.getOpposite()))
+            return false;
+        if (PumpBlock.isPump(connectedState) && connectedState.getValue(PumpBlock.FACING)
+                .getAxis() == side.getAxis())
+            return false;
+        if (VanillaFluidTargets.shouldPipesConnectTo(connectedState))
+            return true;
+        if (BlockHelper.hasBlockSolidSide(connectedState, reader, connectedPos, side.getOpposite())
+                && !AllTags.AllBlockTags.FAN_TRANSPARENT.matches(connectedState))
+            return false;
+        if (hasFluidCapability(reader, connectedPos, side.getOpposite()))
+            return false;
+        if (!(connectedState.getMaterial()
+                .isReplaceable() && connectedState.getDestroySpeed(reader, connectedPos) != -1)
+                && !connectedState.hasProperty(BlockStateProperties.WATERLOGGED))
+            return false;
+        return true;
+    }
+    @Shadow
+    public static List<Direction> getPipeConnections(BlockState state, FluidTransportBehaviour pipe) {
+        List<Direction> list = new ArrayList<>();
+        for (Direction d : Iterate.directions)
+            if (pipe.canHaveFlowToward(state, d))
+                list.add(d);
+        return list;
+    }
+    @Shadow
+    public static int getPumpRange() {
+        return AllConfigs.server().fluids.mechanicalPumpRange.get();
+    }
+    @Shadow
+    public static boolean hasFluidCapability(BlockGetter world, BlockPos pos, Direction side) {
+        BlockEntity tileEntity = world.getBlockEntity(pos);
+        if (tileEntity == null)
+            return false;
+        LazyOptional<IFluidHandler> capability =
+                tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side);
+        return capability.isPresent();
+    }
+    @Shadow
+    @Nullable
+    public static Direction.Axis getStraightPipeAxis(BlockState state) {
+        if (state.getBlock() instanceof PumpBlock)
+            return state.getValue(PumpBlock.FACING)
+                    .getAxis();
+        if (state.getBlock() instanceof AxisPipeBlock)
+            return state.getValue(AxisPipeBlock.AXIS);
+        if (!FluidPipeBlock.isPipe(state))
+            return null;
+        Direction.Axis axisFound = null;
+        int connections = 0;
+        for (Direction.Axis axis : Iterate.axes) {
+            Direction d1 = Direction.get(Direction.AxisDirection.NEGATIVE, axis);
+            Direction d2 = Direction.get(Direction.AxisDirection.POSITIVE, axis);
+            boolean openAt1 = FluidPipeBlock.isOpenAt(state, d1);
+            boolean openAt2 = FluidPipeBlock.isOpenAt(state, d2);
+            if (openAt1)
+                connections++;
+            if (openAt2)
+                connections++;
+            if (openAt1 && openAt2)
+                if (axisFound != null)
+                    return null;
+                else
+                    axisFound = axis;
+        }
+        return connections == 2 ? axisFound : null;
+    }
+
+}

src/main/java/com/drmangotea/tfmg/registry/TFMGBlockEntities.java

@@ -1,20 +1,14 @@
 package com.drmangotea.tfmg.registry;
 
-import com.drmangotea.tfmg.CreateTFMG;
 import com.drmangotea.tfmg.content.concrete.formwork.FormWorkBlockEntity;
 import com.drmangotea.tfmg.content.concrete.formwork.FormWorkRenderer;
 import com.drmangotea.tfmg.content.deposits.FluidDepositTileEntity;
-import com.simibubi.create.content.fluids.pipes.FluidPipeBlockEntity;
+import com.drmangotea.tfmg.content.machines.pipes.normal.LockablePipeBlockEntity;
+import com.drmangotea.tfmg.content.machines.tanks.SteelFluidTankRenderer;
+import com.drmangotea.tfmg.content.machines.tanks.SteelTankBlockEntity;
+import com.simibubi.create.Create;
 import com.simibubi.create.content.fluids.pipes.StraightPipeBlockEntity;
 import com.simibubi.create.content.fluids.pipes.TransparentStraightPipeRenderer;
-import com.simibubi.create.content.fluids.pump.PumpBlockEntity;
-import com.simibubi.create.content.fluids.pump.PumpCogInstance;
-import com.simibubi.create.content.fluids.pump.PumpRenderer;
-import com.simibubi.create.content.kinetics.base.HalfShaftInstance;
-import com.simibubi.create.content.kinetics.base.HorizontalHalfShaftInstance;
-import com.simibubi.create.content.kinetics.simpleRelays.BracketedKineticBlockEntity;
-import com.simibubi.create.content.kinetics.simpleRelays.SimpleKineticBlockEntity;
-import com.simibubi.create.foundation.data.CreateRegistrate;
 import com.tterrag.registrate.util.entry.BlockEntityEntry;
 
 import static com.drmangotea.tfmg.CreateTFMG.REGISTRATE;
@@ -35,6 +29,32 @@ public class TFMGBlockEntities {
             .register();
 
 
+    public static final BlockEntityEntry<LockablePipeBlockEntity> STEEL_PIPE = REGISTRATE
+            .blockEntity("steel_pipe", LockablePipeBlockEntity::new)
+            .validBlocks(TFMGBlocks.STEEL_PIPE)
+            .register();
+
+    public static final BlockEntityEntry<LockablePipeBlockEntity> ENCASED_STEEL_PIPE = REGISTRATE
+            .blockEntity("encased_steel_pipe", LockablePipeBlockEntity::new)
+            .validBlocks(TFMGBlocks.COPPER_ENCASED_STEEL_PIPE)
+            .register();
+
+
+    public static final BlockEntityEntry<StraightPipeBlockEntity> GLASS_STEEL_PIPE = REGISTRATE
+            .blockEntity("glass_steel_pipe", StraightPipeBlockEntity::new)
+            .validBlocks(TFMGBlocks.GLASS_STEEL_PIPE)
+            .renderer(() -> TransparentStraightPipeRenderer::new)
+            .register();
+
+    public static final BlockEntityEntry<SteelTankBlockEntity> STEEL_FLUID_TANK = REGISTRATE
+            .blockEntity("steel_fluid_tank", SteelTankBlockEntity::new)
+            .validBlocks(TFMGBlocks.STEEL_FLUID_TANK)
+            .renderer(() -> SteelFluidTankRenderer::new)
+            .register();
+
+
+
+
 
     public static void register() {}
 }

src/main/java/com/drmangotea/tfmg/registry/TFMGBlocks.java

@@ -1,25 +1,40 @@
 package com.drmangotea.tfmg.registry;
 
-import com.drmangotea.tfmg.base.TFMGBuilderTransformers;
+import com.drmangotea.tfmg.base.TFMGBlockStateGen;
 import com.drmangotea.tfmg.base.TFMGSpriteShifts;
 import com.drmangotea.tfmg.content.concrete.formwork.FormWorkBlock;
 import com.drmangotea.tfmg.content.concrete.formwork.FormWorkGenerator;
 import com.drmangotea.tfmg.content.deposits.FluidDepositBlock;
 import com.drmangotea.tfmg.content.gadgets.explosives.napalm.NapalmBombBlock;
-import com.drmangotea.tfmg.content.gadgets.explosives.thermite_grenades.ThermiteGrenadeItem;
-import com.drmangotea.tfmg.content.items.TFMGFuelItem;
+import com.drmangotea.tfmg.content.items.CoalCokeBlockItem;
+import com.drmangotea.tfmg.content.items.FossilstoneItem;
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.EncasedSteelPipeBlock;
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.GlassSteelPipeBlock;
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.SteelPipeAttachmentModel;
+import com.drmangotea.tfmg.content.machines.pipes.normal.steel.SteelPipeBlock;
+import com.drmangotea.tfmg.content.machines.tanks.SteelFluidTankModel;
+import com.drmangotea.tfmg.content.machines.tanks.SteelTankBlock;
+import com.drmangotea.tfmg.content.machines.tanks.SteelTankGenerator;
+import com.drmangotea.tfmg.content.machines.tanks.SteelTankItem;
+import com.simibubi.create.AllBlocks;
+import com.simibubi.create.AllSpriteShifts;
 import com.simibubi.create.content.decoration.encasing.CasingBlock;
 import com.simibubi.create.content.decoration.encasing.EncasedCTBehaviour;
-import com.simibubi.create.content.logistics.chute.ChuteGenerator;
-import com.simibubi.create.foundation.data.BuilderTransformers;
+import com.simibubi.create.content.decoration.encasing.EncasingRegistry;
+
+import com.simibubi.create.foundation.data.*;
 import com.tterrag.registrate.util.entry.BlockEntry;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.core.Direction;
 import net.minecraft.tags.BlockTags;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.SoundType;
 import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
 import net.minecraft.world.level.material.Material;
 import net.minecraft.world.level.material.MaterialColor;
+import net.minecraftforge.client.model.generators.ConfiguredModel;
 import net.minecraftforge.common.Tags;
 
 
@@ -55,7 +70,7 @@ public class TFMGBlocks {
             .properties(p -> p.requiresCorrectToolForDrops())
             .transform(pickaxeOnly())
             .blockstate(simpleCubeAll("fossilstone"))
-            .item(TFMGFuelItem::fossilstone)
+            .item(FossilstoneItem::new)
             .build()
             .lang("Fossilstone")
             .register();
@@ -101,6 +116,72 @@ public class TFMGBlocks {
                     .register();
 
 
+    //pipes
+    public static final BlockEntry<SteelPipeBlock> STEEL_PIPE = REGISTRATE.block("steel_pipe", SteelPipeBlock::new)
+            .initialProperties(Material.HEAVY_METAL)
+            .transform(pickaxeOnly())
+            .blockstate(BlockStateGen.pipe())
+            .onRegister(CreateRegistrate.blockModel(() -> SteelPipeAttachmentModel::new))
+            .item()
+            .transform(customItemModel())
+            .register();
+
+    public static final BlockEntry<EncasedSteelPipeBlock> COPPER_ENCASED_STEEL_PIPE =
+            REGISTRATE.block("copper_encased_steel_pipe", p -> new EncasedSteelPipeBlock(p, AllBlocks.COPPER_CASING::get))
+                    .initialProperties(SharedProperties::copperMetal)
+                    .properties(p -> p.color(MaterialColor.TERRACOTTA_LIGHT_GRAY))
+                    .properties(BlockBehaviour.Properties::noOcclusion)
+                    .transform(axeOrPickaxe())
+                    .blockstate(BlockStateGen.encasedPipe())
+                    .onRegister(CreateRegistrate.connectedTextures(() -> new EncasedCTBehaviour(AllSpriteShifts.COPPER_CASING)))
+                    .onRegister(CreateRegistrate.casingConnectivity((block, cc) -> cc.make(block, AllSpriteShifts.COPPER_CASING,
+                            (s, f) -> !s.getValue(EncasedSteelPipeBlock.FACING_TO_PROPERTY_MAP.get(f)))))
+                    .onRegister(CreateRegistrate.blockModel(() -> SteelPipeAttachmentModel::new))
+                    .loot((p, b) -> p.dropOther(b, STEEL_PIPE.get()))
+                    .transform(EncasingRegistry.addVariantTo(TFMGBlocks.STEEL_PIPE))
+                    .register();
+
+
+    @SuppressWarnings("removal")
+    public static final BlockEntry<GlassSteelPipeBlock> GLASS_STEEL_PIPE =
+            REGISTRATE.block("glass_steel_pipe", GlassSteelPipeBlock::new)
+                    .initialProperties(SharedProperties::copperMetal)
+                    .addLayer(() -> RenderType::cutoutMipped)
+                    .transform(pickaxeOnly())
+                    .blockstate((c, p) -> {
+                        p.getVariantBuilder(c.getEntry())
+                                .forAllStatesExcept(state -> {
+                                    Direction.Axis axis = state.getValue(BlockStateProperties.AXIS);
+                                    return ConfiguredModel.builder()
+                                            .modelFile(p.models()
+                                                    .getExistingFile(p.modLoc("block/steel_pipe/window")))
+                                            .uvLock(false)
+                                            .rotationX(axis == Direction.Axis.Y ? 0 : 90)
+                                            .rotationY(axis == Direction.Axis.X ? 90 : 0)
+                                            .build();
+                                }, BlockStateProperties.WATERLOGGED);
+                    })
+                    .onRegister(CreateRegistrate.blockModel(() -> SteelPipeAttachmentModel::new))
+                    .loot((p, b) -> p.dropOther(b, STEEL_PIPE.get()))
+                    .register();
+    //
+
+
+    public static final BlockEntry<SteelTankBlock> STEEL_FLUID_TANK = REGISTRATE.block("steel_fluid_tank", SteelTankBlock::regular)
+            .initialProperties(SharedProperties::copperMetal)
+            .properties(BlockBehaviour.Properties::noOcclusion)
+            .properties(p -> p.isRedstoneConductor((p1, p2, p3) -> true))
+            .transform(pickaxeOnly())
+            .blockstate(new SteelTankGenerator()::generate)
+            .onRegister(CreateRegistrate.blockModel(() -> SteelFluidTankModel::standard))
+            .addLayer(() -> RenderType::cutoutMipped)
+            .item(SteelTankItem::new)
+            .model(AssetLookup.customBlockItemModel("_", "block_single_window"))
+            .build()
+            .register();
+    /////
+
+
 
 
     //-----------------------BUILDING BLOCKS---------------------------//
@@ -137,13 +218,62 @@ public class TFMGBlocks {
             .lang("Block of Cast Iron")
             .register();
 
+    public static final BlockEntry<Block> ALUMINUM_BLOCK = REGISTRATE.block("aluminum_block", Block::new)
+            .initialProperties(() -> Blocks.IRON_BLOCK)
+            .properties(p -> p.color(MaterialColor.COLOR_LIGHT_GRAY))
+            .properties(p -> p.requiresCorrectToolForDrops())
+            .onRegister(connectedTextures(() -> new EncasedCTBehaviour(TFMGSpriteShifts.CAST_IRON_BLOCK)))
+            .onRegister(casingConnectivity((block, cc) -> cc.makeCasing(block, TFMGSpriteShifts.CAST_IRON_BLOCK)))
+            .transform(pickaxeOnly())
+            .blockstate(simpleCubeAll("aluminum_block"))
+            .tag(BlockTags.NEEDS_IRON_TOOL)
+            .tag(Tags.Blocks.STORAGE_BLOCKS)
+            .tag(BlockTags.BEACON_BASE_BLOCKS)
+            .transform(tagBlockAndItem("storage_blocks/aluminum"))
+            .tag(Tags.Items.STORAGE_BLOCKS)
+            .build()
+            .lang("Block of Aluminum")
+            .register();
+
+    public static final BlockEntry<Block> LEAD_BLOCK = REGISTRATE.block("lead_block", Block::new)
+            .initialProperties(() -> Blocks.IRON_BLOCK)
+            .properties(p -> p.color(MaterialColor.COLOR_LIGHT_GRAY))
+            .properties(p -> p.requiresCorrectToolForDrops())
+            .onRegister(connectedTextures(() -> new EncasedCTBehaviour(TFMGSpriteShifts.CAST_IRON_BLOCK)))
+            .onRegister(casingConnectivity((block, cc) -> cc.makeCasing(block, TFMGSpriteShifts.CAST_IRON_BLOCK)))
+            .transform(pickaxeOnly())
+            .blockstate(simpleCubeAll("lead_block"))
+            .tag(BlockTags.NEEDS_IRON_TOOL)
+            .tag(Tags.Blocks.STORAGE_BLOCKS)
+            .tag(BlockTags.BEACON_BASE_BLOCKS)
+            .transform(tagBlockAndItem("storage_blocks/lead"))
+            .tag(Tags.Items.STORAGE_BLOCKS)
+            .build()
+            .lang("Block of Lead")
+            .register();
+
+
+    public static final BlockEntry<Block> COAL_COKE_BLOCK = REGISTRATE.block("coal_coke_block", Block::new)
+            .initialProperties(() -> Blocks.IRON_BLOCK)
+            .properties(p -> p.color(MaterialColor.COLOR_LIGHT_GRAY))
+            .properties(p -> p.requiresCorrectToolForDrops())
+            .transform(pickaxeOnly())
+            .blockstate(simpleCubeAll("coal_coke_block"))
+            .tag(BlockTags.NEEDS_STONE_TOOL)
+            .tag(Tags.Blocks.STORAGE_BLOCKS)
+            .item(CoalCokeBlockItem::new)
+            .tag(Tags.Items.STORAGE_BLOCKS)
+            .build()
+            .lang("Block of Coal Coke")
+            .register();
+
 
 
 
 
     //-----------------------CONCRETE---------------------------//
     static {
-        REGISTRATE.creativeModeTab(() -> TFMGCreativeModeTabs.TFMG_CONCRETE);
+        REGISTRATE.creativeModeTab(() -> TFMGCreativeModeTabs.TFMG_BUILDING_BLOCKS);
     }
     public static final BlockEntry<Block> CONCRETE = REGISTRATE.block("concrete", Block::new)
             .initialProperties(() -> Blocks.STONE)

src/main/java/com/drmangotea/tfmg/registry/TFMGCreativeModeTabs.java

@@ -1,15 +1,13 @@
 package com.drmangotea.tfmg.registry;
 
 import com.drmangotea.tfmg.base.creative_mode_tabs.BaseTFMGCreativeModeTab;
-import com.drmangotea.tfmg.base.creative_mode_tabs.ConcreteCreativeModeTab;
-import com.simibubi.create.content.decoration.palettes.PalettesCreativeModeTab;
-import com.simibubi.create.infrastructure.item.BaseCreativeModeTab;
+import com.drmangotea.tfmg.base.creative_mode_tabs.BuldingCreativeModeTab;
 import net.minecraft.world.item.CreativeModeTab;
 
 public class TFMGCreativeModeTabs {
 
         public static final CreativeModeTab TFMG_BASE = new BaseTFMGCreativeModeTab();
-        public static final CreativeModeTab TFMG_CONCRETE = new ConcreteCreativeModeTab();
+        public static final CreativeModeTab TFMG_BUILDING_BLOCKS = new BuldingCreativeModeTab();
 
         public static void init() {
         }

src/main/java/com/drmangotea/tfmg/registry/TFMGItems.java

@@ -2,10 +2,16 @@ package com.drmangotea.tfmg.registry;
 
 import com.drmangotea.tfmg.content.gadgets.explosives.thermite_grenades.ChemicalColor;
 import com.drmangotea.tfmg.content.gadgets.explosives.thermite_grenades.ThermiteGrenadeItem;
+import com.drmangotea.tfmg.content.items.CoalCokeItem;
+import com.drmangotea.tfmg.content.items.ScrewdriverItem;
 import com.tterrag.registrate.util.entry.ItemEntry;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.item.Item;
 
 import static com.drmangotea.tfmg.CreateTFMG.REGISTRATE;
 import static com.drmangotea.tfmg.content.gadgets.explosives.thermite_grenades.ChemicalColor.*;
+import static com.simibubi.create.AllTags.AllItemTags.CREATE_INGOTS;
+import static com.simibubi.create.AllTags.forgeItemTag;
 
 public class TFMGItems {
 
@@ -20,7 +26,30 @@ public class TFMGItems {
     public static final ItemEntry<ThermiteGrenadeItem>
             COPPER_GRENADE = thermiteGrenade("copper_grenade",BLUE);
 
+    public static final ItemEntry<Item>
+            STEEL_INGOT = taggedIngredient("steel_ingot", forgeItemTag("ingots/steel"), CREATE_INGOTS.tag),
+            CAST_IRON_INGOT = taggedIngredient("cast_iron_ingot", forgeItemTag("ingots/cast_iron"), CREATE_INGOTS.tag),
+            ALUMINUM_INGOT = taggedIngredient("aluminum_ingot", forgeItemTag("ingots/aluminum"), CREATE_INGOTS.tag),
+            LEAD_INGOT = taggedIngredient("lead_ingot", forgeItemTag("ingots/lead"), CREATE_INGOTS.tag);
+
+
+    public static final ItemEntry<CoalCokeItem> COAL_COKE = REGISTRATE.item("coal_coke", CoalCokeItem::new)
+            .register();
+
+    public static final ItemEntry<ScrewdriverItem> SCREWDRIVER = REGISTRATE.item("screwdriver", ScrewdriverItem::new)
+            .properties(p -> p.stacksTo(1)
+                    .durability(256))
+            .register();
+
 //////////////////////////
+
+    @SafeVarargs
+    private static ItemEntry<Item> taggedIngredient(String name, TagKey<Item>... tags) {
+        return REGISTRATE.item(name, Item::new)
+                .tag(tags)
+                .register();
+    }
+
     private static ItemEntry<ThermiteGrenadeItem> thermiteGrenade(String name, ChemicalColor color) {
         return REGISTRATE.item(name,  p -> new ThermiteGrenadeItem(p, color))
                 .register();

src/main/java/com/drmangotea/tfmg/registry/TFMGPaletteBlocks.java

@@ -26,7 +26,7 @@ import static com.simibubi.create.foundation.data.WindowGen.*;
 public class TFMGPaletteBlocks {
 
     static {
-        REGISTRATE.creativeModeTab(() -> TFMGCreativeModeTabs.TFMG_BASE);
+        REGISTRATE.creativeModeTab(() -> TFMGCreativeModeTabs.TFMG_BUILDING_BLOCKS);
     }
 
 

src/main/java/com/drmangotea/tfmg/registry/TFMGPartialModels.java

@@ -18,6 +18,7 @@ import java.util.Map;
 public class TFMGPartialModels {
 
         public static final PartialModel
+                STEEL_FLUID_PIPE_CASING = block("steel_pipe/casing"),
                 FORMWORK_BOTTOM = block("formwork_block/block_bottom"),
                 FORMWORK_SIDE = block("formwork_block/block_side");
 
@@ -28,11 +29,19 @@ public class TFMGPartialModels {
 
 
     static {
+    //   for (FluidTransportBehaviour.AttachmentTypes.ComponentPartials type : FluidTransportBehaviour.AttachmentTypes.ComponentPartials.values()) {
+    //       Map<Direction, PartialModel> map = new HashMap<>();
+    //       for (Direction d : Iterate.directions) {
+    //           String asId = Lang.asId(type.name());
+    //           map.put(d, block("steel_pipe/" + asId + "/" + Lang.asId(d.getSerializedName())));
+    //       }
+    //       STEEL_PIPE_ATTACHMENTS.put(type, map);
+    //   }
         for (FluidTransportBehaviour.AttachmentTypes.ComponentPartials type : FluidTransportBehaviour.AttachmentTypes.ComponentPartials.values()) {
             Map<Direction, PartialModel> map = new HashMap<>();
             for (Direction d : Iterate.directions) {
                 String asId = Lang.asId(type.name());
-                map.put(d, block("steel_fluid_pipe/" + asId + "/" + Lang.asId(d.getSerializedName())));
+                map.put(d, block("steel_pipe/" + asId + "/" + Lang.asId(d.getSerializedName())));
             }
             STEEL_PIPE_ATTACHMENTS.put(type, map);
         }

src/main/java/com/drmangotea/tfmg/registry/TFMGParticles.java

@@ -1,4 +0,0 @@
-package com.drmangotea.tfmg.registry;
-
-public class TFMGParticles {
-}

src/main/java/com/drmangotea/tfmg/worldgen/TFMGLayeredPatterns.java

@@ -2,6 +2,8 @@ package com.drmangotea.tfmg.worldgen;
 
 
 import com.drmangotea.tfmg.registry.TFMGBlocks;
+import com.drmangotea.tfmg.registry.TFMGPaletteBlocks;
+import com.drmangotea.tfmg.registry.TFMGPaletteStoneTypes;
 import com.simibubi.create.content.decoration.palettes.AllPaletteStoneTypes;
 import com.simibubi.create.infrastructure.worldgen.LayerPattern;
 import com.tterrag.registrate.util.nullness.NonNullSupplier;
@@ -15,7 +17,7 @@ public class TFMGLayeredPatterns {
 			.layer(l -> l.weight(1)
 					.passiveBlock())
 			.layer(l -> l.weight(2)
-					.block(TFMGBlocks.CONCRETE.get())
+					.block(TFMGPaletteStoneTypes.BAUXITE.getBaseBlock())
 					.size(1, 3))
 			.layer(l -> l.weight(1)
 					.block(Blocks.SMOOTH_BASALT)

src/main/resources/assets/tfmg/lang/default/interface.json

@@ -1,4 +1,4 @@
 {
   "itemGroup.tfmg.base": "Create: The Factory Must Grow",
-  "itemGroup.tfmg.concrete": "Create: TFMG's Concrete"
+  "itemGroup.tfmg.building": "Create: TFMG's Building Blocks"
 }

src/main/resources/assets/tfmg/models/block/copper_encased_steel_pipe/block_flat.json

@@ -0,0 +1,16 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "create:block/copper_casing",
+		"particle": "create:block/copper_casing"
+	},
+	"elements": [
+		{
+			"from": [0, 0, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"south": {"uv": [0, 0, 16, 16], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/copper_encased_steel_pipe/block_open.json

@@ -0,0 +1,16 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/copper_encased_steel_pipe",
+		"particle": "tfmg:block/copper_encased_steel_pipe"
+	},
+	"elements": [
+		{
+			"from": [0, 0, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"south": {"uv": [0, 0, 16, 16], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/casing.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 3, 3],
+			"to": [13, 13, 13],
+			"faces": {
+				"north": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"east": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"south": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"west": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"up": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"down": {"uv": [1, 11, 6, 16], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/down.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 0, 4],
+			"to": [12, 4, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 6, 4, 8], "texture": "#0"},
+				"east": {"uv": [0, 6, 4, 8], "texture": "#0"},
+				"south": {"uv": [4, 6, 0, 8], "texture": "#0"},
+				"west": {"uv": [4, 6, 0, 8], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/east.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [12, 4, 4],
+			"to": [16, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 0, 0, 2], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 6, 0, 8], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/north.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 0],
+			"to": [12, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 8, 0]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 6, 4, 8], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/south.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 12],
+			"to": [12, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 8, 0]},
+			"faces": {
+				"east": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 6, 4, 8], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/up.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 12, 4],
+			"to": [12, 16, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 2], "texture": "#0"},
+				"east": {"uv": [0, 0, 4, 2], "texture": "#0"},
+				"south": {"uv": [4, 0, 0, 2], "texture": "#0"},
+				"west": {"uv": [4, 0, 0, 2], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/connection/west.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [0, 4, 4],
+			"to": [4, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 6, 0, 8], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 0, 0, 2], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/core_x.json

@@ -0,0 +1,17 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes_connected",
+		"particle": "tfmg:block/steel_pipes_connected"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"east": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"},
+				"west": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/core_y.json

@@ -0,0 +1,17 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes_connected",
+		"particle": "tfmg:block/steel_pipes_connected"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"up": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/core_z.json

@@ -0,0 +1,17 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes_connected",
+		"particle": "tfmg:block/steel_pipes_connected"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"north": {"uv": [12, 8, 16, 12], "rotation": 180, "texture": "#0"},
+				"south": {"uv": [12, 8, 16, 12], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/down.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4.95, -3.95, 4.95],
+			"to": [11.05, -0.95, 11.05],
+			"rotation": {"angle": 0, "axis": "z", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [12, 8, 13.5, 11], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [12, 8, 13.5, 11], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [12, 8, 13.5, 11], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [12, 8, 13.5, 11], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [13, 8, 16, 11], "rotation": 90, "texture": "#0", "cullface": "down"}
+			}
+		},
+		{
+			"from": [2.95, -0.95, 2.95],
+			"to": [13.05, 2, 13.05],
+			"rotation": {"angle": 0, "axis": "z", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [9, 9.5, 4, 8], "texture": "#0"},
+				"east": {"uv": [4, 8, 9, 9.5], "rotation": 180, "texture": "#0"},
+				"south": {"uv": [4, 8, 9, 9.5], "rotation": 180, "texture": "#0"},
+				"west": {"uv": [9, 9.5, 4, 8], "texture": "#0"},
+				"up": {"uv": [6, 11, 11, 16], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [11, 11, 16, 16], "rotation": 90, "texture": "#0", "cullface": "down"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/east.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [16.95, 4.95, 4.95],
+			"to": [19.95, 11.05, 11.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [12, 8, 13.5, 11], "rotation": 180, "texture": "#0"},
+				"east": {"uv": [13, 8, 16, 11], "texture": "#0", "cullface": "east"},
+				"south": {"uv": [12, 8, 13.5, 11], "texture": "#0"},
+				"up": {"uv": [12, 8, 13.5, 11], "texture": "#0"},
+				"down": {"uv": [12, 8, 13.5, 11], "texture": "#0"}
+			}
+		},
+		{
+			"from": [14, 2.95, 2.95],
+			"to": [16.95, 13.05, 13.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [9, 9.5, 4, 8], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "east"},
+				"south": {"uv": [4, 8, 9, 9.5], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"up": {"uv": [4, 8, 9, 9.5], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [9, 9.5, 4, 8], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/north.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [2.95, 2.95, -0.95],
+			"to": [13.05, 13.05, 2],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 34, 8]},
+			"faces": {
+				"north": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "north"},
+				"east": {"uv": [4, 8, 9, 9.5], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"west": {"uv": [9, 9.5, 4, 8], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 8, 9, 9.5], "texture": "#0"},
+				"down": {"uv": [9, 9.5, 4, 8], "texture": "#0"}
+			}
+		},
+		{
+			"from": [4.95, 4.95, -3.95],
+			"to": [11.05, 11.05, -0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 34, 8]},
+			"faces": {
+				"north": {"uv": [13, 8, 16, 11], "texture": "#0", "cullface": "north"},
+				"east": {"uv": [12, 8, 13.5, 11], "texture": "#0"},
+				"west": {"uv": [12, 8, 13.5, 11], "rotation": 180, "texture": "#0"},
+				"up": {"uv": [12, 8, 13.5, 11], "rotation": 270, "texture": "#0"},
+				"down": {"uv": [12, 8, 13.5, 11], "rotation": 90, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/south.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4.95, 4.95, 16.95],
+			"to": [11.05, 11.05, 19.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 34, 8]},
+			"faces": {
+				"east": {"uv": [13.5, 8, 12, 11], "texture": "#0"},
+				"south": {"uv": [16, 8, 13, 11], "texture": "#0", "cullface": "south"},
+				"west": {"uv": [13.5, 8, 12, 11], "rotation": 180, "texture": "#0"},
+				"up": {"uv": [13.5, 8, 12, 11], "rotation": 270, "texture": "#0"},
+				"down": {"uv": [13.5, 8, 12, 11], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [2.95, 2.95, 14],
+			"to": [13.05, 13.05, 16.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 34, 8]},
+			"faces": {
+				"north": {"uv": [11, 11, 6, 16], "texture": "#0"},
+				"east": {"uv": [4, 9.5, 9, 8], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [16, 11, 11, 16], "texture": "#0", "cullface": "south"},
+				"west": {"uv": [9, 8, 4, 9.5], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 9.5, 9, 8], "texture": "#0"},
+				"down": {"uv": [9, 8, 4, 9.5], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/up.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [2.95, 14, 2.95],
+			"to": [13.05, 16.95, 13.05],
+			"rotation": {"angle": 0, "axis": "z", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [9, 8, 4, 9.5], "texture": "#0"},
+				"east": {"uv": [4, 9.5, 9, 8], "rotation": 180, "texture": "#0"},
+				"south": {"uv": [4, 9.5, 9, 8], "rotation": 180, "texture": "#0"},
+				"west": {"uv": [9, 8, 4, 9.5], "texture": "#0"},
+				"up": {"uv": [16, 11, 11, 16], "rotation": 90, "texture": "#0", "cullface": "up"},
+				"down": {"uv": [11, 11, 6, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [4.95, 16.95, 4.95],
+			"to": [11.05, 19.95, 11.05],
+			"rotation": {"angle": 0, "axis": "z", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [13.5, 8, 12, 11], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [13.5, 8, 12, 11], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [13.5, 8, 12, 11], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [13.5, 8, 12, 11], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [16, 8, 13, 11], "rotation": 90, "texture": "#0", "cullface": "up"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/drain/west.json

@@ -0,0 +1,35 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [-0.95, 2.95, 2.95],
+			"to": [2, 13.05, 13.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [9, 8, 4, 9.5], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [11, 11, 6, 16], "texture": "#0"},
+				"south": {"uv": [4, 9.5, 9, 8], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [16, 11, 11, 16], "texture": "#0", "cullface": "west"},
+				"up": {"uv": [4, 9.5, 9, 8], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [9, 8, 4, 9.5], "rotation": 270, "texture": "#0"}
+			}
+		},
+		{
+			"from": [-3.95, 4.95, 4.95],
+			"to": [-0.95, 11.05, 11.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [13.5, 8, 12, 11], "rotation": 180, "texture": "#0"},
+				"south": {"uv": [13.5, 8, 12, 11], "texture": "#0"},
+				"west": {"uv": [16, 8, 13, 11], "texture": "#0", "cullface": "west"},
+				"up": {"uv": [13.5, 8, 12, 11], "texture": "#0"},
+				"down": {"uv": [13.5, 8, 12, 11], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/item.json

@@ -0,0 +1,78 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"east": {"uv": [0, 0, 4, 4], "rotation": 90, "texture": "#1"},
+				"west": {"uv": [0, 0, 4, 4], "rotation": 90, "texture": "#1"},
+				"up": {"uv": [0, 0, 4, 4], "rotation": 180, "texture": "#1"},
+				"down": {"uv": [0, 0, 4, 4], "rotation": 180, "texture": "#1"}
+			}
+		},
+		{
+			"from": [4, 4, 12],
+			"to": [12, 12, 14],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 0, 0], "texture": "#1"},
+				"east": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#1"},
+				"south": {"uv": [0, 0, 0, 0], "texture": "#1"},
+				"west": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#1"},
+				"up": {"uv": [0, 8, 4, 9], "rotation": 180, "texture": "#1"},
+				"down": {"uv": [0, 9, 4, 10], "rotation": 180, "texture": "#1"}
+			}
+		},
+		{
+			"from": [4, 4, 2],
+			"to": [12, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 0, 0], "texture": "#1"},
+				"east": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#1"},
+				"south": {"uv": [0, 0, 0, 0], "texture": "#1"},
+				"west": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#1"},
+				"up": {"uv": [0, 9, 4, 10], "rotation": 180, "texture": "#1"},
+				"down": {"uv": [0, 8, 4, 9], "rotation": 180, "texture": "#1"}
+			}
+		},
+		{
+			"from": [3, 3, 0],
+			"to": [13, 13, 2],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 28, 8]},
+			"faces": {
+				"north": {"uv": [11, 11, 16, 16], "texture": "#1"},
+				"east": {"uv": [10.5, 11, 11.5, 16], "texture": "#1"},
+				"south": {"uv": [6, 11, 11, 16], "texture": "#1"},
+				"west": {"uv": [11.5, 16, 10.5, 11], "texture": "#1"},
+				"up": {"uv": [10.5, 11, 11.5, 16], "rotation": 270, "texture": "#1"},
+				"down": {"uv": [11.5, 16, 10.5, 11], "rotation": 270, "texture": "#1"}
+			}
+		},
+		{
+			"from": [3, 3, 14],
+			"to": [13, 13, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 28, 8]},
+			"faces": {
+				"north": {"uv": [6, 11, 11, 16], "texture": "#1"},
+				"east": {"uv": [11.5, 16, 10.5, 11], "texture": "#1"},
+				"south": {"uv": [11, 11, 16, 16], "texture": "#1"},
+				"west": {"uv": [10.5, 11, 11.5, 16], "texture": "#1"},
+				"up": {"uv": [11.5, 16, 10.5, 11], "rotation": 270, "texture": "#1"},
+				"down": {"uv": [10.5, 11, 11.5, 16], "rotation": 270, "texture": "#1"}
+			}
+		}
+	],
+	"display": {
+		"fixed": {
+			"rotation": [0, 90, 0],
+			"scale": [0.5, 0.5, 0.5]
+		}
+	}
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/down.json

@@ -0,0 +1,22 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 0, 3],
+			"to": [13, 2, 13],
+			"faces": {
+				"north": {"uv": [10.5, 11, 11.5, 16], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [10.5, 11, 11.5, 16], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [10.5, 11, 11.5, 16], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [10.5, 11, 11.5, 16], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [6, 11, 11, 16], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [11, 11, 16, 16], "rotation": 270, "texture": "#0", "cullface": "down"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/east.json

@@ -0,0 +1,22 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [14, 3, 3],
+			"to": [16, 13, 13],
+			"faces": {
+				"north": {"uv": [11.5, 16, 10.5, 11], "texture": "#0"},
+				"east": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "east"},
+				"south": {"uv": [10.5, 11, 11.5, 16], "texture": "#0"},
+				"west": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"up": {"uv": [11.5, 16, 10.5, 11], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [10.5, 11, 11.5, 16], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/north.json

@@ -0,0 +1,23 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 3, 0],
+			"to": [13, 13, 2],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 28, 8]},
+			"faces": {
+				"north": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "north"},
+				"east": {"uv": [10.5, 11, 11.5, 16], "texture": "#0"},
+				"south": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"west": {"uv": [11.5, 16, 10.5, 11], "texture": "#0"},
+				"up": {"uv": [10.5, 11, 11.5, 16], "rotation": 270, "texture": "#0"},
+				"down": {"uv": [11.5, 16, 10.5, 11], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/south.json

@@ -0,0 +1,23 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 3, 14],
+			"to": [13, 13, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 28, 8]},
+			"faces": {
+				"north": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"east": {"uv": [11.5, 16, 10.5, 11], "texture": "#0"},
+				"south": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "south"},
+				"west": {"uv": [10.5, 11, 11.5, 16], "texture": "#0"},
+				"up": {"uv": [11.5, 16, 10.5, 11], "rotation": 270, "texture": "#0"},
+				"down": {"uv": [10.5, 11, 11.5, 16], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/up.json

@@ -0,0 +1,22 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 14, 3],
+			"to": [13, 16, 13],
+			"faces": {
+				"north": {"uv": [11.5, 16, 10.5, 11], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [11.5, 16, 10.5, 11], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [11.5, 16, 10.5, 11], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [11.5, 16, 10.5, 11], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [11, 11, 16, 16], "rotation": 90, "texture": "#0", "cullface": "up"},
+				"down": {"uv": [6, 11, 11, 16], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim/west.json

@@ -0,0 +1,22 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [0, 3, 3],
+			"to": [2, 13, 13],
+			"faces": {
+				"north": {"uv": [10.5, 11, 11.5, 16], "texture": "#0"},
+				"east": {"uv": [6, 11, 11, 16], "texture": "#0"},
+				"south": {"uv": [11.5, 16, 10.5, 11], "texture": "#0"},
+				"west": {"uv": [11, 11, 16, 16], "texture": "#0", "cullface": "west"},
+				"up": {"uv": [10.5, 11, 11.5, 16], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [11.5, 16, 10.5, 11], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/down.json

@@ -0,0 +1,20 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 2, 4],
+			"to": [12, 4, 12],
+			"faces": {
+				"north": {"uv": [0, 9, 4, 10], "texture": "#0"},
+				"east": {"uv": [0, 9, 4, 10], "texture": "#0"},
+				"south": {"uv": [4, 9, 0, 10], "texture": "#0"},
+				"west": {"uv": [4, 9, 0, 10], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/east.json

@@ -0,0 +1,20 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [12, 4, 4],
+			"to": [14, 12, 12],
+			"faces": {
+				"north": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 8, 0, 9], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 9, 0, 10], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/north.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 2],
+			"to": [12, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"east": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 9, 4, 10], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 8, 4, 9], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/south.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 12],
+			"to": [12, 12, 14],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 8]},
+			"faces": {
+				"east": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 8, 4, 9], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 9, 4, 10], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/up.json

@@ -0,0 +1,20 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 12, 4],
+			"to": [12, 14, 12],
+			"faces": {
+				"north": {"uv": [0, 8, 4, 9], "texture": "#0"},
+				"east": {"uv": [0, 8, 4, 9], "texture": "#0"},
+				"south": {"uv": [4, 8, 0, 9], "texture": "#0"},
+				"west": {"uv": [4, 8, 0, 9], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/rim_connector/west.json

@@ -0,0 +1,20 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [2, 4, 4],
+			"to": [4, 12, 12],
+			"faces": {
+				"north": {"uv": [0, 8, 4, 9], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 9, 4, 10], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 9, 0, 10], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 8, 0, 9], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/window.json

@@ -0,0 +1,85 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/glass_steel_pipe",
+		"particle": "tfmg:block/steel_block"
+	},
+	"elements": [
+		{
+			"name": "Outer",
+			"from": [4, 0, 4],
+			"to": [12, 16, 12],
+			"faces": {
+				"north": {"uv": [0, 16, 16, 8], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [0, 16, 16, 8], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4, 0, 11.9],
+			"to": [12, 16, 11.9],
+			"faces": {
+				"north": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4.1, 0, 4],
+			"to": [4.1, 16, 12],
+			"faces": {
+				"east": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4, 0, 4.1],
+			"to": [12, 16, 4.1],
+			"faces": {
+				"south": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [11.9, 0, 4],
+			"to": [11.9, 16, 12],
+			"faces": {
+				"west": {"uv": [0, 8, 16, 16], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [4, 0, 4],
+			"to": [6, 16, 6],
+			"faces": {
+				"east": {"uv": [0, 14, 16, 16], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 8, 16, 10], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [4, 0, 10],
+			"to": [6, 16, 12],
+			"faces": {
+				"north": {"uv": [0, 10, 16, 8], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [0, 16, 16, 14], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [10, 0, 4],
+			"to": [12, 16, 6],
+			"faces": {
+				"south": {"uv": [0, 14, 16, 16], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 8, 16, 10], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"from": [10, 0, 10],
+			"to": [12, 16, 12],
+			"faces": {
+				"north": {"uv": [0, 16, 16, 14], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 10, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/locked_steel_pipe/window_alt.json

@@ -0,0 +1,58 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/glass_steel_pipe",
+		"particle": "#0"
+	},
+	"elements": [
+		{
+			"name": "Outer",
+			"from": [4, 0, 4],
+			"to": [12, 16, 12],
+			"shade": false,
+			"faces": {
+				"north": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"},
+				"east": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4, 0, 11.5],
+			"to": [12, 16, 11.5],
+			"shade": false,
+			"faces": {
+				"north": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4, 0, 4.5],
+			"to": [12, 16, 4.5],
+			"shade": false,
+			"faces": {
+				"south": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [4.5, 0, 4],
+			"to": [4.5, 16, 12],
+			"shade": false,
+			"faces": {
+				"east": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		},
+		{
+			"name": "Inner",
+			"from": [11.5, 0, 4],
+			"to": [11.5, 16, 12],
+			"shade": false,
+			"faces": {
+				"west": {"uv": [0, 0, 16, 8], "rotation": 90, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom.json

@@ -0,0 +1,74 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "Lid",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [16, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 15],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [1, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 0, 16, 12], "texture": "#1", "cullface": "west"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom_window.json

@@ -0,0 +1,154 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [4, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 1, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 16, 4],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 1, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [12, 4, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 1, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 12],
+			"to": [1, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 1, 12], "texture": "#1", "cullface": "west"},
+				"east": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 4, 0.95],
+			"to": [12, 16, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "north"},
+				"south": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "north"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 4],
+			"to": [15.05, 16, 12],
+			"faces": {
+				"east": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "east"},
+				"west": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "east"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 4, 15.05],
+			"to": [12, 16, 15.05],
+			"faces": {
+				"north": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "south"},
+				"south": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "south"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 4],
+			"to": [0.95, 16, 12],
+			"faces": {
+				"east": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "west"},
+				"west": {"uv": [0, 4, 8, 16], "texture": "#3", "cullface": "west"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [12, 4, 0],
+			"to": [16, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "north"},
+				"west": {"uv": [15, 0, 16, 12], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 4, 12],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [15, 0, 16, 12], "texture": "#1", "cullface": "east"},
+				"east": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 15],
+			"to": [4, 16, 16],
+			"faces": {
+				"north": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "south"},
+				"east": {"uv": [15, 0, 16, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 0],
+			"to": [1, 16, 4],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 12], "texture": "#1", "cullface": "west"},
+				"south": {"uv": [15, 0, 16, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 0, 4, 12], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom_window_ne.json

@@ -0,0 +1,73 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 16, 12],
+			"faces": {
+				"east": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"south": {"uv": [4, 0, 5, 12], "texture": "#1"},
+				"west": {"uv": [0, 0, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 4, 0.95],
+			"to": [4, 16, 0.95],
+			"faces": {
+				"north": {"uv": [0, 4, 4, 16], "texture": "#3"},
+				"south": {"uv": [4, 4, 8, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 12],
+			"to": [15.05, 16, 16],
+			"faces": {
+				"east": {"uv": [4, 4, 8, 16], "texture": "#3"},
+				"west": {"uv": [0, 4, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [4, 4, 0],
+			"to": [16, 16, 1],
+			"faces": {
+				"north": {"uv": [0, 0, 12, 12], "texture": "#1"},
+				"south": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"west": {"uv": [11, 0, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-23, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom_window_nw.json

@@ -0,0 +1,73 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [12, 16, 1],
+			"faces": {
+				"north": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"east": {"uv": [4, 0, 5, 12], "texture": "#1"},
+				"south": {"uv": [0, 0, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 12],
+			"to": [0.95, 16, 16],
+			"faces": {
+				"east": {"uv": [4, 4, 8, 16], "texture": "#3"},
+				"west": {"uv": [0, 4, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 4, 0.95],
+			"to": [16, 16, 0.95],
+			"faces": {
+				"north": {"uv": [4, 4, 8, 16], "texture": "#3"},
+				"south": {"uv": [0, 4, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 0],
+			"to": [1, 16, 12],
+			"faces": {
+				"east": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"south": {"uv": [11, 0, 12, 12], "texture": "#1"},
+				"west": {"uv": [0, 0, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 39]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom_window_se.json

@@ -0,0 +1,73 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [4, 4, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 12, 12], "texture": "#1"},
+				"south": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"west": {"uv": [4, 0, 5, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 0],
+			"to": [15.05, 16, 4],
+			"faces": {
+				"east": {"uv": [0, 4, 4, 16], "texture": "#3"},
+				"west": {"uv": [4, 4, 8, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 4, 15.05],
+			"to": [4, 16, 15.05],
+			"faces": {
+				"north": {"uv": [0, 4, 4, 16], "texture": "#3"},
+				"south": {"uv": [4, 4, 8, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 4, 4],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [11, 0, 12, 12], "texture": "#1"},
+				"east": {"uv": [0, 0, 12, 12], "texture": "#1"},
+				"west": {"uv": [4, 0, 16, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_bottom_window_sw.json

@@ -0,0 +1,73 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 4, 4],
+			"to": [1, 16, 16],
+			"faces": {
+				"north": {"uv": [4, 0, 5, 12], "texture": "#1"},
+				"east": {"uv": [0, 0, 12, 12], "texture": "#1"},
+				"west": {"uv": [4, 0, 16, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 4, 15.05],
+			"to": [16, 16, 15.05],
+			"faces": {
+				"north": {"uv": [4, 4, 8, 16], "texture": "#3"},
+				"south": {"uv": [0, 4, 4, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 0],
+			"to": [0.95, 16, 4],
+			"faces": {
+				"east": {"uv": [0, 4, 4, 16], "texture": "#3"},
+				"west": {"uv": [4, 4, 8, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 15],
+			"to": [12, 16, 16],
+			"faces": {
+				"north": {"uv": [4, 0, 16, 12], "texture": "#1"},
+				"east": {"uv": [11, 0, 12, 12], "texture": "#1"},
+				"south": {"uv": [0, 0, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [39, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle.json

@@ -0,0 +1,57 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [16, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 15],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [1, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 0, 16, 16], "texture": "#1", "cullface": "west"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"children": [0, 1, 2, 3]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle_window.json

@@ -0,0 +1,138 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/fluid_tank_window",
+		"particle": "tfmg:block/fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [4, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 1, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 16, 4],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 1, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [12, 0, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 1, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 12],
+			"to": [1, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 1, 16], "texture": "#1", "cullface": "west"},
+				"east": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 0, 0.95],
+			"to": [12, 16, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "north"},
+				"south": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "north"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 4],
+			"to": [15.05, 16, 12],
+			"faces": {
+				"east": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "east"},
+				"west": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "east"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 0, 15.05],
+			"to": [12, 16, 15.05],
+			"faces": {
+				"north": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "south"},
+				"south": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "south"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 4],
+			"to": [0.95, 16, 12],
+			"faces": {
+				"east": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "west"},
+				"west": {"uv": [8, 0, 16, 16], "texture": "#3", "cullface": "west"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [12, 0, 0],
+			"to": [16, 16, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "north"},
+				"west": {"uv": [15, 0, 16, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 0, 12],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [15, 0, 16, 16], "texture": "#1", "cullface": "east"},
+				"east": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 15],
+			"to": [4, 16, 16],
+			"faces": {
+				"north": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "south"},
+				"east": {"uv": [15, 0, 16, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 0],
+			"to": [1, 16, 4],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 16], "texture": "#1", "cullface": "west"},
+				"south": {"uv": [15, 0, 16, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 0, 4, 16], "texture": "#1", "cullface": "west"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle_window_ne.json

@@ -0,0 +1,57 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 16, 12],
+			"faces": {
+				"east": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"south": {"uv": [4, 0, 5, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 0, 0.95],
+			"to": [4, 16, 0.95],
+			"faces": {
+				"north": {"uv": [8, 0, 12, 16], "texture": "#3"},
+				"south": {"uv": [12, 0, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 12],
+			"to": [15.05, 16, 16],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 16], "texture": "#3"},
+				"west": {"uv": [8, 0, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [4, 0, 0],
+			"to": [16, 16, 1],
+			"faces": {
+				"north": {"uv": [0, 0, 12, 16], "texture": "#1"},
+				"south": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [11, 0, 12, 16], "texture": "#1"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle_window_nw.json

@@ -0,0 +1,57 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [12, 16, 1],
+			"faces": {
+				"north": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"east": {"uv": [4, 0, 5, 16], "texture": "#1"},
+				"south": {"uv": [0, 0, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 12],
+			"to": [0.95, 16, 16],
+			"faces": {
+				"east": {"uv": [12, 0, 16, 16], "texture": "#3"},
+				"west": {"uv": [8, 0, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 0, 0.95],
+			"to": [16, 16, 0.95],
+			"faces": {
+				"north": {"uv": [12, 0, 16, 16], "texture": "#3"},
+				"south": {"uv": [8, 0, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 0],
+			"to": [1, 16, 12],
+			"faces": {
+				"east": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"south": {"uv": [11, 0, 12, 16], "texture": "#1"},
+				"west": {"uv": [0, 0, 12, 16], "texture": "#1"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle_window_se.json

@@ -0,0 +1,57 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [4, 0, 15],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [0, 0, 12, 16], "texture": "#1"},
+				"south": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"west": {"uv": [4, 0, 5, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 0],
+			"to": [15.05, 16, 4],
+			"faces": {
+				"east": {"uv": [8, 0, 12, 16], "texture": "#3"},
+				"west": {"uv": [12, 0, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 0, 15.05],
+			"to": [4, 16, 15.05],
+			"faces": {
+				"north": {"uv": [8, 0, 12, 16], "texture": "#3"},
+				"south": {"uv": [12, 0, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 0, 4],
+			"to": [16, 16, 16],
+			"faces": {
+				"north": {"uv": [11, 0, 12, 16], "texture": "#1"},
+				"east": {"uv": [0, 0, 12, 16], "texture": "#1"},
+				"west": {"uv": [4, 0, 16, 16], "texture": "#1"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_middle_window_sw.json

@@ -0,0 +1,57 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 4],
+			"to": [1, 16, 16],
+			"faces": {
+				"north": {"uv": [4, 0, 5, 16], "texture": "#1"},
+				"east": {"uv": [0, 0, 12, 16], "texture": "#1"},
+				"west": {"uv": [4, 0, 16, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 0, 15.05],
+			"to": [16, 16, 15.05],
+			"faces": {
+				"north": {"uv": [12, 0, 16, 16], "texture": "#3"},
+				"south": {"uv": [8, 0, 12, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 0],
+			"to": [0.95, 16, 4],
+			"faces": {
+				"east": {"uv": [8, 0, 12, 16], "texture": "#3"},
+				"west": {"uv": [12, 0, 16, 16], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 15],
+			"to": [12, 16, 16],
+			"faces": {
+				"north": {"uv": [4, 0, 16, 16], "texture": "#1"},
+				"east": {"uv": [11, 0, 12, 16], "texture": "#1"},
+				"south": {"uv": [0, 0, 12, 16], "texture": "#1"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single.json

@@ -0,0 +1,127 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "Lid",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 15],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"north": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [1, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 12, 8]},
+			"faces": {
+				"east": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Lid",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 4, 16, 12], "texture": "#1", "cullface": "north"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": []
+		},
+		{
+			"name": "block_middle",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": []
+				}
+			]
+		},
+		{
+			"name": "block_bottom",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [0, 1, 2, 3]
+				}
+			]
+		},
+		{
+			"name": "block_top",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [4, 5]
+				}
+			]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single_window.json

@@ -0,0 +1,168 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"5": "tfmg:block/steel_fluid_tank_window_single",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "Lid",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [4, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [8, 4, 9, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 12, 4],
+			"faces": {
+				"east": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [8, 4, 9, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [12, 4, 15],
+			"to": [16, 12, 16],
+			"faces": {
+				"north": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [8, 4, 9, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 4, 12],
+			"to": [1, 12, 16],
+			"faces": {
+				"north": {"uv": [8, 4, 9, 12], "texture": "#1", "cullface": "west"},
+				"east": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 4, 0.95],
+			"to": [12, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "north"},
+				"south": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "north"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 4],
+			"to": [15.05, 12, 12],
+			"faces": {
+				"east": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "east"},
+				"west": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "east"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 4, 15.05],
+			"to": [12, 12, 15.05],
+			"faces": {
+				"north": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "south"},
+				"south": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "south"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 4],
+			"to": [0.95, 12, 12],
+			"faces": {
+				"east": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "west"},
+				"west": {"uv": [0, 0, 8, 8], "texture": "#5", "cullface": "west"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [12, 4, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "north"},
+				"west": {"uv": [7, 4, 8, 12], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 4, 12],
+			"to": [16, 12, 16],
+			"faces": {
+				"north": {"uv": [7, 4, 8, 12], "texture": "#1", "cullface": "east"},
+				"east": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 15],
+			"to": [4, 12, 16],
+			"faces": {
+				"north": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "south"},
+				"east": {"uv": [7, 4, 8, 12], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 0],
+			"to": [1, 12, 4],
+			"faces": {
+				"east": {"uv": [12, 4, 16, 12], "texture": "#1", "cullface": "west"},
+				"south": {"uv": [7, 4, 8, 12], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 4, 4, 12], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single_window_ne.json

@@ -0,0 +1,104 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"5": "tfmg:block/steel_fluid_tank_window_single",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [15, 4, 0],
+			"to": [16, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"south": {"uv": [4, 4, 5, 12], "texture": "#1"},
+				"west": {"uv": [0, 4, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 4, 0.95],
+			"to": [4, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 8], "texture": "#5"},
+				"south": {"uv": [4, 0, 8, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 12],
+			"to": [15.05, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 0, 8, 8], "texture": "#5"},
+				"west": {"uv": [0, 0, 4, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [4, 4, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 4, 12, 12], "texture": "#1"},
+				"south": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"west": {"uv": [11, 4, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-23, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-23, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		},
+		{
+			"name": "block_bottom_centered_window",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [5]
+				}
+			]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single_window_nw.json

@@ -0,0 +1,104 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"5": "tfmg:block/steel_fluid_tank_window_single",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 4, 0],
+			"to": [12, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"east": {"uv": [4, 4, 5, 12], "texture": "#1"},
+				"south": {"uv": [0, 4, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 12],
+			"to": [0.95, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 0, 8, 8], "texture": "#5"},
+				"west": {"uv": [0, 0, 4, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 4, 0.95],
+			"to": [16, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 0, 8, 8], "texture": "#5"},
+				"south": {"uv": [0, 0, 4, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 0],
+			"to": [1, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"south": {"uv": [11, 4, 12, 12], "texture": "#1"},
+				"west": {"uv": [0, 4, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 39]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 39]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		},
+		{
+			"name": "block_bottom_centered_window",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [5]
+				}
+			]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single_window_se.json

@@ -0,0 +1,104 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"5": "tfmg:block/steel_fluid_tank_window_single",
+		"particle": "tfmg:block/fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [4, 4, 15],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 4, 12, 12], "texture": "#1"},
+				"south": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"west": {"uv": [4, 4, 5, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 4, 0],
+			"to": [15.05, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 8], "texture": "#5"},
+				"west": {"uv": [4, 0, 8, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 4, 15.05],
+			"to": [4, 12, 15.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 8], "texture": "#5"},
+				"south": {"uv": [4, 0, 8, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 4, 4],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [11, 4, 12, 12], "texture": "#1"},
+				"east": {"uv": [0, 4, 12, 12], "texture": "#1"},
+				"west": {"uv": [4, 4, 16, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		},
+		{
+			"name": "block_bottom_centered_window",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [5]
+				}
+			]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_single_window_sw.json

@@ -0,0 +1,104 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"5": "tfmg:block/steel_fluid_tank_window_single",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 4, 4],
+			"to": [1, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 5, 12], "texture": "#1"},
+				"east": {"uv": [0, 4, 12, 12], "texture": "#1"},
+				"west": {"uv": [4, 4, 16, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 4, 15.05],
+			"to": [16, 12, 15.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 0, 8, 8], "texture": "#5"},
+				"south": {"uv": [0, 0, 4, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 4, 0],
+			"to": [0.95, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 8], "texture": "#5"},
+				"west": {"uv": [4, 0, 8, 8], "texture": "#5"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 4, 15],
+			"to": [12, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 16, 12], "texture": "#1"},
+				"east": {"uv": [11, 4, 12, 12], "texture": "#1"},
+				"south": {"uv": [0, 4, 12, 12], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [39, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 0, 0],
+			"to": [16, 4, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [39, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"east": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"south": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"west": {"uv": [0, 12, 16, 16], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#4"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "down"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		},
+		{
+			"name": "block_bottom_centered_window",
+			"origin": [8, 8, 8],
+			"color": 0,
+			"children": [
+				{
+					"name": "tank",
+					"origin": [8, 8, -23],
+					"color": 0,
+					"children": [5]
+				}
+			]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top.json

@@ -0,0 +1,71 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "Lid",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 12, 16],
+			"faces": {
+				"east": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 15],
+			"to": [16, 12, 16],
+			"faces": {
+				"north": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [1, 12, 16],
+			"faces": {
+				"east": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 4, 16, 16], "texture": "#1", "cullface": "west"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top_window.json

@@ -0,0 +1,154 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "Lid",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1", "cullface": "west"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [4, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "north"},
+				"east": {"uv": [0, 4, 1, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 12, 4],
+			"faces": {
+				"east": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "east"},
+				"south": {"uv": [0, 4, 1, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [12, 0, 15],
+			"to": [16, 12, 16],
+			"faces": {
+				"north": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "south"},
+				"west": {"uv": [0, 4, 1, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideRight",
+			"from": [0, 0, 12],
+			"to": [1, 12, 16],
+			"faces": {
+				"north": {"uv": [0, 4, 1, 16], "texture": "#1", "cullface": "west"},
+				"east": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "west"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 0, 0.95],
+			"to": [12, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "north"},
+				"south": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "north"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 4],
+			"to": [15.05, 12, 12],
+			"faces": {
+				"east": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "east"},
+				"west": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "east"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [4, 0, 15.05],
+			"to": [12, 12, 15.05],
+			"faces": {
+				"north": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "south"},
+				"south": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "south"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 4],
+			"to": [0.95, 12, 12],
+			"faces": {
+				"east": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "west"},
+				"west": {"uv": [0, 0, 8, 12], "texture": "#3", "cullface": "west"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [12, 0, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "north"},
+				"south": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "north"},
+				"west": {"uv": [15, 4, 16, 16], "texture": "#1", "cullface": "north"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 0, 12],
+			"to": [16, 12, 16],
+			"faces": {
+				"north": {"uv": [15, 4, 16, 16], "texture": "#1", "cullface": "east"},
+				"east": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "east"},
+				"west": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "east"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 15],
+			"to": [4, 12, 16],
+			"faces": {
+				"north": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "south"},
+				"east": {"uv": [15, 4, 16, 16], "texture": "#1", "cullface": "south"},
+				"south": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "south"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 0],
+			"to": [1, 12, 4],
+			"faces": {
+				"east": {"uv": [12, 4, 16, 16], "texture": "#1", "cullface": "west"},
+				"south": {"uv": [15, 4, 16, 16], "texture": "#1", "cullface": "west"},
+				"west": {"uv": [0, 4, 4, 16], "texture": "#1", "cullface": "west"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top_window_ne.json

@@ -0,0 +1,77 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [15, 0, 0],
+			"to": [16, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"south": {"uv": [4, 4, 5, 16], "texture": "#1"},
+				"west": {"uv": [0, 4, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 0, 0.95],
+			"to": [4, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 12], "texture": "#3"},
+				"south": {"uv": [4, 0, 8, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 12],
+			"to": [15.05, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 0, 8, 12], "texture": "#3"},
+				"west": {"uv": [0, 0, 4, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [4, 0, 0],
+			"to": [16, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 4, 12, 16], "texture": "#1"},
+				"south": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"west": {"uv": [11, 4, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-23, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top_window_nw.json

@@ -0,0 +1,77 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 0],
+			"to": [12, 12, 1],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"east": {"uv": [4, 4, 5, 16], "texture": "#1"},
+				"south": {"uv": [0, 4, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 12],
+			"to": [0.95, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 0, 8, 12], "texture": "#3"},
+				"west": {"uv": [0, 0, 4, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 0, 0.95],
+			"to": [16, 12, 0.95],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 0, 8, 12], "texture": "#3"},
+				"south": {"uv": [0, 0, 4, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 0],
+			"to": [1, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"south": {"uv": [11, 4, 12, 16], "texture": "#1"},
+				"west": {"uv": [0, 4, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, 39]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top_window_se.json

@@ -0,0 +1,77 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [4, 0, 15],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 4, 12, 16], "texture": "#1"},
+				"south": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"west": {"uv": [4, 4, 5, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [15.05, 0, 0],
+			"to": [15.05, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 12], "texture": "#3"},
+				"west": {"uv": [4, 0, 8, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0, 0, 15.05],
+			"to": [4, 12, 15.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 12], "texture": "#3"},
+				"south": {"uv": [4, 0, 8, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [15, 0, 4],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [11, 4, 12, 16], "texture": "#1"},
+				"east": {"uv": [0, 4, 12, 16], "texture": "#1"},
+				"west": {"uv": [4, 4, 16, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 8, -23]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_fluid_tank/block_top_window_sw.json

@@ -0,0 +1,77 @@
+{
+	"credit": "Made with Blockbench",
+	"parent": "block/block",
+	"textures": {
+		"0": "tfmg:block/steel_fluid_tank_top",
+		"1": "tfmg:block/steel_fluid_tank",
+		"3": "tfmg:block/steel_fluid_tank_window",
+		"4": "tfmg:block/steel_fluid_tank_inner",
+		"particle": "tfmg:block/steel_fluid_tank"
+	},
+	"elements": [
+		{
+			"name": "SideRight",
+			"from": [0, 0, 4],
+			"to": [1, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 5, 16], "texture": "#1"},
+				"east": {"uv": [0, 4, 12, 16], "texture": "#1"},
+				"west": {"uv": [4, 4, 16, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [12, 0, 15.05],
+			"to": [16, 12, 15.05],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 0, 8, 12], "texture": "#3"},
+				"south": {"uv": [0, 0, 4, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "Window",
+			"from": [0.95, 0, 0],
+			"to": [0.95, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 12], "texture": "#3"},
+				"west": {"uv": [4, 0, 8, 12], "texture": "#3"}
+			}
+		},
+		{
+			"name": "SideLeft",
+			"from": [0, 0, 15],
+			"to": [12, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [8, 4, 8]},
+			"faces": {
+				"north": {"uv": [4, 4, 16, 16], "texture": "#1"},
+				"east": {"uv": [11, 4, 12, 16], "texture": "#1"},
+				"south": {"uv": [0, 4, 12, 16], "texture": "#1"}
+			}
+		},
+		{
+			"name": "Bottom",
+			"from": [0, 12, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [39, 8, 8]},
+			"faces": {
+				"north": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"east": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"south": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"west": {"uv": [0, 0, 16, 4], "texture": "#1"},
+				"up": {"uv": [0, 0, 16, 16], "texture": "#0", "cullface": "up"},
+				"down": {"uv": [0, 0, 16, 16], "texture": "#4"}
+			}
+		}
+	],
+	"groups": [
+		{
+			"name": "tank",
+			"origin": [8, 8, -23],
+			"color": 0,
+			"children": [0, 1, 2, 3, 4]
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/casing.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [3, 3, 3],
+			"to": [13, 13, 13],
+			"faces": {
+				"north": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"east": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"south": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"west": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"up": {"uv": [1, 11, 6, 16], "texture": "#0"},
+				"down": {"uv": [1, 11, 6, 16], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/down.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 0, 4],
+			"to": [12, 4, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 6, 4, 8], "texture": "#0"},
+				"east": {"uv": [0, 6, 4, 8], "texture": "#0"},
+				"south": {"uv": [4, 6, 0, 8], "texture": "#0"},
+				"west": {"uv": [4, 6, 0, 8], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/east.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [12, 4, 4],
+			"to": [16, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 0, 0, 2], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 6, 0, 8], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/north.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 0],
+			"to": [12, 12, 4],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 8, 0]},
+			"faces": {
+				"east": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 6, 4, 8], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/south.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 12],
+			"to": [12, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 8, 0]},
+			"faces": {
+				"east": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"west": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [0, 0, 4, 2], "rotation": 180, "texture": "#0"},
+				"down": {"uv": [0, 6, 4, 8], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/up.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [4, 12, 4],
+			"to": [12, 16, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 2], "texture": "#0"},
+				"east": {"uv": [0, 0, 4, 2], "texture": "#0"},
+				"south": {"uv": [4, 0, 0, 2], "texture": "#0"},
+				"west": {"uv": [4, 0, 0, 2], "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/connection/west.json

@@ -0,0 +1,21 @@
+{
+	"credit": "Made with Blockbench",
+	"texture_size": [32, 32],
+	"textures": {
+		"0": "tfmg:block/steel_pipes",
+		"particle": "tfmg:block/steel_pipes"
+	},
+	"elements": [
+		{
+			"from": [0, 4, 4],
+			"to": [4, 12, 12],
+			"rotation": {"angle": 0, "axis": "y", "origin": [16, 0, -16]},
+			"faces": {
+				"north": {"uv": [0, 0, 4, 2], "rotation": 90, "texture": "#0"},
+				"south": {"uv": [0, 6, 4, 8], "rotation": 90, "texture": "#0"},
+				"up": {"uv": [4, 6, 0, 8], "rotation": 90, "texture": "#0"},
+				"down": {"uv": [4, 0, 0, 2], "rotation": 270, "texture": "#0"}
+			}
+		}
+	]
+}

src/main/resources/assets/tfmg/models/block/steel_pipe/core_x.json

@@ -0,0 +1,17 @@
+{
+	"credit": "Made with Blockbench",
+	"textures": {
+		"0": "tfmg:block/steel_pipes_connected",
+		"particle": "tfmg:block/steel_pipes_connected"
+	},
+	"elements": [
+		{
+			"from": [4, 4, 4],
+			"to": [12, 12, 12],
+			"faces": {
+				"east": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"},
+				"west": {"uv": [16, 8, 12, 12], "rotation": 180, "texture": "#0"}
+			}
+		}
+	]
+}