Add Drone Centre (#2412)

* Add Drone Centre

* Apply texture and model

* Update en_US.lang

* Remove import.*

* Switch to block render

* Balance range and break chance

* Add recipe

* Spotless

* Update lang

* Fix recipe

* Rewrite connection system and UI

* Remove debuff party

* Spotless

* Fix server class not found

* A stupid enough recipe

* Another bad recipe

* Update tooltip & i18n

* Close it!

* Spotless

* Disable draggable

* prohibited remote control when centre is offline

* Rename

* Rename; Change specifiers

* Update texture

* spotless

---------

Co-authored-by: Martin Robertz <dream-master@gmx.net>

18 files changed, 1392 insertions, 5 deletions

diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java
index 7617b2c195..043cd0b763 100644
--- a/src/main/java/gregtech/api/GregTech_API.java
+++ b/src/main/java/gregtech/api/GregTech_API.java
@@ -297,6 +297,7 @@ public class GregTech_API {
     public static Block sBlockCasings1, sBlockCasings2, sBlockCasings3, sBlockCasings4, sBlockCasings5, sBlockCasings6,
         sBlockCasings8, sBlockCasings9, sSolenoidCoilCasings;
     public static Block sBlockLongDistancePipes;
+    public static Block sDroneRender;
     /**
      * Getting assigned by the Config
      */
diff --git a/src/main/java/gregtech/api/enums/GT_Values.java b/src/main/java/gregtech/api/enums/GT_Values.java
index 418bf2d14c..78475455b1 100644
--- a/src/main/java/gregtech/api/enums/GT_Values.java
+++ b/src/main/java/gregtech/api/enums/GT_Values.java
@@ -613,6 +613,7 @@ public class GT_Values {
         + "minecraft7771";
 
     public static final String AuthorQuerns = "Author: " + EnumChatFormatting.RED + "Querns";
+    public static final String AuthorSilverMoon = "Author: " + EnumChatFormatting.AQUA + "SilverMoon";
     public static final String AuthorTheEpicGamer274 = "Author: " + "TheEpicGamer274";
 
     // 7.5F comes from GT_Tool_Turbine_Large#getBaseDamage() given huge turbines are the most efficient now.
diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java
index ac1aeeb7b2..c6149f20b9 100644
--- a/src/main/java/gregtech/api/enums/ItemList.java
+++ b/src/main/java/gregtech/api/enums/ItemList.java
@@ -2023,7 +2023,12 @@ public enum ItemList implements IItemContainer {
     InfinityCooledCasing,
     Machine_Multi_TranscendentPlasmaMixer,
     Cover_Metrics_Transmitter,
-    NC_AdvancedSensorCard;
+    NC_AdvancedSensorCard,
+    Machine_Multi_DroneCentre,
+    TierdDrone0,
+    TierdDrone1,
+    TierdDrone2,
+    Hatch_DroneDownLink;
 
     public static final ItemList[] DYE_ONLY_ITEMS = { Color_00, Color_01, Color_02, Color_03, Color_04, Color_05,
         Color_06, Color_07, Color_08, Color_09, Color_10, Color_11, Color_12, Color_13, Color_14, Color_15 },
diff --git a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
index 3994a02085..d32cb781e2 100644
--- a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
+++ b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
@@ -676,7 +676,9 @@ public enum MetaTileEntityIDs {
     RECIPE_FILTER_ZPM(9337),
     RECIPE_FILTER_UV(9338),
     RECIPE_FILTER_UHV(9339),
-    INDUSTRIAL_APIARY(9399);
+    INDUSTRIAL_APIARY(9399),
+    Drone_Centre(9400),
+    DroneDownLink(9401);
 
     public final int ID;
 
diff --git a/src/main/java/gregtech/common/GT_Client.java b/src/main/java/gregtech/common/GT_Client.java
index ebce87fdb5..a4d41366d4 100644
--- a/src/main/java/gregtech/common/GT_Client.java
+++ b/src/main/java/gregtech/common/GT_Client.java
@@ -96,6 +96,7 @@ import gregtech.common.render.GT_FluidDisplayStackRenderer;
 import gregtech.common.render.GT_MetaGenerated_Tool_Renderer;
 import gregtech.common.render.GT_MultiTile_Renderer;
 import gregtech.common.render.GT_PollutionRenderer;
+import gregtech.common.render.GT_RenderDrone;
 import gregtech.common.render.GT_Renderer_Block;
 import gregtech.common.render.GT_Renderer_Entity_Arrow;
 import gregtech.common.render.items.GT_MetaGenerated_Item_Renderer;
@@ -623,6 +624,7 @@ public class GT_Client extends GT_Proxy implements Runnable {
         super.onLoad();
         new GT_Renderer_Block();
         new GT_MultiTile_Renderer();
+        new GT_RenderDrone();
         metaGeneratedItemRenderer = new GT_MetaGenerated_Item_Renderer();
         for (GT_MetaGenerated_Item item : GT_MetaGenerated_Item.sInstances.values()) {
             metaGeneratedItemRenderer.registerItem(item);
diff --git a/src/main/java/gregtech/common/GT_Proxy.java b/src/main/java/gregtech/common/GT_Proxy.java
index 978b0caf9a..13f5939e38 100644
--- a/src/main/java/gregtech/common/GT_Proxy.java
+++ b/src/main/java/gregtech/common/GT_Proxy.java
@@ -175,6 +175,7 @@ import gregtech.common.items.GT_MetaGenerated_Tool_01;
 import gregtech.common.misc.GlobalEnergyWorldSavedData;
 import gregtech.common.misc.GlobalMetricsCoverDatabase;
 import gregtech.common.misc.spaceprojects.SpaceProjectWorldSavedData;
+import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_DroneCentre;
 
 public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler {
 
@@ -1397,6 +1398,8 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler {
 
     public void onServerStarted() {
         GregTech_API.sWirelessRedstone.clear();
+        GT_MetaTileEntity_DroneCentre.getCentreMap()
+            .clear();
         GT_Log.out.println(
             "GT_Mod: Cleaning up all OreDict Crafting Recipes, which have an empty List in them, since they are never meeting any Condition.");
         List<IRecipe> tList = CraftingManager.getInstance()
diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Drone.java b/src/main/java/gregtech/common/blocks/GT_Block_Drone.java
new file mode 100644
index 0000000000..81d1acc228
--- /dev/null
+++ b/src/main/java/gregtech/common/blocks/GT_Block_Drone.java
@@ -0,0 +1,65 @@
+package gregtech.common.blocks;
+
+import java.util.ArrayList;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.GregTech_API;
+import gregtech.common.tileentities.render.TileDrone;
+
+public class GT_Block_Drone extends Block {
+
+    public GT_Block_Drone() {
+        super(Material.iron);
+        this.setResistance(20f);
+        this.setHardness(-1.0f);
+        this.setCreativeTab(GregTech_API.TAB_GREGTECH);
+        this.setBlockName("gt.dronerender");
+        this.setLightLevel(100.0f);
+        GameRegistry.registerBlock(this, getUnlocalizedName());
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister iconRegister) {
+        blockIcon = iconRegister.registerIcon("gregtech:iconsets/TRANSPARENT");
+    }
+
+    @Override
+    public boolean isOpaqueCube() {
+        return false;
+    }
+
+    @Override
+    public boolean canRenderInPass(int a) {
+        return true;
+    }
+
+    @Override
+    public boolean renderAsNormalBlock() {
+        return false;
+    }
+
+    @Override
+    public boolean hasTileEntity(int metadata) {
+        return true;
+    }
+
+    @Override
+    public TileEntity createTileEntity(World world, int metadata) {
+        return new TileDrone();
+    }
+
+    @Override
+    public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int meta, int fortune) {
+        return new ArrayList<>();
+    }
+}
diff --git a/src/main/java/gregtech/common/items/GT_TierDrone.java b/src/main/java/gregtech/common/items/GT_TierDrone.java
new file mode 100644
index 0000000000..58da852d0e
--- /dev/null
+++ b/src/main/java/gregtech/common/items/GT_TierDrone.java
@@ -0,0 +1,18 @@
+package gregtech.common.items;
+
+import gregtech.api.items.GT_Generic_Item;
+
+public class GT_TierDrone extends GT_Generic_Item {
+
+    private final int level;
+
+    public GT_TierDrone(String aUnlocalized, String aEnglish, String aEnglishTooltip, int level) {
+        super(aUnlocalized, aEnglish, aEnglishTooltip);
+        this.level = level;
+        this.setMaxStackSize(64);
+    }
+
+    public int getLevel() {
+        return level;
+    }
+}
diff --git a/src/main/java/gregtech/common/render/GT_RenderDrone.java b/src/main/java/gregtech/common/render/GT_RenderDrone.java
new file mode 100644
index 0000000000..af1336a219
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_RenderDrone.java
@@ -0,0 +1,93 @@
+package gregtech.common.render;
+
+import static gregtech.api.enums.Mods.GregTech;
+
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.model.AdvancedModelLoader;
+import net.minecraftforge.client.model.IModelCustom;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.common.tileentities.render.TileDrone;
+
+@SideOnly(Side.CLIENT)
+public class GT_RenderDrone extends TileEntitySpecialRenderer {
+
+    private static final ResourceLocation DroneTexture = new ResourceLocation(GregTech.ID, "textures/model/drone.png");
+    private static final IModelCustom Drone = AdvancedModelLoader
+        .loadModel(new ResourceLocation(GregTech.ID, "textures/model/drone.obj"));
+
+    public GT_RenderDrone() {
+        ClientRegistry.bindTileEntitySpecialRenderer(TileDrone.class, this);
+    }
+
+    @Override
+    public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float timeSinceLastTick) {
+        if (!(tile instanceof TileDrone drone)) return;
+        final float size = 1.0f;
+        GL11.glPushMatrix();
+        GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
+        renderDrone(size);
+        renderBlade(drone, size);
+        GL11.glPopMatrix();
+    }
+
+    private void renderDrone(double size) {
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glDisable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        this.bindTexture(DroneTexture);
+        GL11.glScaled(size, size, size);
+        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+        Drone.renderOnly("drone", "box", "main");
+        GL11.glDisable(GL11.GL_BLEND);
+        GL11.glDepthMask(true);
+        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_LIGHTING);
+    }
+
+    private void renderBlade(TileDrone drone, double size) {
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glDisable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        this.bindTexture(DroneTexture);
+        GL11.glScaled(size, size, size);
+        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
+        GL11.glPushMatrix();
+        GL11.glTranslated(-0.7d * size, -1 * size, -0.7 * size);
+        GL11.glRotated(drone.rotation, 0, 1, 0);
+        GL11.glTranslated(0.7d * size, 1 * size, 0.7 * size);
+        Drone.renderOnly("blade2");
+        GL11.glPopMatrix();
+        GL11.glPushMatrix();
+        GL11.glTranslated(-0.7d * size, -1 * size, 0.7 * size);
+        GL11.glRotated(drone.rotation, 0, 1, 0);
+        GL11.glTranslated(0.7d * size, 1 * size, -0.7 * size);
+        Drone.renderOnly("blade3");
+        GL11.glPopMatrix();
+        GL11.glPushMatrix();
+        GL11.glTranslated(0.7d * size, -1 * size, -0.7 * size);
+        GL11.glRotated(drone.rotation, 0, 1, 0);
+        GL11.glTranslated(-0.7d * size, 1 * size, 0.7 * size);
+        Drone.renderOnly("blade1");
+        GL11.glPopMatrix();
+        GL11.glPushMatrix();
+        GL11.glTranslated(0.7d * size, -1 * size, 0.7 * size);
+        GL11.glRotated(drone.rotation, 0, 1, 0);
+        GL11.glTranslated(-0.7d * size, 1 * size, -0.7 * size);
+        Drone.renderOnly("blade4");
+        GL11.glPopMatrix();
+        GL11.glDisable(GL11.GL_BLEND);
+        GL11.glDepthMask(true);
+        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_LIGHTING);
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/drone/DroneConnection.java b/src/main/java/gregtech/common/tileentities/machines/multi/drone/DroneConnection.java
new file mode 100644
index 0000000000..57a8bea352
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/drone/DroneConnection.java
@@ -0,0 +1,123 @@
+package gregtech.common.tileentities.machines.multi.drone;
+
+import static gregtech.GT_Mod.gregtechproxy;
+
+import java.util.Optional;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.interfaces.tileentity.IHasWorldObjectAndCoords;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.util.GT_Util;
+
+public class DroneConnection {
+
+    String customName;
+    GT_MetaTileEntity_MultiBlockBase machine;
+    ItemStack machineItem;
+    ChunkCoordinates machineCoord;
+    GT_MetaTileEntity_DroneCentre centre;
+    ChunkCoordinates centreCoord;
+    World world;
+
+    public DroneConnection(GT_MetaTileEntity_MultiBlockBase machine, GT_MetaTileEntity_DroneCentre centre) {
+        this.machine = machine;
+        this.machineItem = machine.getStackForm(1);
+        machineCoord = machine.getBaseMetaTileEntity()
+            .getCoords();
+        this.centre = centre;
+        centreCoord = centre.getBaseMetaTileEntity()
+            .getCoords();
+        this.world = centre.getBaseMetaTileEntity()
+            .getWorld();
+        customName = Optional.ofNullable(centre.tempNameList.remove(machineCoord.toString()))
+            .orElse(machine.getLocalName());
+    }
+
+    public DroneConnection(NBTTagCompound aNBT) {
+        NBTTagCompound machineTag = aNBT.getCompoundTag("machine");
+        NBTTagCompound centreTag = aNBT.getCompoundTag("centre");
+        if (!gregtechproxy.isClientSide()) {
+            this.world = DimensionManager.getWorld(aNBT.getInteger("worldID"));
+        } else {
+            this.world = Minecraft.getMinecraft().thePlayer.worldObj;
+        }
+        machineItem = ItemStack.loadItemStackFromNBT(aNBT.getCompoundTag("item"));
+        machineCoord = new ChunkCoordinates(
+            machineTag.getInteger("x"),
+            machineTag.getInteger("y"),
+            machineTag.getInteger("z"));
+        this.machine = getLoadedGT_BaseMachineAt(machineCoord, world, true);
+        centreCoord = new ChunkCoordinates(
+            centreTag.getInteger("x"),
+            centreTag.getInteger("y"),
+            centreTag.getInteger("z"));
+        this.centre = (GT_MetaTileEntity_DroneCentre) getLoadedGT_BaseMachineAt(centreCoord, world, true);
+        this.customName = aNBT.getString("name");
+    }
+
+    public GT_MetaTileEntity_MultiBlockBase getMachine() {
+        return machine;
+    }
+
+    public boolean reCheckConnection() {
+        if (machine == null) this.machine = getLoadedGT_BaseMachineAt(machineCoord, world, true);
+        if (centre == null)
+            this.centre = (GT_MetaTileEntity_DroneCentre) getLoadedGT_BaseMachineAt(centreCoord, world, true);
+        if (machine != null && centre != null
+            && !centre.getConnectionList()
+                .contains(this))
+            centre.getConnectionList()
+                .add(this);
+        return isValid();
+    }
+
+    public String getCustomName() {
+        return customName;
+    }
+
+    public void setCustomName(String name) {
+        customName = name;
+    }
+
+    public NBTTagCompound transConnectionToNBT() {
+        NBTTagCompound aNBT = new NBTTagCompound();
+        if (!this.isValid()) return aNBT;
+        aNBT.setTag("machine", transGT_BaseMachineToNBT(machine));
+        aNBT.setTag("centre", transGT_BaseMachineToNBT(centre));
+        aNBT.setTag("item", machineItem.writeToNBT(new NBTTagCompound()));
+        aNBT.setInteger(
+            "worldID",
+            machine.getBaseMetaTileEntity()
+                .getWorld().provider.dimensionId);
+        aNBT.setString("name", getCustomName());
+        return aNBT;
+    }
+
+    public GT_MetaTileEntity_MultiBlockBase getLoadedGT_BaseMachineAt(ChunkCoordinates coords, World world,
+        boolean isLoaded) {
+        TileEntity te = GT_Util.getTileEntity(world, coords, isLoaded);
+        if (te == null) return null;
+        return (GT_MetaTileEntity_MultiBlockBase) ((IGregTechTileEntity) te).getMetaTileEntity();
+    }
+
+    private NBTTagCompound transGT_BaseMachineToNBT(GT_MetaTileEntity_MultiBlockBase machine) {
+        IHasWorldObjectAndCoords baseCoord = machine.getBaseMetaTileEntity();
+        NBTTagCompound tag = new NBTTagCompound();
+        tag.setInteger("x", baseCoord.getXCoord());
+        tag.setInteger("y", baseCoord.getYCoord());
+        tag.setInteger("z", baseCoord.getZCoord());
+        return tag;
+    }
+
+    public boolean isValid() {
+        return machine != null && machine.isValid() && centre != null && centre.isValid();
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/drone/GT_MetaTileEntity_DroneCentre.java b/src/main/java/gregtech/common/tileentities/machines/multi/drone/GT_MetaTileEntity_DroneCentre.java
new file mode 100644
index 0000000000..ee4ea4978d
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/drone/GT_MetaTileEntity_DroneCentre.java
@@ -0,0 +1,666 @@
+package gregtech.common.tileentities.machines.multi.drone;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_HatchElement.InputBus;
+import static gregtech.api.enums.GT_Values.AuthorSilverMoon;
+import static gregtech.api.multitileentity.multiblock.casing.Glasses.chainAllGlasses;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.google.common.collect.HashMultimap;
+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.gtnewhorizon.structurelib.util.Vec3Impl;
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.api.forge.ItemStackHandler;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.math.MainAxisAlignment;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedRow;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.Scrollable;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget;
+
+import appeng.api.util.DimensionalCoord;
+import appeng.api.util.WorldCoord;
+import appeng.client.render.BlockPosHighlighter;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.SimpleCheckRecipeResult;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.GT_TierDrone;
+import mcp.mobius.waila.api.IWailaConfigHandler;
+import mcp.mobius.waila.api.IWailaDataAccessor;
+
+public class GT_MetaTileEntity_DroneCentre extends
+    GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_DroneCentre> implements ISurvivalConstructable {
+
+    private static final IIconContainer ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/DRONE_CENTRE_ACTIVE");
+    private static final IIconContainer FACE = new Textures.BlockIcons.CustomIcon("iconsets/DRONE_CENTRE_FACE");
+    private static final IIconContainer INACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/DRONE_CENTRE_INACTIVE");
+    private Vec3Impl centreCoord;
+    private int droneLevel = 0;
+    private int buttonID;
+    private final List<DroneConnection> connectionList = new ArrayList<>();
+    public HashMap<String, String> tempNameList = new HashMap<>();
+    // Save centre by dimID
+    private static final HashMultimap<Integer, GT_MetaTileEntity_DroneCentre> droneMap = HashMultimap.create();
+    // spotless off
+    private static final IStructureDefinition<GT_MetaTileEntity_DroneCentre> STRUCTURE_DEFINITION = StructureDefinition
+        .<GT_MetaTileEntity_DroneCentre>builder()
+        .addShape(
+            "main",
+            transpose(
+                new String[][] { { "     ", "     ", "     ", "     ", "CCCCC", "CCCCC", "CCCCC", "CCCCC", "CCCCC" },
+                    { "CE~EC", "C   C", "C   C", "C   C", "CAAAC", "CCCCC", "CAAAC", "C   C", "CCCCC" },
+                    { "CEEEC", "CBBBC", "CBDBC", "CBBBC", "CCCCC", "CCCCC", "CCCCC", "CCCCC", "CCCCC" },
+                    { "C   C", "     ", "     ", "     ", "     ", "     ", "     ", "     ", "C   C" },
+                    { "C   C", "     ", "     ", "     ", "     ", "     ", "     ", "     ", "C   C" },
+                    { "C   C", "     ", "     ", "     ", "     ", "     ", "     ", "     ", "C   C" } }))
+        .addElement(
+            'E',
+            buildHatchAdder(GT_MetaTileEntity_DroneCentre.class).atLeast(InputBus)
+                .casingIndex(59)
+                .dot(1)
+                .buildAndChain(ofBlock(GregTech_API.sBlockCasings4, 2)))
+        .addElement('C', ofBlock(GregTech_API.sBlockCasings4, 2))
+        .addElement('A', chainAllGlasses())
+        .addElement('B', ofBlock(GregTech_API.sBlockCasings1, 11))
+        .addElement('D', ofBlock(GregTech_API.sBlockCasings4, 0))
+        .build();
+
+    // spotless on
+    public GT_MetaTileEntity_DroneCentre(String name) {
+        super(name);
+    }
+
+    public GT_MetaTileEntity_DroneCentre(int ID, String Name, String NameRegional) {
+        super(ID, Name, NameRegional);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_DroneCentre(super.mName);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing,
+        int colorIndex, boolean aActive, boolean redstoneLevel) {
+        if (side == aFacing) {
+            if (getBaseMetaTileEntity().isActive()) {
+                return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(59), TextureFactory.builder()
+                    .addIcon(ACTIVE)
+                    .extFacing()
+                    .build() };
+            } else {
+                return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(59), TextureFactory.builder()
+                    .addIcon(INACTIVE)
+                    .extFacing()
+                    .build() };
+            }
+        } else if (side == aFacing.getOpposite()) {
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(59), TextureFactory.builder()
+                .addIcon(FACE)
+                .extFacing()
+                .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(59) };
+    }
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_DroneCentre> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Drone Centre")
+            .addInfo("Drone Center Controller")
+            .addInfo(EnumChatFormatting.AQUA + "Drone #10032, cleared for takeoff!")
+            .addInfo("Monitors multiblock machines in range.")
+            .addInfo("Replace maintenance hatch on other multi with drone downlink module.")
+            .addInfo("Provides maintenance, power control, monitoring and etc.")
+            .addInfo("Range is determined by drone tier: T1-32, T2-128, T3-512")
+            .addInfo("Place drones in input bus; only one needed to operate.")
+            .addInfo("Automatically upgrade based on the drone level in the input bus.")
+            .addInfo("There is a chance per second that the drone will crash.")
+            .addInfo("Chance is determined by drone tier: T1-1/28800, T2-1/172800, T3-0")
+            .addInfo("If machine is too far, remote control would not available")
+            .addInfo(AuthorSilverMoon)
+            .addSeparator()
+            .beginStructureBlock(5, 6, 9, false)
+            .addStructureInfo("Do not need maintenance hatch")
+            .addSeparator()
+            .toolTipFinisher("Gregtech");
+        return tt;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece("main", stackSize, hintsOnly, 2, 1, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stack, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece("main", stack, 2, 1, 0, elementBudget, env, false, true);
+    }
+
+    @Override
+    protected IAlignmentLimits getInitialAlignmentLimits() {
+        // I don't think a drone can take off HORIZONTALLY!
+        return (d, r, f) -> (d.flag & (ForgeDirection.UP.flag | ForgeDirection.DOWN.flag)) == 0 && r.isNotRotated()
+            && !f.isVerticallyFliped();
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return checkPiece("main", 2, 1, 0);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (aBaseMetaTileEntity.isServerSide()) {
+            fixAll();
+            if (aTick % 200 == 0) {
+                if (switch (droneLevel) {
+                    case 1 -> getBaseMetaTileEntity().getRandomNumber(28800);
+                    case 2 -> getBaseMetaTileEntity().getRandomNumber(172800);
+                    default -> 1;
+                } == 0) {
+                    droneLevel = 0;
+                    if (!tryConsumeDrone()) criticalStopMachine();
+                }
+            }
+            // Clean invalid connections every 4 seconds
+            if (aTick % 80 == 0) connectionList.removeIf(v -> !v.isValid());
+        }
+        if (mMaxProgresstime > 0 && mMaxProgresstime - mProgresstime == 1) destroyRenderBlock();
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        droneLevel = aNBT.getInteger("drone");
+        NBTTagCompound nameList = aNBT.getCompoundTag("conList");
+        for (String s : nameList.func_150296_c()) {
+            tempNameList.put(s, nameList.getString(s));
+        }
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("drone", droneLevel);
+        NBTTagCompound conList = new NBTTagCompound();
+        for (DroneConnection con : connectionList) {
+            if (!Objects.equals(con.customName, con.machine.getLocalName()))
+                conList.setString(con.machineCoord.toString(), con.customName);
+        }
+        aNBT.setTag("conList", conList);
+    }
+
+    @Override
+    public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y,
+        int z) {
+        super.getWailaNBTData(player, tile, tag, world, x, y, z);
+        tag.setInteger("connectionCount", connectionList.size());
+        if (droneLevel != 0) tag.setInteger("droneLevel", droneLevel);
+    }
+
+    @Override
+    public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor,
+        IWailaConfigHandler config) {
+        NBTTagCompound tag = accessor.getNBTData();
+        currenttip.add(
+            EnumChatFormatting.AQUA + StatCollector.translateToLocal("GT5U.waila.drone_downlink.droneLevel")
+                + tag.getInteger("droneLevel"));
+        currenttip.add(
+            StatCollector.translateToLocal("GT5U.waila.drone_downlink.connectionCount")
+                + tag.getInteger("connectionCount"));
+        super.getWailaBody(itemStack, currenttip, accessor, config);
+    }
+
+    @Override
+    @NotNull
+    public CheckRecipeResult checkProcessing() {
+        if (droneLevel == 0) {
+            if (!tryConsumeDrone()) return SimpleCheckRecip