The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

12 files changed, 3833 insertions, 0 deletions

diff --git a/src/main/java/gtnhlanth/common/tileentity/MTEDigester.java b/src/main/java/gtnhlanth/common/tileentity/MTEDigester.java
new file mode 100644
index 0000000000..9e1fc65c1b
--- /dev/null
+++ b/src/main/java/gtnhlanth/common/tileentity/MTEDigester.java
@@ -0,0 +1,240 @@
+package gtnhlanth.common.tileentity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.HatchElement.Energy;
+import static gregtech.api.enums.HatchElement.InputBus;
+import static gregtech.api.enums.HatchElement.InputHatch;
+import static gregtech.api.enums.HatchElement.Maintenance;
+import static gregtech.api.enums.HatchElement.Muffler;
+import static gregtech.api.enums.HatchElement.OutputBus;
+import static gregtech.api.enums.HatchElement.OutputHatch;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages;
+import static gregtech.api.util.GTStructureUtility.buildHatchAdder;
+import static gregtech.api.util.GTStructureUtility.ofCoil;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+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.GregTechAPI;
+import gregtech.api.enums.HeatingCoilLevel;
+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.metatileentity.implementations.MTEEnhancedMultiBlockBase;
+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.GTRecipe;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.api.util.OverclockCalculator;
+import gtnhlanth.api.recipe.LanthanidesRecipeMaps;
+import gtnhlanth.util.DescTextLocalization;
+
+public class MTEDigester extends MTEEnhancedMultiBlockBase<MTEDigester> implements ISurvivalConstructable {
+
+    protected int casingAmount = 0;
+    protected int height = 0;
+
+    private HeatingCoilLevel heatLevel;
+
+    private final IStructureDefinition<MTEDigester> multiDefinition = StructureDefinition.<MTEDigester>builder()
+        .addShape(
+            mName,
+            transpose(
+                new String[][] { { "       ", " ttttt ", " t---t ", " t---t ", " t---t ", " ttttt ", "       " },
+                    { "  ttt  ", " t---t ", "t-----t", "t-----t", "t-----t", " t---t ", "  ttt  " },
+                    { " tccct ", "tc---ct", "c-----c", "c-----c", "c-----c", "tc---ct", " tccct " },
+                    { " tt~tt ", "thhhhht", "thsssht", "thsssht", "thsssht", "thhhhht", " ttttt " }, }))
+
+        .addElement(
+            't',
+            buildHatchAdder(MTEDigester.class)
+                .atLeast(InputHatch, OutputHatch, InputBus, OutputBus, Maintenance, Energy, Muffler)
+                .casingIndex(47)
+                .dot(1)
+                .buildAndChain(GregTechAPI.sBlockCasings4, 0))
+        .addElement('h', ofBlock(GregTechAPI.sBlockCasings1, 11))
+        .addElement('s', ofBlock(GregTechAPI.sBlockCasings4, 1))
+        .addElement('c', ofCoil(MTEDigester::setCoilLevel, MTEDigester::getCoilLevel))
+        .build();
+
+    public MTEDigester(String name) {
+        super(name);
+    }
+
+    public MTEDigester(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return checkPiece(mName, 3, 3, 0) && !mMufflerHatches.isEmpty() && mMaintenanceHatches.size() == 1;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    public HeatingCoilLevel getCoilLevel() {
+        return this.heatLevel;
+    }
+
+    public void setCoilLevel(HeatingCoilLevel level) {
+        this.heatLevel = level;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return LanthanidesRecipeMaps.digesterRecipes;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @Nonnull
+            @Override
+            protected OverclockCalculator createOverclockCalculator(@Nonnull GTRecipe recipe) {
+                return super.createOverclockCalculator(recipe).enablePerfectOC();
+            }
+
+            @Override
+            protected @Nonnull CheckRecipeResult validateRecipe(@Nonnull GTRecipe recipe) {
+                return recipe.mSpecialValue <= MTEDigester.this.getCoilLevel()
+                    .getHeat() ? CheckRecipeResultRegistry.SUCCESSFUL
+                        : CheckRecipeResultRegistry.insufficientHeat(recipe.mSpecialValue);
+            }
+
+        };
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsInputSeparation() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsSingleRecipeLocking() {
+        return true;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack itemStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 20;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) {
+        return new MTEDigester(this.mName);
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        buildPiece(mName, itemStack, b, 3, 3, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 3, 3, 0, elementBudget, env, false, true);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack arg0) {
+        return DescTextLocalization.addText("Digester.hint", 6);
+    }
+
+    public ITexture[] getTexture(IGregTechTileEntity te, ForgeDirection side, ForgeDirection facing, int colorIndex,
+        boolean active, boolean redstone) {
+
+        // Oil Cracker textures cuz I'm lazy
+
+        if (side == facing) {
+            if (active) return new ITexture[] { casingTexturePages[0][47], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { casingTexturePages[0][47], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_OIL_CRACKER)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_OIL_CRACKER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { casingTexturePages[0][47] };
+    }
+
+    @Override
+    protected MultiblockTooltipBuilder createTooltip() {
+        final MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder();
+        tt.addMachineType("Digester")
+            .addInfo("Controller block for the Digester")
+            .addInfo("Input ores and fluid, output water.")
+            .addInfo(DescTextLocalization.BLUEPRINT_INFO)
+            .addSeparator()
+            .addController("Front bottom")
+            .addInputHatch("Hint block with dot 1")
+            .addInputBus("Hint block with dot 1")
+            .addOutputHatch("Hint block with dot 1")
+            .addOutputBus("Hint block with dot 1")
+            .addMaintenanceHatch("Hint block with dot 1")
+            .addMufflerHatch("Hint block with dot 1")
+            .toolTipFinisher("GTNH: Lanthanides");
+        return tt;
+    }
+
+    @Override
+    public IStructureDefinition<MTEDigester> getStructureDefinition() {
+        return multiDefinition;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack arg0) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack arg0) {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+}
diff --git a/src/main/java/gtnhlanth/common/tileentity/MTEDissolutionTank.java b/src/main/java/gtnhlanth/common/tileentity/MTEDissolutionTank.java
new file mode 100644
index 0000000000..7d5a64b579
--- /dev/null
+++ b/src/main/java/gtnhlanth/common/tileentity/MTEDissolutionTank.java
@@ -0,0 +1,264 @@
+package gtnhlanth.common.tileentity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAdder;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.HatchElement.Energy;
+import static gregtech.api.enums.HatchElement.InputBus;
+import static gregtech.api.enums.HatchElement.InputHatch;
+import static gregtech.api.enums.HatchElement.Maintenance;
+import static gregtech.api.enums.HatchElement.OutputBus;
+import static gregtech.api.enums.HatchElement.OutputHatch;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages;
+import static gregtech.api.util.GTStructureUtility.buildHatchAdder;
+
+import java.util.Arrays;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+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 bartworks.common.loaders.ItemRegistry;
+import gregtech.api.GregTechAPI;
+import gregtech.api.interfaces.ISecondaryDescribable;
+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.metatileentity.implementations.MTEEnhancedMultiBlockBase;
+import gregtech.api.recipe.RecipeMap;
+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.GTRecipe;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import gtnhlanth.api.recipe.LanthanidesRecipeMaps;
+import gtnhlanth.util.DescTextLocalization;
+
+public class MTEDissolutionTank extends MTEEnhancedMultiBlockBase<MTEDissolutionTank>
+    implements ISurvivalConstructable, ISecondaryDescribable {
+
+    private final IStructureDefinition<MTEDissolutionTank> multiDefinition = StructureDefinition
+        .<MTEDissolutionTank>builder()
+        .addShape(
+            mName,
+            transpose(
+                new String[][] { { " sss ", "sssss", "sssss", "sssss", " sss " },
+                    { "sgggs", "g---g", "g---g", "g---g", "sgggs" }, { "sgggs", "g---g", "g---g", "g---g", "sgggs" },
+                    { "ss~ss", "shhhs", "shhhs", "shhhs", "sssss" }, { "s   s", "     ", "     ", "     ", "s   s" } }))
+        .addElement(
+            's',
+            buildHatchAdder(MTEDissolutionTank.class)
+                .atLeast(InputHatch, OutputHatch, InputBus, OutputBus, Maintenance, Energy)
+                .casingIndex(49)
+                .dot(1)
+                .buildAndChain(GregTechAPI.sBlockCasings4, 1))
+        .addElement('h', ofBlock(GregTechAPI.sBlockCasings1, 11))
+        .addElement('g', ofBlockAdder(MTEDissolutionTank::addGlass, ItemRegistry.bw_glasses[0], 1))
+        .build();
+
+    public MTEDissolutionTank(String name) {
+        super(name);
+    }
+
+    public MTEDissolutionTank(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    @Override
+    public IStructureDefinition<MTEDissolutionTank> getStructureDefinition() {
+        return multiDefinition;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return checkPiece(mName, 2, 3, 0) && mMaintenanceHatches.size() == 1;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    private boolean addGlass(Block block, int meta) {
+        return block == ItemRegistry.bw_glasses[0];
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return LanthanidesRecipeMaps.dissolutionTankRecipes;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult onRecipeStart(@Nonnull GTRecipe recipe) {
+                if (!checkRatio(recipe, Arrays.asList(inputFluids))) {
+                    criticalStopMachine();
+                    return SimpleCheckRecipeResult.ofFailurePersistOnShutdown("dissolution_ratio");
+                }
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+
+        };
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsInputSeparation() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsSingleRecipeLocking() {
+        return true;
+    }
+
+    private boolean checkRatio(GTRecipe tRecipe, List<FluidStack> tFluidInputs) {
+        FluidStack majorGenericFluid = tRecipe.mFluidInputs[0];
+        FluidStack minorGenericFluid = tRecipe.mFluidInputs[1];
+
+        int majorAmount;
+        int minorAmount;
+
+        FluidStack fluidInputOne = tFluidInputs.get(0);
+        FluidStack fluidInputTwo = tFluidInputs.get(1);
+
+        if (fluidInputOne.getUnlocalizedName()
+            .equals(majorGenericFluid.getUnlocalizedName())) {
+            if (fluidInputTwo.getUnlocalizedName()
+                .equals(minorGenericFluid.getUnlocalizedName())) {
+                // majorInput = fluidInputOne;
+                majorAmount = fluidInputOne.amount;
+                // minorInput = fluidInputTwo;
+                minorAmount = fluidInputTwo.amount;
+                // GTLog.out.print("in first IF");
+            } else return false; // No valid other input
+
+        } else if (fluidInputTwo.getUnlocalizedName()
+            .equals(majorGenericFluid.getUnlocalizedName())) {
+                if (fluidInputOne.getUnlocalizedName()
+                    .equals(minorGenericFluid.getUnlocalizedName())) {
+                    // majorInput = fluidInputTwo;
+                    majorAmount = fluidInputTwo.amount;
+                    // minorInput = fluidInputOne;
+                    minorAmount = fluidInputOne.amount;
+                    // GTLog.out.print("in second if");
+                } else return false;
+
+            } else return false;
+
+        return majorAmount / tRecipe.mSpecialValue == minorAmount;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack itemStack) {
+        return 10000;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) {
+        return new MTEDissolutionTank(this.mName);
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        buildPiece(mName, itemStack, b, 2, 3, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 2, 3, 0, elementBudget, env, false, true);
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack arg0) {
+        return DescTextLocalization.addText("DissolutionTank.hint", 4);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity te, ForgeDirection side, ForgeDirection facing, int colorIndex,
+        boolean active, boolean redstone) {
+
+        if (side == facing) {
+            if (active) return new ITexture[] { casingTexturePages[0][49], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { casingTexturePages[0][49], TextureFactory.builder()
+                .addIcon(OVERLAY_FRONT_OIL_CRACKER)
+                .extFacing()
+                .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_OIL_CRACKER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { casingTexturePages[0][49] };
+    }
+
+    @Override
+    protected MultiblockTooltipBuilder createTooltip() {
+        final MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder();
+        tt.addMachineType("Dissolution Tank")
+            .addInfo("Controller block for the Dissolution Tank")
+            .addInfo("Input Water and Fluid, output Fluid")
+            .addInfo("You must input the Fluids at the correct Ratio")
+            .addInfo(DescTextLocalization.BLUEPRINT_INFO)
+            .addSeparator()
+            .addController("Front bottom")
+            .addInputHatch("Hint block with dot 1")
+            .addInputBus("Hint block with dot 1")
+            .addOutputHatch("Hint block with dot 1")
+            .addOutputBus("Hint block with dot 1")
+            .addMaintenanceHatch("Hint block with dot 1")
+            .toolTipFinisher("GTNH: Lanthanides");
+
+        return tt;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack arg0) {
+        return false;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack arg0) {
+        return 0;
+    }
+}
diff --git a/src/main/java/gtnhlanth/common/tileentity/MTELINAC.java b/src/main/java/gtnhlanth/common/tileentity/MTELINAC.java
new file mode 100644
index 0000000000..78ea9c7846
--- /dev/null
+++ b/src/main/java/gtnhlanth/common/tileentity/MTELINAC.java
@@ -0,0 +1,749 @@
+package gtnhlanth.common.tileentity;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static gregtech.api.enums.GTValues.VN;
+import static gregtech.api.enums.HatchElement.Energy;
+import static gregtech.api.enums.HatchElement.InputHatch;
+import static gregtech.api.enums.HatchElement.Maintenance;
+import static gregtech.api.enums.HatchElement.OutputHatch;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages;
+import static gregtech.api.util.GTStructureUtility.buildHatchAdder;
+import static gtnhlanth.util.DescTextLocalization.addDotText;
+
+import java.util.ArrayList;
+import java.util.Objects;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.gtnewhorizon.structurelib.StructureLib;
+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 bartworks.API.BorosilicateGlass;
+import gregtech.api.GregTechAPI;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.TickTime;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.MTEEnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.MTEHatchEnergy;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.api.util.shutdown.ShutDownReason;
+import gregtech.api.util.shutdown.SimpleShutDownReason;
+import gtnhlanth.common.beamline.BeamInformation;
+import gtnhlanth.common.beamline.BeamLinePacket;
+import gtnhlanth.common.beamline.Particle;
+import gtnhlanth.common.hatch.MTEHatchInputBeamline;
+import gtnhlanth.common.hatch.MTEHatchOutputBeamline;
+import gtnhlanth.common.register.LanthItemList;
+import gtnhlanth.common.tileentity.recipe.beamline.BeamlineRecipeLoader;
+import gtnhlanth.util.DescTextLocalization;
+import gtnhlanth.util.Util;
+
+public class MTELINAC extends MTEEnhancedMultiBlockBase<MTELINAC> implements ISurvivalConstructable {
+
+    private static final IStructureDefinition<MTELINAC> STRUCTURE_DEFINITION;
+
+    protected static final String STRUCTURE_PIECE_BASE = "base";
+    protected static final String STRUCTURE_PIECE_LAYER = "layer";
+    protected static final String STRUCTURE_PIECE_END = "end";
+
+    private byte glassTier;
+
+    private boolean onEndInnerLayer = false;
+
+    private int machineTemp = 0; // Coolant temperature
+
+    private ArrayList<MTEHatchInputBeamline> mInputBeamline = new ArrayList<>();
+    private ArrayList<MTEHatchOutputBeamline> mOutputBeamline = new ArrayList<>();
+
+    private static final int CASING_INDEX = GTUtility.getCasingTextureIndex(GregTechAPI.sBlockCasings5, 14);
+
+    private static final byte MIN_GLASS_TIER = 6;
+
+    /*
+     * g: Grate Machine Casing b: Borosilicate glass c: Shielded accelerator casing v: Vacuum k: Shielded glass d:
+     * Coolant Delivery casing y: Superconducting coil
+     */
+
+    static {
+        STRUCTURE_DEFINITION = StructureDefinition.<MTELINAC>builder()
+            .addShape(
+                STRUCTURE_PIECE_BASE,
+                new String[][] { { "ggggggg", "gbbbbbg", "gbbbbbg", "gbbibbg", "gbbbbbg", "gbbbbbg", "ggg~ggg" },
+                    { "ggggggg", "gcccccg", "gcccccg", "gcc-ccg", "gcccccg", "gcccccg", "ggggggg" },
+                    { "ccccccc", "cvvvvvc", "kvvvvvk", "kvv-vvk", "kvvvvvk", "cvvvvvc", "jcccccj" },
+                    { "cckkkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "jcccccj" },
+                    { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "jcccccj" },
+                    { "cckkkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "jcccccj" },
+                    { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "jcccccj" },
+                    { "cckhkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "jcccccj" }, })
+            .addShape(
+                STRUCTURE_PIECE_LAYER,
+                new String[][] { { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "ccccccc" },
+                    { "cckkkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "ccccccc" } })
+            .addShape(
+                STRUCTURE_PIECE_END,
+                new String[][] { { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "ccccccc" },
+                    { "cckhkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "ccccccc" },
+                    { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "ccccccc" },
+                    { "cckkkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "ccccccc" },
+                    { "cckkkcc", "cdvvvdc", "kvvvvvk", "kdv-vdk", "kvvvvvk", "cdvvvdc", "ccccccc" },
+                    { "cckkkcc", "cdddddc", "kdyyydk", "kdy-ydk", "kdyyydk", "cdddddc", "ccccccc" },
+                    { "ccccccc", "cvvvvvc", "kvvvvvk", "kvv-vvk", "kvvvvvk", "cvvvvvc", "ccccccc" },
+                    { "ccccccc", "ccccccc", "ccccccc", "ccc-ccc", "ccccccc", "ccccccc", "ccccccc" },
+                    { "ccccccc", "cbbbbbc", "cbbbbbc", "cbbobbc", "cbbbbbc", "cbbbbbc", "ccccccc" } })
+            .addElement('c', ofBlock(LanthItemList.SHIELDED_ACCELERATOR_CASING, 0))
+            .addElement('g', ofBlock(GregTechAPI.sBlockCasings3, 10)) // Grate Machine Casing
+            .addElement(
+                'b',
+                BorosilicateGlass.ofBoroGlass(
+                    (byte) 0,
+                    MIN_GLASS_TIER,
+                    Byte.MAX_VALUE,
+                    (te, t) -> te.glassTier = t,
+                    te -> te.glassTier))
+            .addElement(
+                'i',
+                buildHatchAdder(MTELINAC.class).hatchClass(MTEHatchInputBeamline.class)
+                    .casingIndex(CASING_INDEX)
+                    .dot(3)
+                    .adder(MTELINAC::addBeamLineInputHatch)
+                    .build())
+            .addElement(
+                'o',
+                buildHatchAdder(MTELINAC.class).hatchClass(MTEHatchOutputBeamline.class)
+                    .casingIndex(CASING_INDEX)
+                    .dot(4)
+                    .adder(MTELINAC::addBeamLineOutputHatch)
+                    .build())
+            .addElement('v', ofBlock(LanthItemList.ELECTRODE_CASING, 0))
+            .addElement('k', ofBlock(LanthItemList.SHIELDED_ACCELERATOR_GLASS, 0))
+            .addElement('d', ofBlock(LanthItemList.COOLANT_DELIVERY_CASING, 0))
+            .addElement('y', ofBlock(GregTechAPI.sBlockCasings1, 15)) // Superconducting coil
+            .addElement(
+                'h',
+                buildHatchAdder(MTELINAC.class).atLeast(InputHatch, OutputHatch)
+                    .casingIndex(CASING_INDEX)
+                    .dot(2)
+                    .build())
+
+            .addElement(
+                'j',
+                buildHatchAdder(MTELINAC.class).atLeast(Maintenance, Energy)
+                    .casingIndex(CASING_INDEX)
+                    .dot(1)
+                    .buildAndChain(ofBlock(LanthItemList.SHIELDED_ACCELERATOR_CASING, 0)))
+
+            .build();
+    }
+
+    private float outputEnergy;
+    private int outputRate;
+    private int outputParticle;
+    private float outputFocus;
+
+    private int length;
+
+    public MTELINAC(int id, String name, String nameRegional) {
+        super(id, name, nameRegional);
+    }
+
+    public MTELINAC(String name) {
+        super(name);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity te) {
+        return new MTELINAC(this.mName);
+    }
+
+    @Override
+    protected MultiblockTooltipBuilder createTooltip() {
+        final MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder();
+        tt.addMachineType("Particle Accelerator")
+            .addInfo("Controller block for the LINAC")
+            .addInfo("Accelerates charged particles to higher energies")
+            .addInfo("Increasing length increases output energy, but decreases focus")
+            .addInfo("Use a lower temperature coolant to improve focus")
+            // .addInfo("Extendable, with a minimum length of 18 blocks")
+            .addInfo(DescTextLocalization.BLUEPRINT_INFO)
+            .addInfo(DescTextLocalization.BEAMLINE_SCANNER_INFO)
+            .addInfo("Valid Coolants:");
+
+        // Valid coolant list
+        for (String fluidName : BeamlineRecipeLoader.coolantMap.keySet()) {
+
+            tt.addInfo(
+                "- " + FluidRegistry.getFluid(fluidName)
+                    .getLocalizedName(null));
+
+        }
+
+        tt.addInfo("Requires (length + 1)kL/s of coolant")
+            .addSeparator()
+            .beginVariableStructureBlock(7, 7, 7, 7, 19, 83, false)
+            .addController("Front bottom")
+            .addCasingInfoRange(LanthItemList.SHIELDED_ACCELERATOR_CASING.getLocalizedName(), 325, 1285, false)
+            .addCasingInfoRange(LanthItemList.COOLANT_DELIVERY_CASING.getLocalizedName(), 148, 852, false)
+            .addCasingInfoRange(LanthItemList.SHIELDED_ACCELERATOR_GLASS.getLocalizedName(), 127, 703, false)
+            .addCasingInfoRange("Superconducting Coil Block", 56, 312, false)
+            .addCasingInfoRange(LanthItemList.ELECTRODE_CASING.getLocalizedName(), 156, 732, false)
+            .addCasingInfoExactly("Grate Machine Casing", 47, false)
+            .addCasingInfoExactly("Borosilicate Glass (LuV+)", 48, false)
+            .addEnergyHatch(addDotText(1))
+            .addMaintenanceHatch(addDotText(1))
+            .addInputHatch(addDotText(2))
+            .addOutputHatch(addDotText(2))
+            .addOtherStructurePart("Beamline Input Hatch", addDotText(3))
+            .addOtherStructurePart("Beamline Output Hatch", addDotText(4))
+
+            .toolTipFinisher("GTNH: Lanthanides");;
+        return tt;
+    }
+
+    private boolean addBeamLineInputHatch(IGregTechTileEntity te, int casingIndex) {
+
+        if (te == null) return false;
+
+        IMetaTileEntity mte = te.getMetaTileEntity();
+
+        if (mte == null) return false;
+
+        if (mte instanceof MTEHatchInputBeamline) {
+            return this.mInputBeamline.add((MTEHatchInputBeamline) mte);
+        }
+
+        return false;
+    }
+
+    private boolean addBeamLineOutputHatch(IGregTechTileEntity te, int casingIndex) {
+
+        if (te == null) return false;
+
+        IMetaTileEntity mte = te.getMetaTileEntity();
+
+        if (mte == null) return false;
+
+        if (mte instanceof MTEHatchOutputBeamline) {
+            return this.mOutputBeamline.add((MTEHatchOutputBeamline) mte);
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack itemStack) {
+
+        float tempFactor = 0;
+        // Focus as determined by multi properties
+        float machineFocus = 0;
+        // Input particle focus
+        float inputFocus = 0;
+
+        // Output focus to be set
+        outputFocus = 0;
+
+        float voltageFactor = 0;
+        float inputEnergy = 0;
+
+        machineTemp = 0;
+
+        // Energy quantity determined by multi
+        float machineEnergy = 0;
+        outputEnergy = 0;
+
+        int particleId = 0;
+        outputParticle = 0;
+
+        int inputRate = 0;
+        outputRate = 0;
+
+        ArrayList<FluidStack> tFluidInputs = this.getStoredFluids();
+