Migrate kubatech source code

6 files changed, 4135 insertions, 0 deletions

diff --git a/src/main/java/kubatech/tileentity/TeaAcceptorTile.java b/src/main/java/kubatech/tileentity/TeaAcceptorTile.java
new file mode 100644
index 0000000000..a8cf9f7a50
--- /dev/null
+++ b/src/main/java/kubatech/tileentity/TeaAcceptorTile.java
@@ -0,0 +1,223 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024  kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.tileentity;
+
+import static kubatech.api.Variables.numberFormat;
+import static kubatech.api.Variables.numberFormatScientific;
+
+import java.math.BigInteger;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiFunction;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+
+import com.gtnewhorizons.modularui.api.ModularUITextures;
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ITileWithModularUI;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.api.widget.Widget;
+import com.gtnewhorizons.modularui.common.builder.UIInfo;
+import com.gtnewhorizons.modularui.common.internal.wrapper.ModularUIContainer;
+import com.gtnewhorizons.modularui.common.widget.DynamicTextWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import codechicken.nei.NEIClientUtils;
+import kubatech.api.enums.ItemList;
+import kubatech.api.tea.TeaNetwork;
+import kubatech.api.utils.StringUtils;
+import kubatech.loaders.ItemLoader;
+import kubatech.loaders.block.kubablock.KubaBlock;
+
+public class TeaAcceptorTile extends TileEntity
+    implements IInventory, ITileWithModularUI, KubaBlock.IModularUIProvider {
+
+    public TeaAcceptorTile() {
+        super();
+    }
+
+    private UUID tileOwner = null;
+    private TeaNetwork teaNetwork = null;
+    private long averageInput = 0L;
+    private long inAmount = 0L;
+    private int ticker = 0;
+
+    public void setTeaOwner(UUID teaOwner) {
+        if (tileOwner == null) {
+            tileOwner = teaOwner;
+            teaNetwork = TeaNetwork.getNetwork(tileOwner);
+            markDirty();
+        }
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound NBTData) {
+        super.readFromNBT(NBTData);
+        try {
+            tileOwner = UUID.fromString(NBTData.getString("tileOwner"));
+            teaNetwork = TeaNetwork.getNetwork(tileOwner);
+        } catch (Exception ignored) {}
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound NBTData) {
+        super.writeToNBT(NBTData);
+        NBTData.setString("tileOwner", tileOwner.toString());
+    }
+
+    @Override
+    public void updateEntity() {
+        if (this.worldObj.isRemote) return;
+        if (++ticker % 100 == 0) {
+            averageInput = inAmount / 100;
+            inAmount = 0;
+        }
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return 10;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int p_70301_1_) {
+        return null;
+    }
+
+    @Override
+    public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) {
+        return null;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int p_70304_1_) {
+        return null;
+    }
+
+    @Override
+    public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {
+        if (teaNetwork != null) {
+            inAmount += p_70299_2_.stackSize;
+            teaNetwork.addTea(p_70299_2_.stackSize);
+        }
+    }
+
+    @Override
+    public String getInventoryName() {
+        return "Tea acceptor";
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return 64;
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+        return p_70300_1_.getPersistentID()
+            .equals(tileOwner);
+    }
+
+    @Override
+    public void openInventory() {}
+
+    @Override
+    public void closeInventory() {}
+
+    private static final int minDamage = ItemList.BlackTea.get(1)
+        .getItemDamage();
+    private static final int maxDamage = ItemList.YellowTea.get(1)
+        .getItemDamage();
+
+    @Override
+    public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
+        if (teaNetwork == null) return false;
+        if (!teaNetwork.canAdd(p_94041_2_.stackSize)) return false;
+        return p_94041_2_.getItem() == ItemLoader.kubaitems && p_94041_2_.getItemDamage() >= minDamage
+            && p_94041_2_.getItemDamage() <= maxDamage;
+    }
+
+    private static final UIInfo<?, ?> UI = KubaBlock.TileEntityUIFactory.apply(ModularUIContainer::new);
+
+    @Override
+    public UIInfo<?, ?> getUI() {
+        return UI;
+    }
+
+    private static TextWidget posCenteredHorizontally(int y, TextWidget textWidget) {
+        return (TextWidget) textWidget.setPosProvider(posCenteredHorizontallyProvider.apply(textWidget, y));
+    }
+
+    private static final BiFunction<TextWidget, Integer, Widget.PosProvider> posCenteredHorizontallyProvider = (
+        TextWidget widget, Integer y) -> (Widget.PosProvider) (screenSize, window,
+            parent) -> new Pos2d((window.getSize().width / 2) - (widget.getSize().width / 2), y);
+
+    @Override
+    public ModularWindow createWindow(UIBuildContext buildContext) {
+        ModularWindow.Builder builder = ModularWindow.builder(170, 70);
+        builder.setBackground(ModularUITextures.VANILLA_BACKGROUND);
+        EntityPlayer player = buildContext.getPlayer();
+        AtomicReference<BigInteger> teaAmount = new AtomicReference<>(BigInteger.ZERO);
+        builder.widgets(
+            posCenteredHorizontally(
+                10,
+                new TextWidget(
+                    new Text("Tea Acceptor").format(EnumChatFormatting.BOLD)
+                        .format(EnumChatFormatting.DARK_RED))),
+            posCenteredHorizontally(30, new DynamicTextWidget(() -> {
+                if (player.getPersistentID()
+                    .equals(tileOwner)) return new Text("[Tea]").color(Color.GREEN.normal);
+                else return new Text("This is not your block").color(Color.RED.normal);
+            })),
+            posCenteredHorizontally(
+                40,
+                (TextWidget) new DynamicTextWidget(
+                    () -> new Text(
+                        StringUtils.applyRainbow(
+                            NEIClientUtils.shiftKey() ? numberFormat.format(teaAmount.get())
+                                : numberFormatScientific.format(teaAmount.get()),
+                            (int) ((teaAmount.get()
+                                .longValue() / Math.max(1, averageInput * 10)) % Integer.MAX_VALUE),
+                            EnumChatFormatting.BOLD.toString())).shadow()).setSynced(false)
+                                .attachSyncer(
+                                    new FakeSyncWidget.BigIntegerSyncer(() -> teaNetwork.teaAmount, teaAmount::set),
+                                    builder)),
+            posCenteredHorizontally(
+                50,
+                new DynamicTextWidget(() -> new Text("IN: " + averageInput + "/t").color(Color.BLACK.normal)))
+                    .addTooltip(new Text("Average input from the last 5 seconds").color(Color.GRAY.normal)));
+        return builder.build();
+    }
+}
diff --git a/src/main/java/kubatech/tileentity/TeaStorageTile.java b/src/main/java/kubatech/tileentity/TeaStorageTile.java
new file mode 100644
index 0000000000..46278e9853
--- /dev/null
+++ b/src/main/java/kubatech/tileentity/TeaStorageTile.java
@@ -0,0 +1,83 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024  kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.tileentity;
+
+import java.math.BigInteger;
+import java.util.UUID;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+import kubatech.api.tea.TeaNetwork;
+
+public class TeaStorageTile extends TileEntity {
+
+    public TeaStorageTile() {
+        super();
+    }
+
+    private UUID tileOwner = null;
+    private TeaNetwork teaNetwork = null;
+
+    public void setTeaOwner(UUID teaOwner) {
+        if (tileOwner == null) {
+            tileOwner = teaOwner;
+            teaNetwork = TeaNetwork.getNetwork(tileOwner);
+            markDirty();
+            teaNetwork.registerTeaStorageExtender(this);
+        }
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound NBTData) {
+        super.readFromNBT(NBTData);
+        try {
+            tileOwner = UUID.fromString(NBTData.getString("tileOwner"));
+            teaNetwork = TeaNetwork.getNetwork(tileOwner);
+            teaNetwork.registerTeaStorageExtender(this);
+        } catch (Exception ignored) {}
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound NBTData) {
+        super.writeToNBT(NBTData);
+        NBTData.setString("tileOwner", tileOwner.toString());
+    }
+
+    @Override
+    public boolean canUpdate() {
+        return false;
+    }
+
+    public BigInteger teaExtendAmount() {
+        return BigInteger.valueOf(Long.MAX_VALUE);
+    }
+
+    @Override
+    public void onChunkUnload() {
+        if (teaNetwork != null) teaNetwork.unregisterTeaStorageExtender(this);
+    }
+
+    @Override
+    public void invalidate() {
+        if (teaNetwork != null) teaNetwork.unregisterTeaStorageExtender(this);
+    }
+}
diff --git a/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_DEFusionCrafter.java b/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_DEFusionCrafter.java
new file mode 100644
index 0000000000..f0579bf054
--- /dev/null
+++ b/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_DEFusionCrafter.java
@@ -0,0 +1,281 @@
+package kubatech.tileentity.gregtech.multiblock;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlocksTiered;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_HatchElement.Energy;
+import static gregtech.api.enums.GT_HatchElement.InputBus;
+import static gregtech.api.enums.GT_HatchElement.InputHatch;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_HatchElement.OutputBus;
+import static gregtech.api.enums.GT_HatchElement.OutputHatch;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_GLOW;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static kubatech.api.Variables.StructureHologram;
+import static kubatech.api.Variables.buildAuthorList;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_Recipe;
+import kubatech.Tags;
+import kubatech.api.implementations.KubaTechGTMultiBlockBase;
+import kubatech.loaders.BlockLoader;
+import kubatech.loaders.DEFCRecipes;
+
+public class GT_MetaTileEntity_DEFusionCrafter extends KubaTechGTMultiBlockBase<GT_MetaTileEntity_DEFusionCrafter>
+    implements ISurvivalConstructable {
+
+    private static final int CASING_INDEX = (1 << 7) + (15 + 48);
+    private int mTierCasing = 0;
+    private int mFusionTierCasing = 0;
+    private int mCasing = 0;
+
+    @SuppressWarnings("unused")
+    public GT_MetaTileEntity_DEFusionCrafter(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_DEFusionCrafter(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_DEFusionCrafter(mName);
+    }
+
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final List<Pair<Block, Integer>> fusionCasingTiers = Arrays
+        .asList(Pair.of(GregTech_API.sBlockCasings4, 6), Pair.of(GregTech_API.sBlockCasings4, 8));
+    private static final List<Pair<Block, Integer>> coreTiers = Arrays.asList(
+        Pair.of(BlockLoader.defcCasingBlock, 8),
+        Pair.of(BlockLoader.defcCasingBlock, 9),
+        Pair.of(BlockLoader.defcCasingBlock, 10),
+        Pair.of(BlockLoader.defcCasingBlock, 11),
+        Pair.of(BlockLoader.defcCasingBlock, 12));
+    private static final IStructureDefinition<GT_MetaTileEntity_DEFusionCrafter> STRUCTURE_DEFINITION = StructureDefinition
+        .<GT_MetaTileEntity_DEFusionCrafter>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            transpose(
+                new String[][] { // spotless:off
+                    { "nnnnn", "nnnnn", "nnnnn", "nnnnn", "nnnnn" },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "RRRRR", "R F R", "RFfFR", "R F R", "RRRRR" },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "RRRRR", "R F R", "RFfFR", "R F R", "RRRRR" },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "     ", "  F  ", " FfF ", "  F  ", "     " },
+                    { "NN~NN", "NNNNN", "NNNNN", "NNNNN", "NNNNN" }
+                })) // spotless:on
+        .addElement(
+            'N',
+            buildHatchAdder(GT_MetaTileEntity_DEFusionCrafter.class)
+                .atLeast(InputBus, InputHatch, OutputBus, OutputHatch, Energy, Maintenance)
+                .casingIndex(CASING_INDEX)
+                .dot(1)
+                .buildAndChain(onElementPass(e -> e.mCasing++, ofBlock(BlockLoader.defcCasingBlock, 7))))
+        .addElement('n', onElementPass(e -> e.mCasing++, ofBlock(BlockLoader.defcCasingBlock, 7)))
+        .addElement('f', ofBlock(GregTech_API.sBlockCasings4, 7))
+        .addElement('F', ofBlocksTiered((Block b, int m) -> {
+            if (b != GregTech_API.sBlockCasings4 || (m != 6 && m != 8)) return -2;
+            return m == 6 ? 1 : 2;
+        }, fusionCasingTiers, -1, (e, i) -> e.mFusionTierCasing = i, e -> e.mFusionTierCasing))
+        .addElement('R', ofBlocksTiered((Block b, int m) -> {
+            if (b != BlockLoader.defcCasingBlock || m < 8 || m > 12) return -2;
+            return m - 7;
+        }, coreTiers, -1, (e, i) -> e.mTierCasing = i, e -> e.mTierCasing))
+        .build();
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_DEFusionCrafter> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        mCasing = 0;
+        mTierCasing = -1;
+        mFusionTierCasing = -1;
+        if (!checkPiece(STRUCTURE_PIECE_MAIN, 2, 9, 0)) return false;
+        if (mCasing < 19) return false;
+        if (mTierCasing == -2 || mFusionTierCasing == -2) return false;
+        if (mTierCasing > 3 && mFusionTierCasing < 2) return false;
+        return mMaintenanceHatches.size() == 1;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fusion Crafter")
+            .addInfo("Controller Block for the Draconic Evolution Fusion Crafter")
+            .addInfo(buildAuthorList("kuba6000", "Prometheus0000"))
+            .addInfo("Machine can be overclocked by using casings above the recipe tier:")
+            .addInfo("Recipe time is divided by number of tiers above the recipe")
+            .addInfo("Normal EU OC still applies !")
+            .addInfo(StructureHologram)
+            .addSeparator()
+            .beginStructureBlock(5, 10, 5, false)
+            .addController("Front bottom center")
+            .addCasingInfoMin("Naquadah Alloy Fusion Casing", 19, false)
+            .addOtherStructurePart("Fusion Coil Block", "Center pillar")
+            .addOtherStructurePart("Fusion Machine Casing", "Touching Fusion Coil Block at every side")
+            .addOtherStructurePart("Tiered Fusion Casing", "Rings (5x5 hollow) at layer 4 and 7")
+            .addStructureInfo("Bloody Ichorium for tier 1, Draconium for tier 2, etc")
+            .addStructureInfo("To use tier 3 + you have to use fusion casing MK II")
+            .addInputBus("Any bottom casing", 1)
+            .addInputHatch("Any bottom casing", 1)
+            .addOutputBus("Any bottom casing", 1)
+            .addOutputHatch("Any bottom casing", 1)
+            .addEnergyHatch("Any bottom casing", 1)
+            .addMaintenanceHatch("Any bottom casing", 1)
+            .toolTipFinisher(Tags.MODNAME);
+        return tt;
+    }
+
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { TextureFactory.of(MACHINE_CASING_MAGIC), TextureFactory.builder()
+                .addIcon(OVERLAY_TELEPORTER_ACTIVE)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_TELEPORTER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { TextureFactory.of(MACHINE_CASING_MAGIC), TextureFactory.builder()
+                .addIcon(OVERLAY_TELEPORTER)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_TELEPORTER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        if (aActive) return new ITexture[] { TextureFactory.of(MACHINE_CASING_MAGIC), TextureFactory.builder()
+            .addIcon(MACHINE_CASING_MAGIC_ACTIVE)
+            .extFacing()
+            .build(),
+            TextureFactory.builder()
+                .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                .extFacing()
+                .glow()
+                .build() };
+        return new ITexture[] { TextureFactory.of(MACHINE_CASING_MAGIC), TextureFactory.builder()
+            .addIcon(MACHINE_CASING_MAGIC)
+            .extFacing()
+            .build(),
+            TextureFactory.builder()
+                .addIcon(MACHINE_CASING_MAGIC_GLOW)
+                .extFacing()
+                .glow()
+                .build() };
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return DEFCRecipes.fusionCraftingRecipes;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) {
+                return recipe.mSpecialValue <= mTierCasing ? CheckRecipeResultRegistry.SUCCESSFUL
+                    : CheckRecipeResultRegistry.insufficientMachineTier(recipe.mSpecialValue);
+            }
+
+            @NotNull
+            @Override
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return super.createOverclockCalculator(recipe)
+                    .setSpeedBoost(1f / (mTierCasing - recipe.mSpecialValue + 1));
+            }
+        };
+    }
+
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        buildPiece(STRUCTURE_PIECE_MAIN, itemStack, b, 2, 9, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 9, 0, elementBudget, env, true, true);
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsInputSeparation() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+}
diff --git a/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_ExtremeEntityCrusher.java b/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_ExtremeEntityCrusher.java
new file mode 100644
index 0000000000..be0c628066
--- /dev/null
+++ b/src/main/java/kubatech/tileentity/gregtech/multiblock/GT_MetaTileEntity_ExtremeEntityCrusher.java
@@ -0,0 +1,822 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024  kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.tileentity.gregtech.multiblock;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.isAir;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_HatchElement.Energy;
+import static gregtech.api.enums.GT_HatchElement.InputBus;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_HatchElement.OutputBus;
+import static gregtech.api.enums.GT_HatchElement.OutputHatch;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_GLOW;
+import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+import static kubatech.api.Variables.Author;
+import static kubatech.api.Variables.StructureHologram;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.UUID;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.EnumCreatureAttribute;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.attributes.AttributeModifier;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.EnumDifficulty;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldProviderHell;
+import net.minecraft.world.WorldServer;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.FakePlayer;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass;
+import com.google.common.collect.Multimap;
+import com.gtnewhorizon.structurelib.alignment.IAlignmentLimits;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.api.forge.ItemStackHandler;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedRow;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.kuba6000.mobsinfo.api.utils.FastRandom;
+import com.mojang.authlib.GameProfile;
+
+import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry;
+import WayofTime.alchemicalWizardry.api.event.RitualRunEvent;
+import WayofTime.alchemicalWizardry.api.rituals.Rituals;
+import WayofTime.alchemicalWizardry.api.soulNetwork.SoulNetworkHandler;
+import WayofTime.alchemicalWizardry.api.tile.IBloodAltar;
+import WayofTime.alchemicalWizardry.common.rituals.RitualEffectWellOfSuffering;
+import WayofTime.alchemicalWizardry.common.tileEntity.TEMasterStone;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import crazypants.enderio.EnderIO;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.recipe.check.SimpleCheckRecipeResult;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import kubatech.Tags;
+import kubatech.api.LoaderReference;
+import kubatech.api.helpers.ReflectionHelper;
+import kubatech.api.implementations.KubaTechGTMultiBlockBase;
+import kubatech.api.tileentity.CustomTileEntityPacketHandler;
+import kubatech.api.utils.ModUtils;
+import kubatech.client.effect.EntityRenderer;
+import kubatech.loaders.MobHandlerLoader;
+import kubatech.network.CustomTileEntityPacket;
+
+public class GT_MetaTileEntity_ExtremeEntityCrusher
+    extends KubaTechGTMultiBlockBase<GT_MetaTileEntity_ExtremeEntityCrusher>
+    implements CustomTileEntityPacketHandler, ISurvivalConstructable {
+
+    public static final double DIAMOND_SPIKES_DAMAGE = 9d;
+    // Powered spawner with octadic capacitor spawns ~22/min ~= 0.366/sec ~= 2.72s/spawn ~= 54.54t/spawn
+    public static final int MOB_SPAWN_INTERVAL = 55;
+    public final Random rand = new FastRandom();
+    private final WeaponCache weaponCache;
+
+    @SuppressWarnings("unused")
+    public GT_MetaTileEntity_ExtremeEntityCrusher(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+        weaponCache = new WeaponCache(mInventory);
+    }
+
+    public GT_MetaTileEntity_ExtremeEntityCrusher(String aName) {
+        super(aName);
+        weaponCache = new WeaponCache(mInventory);
+        if (LoaderReference.BloodMagic) MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @Override
+    public void onRemoval() {
+        if (LoaderReference.BloodMagic) MinecraftForge.EVENT_BUS.unregister(this);
+        if (getBaseMetaTileEntity().isClientSide() && entityRenderer != null) {
+            entityRenderer.setDead();
+        }
+    }
+
+    @Override
+    public void onUnload() {
+        if (LoaderReference.BloodMagic) MinecraftForge.EVENT_BUS.unregister(this);
+    }
+
+    private static final String WellOfSufferingRitualName = "AW013Suffering";
+
+    private static final Item poweredSpawnerItem = Item.getItemFromBlock(EnderIO.blockPoweredSpawner);
+    private static final int CASING_INDEX = 16;
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final IStructureDefinition<GT_MetaTileEntity_ExtremeEntityCrusher> STRUCTURE_DEFINITION = StructureDefinition
+        .<GT_MetaTileEntity_ExtremeEntityCrusher>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            transpose(
+                new String[][] { // spotless:off
+                    { "ccccc", "ccccc", "ccccc", "ccccc", "ccccc" },
+                    { "fgggf", "g---g", "g---g", "g---g", "fgggf" },
+                    { "fgggf", "g---g", "g---g", "g---g", "fgggf" },
+                    { "fgggf", "g---g", "g---g", "g---g", "fgggf" },
+                    { "fgggf", "g---g", "g---g", "g---g", "fgggf" },
+                    { "fgggf", "gsssg", "gsssg", "gsssg", "fgggf" },
+                    { "CC~CC", "CCCCC", "CCCCC", "CCCCC", "CCCCC" },
+                })) // spotless:on
+        .addElement('c', onElementPass(t -> t.mCasing++, ofBlock(GregTech_API.sBlockCasings2, 0)))
+        .addElement(
+            'C',
+            buildHatchAdder(GT_MetaTileEntity_ExtremeEntityCrusher.class)
+                .atLeast(InputBus, OutputBus, OutputHatch, Energy, Maintenance)
+                .casingIndex(CASING_INDEX)
+                .dot(1)
+                .buildAndChain(onElementPass(t -> t.mCasing++, ofBlock(GregTech_API.sBlockCasings2, 0))))
+        .addElement(
+            'g',
+            LoaderReference.Bartworks
+                ? BorosilicateGlass.ofBoroGlass((byte) 0, (t, v) -> t.mGlassTier = v, t -> t.mGlassTier)
+                : onElementPass(t -> t.mGlassTier = 100, ofBlock(Blocks.glass, 0)))
+        .addElement('f', ofFrame(Materials.Steel))
+        .addElement(
+            's',
+            LoaderReference.ExtraUtilities ? ofBlock(Block.getBlockFromName("ExtraUtilities:spike_base_diamond"), 0)
+                : isAir())
+        .build();
+
+    private TileEntity masterStoneRitual = null;
+    private TileEntity tileAltar = null;
+    private boolean isInRitualMode = false;
+    private int mCasing = 0;
+    private byte mGlassTier = 0;
+    private boolean mAnimationEnabled = true;
+    private boolean mIsProducingInfernalDrops = true;
+    private boolean voidAllDamagedAndEnchantedItems = false;
+
+    private EntityRenderer entityRenderer = null;
+    private boolean renderEntity = false;
+    public EECFakePlayer EECPlayer = null;
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setBoolean("isInRitualMode", isInRitualMode);
+        aNBT.setBoolean("mAnimationEnabled", mAnimationEnabled);
+        aNBT.setByte("mGlassTier", mGlassTier);
+        aNBT.setBoolean("mIsProducingInfernalDrops", mIsProducingInfernalDrops);
+        aNBT.setBoolean("voidAllDamagedAndEnchantedItems", voidAllDamagedAndEnchantedItems);
+        if (weaponCache.getStackInSlot(0) != null) aNBT.setTag(
+            "weaponCache",
+            weaponCache.getStackInSlot(0)
+                .writeToNBT(new NBTTagCompound()));