Repackage Tesla code into interfaces and util class

Currently bugged, Tesla Towers always drain power from Energy Injectors

7 files changed, 450 insertions, 331 deletions

diff --git a/src/main/java/com/github/technus/tectech/mechanics/spark/ThaumSpark.java b/src/main/java/com/github/technus/tectech/mechanics/spark/ThaumSpark.java
index 604624828c..e31e63f250 100644
--- a/src/main/java/com/github/technus/tectech/mechanics/spark/ThaumSpark.java
+++ b/src/main/java/com/github/technus/tectech/mechanics/spark/ThaumSpark.java
@@ -1,5 +1,7 @@
 package com.github.technus.tectech.mechanics.spark;
 
+import com.github.technus.tectech.util.Vec3Impl;
+
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -9,22 +11,10 @@ public class ThaumSpark implements Serializable {
     public int x, y, z, wID;
     public byte xR, yR, zR;
 
-    public ThaumSpark(){
-        this.x = 0;
-        this.z = 0;
-        this.y = 0;
-
-        this.xR = 0;
-        this.yR = 0;
-        this.zR = 0;
-
-        this.wID = 0;
-    }
-
     public ThaumSpark(int x, int y, int z, byte xR, byte yR, byte zR, int wID) {
         this.x = x;
-        this.z = z;
         this.y = y;
+        this.z = z;
 
         this.xR = xR;
         this.yR = yR;
@@ -33,6 +23,19 @@ public class ThaumSpark implements Serializable {
         this.wID = wID;
     }
 
+    public ThaumSpark(Vec3Impl origin, Vec3Impl target, int wID) {
+        this.x = origin.get0();
+        this.y = origin.get1();
+        this.z = origin.get2();
+
+        Vec3Impl offset = target.sub(origin);
+        this.xR = (byte) offset.get0();
+        this.yR = (byte) offset.get1();
+        this.zR = (byte) offset.get2();
+
+        this.wID = wID;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectable.java b/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectable.java
new file mode 100644
index 0000000000..07ecc4bc31
--- /dev/null
+++ b/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectable.java
@@ -0,0 +1,127 @@
+package com.github.technus.tectech.mechanics.tesla;
+
+import com.github.technus.tectech.mechanics.spark.ThaumSpark;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+import static com.github.technus.tectech.util.Util.entriesSortedByValues;
+import static java.lang.Math.sqrt;
+
+public interface ITeslaConnectable extends ITeslaConnectableSimple {
+    //Map with all Teslas in the same dimension and the distance to them //TODO Range
+    Map<ITeslaConnectableSimple, Integer> teslaNodeMap = new HashMap<>();
+    //ThaumCraft lighting coordinate pairs, so we can send them in bursts and save on lag
+    HashSet<ThaumSpark> sparkList = new HashSet<>();
+
+    //-128 to -1 disables capability
+    //0 means any source or target
+    //1 to 127 must match on source and target or source/target must be 0
+    byte getTeslaTransmissionCapability();
+
+    //Transmission Range is typically 16+ in blocks
+    int getTeslaTransmissionRange();
+    boolean isOverdriveEnabled();
+
+    int getTeslaEnergyLossPerBlock();
+    float getTeslaOverdriveLossCoefficient();
+
+    long getTeslaOutputVoltage();
+    long getTeslaOutputCurrent();
+
+    boolean teslaDrainEnergy(long teslaVoltageDrained);
+
+    class TeslaUtil {
+        public static final HashSet<ITeslaConnectableSimple> teslaNodeSet = new HashSet<>();//Targets for power transmission
+
+        public static void generateTeslaNodeMap(ITeslaConnectable origin) {
+            origin.teslaNodeMap.clear();
+            for (ITeslaConnectableSimple target : teslaNodeSet) {
+                //Sanity checks
+                if (target == null) {
+                    //The Tesla Covers do not remove themselves from the list and this is the code that does
+                    teslaNodeSet.remove(null);
+                    continue;
+                } else if (origin.equals(target) || !origin.getTeslaDimension().equals(target.getTeslaDimension())) {
+                    //Skip if looking at myself and skip if not in the same dimension
+                    //TODO, INTERDIM?
+                    continue;
+                } else if (origin.getTeslaTransmissionCapability() != 0 && origin.getTeslaReceptionCapability() != 0 &&
+                        origin.getTeslaTransmissionCapability() != origin.getTeslaReceptionCapability()) {
+                    //Skip if incompatible
+                    continue;
+                }
+
+                //Range calc
+                int distance = (int) sqrt(origin.getTeslaPosition().distanceSq(target.getTeslaPosition()));
+                if (distance > origin.getTeslaTransmissionRange() * target.getTeslaReceptionCoefficient()) {
+                    //Skip if the range is too vast
+                    continue;
+                }
+                origin.teslaNodeMap.put(target, distance);
+            }
+        }
+
+        public static void cleanTeslaNodeMap(ITeslaConnectable origin) {
+            //TODO Do we still need this?
+            for (ITeslaConnectableSimple target : origin.teslaNodeMap.keySet()) {
+                if (target == null) {
+                    origin.teslaNodeMap.remove(null);
+                }
+            }
+        }
+
+        public static long powerTeslaNodeMap(ITeslaConnectable origin) {
+            //Teslas can only send OR receive
+            if (origin.isTeslaReadyToReceive()) {
+                return 0L;//TODO Negative values to indicate charging?
+            }
+            long remainingAmperes = origin.getTeslaOutputCurrent();
+            while (remainingAmperes > 0) {
+                long startingAmperes = remainingAmperes;
+                for (Map.Entry<ITeslaConnectableSimple, Integer> Rx : entriesSortedByValues(teslaNodeMap)) {
+                    if (origin.getTeslaStoredEnergy() < (origin.isOverdriveEnabled() ? origin.getTeslaOutputVoltage() * 2 : origin.getTeslaOutputVoltage())) {
+                        //Return and end the tick if we're out of energy to send
+                        return origin.getTeslaOutputCurrent() - remainingAmperes;
+                    }
+
+                    ITeslaConnectableSimple target = Rx.getKey();
+                    int distance = Rx.getValue();
+
+                    //Calculate the voltage output
+                    long outputVoltageInjectable;
+                    long outputVoltageConsumption;
+
+                    if (origin.isOverdriveEnabled()) {
+                        outputVoltageInjectable = origin.getTeslaOutputVoltage();
+                        outputVoltageConsumption = origin.getTeslaOutputVoltage() + (distance * origin.getTeslaEnergyLossPerBlock()) +
+                                (long) Math.round(origin.getTeslaOutputVoltage() * origin.getTeslaOverdriveLossCoefficient());
+                    } else {
+                        outputVoltageInjectable = origin.getTeslaOutputVoltage() - (distance * origin.getTeslaEnergyLossPerBlock());
+                        outputVoltageConsumption = origin.getTeslaOutputVoltage();
+                    }
+
+                    //Skip the target if the cost is too high
+                    if (origin.getTeslaStoredEnergy() < outputVoltageConsumption) {
+                        continue;
+                    }
+
+                    if (target.teslaInjectEnergy(outputVoltageInjectable)) {
+                        origin.teslaDrainEnergy(outputVoltageConsumption);
+                        sparkList.add(new ThaumSpark(origin.getTeslaPosition(), target.getTeslaPosition(), origin.getTeslaDimension()));
+                        remainingAmperes--;
+                    }
+                    if (remainingAmperes == 0) {
+                        return origin.getTeslaOutputCurrent();
+                    }
+                }
+                //End the tick after one iteration with no transmissions
+                if (remainingAmperes == startingAmperes) {
+                    return origin.getTeslaOutputCurrent() - remainingAmperes;
+                }
+            }
+            return origin.getTeslaOutputCurrent() - remainingAmperes;
+        }
+    }
+}
diff --git a/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectableSimple.java b/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectableSimple.java
new file mode 100644
index 0000000000..3b56b6968c
--- /dev/null
+++ b/src/main/java/com/github/technus/tectech/mechanics/tesla/ITeslaConnectableSimple.java
@@ -0,0 +1,22 @@
+package com.github.technus.tectech.mechanics.tesla;
+
+import com.github.technus.tectech.util.Vec3Impl;
+
+public interface ITeslaConnectableSimple {
+    //-128 to -1 disables capability
+    //0 means any source or target
+    //1 to 127 must match on source and target or source/target must be 0
+    byte getTeslaReceptionCapability();
+
+    //Reception Coefficient is a range extension, typical is 1
+    float getTeslaReceptionCoefficient();
+
+    boolean isTeslaReadyToReceive();
+
+    long getTeslaStoredEnergy();
+
+    boolean teslaInjectEnergy(long teslaVoltageInjected);
+
+    Vec3Impl getTeslaPosition();
+    Integer getTeslaDimension();
+}
diff --git a/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil.java b/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil.java
index 6442ba51b6..2efe2f3cbc 100644
--- a/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil.java
+++ b/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil.java
@@ -1,40 +1,95 @@
 package com.github.technus.tectech.thing.cover;
 
+import com.github.technus.tectech.mechanics.tesla.ITeslaConnectableSimple;
+import com.github.technus.tectech.util.Vec3Impl;
 import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
 import net.minecraft.entity.player.EntityPlayer;
 
-import static com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_TM_teslaCoil.teslaNodeSet;
+import static com.github.technus.tectech.mechanics.tesla.ITeslaConnectable.TeslaUtil.*;
 import static ic2.api.info.Info.DMG_ELECTRIC;
 
-public class GT_Cover_TM_TeslaCoil extends GT_CoverBehavior {
+public class GT_Cover_TM_TeslaCoil extends GT_CoverBehavior implements ITeslaConnectableSimple {
+    private IGregTechTileEntity IGT;
+
     public GT_Cover_TM_TeslaCoil() {
     }
 
+    @Override
     public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) {
-        if (aTileEntity.getEUCapacity() > 0) {
-            teslaNodeSet.add(aTileEntity.getIGregTechTileEntityOffset(0, 0, 0));
+        //Only do stuff if we're on top and have power
+        if (aSide == 1 || aTileEntity.getEUCapacity() > 0) {
+            //Pull IGT onto the outside, should only execute first tick
+            if (IGT == null) {
+                IGT = aTileEntity.getIGregTechTileEntityOffset(0, 0, 0);
+            }
+            //Makes sure we're on the list
+            teslaNodeSet.add(this);
         }
+
         return super.doCoverThings(aSide, aInputRedstone, aCoverID, aCoverVariable, aTileEntity, aTimer);
     }
 
+    @Override
     public String getDescription(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return "Do not attempt to use screwdriver!";
+        return "Do not attempt to use screwdriver!";//TODO Translation support
     }
 
+    @Override
     public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return true;
     }
 
+    @Override
     public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        //Shock a non-hazmat player if they dare stuff a screwdriver into one of these
         if (aTileEntity.getStoredEU() > 0 && !GT_Utility.isWearingFullElectroHazmat(aPlayer)) {
             aPlayer.attackEntityFrom(DMG_ELECTRIC, 20);
         }
         return aCoverVariable;
     }
 
+    @Override
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+        //It updates once every 200 ticks, so once every 10 seconds
         return 200;
     }
+
+    @Override
+    public byte getTeslaReceptionCapability() {
+        return 2;
+    }
+
+    @Override
+    public float getTeslaReceptionCoefficient() {
+        return 1;
+    }
+
+    @Override
+    public boolean isTeslaReadyToReceive() {
+        return true;
+    }
+
+    @Override
+    public long getTeslaStoredEnergy() {
+        return IGT.getStoredEU();
+    }
+
+    @Override
+    public Vec3Impl getTeslaPosition() {
+        return new Vec3Impl(IGT);
+    }
+
+    @Override
+    public Integer getTeslaDimension() {
+        return IGT.getWorld().provider.dimensionId;
+    }
+
+    @Override
+    public boolean teslaInjectEnergy(long teslaVoltageInjected) {
+        //Same as in the microwave transmitters, this does not account for amp limits
+        return IGT.injectEnergyUnits((byte) 1, teslaVoltageInjected, 1L) > 0L;
+    }
 }
diff --git a/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil_Ultimate.java b/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil_Ultimate.java
index 2b5db1f5c9..028ac3a4d6 100644
--- a/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil_Ultimate.java
+++ b/src/main/java/com/github/technus/tectech/thing/cover/GT_Cover_TM_TeslaCoil_Ultimate.java
@@ -7,23 +7,33 @@ public class GT_Cover_TM_TeslaCoil_Ultimate extends GT_Cover_TM_TeslaCoil {
     public GT_Cover_TM_TeslaCoil_Ultimate() {
     }
 
+    @Override
     public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return true;
     }
 
+    @Override
     public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) {
         return true;
     }
 
+    @Override
     public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) {
         return true;
     }
 
+    @Override
     public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
         return true;
     }
 
+    @Override
     public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) {
         return true;
     }
+
+    @Override
+    public byte getTeslaReceptionCapability() {
+        return 1;
+    }
 }
diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_TM_teslaCoil.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_TM_teslaCoil.java
index e63a92d107..729b73044e 100644
--- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_TM_teslaCoil.java
+++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_TM_teslaCoil.java
@@ -7,8 +7,7 @@ import com.github.technus.tectech.mechanics.spark.RendererMessage;
 import com.github.technus.tectech.mechanics.spark.ThaumSpark;
 import com.github.technus.tectech.mechanics.structure.Structure;
 import com.github.technus.tectech.mechanics.structure.adders.IHatchAdder;
-import com.github.technus.tectech.thing.cover.GT_Cover_TM_TeslaCoil;
-import com.github.technus.tectech.thing.cover.GT_Cover_TM_TeslaCoil_Ultimate;
+import com.github.technus.tectech.mechanics.tesla.ITeslaConnectable;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_Capacitor;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
@@ -18,7 +17,6 @@ import com.github.technus.tectech.thing.metaTileEntity.multi.base.INameFunction;
 import com.github.technus.tectech.thing.metaTileEntity.multi.base.IStatusFunction;
 import com.github.technus.tectech.thing.metaTileEntity.multi.base.Parameters;
 import com.github.technus.tectech.thing.metaTileEntity.multi.base.render.TT_RenderedExtendedFacingTexture;
-import com.github.technus.tectech.thing.metaTileEntity.single.GT_MetaTileEntity_TeslaCoil;
 import com.github.technus.tectech.util.CommonValues;
 import com.github.technus.tectech.util.Vec3Impl;
 import cpw.mods.fml.relauncher.Side;
@@ -37,21 +35,18 @@ import net.minecraft.util.EnumChatFormatting;
 import net.minecraftforge.fluids.FluidStack;
 
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
 
 import static com.github.technus.tectech.mechanics.structure.Structure.adders;
+import static com.github.technus.tectech.mechanics.tesla.ITeslaConnectable.TeslaUtil.*;
 import static com.github.technus.tectech.thing.casing.GT_Block_CasingsTT.texturePage;
 import static com.github.technus.tectech.thing.casing.TT_Container_Casings.sBlockCasingsBA0;
 import static com.github.technus.tectech.thing.metaTileEntity.multi.base.LedStatus.*;
 import static com.github.technus.tectech.util.CommonValues.V;
-import static com.github.technus.tectech.util.Util.entriesSortedByValues;
 import static gregtech.api.enums.GT_Values.E;
 import static java.lang.Math.*;
 import static net.minecraft.util.StatCollector.translateToLocal;
 
-public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable {
+public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable, ITeslaConnectable {
     //region variables
     private static final int transferRadiusTowerFromConfig = TecTech.configTecTech.TESLA_MULTI_RANGE_TOWER;//Default is 32
     private static final int transferRadiusTransceiverFromConfig = TecTech.configTecTech.TESLA_MULTI_RANGE_TRANSCEIVER;//Default is 16
@@ -76,9 +71,6 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
 
     private FluidStack[] mOutputFluidsQueue; //Used to buffer the fluid outputs, so the tesla takes a second to 'cool' any plasma it would output as a gas
 
-    public static final HashSet<IGregTechTileEntity> teslaNodeSet = new HashSet<>(); //Targets for power transmission
-    private final HashSet<ThaumSpark> sparkList = new HashSet<>(); //Thaumcraft lighting coordinate pairs, so we can send them in bursts and save on lag
-    private Map<IGregTechTileEntity, Integer> teslaNodeMap = new HashMap<>(); //Targets for power transmission
     private final ArrayList<GT_MetaTileEntity_Hatch_Capacitor> eCapacitorHatches = new ArrayList<>(); //Capacitor hatches which determine the max voltage tier and count of amps
 
     private int sortTime = 0; //Scan timer used for tesla search intervals
@@ -88,6 +80,10 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
     private int vTier = -1; //Tesla voltage tier limited by capacitors
     private long outputCurrentMax = 0; //Tesla current output limited by capacitors
 
+    //outputVoltage and current after settings
+    private long outputVoltage;
+    private long outputCurrent;
+
     //Prevents unnecessary offset calculation, saving on lag
     private byte oldRotation = -1;
     private byte oldOrientation = -1;
@@ -185,7 +181,8 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         if (value > transferRadiusTransceiverFromConfig) return STATUS_HIGH;
         if (value < transferRadiusTransceiverFromConfig) return STATUS_LOW;
         return STATUS_OK;
-    };    private static final IStatusFunction<GT_MetaTileEntity_TM_teslaCoil> TRANSFER_RADIUS_COVER_ULTIMATE_STATUS = (base, p) -> {
+    };
+    private static final IStatusFunction<GT_MetaTileEntity_TM_teslaCoil> TRANSFER_RADIUS_COVER_ULTIMATE_STATUS = (base, p) -> {
         double value = p.get();
         if (Double.isNaN(value)) return STATUS_WRONG;
         value = (int) value;
@@ -262,24 +259,6 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         super(aName);
     }
 
-    private int getPerBlockLoss(){
-        return plasmaTierLoss[plasmaTier];
-    }
-
-    private long[] getOutputVoltage(long outputVoltage, int distance, boolean overDriveToggle) {
-        long outputVoltageInjectable;
-        long outputVoltageConsumption;
-
-        if (overDriveToggle) {
-            outputVoltageInjectable = outputVoltage;
-            outputVoltageConsumption = outputVoltage + (distance * getPerBlockLoss()) + (long) Math.round(overDriveLoss * outputVoltage);
-        } else {
-            outputVoltageInjectable = outputVoltage - (distance * getPerBlockLoss());
-            outputVoltageConsumption = outputVoltage;
-        }
-        return new long[]{outputVoltageInjectable, outputVoltageConsumption};
-    }
-
     private float getRangeMulti(int mTier, int vTier) {
         //By Default:
         //Helium and Nitrogen Plasmas will double the range
@@ -303,16 +282,6 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         return 1F * plasmaBoost;
     }
 
-    private void thaumLightning(IGregTechTileEntity mte, IGregTechTileEntity node) {
-        byte xR = (byte) (node.getXCoord() - posTop.get0());
-        byte yR = (byte) (node.getYCoord() - posTop.get1());
-        byte zR = (byte) (node.getZCoord() - posTop.get2());
-
-        int wID = mte.getWorld().provider.dimensionId;
-
-        sparkList.add(new ThaumSpark(posTop.get0(), posTop.get1(), posTop.get2(), xR, yR, zR, wID));
-    }
-
     private void checkPlasmaBoost() {
         //If there's fluid in the queue, try to output it
         //That way it takes at least a second to 'process' the plasma
@@ -367,7 +336,9 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         Vec3Impl xyzOffsets;
         xyzOffsets = getExtendedFacing().getWorldOffset(new Vec3Impl(0, -1, 1));
         mTier = iGregTechTileEntity.getMetaIDOffset(xyzOffsets.get0(), xyzOffsets.get1(), xyzOffsets.get2());
-        if (mTier == 9){mTier = 6;}//Hacky remap because the ZPM coils were added later
+        if (mTier == 9) {
+            mTier = 6;
+        }//Hacky remap because the ZPM coils were added later
 
         if (structureCheck_EM(shape, blockType, blockMetas[mTier], addingMethods, casingTextures, blockTypeFallback, blockMetaFallback, 3, 16, 0) && eCapacitorHatches.size() > 0) {
             for (GT_MetaTileEntity_Hatch_Capacitor cap : eCapacitorHatches) {
@@ -480,11 +451,10 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
     @Override
     public void onRemoval() {
         super.onRemoval();
-        IGregTechTileEntity aBaseMetaTileEntity = this.getBaseMetaTileEntity();
-        if (aBaseMetaTileEntity.isClientSide()) {
+        if (this.getBaseMetaTileEntity().isClientSide()) {
             return;
         }
-        teslaNodeSet.remove(aBaseMetaTileEntity);
+        teslaNodeSet.remove(this);
         for (GT_MetaTileEntity_Hatch_Capacitor cap : eCapacitorHatches) {
             if (GT_MetaTileEntity_MultiBlockBase.isValidMetaTileEntity(cap)) {
                 cap.getBaseMetaTileEntity().setActive(false);
@@ -558,7 +528,7 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
     public void loadNBTData(NBTTagCompound aNBT) {
         super.loadNBTData(aNBT);
         energyCapacity = aNBT.getLong("eEnergyCapacity");
-        teslaNodeSet.add(this.getBaseMetaTileEntity());
+        teslaNodeSet.add(this);
     }
 
     @Override
@@ -578,113 +548,10 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
     public void onFirstTick_EM(IGregTechTileEntity aBaseMetaTileEntity) {
         super.onFirstTick_EM(aBaseMetaTileEntity);
         if (!aBaseMetaTileEntity.isClientSide()) {
-            teslaNodeSet.add(aBaseMetaTileEntity);
-        }
-    }
-
-
-    public static Map<IGregTechTileEntity, Integer> generateTeslaNodeMap(IGregTechTileEntity orgin){
-        Map<IGregTechTileEntity, Integer> generatedNodeMap = new HashMap<>();
-        IMetaTileEntity originInside = orgin.getMetaTileEntity();
-        int originX;
-        int originY;
-        int originZ;
-        if (originInside instanceof GT_MetaTileEntity_TM_teslaCoil) {
-            GT_MetaTileEntity_TM_teslaCoil teslaTower = (GT_MetaTileEntity_TM_teslaCoil) originInside;
-            originX = teslaTower.posTop.get0();
-            originY = teslaTower.posTop.get1();
-            originZ = teslaTower.posTop.get2();
-        } else {
-            originX = orgin.getXCoord();
-            originY = orgin.getYCoord();
-            originZ = orgin.getZCoord();
-        }
-
-        for (IGregTechTileEntity node : teslaNodeSet) {
-            if (node == null) {
-                //Technically, the Tesla Covers do not remove themselves from the list and this is the code that does
-                teslaNodeSet.remove(null);
-                continue;
-            } else if (node == orgin || orgin.getWorld().provider.dimensionId != node.getWorld().provider.dimensionId) {
-                //Skip if looking at myself and skip if not in the same dimension
-                //TODO, INTERDIM?
-                continue;
-            }
-
-            //Makes the target coordinates the center of the sphere of the tower if it has one
-            IMetaTileEntity nodeInside = node.getMetaTileEntity();
-            int targetX;
-            int targetY;
-            int targetZ;
-            if (nodeInside instanceof GT_MetaTileEntity_TM_teslaCoil) {
-                GT_MetaTileEntity_TM_teslaCoil teslaTower = (GT_MetaTileEntity_TM_teslaCoil) nodeInside;
-                targetX = teslaTower.posTop.get0();
-                targetY = teslaTower.posTop.get1();
-                targetZ = teslaTower.posTop.get2();
-            } else {
-                targetX = node.getXCoord();
-                targetY = node.getYCoord();
-                targetZ = node.getZCoord();
-            }
-
-            //Find the xyz offsets and calculate the distance between us and the target
-            int xPosOffset = targetX - originX;
-            int yPosOffset = targetY - originY;
-            int zPosOffset = targetZ - originZ;
-            int distance = (int) ceil(sqrt(pow(xPosOffset, 2) + pow(yPosOffset, 2) + pow(zPosOffset, 2)));
-            //Thought we need abs here, we don't. An Integer to the power of two is going to be either 0 or positive.
-            //We also can just put stuff here without further checks, as we always check the next section
-            generatedNodeMap.put(node, distance);
-        }
-        return generatedNodeMap;
-    }
-
-    public static void cleanTeslaNodeMap(Map<IGregTechTileEntity, Integer> nodeMap, IGregTechTileEntity orgin) {
-        IMetaTileEntity orginInside = orgin.getMetaTileEntity();
-        //Assumes that if the orgin is not a Tesla Tower, it mus be a single block.
-        boolean isMulti = orginInside instanceof GT_MetaTileEntity_TM_teslaCoil;
-
-        for (Map.Entry<IGregTechTileEntity, Integer> Rx : nodeMap.entrySet()) {
-            //All the checks need to pass or the target gets removed from the transmission list
-            IGregTechTileEntity node = Rx.getKey();
-            //Null check
-            if (node != null) {
-                IMetaTileEntity nodeInside = node.getMetaTileEntity();
-                //We need this in a try catch, just as a precaution that a chunk had unloaded or a machine was removed
-                try {
-                    //Is it an Active Tesla Tower with at least some energy capacity?
-                    //Singles and Multis can send power here, so we don't check
-                    if (nodeInside instanceof GT_MetaTileEntity_TM_teslaCoil && node.isActive()) {
-                        GT_MetaTileEntity_TM_teslaCoil teslaTower = (GT_MetaTileEntity_TM_teslaCoil) nodeInside;
-                        if (teslaTower.maxEUStore() > 0) {
-                            continue;
-                        }
-                        //Is it a Tesla Transceiver with at least one battery?
-                        //Only multis can send power to singles
-                    } else if (isMulti && nodeInside instanceof GT_MetaTileEntity_TeslaCoil) {
-                        GT_MetaTileEntity_TeslaCoil teslaTransceiver = (GT_MetaTileEntity_TeslaCoil) nodeInside;
-                        if (teslaTransceiver.mBatteryCount > 0) {
-                            continue;
-                        }
-                        //Is it a tile entity with a Tesla Coil Cover?
-                        //Only single can send power to non-Rich edition covers
-                        //Since Rich edition inherits from regular, we need the final check
-                    } else if (!isMulti && node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil &&
-                            node.getEUCapacity() > 0 && !(node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil_Ultimate)) {
-                        continue;
-                        //Is it a tile entity with a Tesla Coil Cover Rich edition?
-                        //Only multis can send power to Rich edition covers
-                    } else if (isMulti && node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil_Ultimate && node.getEUCapacity() > 0) {
-                        continue;
-                    }
-                } catch (Exception ignored) {
-                }
-            }
-            nodeMap.remove(Rx.getKey());
+            teslaNodeSet.add(this);
         }
     }
 
-
     @Override
     public boolean onRunningTick(ItemStack aStack) {
         IGregTechTileEntity mte = getBaseMetaTileEntity();
@@ -706,13 +573,12 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         if (sortTime == sortTimeMinSetting.get()) {
             sortTime = 0;
             sortTimeDisplay.updateStatus();
-            teslaNodeMap = generateTeslaNodeMap(mte);
+            generateTeslaNodeMap(this);
         }
         sortTime++;
         sortTimeDisplay.set(sortTime);
 
         //Power Limit Settings
-        long outputVoltage;
         if (outputVoltageSetting.get() > 0) {
             outputVoltage = min(outputVoltageMax, (long) outputVoltageSetting.get());
         } else {
@@ -720,95 +586,34 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
         }
         outputVoltageDisplay.set(outputVoltage);
 
-        long outputCurrent;
         if (outputCurrentSetting.get() > 0) {
             outputCurrent = min(outputCurrentMax, (long) outputCurrentSetting.get());
         } else {
             outputCurrent = outputCurrentMax;
         }
-        outputCurrentDisplay.set(0);
-
-        //Stuff to do if ePowerPass
-        if (ePowerPass) {
-            //Range calculation and display
-            int transferRadiusTower = (int) (transferRadiusTowerSetting.get() * getRangeMulti(mTier, vTier));
-            transferRadiusTowerDisplay.set(transferRadiusTower);
-            int transferRadiusTransceiver = (int) (transferRadiusTransceiverSetting.get() * getRangeMulti(mTier, vTier));
-            transferRadiusTransceiverDisplay.set(transferRadiusTransceiver);
-            int transferRadiusCoverUltimate = (int) (transferRadiusCoverUltimateSetting.get() * getRangeMulti(mTier, vTier));
-            transferRadiusCoverUltimateDisplay.set(transferRadiusCoverUltimate);
-
-            //Clean the teslaNodeMap
-            cleanTeslaNodeMap(teslaNodeMap, mte);
-
-            //Power transfer
-            long sparks = outputCurrent;
-            while (sparks > 0) {
-                boolean overdriveToggle = overDriveSetting.get() > 0;
-                boolean idle = true;
-                for (Map.Entry<IGregTechTileEntity, Integer> Rx : entriesSortedByValues(teslaNodeMap)) {
-                    if (getEUVar() >= (overdriveToggle ? outputVoltage * 2 : outputVoltage)) {
-                        IGregTechTileEntity node = Rx.getKey();
-                        IMetaTileEntity nodeInside = node.getMetaTileEntity();
-
-                        long[] outputVoltageNow = getOutputVoltage(outputVoltage, Rx.getValue(), overdriveToggle);
-                        long outputVoltageInjectable = outputVoltageNow[0];
-                        long outputVoltageConsumption = outputVoltageNow[1];
-
-                        if (nodeInside instanceof GT_MetaTileEntity_TM_teslaCoil && Rx.getValue() <= transferRadiusTower) {
-                            GT_MetaTileEntity_TM_teslaCoil nodeTesla = (GT_MetaTileEntity_TM_teslaCoil) nodeInside;
-                            if (!nodeTesla.ePowerPass) {
-                                if (nodeTesla.getEUVar() + outputVoltageInjectable <= (nodeTesla.maxEUStore() / 2)) {
-                                    setEUVar(getEUVar() - outputVoltageConsumption);
-                                    node.increaseStoredEnergyUnits(outputVoltageConsumption, true);
-                                    thaumLightning(mte, node);
-                                    sparks--;
-                                    idle = false;
-                                }
-                            }
-                        } else if (nodeInside instanceof GT_MetaTileEntity_TeslaCoil && Rx.getValue() <= transferRadiusTransceiver) {
-                            GT_MetaTileEntity_TeslaCoil nodeTesla = (GT_MetaTileEntity_TeslaCoil) nodeInside;
-                            if (!nodeTesla.powerPassToggle) {
-                                if (node.injectEnergyUnits((byte) 6, outputVoltageInjectable, 1L) > 0L) {
-                                    setEUVar(getEUVar() - outputVoltageConsumption);
-                                    thaumLightning(mte, node);
-                                    sparks--;
-                                    idle = false;
-                                }
-                            }
-                        } else if ((node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil_Ultimate) && Rx.getValue() <= transferRadiusCoverUltimate) {
-                            if (node.injectEnergyUnits((byte) 1, outputVoltageInjectable, 1L) > 0L) {
-                                setEUVar(getEUVar() - outputVoltageConsumption);
-                                thaumLightning(mte, node);
-                                sparks--;
-                                idle = false;
-                            }
-                        }
-                        if (sparks == 0) {
-                            break;
-                        }
-                    } else {
-                        idle = true;
-                        break;
-                    }
-                }
-                if (idle) {
-                    break;
-                }
-            }
-            outputCurrentDisplay.set(outputCurrent - sparks);
-            if (sortTime % 60 == 0 && !sparkList.isEmpty()) {
-                NetworkDispatcher.INSTANCE.sendToAllAround(new RendererMessage.RendererData(sparkList),
-                        mte.getWorld().provider.dimensionId,
-                        posTop.get0(),
-                        posTop.get1(),
-                        posTop.get2(),
-                        256);
-            }
-            sparkList.clear();
-        } else {
-            outputCurrentDisplay.set(0);
+
+        //Range calculation and display
+        int transferRadiusTower = getTeslaTransmissionRange();
+        transferRadiusTowerDisplay.set(transferRadiusTower);
+        transferRadiusTransceiverDisplay.set(transferRadiusTower * 2);
+        transferRadiusCoverUltimateDisplay.set(transferRadiusTower);
+
+        //Clean the teslaNodeMap
+        cleanTeslaNodeMap(this);
+
+        //Power transfer
+        outputCurrentDisplay.set(powerTeslaNodeMap(this));
+
+        if (!sparkList.isEmpty()) {
+            NetworkDispatcher.INSTANCE.sendToAllAround(new RendererMessage.RendererData(sparkList),
+                    mte.getWorld().provider.dimensionId,
+                    posTop.get0(),
+                    posTop.get1(),
+                    posTop.get2(),
+                    256);
         }
+        sparkList.clear();
+
         return true;
     }
 
@@ -882,4 +687,88 @@ public class GT_MetaTileEntity_TM_teslaCoil extends GT_MetaTileEntity_Multiblock
     public String[] getStructureDescription(ItemStack stackSize) {
         return description;
     }
+
+    @Override
+    public byte getTeslaReceptionCapability() {
+        return 0;
+    }
+
+    @Override
+    public float getTeslaReceptionCoefficient() {
+        return 0;
+    }
+
+    @Override
+    public byte getTeslaTransmissionCapability() {
+        return 1;
+    }
+
+    @Override
+    public int getTeslaTransmissionRange() {
+        return (int) (transferRadiusTowerSetting.get() * getRangeMulti(mTier, vTier));
+    }
+
+    @Override
+    public boolean isOverdriveEnabled() {
+        return overDriveSetting.get() > 0;
+    }
+
+    @Override
+    public int getTeslaEnergyLossPerBlock() {
+        return plasmaTierLoss[plasmaTier];
+    }
+
+    @Override
+    public float getTeslaOverdriveLossCoefficient() {
+        return overDriveLoss;
+    }
+
+    @Override
+    public long getTeslaOutputVoltage() {
+        return outputVoltage;
+    }
+
+    @Override
+    public long getTeslaOutputCurrent() {
+        return outputCurrent;
+    }
+
+    @Override
+    public boolean teslaDrainEnergy(long teslaVoltageDrained) {
+        if (getEUVar() < teslaVoltageDrained) {
+            return false;
+        }
+
+        setEUVar(getEUVar() - teslaVoltageDrained);
+        return true;
+    }
+
+    @Override
+    public boolean isTeslaReadyToReceive() {
+        return !this.ePowerPass;
+    }
+
+    @Override
+    public long getTeslaStoredEnergy() {
+        return getEUVar();
+    }
+
+    @Override
+    public Vec3Impl getTeslaPosition() {
+        return posTop;
+    }
+
+    @Override
+    public Integer getTeslaDimension() {
+        return this.getBaseMetaTileEntity().getWorld().provider.dimensionId;
+    }
+
+    @Override
+    public boolean teslaInjectEnergy(long teslaVoltageInjected) {
+        if (this.getEUVar() + teslaVoltageInjected <= (this.maxEUStore() / 2)) {
+            this.getBaseMetaTileEntity().increaseStoredEnergyUnits(teslaVoltageInjected, true);
+            return true;
+        }
+        return false;
+    }
 }
diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_TeslaCoil.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_TeslaCoil.java
index 8d3696d9ad..388a253b27 100644
--- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_TeslaCoil.java
+++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_TeslaCoil.java
@@ -1,14 +1,14 @@
 package com.github.technus.tectech.thing.metaTileEntity.single;

 

+import com.github.technus.tectech.mechanics.tesla.ITeslaConnectable;

 import com.github.technus.tectech.util.CommonValues;

 import com.github.technus.tectech.TecTech;

-import com.github.technus.tectech.util.Util;

 import com.github.technus.tectech.loader.NetworkDispatcher;

 import com.github.technus.tectech.mechanics.spark.RendererMessage;

 import com.github.technus.tectech.mechanics.spark.ThaumSpark;

-import com.github.technus.tectech.thing.cover.GT_Cover_TM_TeslaCoil;

-import com.github.technus.tectech.thing.cover.GT_Cover_TM_TeslaCoil_Ultimate;

 import com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_TM_teslaCoil;

+import com.github.technus.tectech.util.Util;

+import com.github.technus.tectech.util.Vec3Impl;

 import eu.usrv.yamcore.auxiliary.PlayerChatHelper;

 import gregtech.api.interfaces.ITexture;

 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;

@@ -23,25 +23,19 @@ import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.reflect.FieldUtils;

 

 import java.util.Arrays;

-import java.util.HashMap;

-import java.util.HashSet;

-import java.util.Map;

 

-import static com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_TM_teslaCoil.*;

+import static com.github.technus.tectech.mechanics.tesla.ITeslaConnectable.TeslaUtil.*;

 import static com.github.technus.tectech.util.CommonValues.V;

-import static com.github.technus.tectech.util.Util.entriesSortedByValues;

 import static com.github.technus.tectech.thing.metaTileEntity.Textures.*;

 import static java.lang.Math.round;

 import static net.minecraft.util.StatCollector.translateToLocal;

 import static net.minecraft.util.StatCollector.translateToLocalFormatted;

 

-public class GT_MetaTileEntity_TeslaCoil extends GT_MetaTileEntity_BasicBatteryBuffer {

+public class GT_MetaTileEntity_TeslaCoil extends GT_MetaTileEntity_BasicBatteryBuffer implements ITeslaConnectable {

     private final static int transferRadiusMax = TecTech.configTecTech.TESLA_SINGLE_RANGE;//Default is 20

     private final static int perBlockLoss = TecTech.configTecTech.TESLA_SINGLE_LOSS_PER_BLOCK;//Default is 1

     private final static float overDriveLoss = TecTech.configTecTech.TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE;//Default is 0.25F

 

-    private Map<IGregTechTileEntity, Integer> teslaNodeMap = new HashMap<>();//Tesla Map to map them tesla bois!

-    private final static HashSet<ThaumSpark> sparkList = new HashSet<>();

     private byte sparkCount = 0;

 

     private final static int transferRadiusMin = 4;//Minimum user configurable

@@ -229,23 +223,22 @@ public class GT_MetaTileEntity_TeslaCoil extends GT_MetaTileEntity_BasicBatteryB
     public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {

         super.onFirstTick(aBaseMetaTileEntity);

         if (!aBaseMetaTileEntity.isClientSide()) {

-            teslaNodeSet.add(aBaseMetaTileEntity);

+            teslaNodeSet.add(this);

         }

     }

 

     @Override

     public void onRemoval() {

         super.onRemoval();

-        IGregTechTileEntity aBaseMetaTileEntity = this.getBaseMetaTileEntity();

-        if (!aBaseMetaTileEntity.isClientSide()) {

-            teslaNodeSet.remove(aBaseMetaTileEntity);

+        if (!this.getBaseMetaTileEntity().isClientSide()) {

+            teslaNodeSet.remove(this);

         }

     }

 

     @Override

     public void loadNBTData(NBTTagCompound aNBT) {

         super.loadNBTData(aNBT);

-        teslaNodeSet.add(this.getBaseMetaTileEntity());

+        teslaNodeSet.add(this);

     }

 

     @Override

@@ -270,72 +263,13 @@ public class GT_MetaTileEntity_TeslaCoil extends GT_MetaTileEntity_BasicBatteryB
         //Create the teslaNodeMap

         if (sortTime == sortTimeMax) {

             sortTime = 0;

-            teslaNodeMap = generateTeslaNodeMap(aBaseMetaTileEntity);

+            generateTeslaNodeMap(this);

         }

         sortTime++;

 

-        //Stuff to do if ePowerPass

-        if (powerPassToggle) {

-            float rangeFrac = (float) ((-0.5 * Math.pow(energyFrac, 2)) + (1.5 * energyFrac));

-            long outputCurrent = mBatteryCount;

-            //Radius for transceiver to tower transfers

-            int transferRadiusTower = (int) (transferRadius * rangeFrac);

-            //Radius for transceiver to cover transfers

-            int transferRadiusCover = (int) (transferRadiusTower / 1.25);

-

-            //Clean the teslaNodeMap

-            cleanTeslaNodeMap(teslaNodeMap, aBaseMetaTileEntity);

-

-            //Power transfer

-            while (outputCurrent > 0) {

-                boolean idle = true;

-                for (Map.Entry<IGregTechTileEntity, Integer> Rx : entriesSortedByValues(teslaNodeMap)) {

-                    if (getEUVar() >= (overdriveToggle ? outputVoltage * 2 : outputVoltage)) {

-                        IGregTechTileEntity node = Rx.getKey();

-                        IMetaTileEntity nodeInside = node.getMetaTileEntity();

-

-                        long[] outputVoltageNow = getOutputVoltage(outputVoltage, Rx.getValue(), overdriveToggle);

-                        long outputVoltageInjectable = outputVoltageNow[0];

-                        long outputVoltageConsumption = outputVoltageNow[1];

-

-                        if (nodeInside instanceof GT_MetaTileEntity_TM_teslaCoil && Rx.getValue() <= transferRadiusTower) {

-                            GT_MetaTileEntity_TM_teslaCoil nodeTesla = (GT_MetaTileEntity_TM_teslaCoil) nodeInside;

-                            if (!nodeTesla.ePowerPass) {

-                                if (nodeTesla.getEUVar() + outputVoltageInjectable <= (nodeTesla.maxEUStore() / 2)) {

-                                    setEUVar(getEUVar() - outputVoltageConsumption);

-                                    node.increaseStoredEnergyUnits(outputVoltageInjectable, true);

-                                    thaumLightning(aBaseMetaTileEntity, node);

-                                    outputCurrent--;

-                                    idle = false;

-                                }

-                            }

-                        } else if ((node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil) && !(node.getCoverBehaviorAtSide((byte) 1) instanceof GT_Cover_TM_TeslaCoil_Ultimate) && Rx.getValue() <= transferRadiusCover) {

-                            if (nodeInside instanceof GT_MetaTileEntity_TeslaCoil){

-                                GT_MetaTileEntity_TeslaCoil nodeTesla = (GT_MetaTileEntity_TeslaCoil) nodeInside;

-                                if (nodeTesla.powerPassToggle){

-                                    continue;

-                                }

-                            }

-                            if (node.injectEnergyUnits((byte) 1, outputVoltageInjectable, 1L) > 0L) {

-                                setEUVar(getEUVar() - outputVoltageConsumption);

-                                thaumLightning(aBaseMetaTileEntity, node);

-                                outputCurrent--;

-                                idle = false;

-                            }

-                        }

-                        if (outputCurrent == 0) {

-                            break;

-                        }

-                    } else {

-                        idle = true;

-                        break;

-                    }

-                }

-                if (idle) {

-                    break;

-                }

-            }

-        }

+        //Send Power

+        powerTeslaNodeMap(this);

+

         sparkCount++;

         if (sparkCount == 60 && !sparkList.isEmpty()) {

             sparkCount = 0;

@@ -364,4 +298,83 @@ public class GT_MetaTileEntity_TeslaCoil extends GT_MetaTileEntity_BasicBatteryB
         return true;

     }

 

+    @Override

+    public byte getTeslaReceptionCapability() {

+        return 1;

+    }

+

+    @Override

+    public float getTeslaReceptionCoefficient() {

+        return 1;

+    }

+

+    @Override

+    public byte getTeslaTransmissionCapability() {

+        return 2;

+    }

+

+    @Override

+    public int getTeslaTransmissionRange() {

+        return transferRadius;

+    }

+

+    @Override

+    public boolean isOverdriveEnabled() {

+        return overdriveToggle;

+    }

+

+    @Override

+    public int getTeslaEnergyLossPerBlock() {

+        return perBlockLoss;

+    }

+

+    @Override

+    public float getTeslaOverdriveLossCoefficient() {

+        return overDriveLoss;

+    }

+

+    @Override

+    public long getTeslaOutputVoltage() {

+        return outputVoltage;

+    }

+

+    @Override

+    public long getTeslaOutputCurrent() {

+        return mBatteryCount;

+    }

+

+    @Override

+    public boolean teslaDrainEnergy(long teslaVoltageDrained) {

+        if (getEUVar() < teslaVoltageDrained) {

+            return false;

+        }

+

+        setEUVar(getEUVar() - teslaVoltageDrained);

+        return true;

+    }

+

+    @Override

+    public boolean isTeslaReadyToReceive() {

+        return !this.powerPassToggle;

+    }

+

+    @Override

+    public long getTeslaStoredEnergy() {

+        return getEUVar();

+    }

+

+    @Override

+    public Vec3Impl getTeslaPosition() {

+        return new Vec3Impl(this.getBaseMetaTileEntity());

+    }

+

+    @Override

+    public Integer getTeslaDimension() {

+        return this.getBaseMetaTileEntity().getWorld().provider.dimensionId;

+    }

+

+    @Override

+    public boolean teslaInjectEnergy(long teslaVoltageInjected) {

+        return this.getBaseMetaTileEntity().injectEnergyUnits((byte) 1, teslaVoltageInjected, 1L) > 0L;

+    }

 }