Merge addon sources

5 files changed, 808 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java
new file mode 100644
index 0000000000..924484e098
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/ChargingHelper.java
@@ -0,0 +1,346 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import static gregtech.api.GregTech_API.mEUtoRF;
+import static gregtech.api.enums.Mods.Baubles;
+import static gregtech.api.enums.Mods.COFHCore;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+import baubles.api.BaublesApi;
+import cofh.api.energy.IEnergyContainerItem;
+import cpw.mods.fml.common.eventhandler.EventPriority;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.common.items.GT_MetaGenerated_Item_01;
+import gregtech.common.items.GT_MetaGenerated_Item_02;
+import gregtech.common.items.GT_MetaGenerated_Item_03;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.NBTUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GregtechMetaWirelessCharger;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+
+public class ChargingHelper {
+
+    private static final Map<String, Pair<GregtechMetaWirelessCharger, Byte>> mValidPlayers = new HashMap<>();
+    protected static Map<BlockPos, GregtechMetaWirelessCharger> mChargerMap = new HashMap<>();
+    private int mTickTimer = 0;
+    private static final int mTickMultiplier = 20;
+
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onServerTick(ServerTickEvent event) {
+        if (++mTickTimer % mTickMultiplier == 0) {
+            if (Utils.isServer()) {
+                for (EntityPlayer mPlayerMan : PlayerUtils.getOnlinePlayers()) {
+                    doPlayerChargeTick(mPlayerMan);
+                }
+            }
+        }
+    }
+
+    @SuppressWarnings("unused")
+    private void doPlayerChargeTick(EntityPlayer mPlayerMan) {
+        try {
+            long mVoltage;
+            long mEuStored;
+
+            if (!mChargerMap.isEmpty() && mValidPlayers.containsKey(mPlayerMan.getDisplayName())) {
+                InventoryPlayer mPlayerInventory = mPlayerMan.inventory;
+                ItemStack[] mArmourContents = mPlayerInventory.armorInventory.clone();
+                ItemStack[] mInventoryContents = mPlayerInventory.mainInventory.clone();
+                ItemStack[] baubleSlots = null;
+                if (Baubles.isModLoaded()) {
+                    IInventory baubleInv = BaublesApi.getBaubles(mPlayerMan);
+                    if (baubleInv != null) {
+                        baubleSlots = new ItemStack[baubleInv.getSizeInventory()];
+                        for (int i = 0; i < baubleInv.getSizeInventory(); i++) {
+                            baubleSlots[i] = baubleInv.getStackInSlot(i);
+                        }
+                    }
+                }
+
+                for (GregtechMetaWirelessCharger mEntityTemp : mChargerMap.values()) {
+                    if (mEntityTemp != null) {
+                        if (mEntityTemp.getBaseMetaTileEntity() == null || !mEntityTemp.getBaseMetaTileEntity()
+                            .isAllowedToWork()) continue;
+                        if (mPlayerMan.getEntityWorld().provider.dimensionId == mEntityTemp.getDimensionID()) {
+                            mVoltage = mEntityTemp.maxEUInput();
+                            mEuStored = mEntityTemp.getEUVar();
+                            if (mVoltage > 0 && mEuStored >= mVoltage) {
+                                Map<String, UUID> LR = mEntityTemp.getLongRangeMap();
+                                Map<String, UUID> LO = mEntityTemp.getLocalMap();
+
+                                long mStartingEu = mEntityTemp.getEUVar();
+                                if (canCharge(mEntityTemp, mPlayerMan, LR, LO)) {
+                                    chargeItems(mEntityTemp, mArmourContents);
+                                    chargeItems(mEntityTemp, mInventoryContents);
+                                    chargeItems(mEntityTemp, baubleSlots);
+                                }
+
+                                if (mStartingEu - mEntityTemp.getEUVar() <= 0) {
+                                    long mMaxDistance;
+                                    if (mEntityTemp.getMode() == 0) {
+                                        mMaxDistance = (4 * GT_Values.V[mEntityTemp.getTier()]);
+                                    } else if (mEntityTemp.getMode() == 1) {
+                                        mMaxDistance = (mEntityTemp.getTier() * 10L);
+                                    } else {
+                                        mMaxDistance = (4 * GT_Values.V[mEntityTemp.getTier()] / 2);
+                                    }
+                                    double mDistance = calculateDistance(mEntityTemp, mPlayerMan);
+                                    long mVoltageCost = MathUtils.findPercentageOfInt(mMaxDistance, (float) mDistance);
+
+                                    if (mVoltageCost > 0) {
+                                        if (mVoltageCost > mEntityTemp.maxEUInput()) {
+                                            mEntityTemp.setEUVar((mEntityTemp.getEUVar() - mEntityTemp.maxEUInput()));
+                                        } else {
+                                            mEntityTemp.setEUVar((mEntityTemp.getEUVar() - mVoltageCost));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Throwable t) {
+            if (!mChargerMap.isEmpty()) {
+                for (BlockPos aPos : mChargerMap.keySet()) {
+                    GregtechMetaWirelessCharger r = mChargerMap.get(aPos);
+                    if (r == null || r.getBaseMetaTileEntity()
+                        .isInvalidTileEntity()) {
+                        mChargerMap.remove(aPos);
+                    }
+                }
+            }
+        }
+    }
+
+    public static GregtechMetaWirelessCharger getEntry(BlockPos mPos) {
+        return mChargerMap.get(mPos);
+    }
+
+    public static boolean addEntry(BlockPos mPos, GregtechMetaWirelessCharger mEntity) {
+        if (mEntity == null) {
+            return false;
+        }
+        mChargerMap.put(mPos, mEntity);
+        return true;
+    }
+
+    public static boolean removeEntry(BlockPos mPos, GregtechMetaWirelessCharger mEntity) {
+        if (mEntity == null) {
+            return false;
+        }
+        if (mChargerMap.containsKey(mPos)) {
+            return mChargerMap.remove(mPos, mEntity);
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean addValidPlayer(EntityPlayer mPlayer, GregtechMetaWirelessCharger mEntity) {
+        if (mEntity == null) {
+            return false;
+        }
+        if (mValidPlayers.containsKey(mPlayer.getDisplayName())) {
+            return false;
+        } else {
+            Pair<GregtechMetaWirelessCharger, Byte> mEntry = new Pair<>(mEntity, (byte) mEntity.getMode());
+            return mValidPlayers.put(mPlayer.getDisplayName(), mEntry) == null;
+        }
+    }
+
+    public static boolean removeValidPlayer(EntityPlayer mPlayer, GregtechMetaWirelessCharger mEntity) {
+        if (mEntity == null) {
+            return false;
+        }
+        if (mValidPlayers.containsKey(mPlayer.getDisplayName())) {
+            Pair<GregtechMetaWirelessCharger, Byte> mEntry = new Pair<>(mEntity, (byte) mEntity.getMode());
+            return mValidPlayers.remove(mPlayer.getDisplayName(), mEntry);
+        } else {
+            return false;
+        }
+    }
+
+    private boolean canCharge(GregtechMetaWirelessCharger charger, EntityPlayer chargeablePlayer,
+        Map<String, UUID> longRangeChargers, Map<String, UUID> shortRangeChargers) {
+        if (charger.getMode() == 0) {
+            return !longRangeChargers.isEmpty() && longRangeChargers.containsKey(chargeablePlayer.getDisplayName());
+        } else if (charger.getMode() == 1) {
+            return !shortRangeChargers.isEmpty() && shortRangeChargers.containsKey(chargeablePlayer.getDisplayName());
+        } else {
+            if (!longRangeChargers.isEmpty() && longRangeChargers.containsKey(chargeablePlayer.getDisplayName())) {
+                return true;
+            }
+            return !shortRangeChargers.isEmpty() && shortRangeChargers.containsKey(chargeablePlayer.getDisplayName());
+        }
+    }
+
+    private double calculateDistance(GregtechMetaWirelessCharger mEntityTemp, EntityPlayer mPlayerMan) {
+        if (mEntityTemp == null || mPlayerMan == null) {
+            return 0;
+        }
+        return mEntityTemp.getDistanceBetweenTwoPositions(
+            mEntityTemp.getTileEntityPosition(),
+            mEntityTemp.getPositionOfEntity(mPlayerMan));
+    }
+
+    private void chargeItems(@Nonnull GregtechMetaWirelessCharger mEntity, ItemStack[] mItems) {
+        if (mItems == null || mItems.length == 0) {
+            return;
+        }
+        chargeItemsEx(mEntity, mItems);
+    }
+
+    private void chargeItemsEx(@Nonnull GregtechMetaWirelessCharger mEntity, ItemStack[] mItems) {
+        // Bad Inventory
+        if (mItems == null || mItems.length == 0) {
+            return;
+        }
+        // Set Variables to Charge
+        final long mVoltage = mEntity.maxEUInput();
+        long mEuStored = mEntity.getEUVar();
+        // For Inventory Contents
+
+        for (ItemStack mTemp : mItems) {
+            // Is item Electrical
+            if (isItemValid(mTemp)) {
+                // Transfer Limit
+                double mItemEuTLimit = ((IElectricItem) mTemp.getItem()).getTransferLimit(mTemp);
+                // Check if Tile has more or equal EU to what can be transferred into the item.
+                if (mEuStored >= mItemEuTLimit) {
+
+                    double mItemMaxCharge = ((IElectricItem) mTemp.getItem()).getMaxCharge(mTemp);
+                    double mitemCurrentCharge = ElectricItem.manager.getCharge(mTemp);
+
+                    if (mitemCurrentCharge >= mItemMaxCharge) {
+                        continue;
+                    }
+
+                    // Try to get charge direct from NBT for GT and IC2 stacks
+                    if (mTemp.getItem() instanceof GT_MetaGenerated_Tool_01
+                        || mTemp.getItem() instanceof GT_MetaGenerated_Item_01
+                        || mTemp.getItem() instanceof GT_MetaGenerated_Item_02
+                        || mTemp.getItem() instanceof GT_MetaGenerated_Item_03
+                        || mTemp.getItem()
+                            .getClass()
+                            .getName()
+                            .equalsIgnoreCase(GT_MetaGenerated_Tool_01.class.getName())) {
+                        if (!NBTUtils.hasKey(mTemp, "GT.ItemCharge")) {
+                            if (!mTemp.getDisplayName()
+                                .toLowerCase()
+                                .contains("battery")) {
+                                if (!GT_ModHandler.isElectricItem(mTemp)) {
+                                    continue;
+                                }
+                            } else {
+                                mitemCurrentCharge = 0;
+                            }
+                        } else {
+                            mitemCurrentCharge = NBTUtils.getLong(mTemp, "GT.ItemCharge");
+                        }
+                    } else if (mTemp.getItem() instanceof IElectricItem) {
+                        mitemCurrentCharge = NBTUtils.getLong(mTemp, "charge");
+                    }
+
+                    double mVoltageIncrease;
+                    if (mItemEuTLimit >= mVoltage) {
+                        mVoltageIncrease = mVoltage;
+                    } else if (mItemEuTLimit < mVoltage) {
+                        mVoltageIncrease = mItemEuTLimit;
+                    } else {
+                        mVoltageIncrease = mItemEuTLimit;
+                    }
+
+                    int mMulti;
+                    if ((mitemCurrentCharge + (mVoltageIncrease * 20)) <= (mItemMaxCharge - (mVoltageIncrease * 20))) {
+                        mMulti = 20;
+                    } else if ((mitemCurrentCharge + (mVoltageIncrease * 10))
+                        <= (mItemMaxCharge - (mVoltageIncrease * 10))) {
+                            mMulti = 10;
+                        } else if ((mitemCurrentCharge + (mVoltageIncrease * 5))
+                            <= (mItemMaxCharge - (mVoltageIncrease * 5))) {
+                                mMulti = 5;
+                            } else {
+                                mMulti = 1;
+                            }
+
+                    int mMultiVoltage = (int) (mMulti * mVoltageIncrease);
+
+                    if ((mitemCurrentCharge + mMultiVoltage) <= mItemMaxCharge) {
+                        if (GT_ModHandler.chargeElectricItem(mTemp, mMultiVoltage, Integer.MAX_VALUE, true, false)
+                            > 0) {
+                            for (int i = 0; i < mMulti; i++) {
+                                ElectricItem.manager.charge(mTemp, mVoltageIncrease, Integer.MAX_VALUE, false, false);
+                            }
+                        }
+                        if (ElectricItem.manager.getCharge(mTemp) > mitemCurrentCharge) {
+                            mEntity.setEUVar(mEuStored - (mVoltage * mMulti));
+                            mEuStored = mEntity.getEUVar();
+                        }
+                    }
+
+                    // Try top up Item Chrage
+                    mitemCurrentCharge = ElectricItem.manager.getCharge(mTemp);
+                    if (mitemCurrentCharge < mItemMaxCharge && mitemCurrentCharge >= (mItemMaxCharge - mVoltage)) {
+                        int xDif = (int) (mItemMaxCharge - mitemCurrentCharge);
+                        if (GT_ModHandler.chargeElectricItem(mTemp, xDif, Integer.MAX_VALUE, true, false) >= 0) {
+                            if (ElectricItem.manager.getCharge(mTemp) >= mItemMaxCharge) {
+                                mEntity.setEUVar(mEntity.getEUVar() - (xDif));
+                                mEuStored = mEntity.getEUVar();
+                            }
+                        }
+                    }
+                }
+            } else if (isItemValidRF(mTemp)) {
+                try {
+                    IEnergyContainerItem rfItem = (IEnergyContainerItem) mTemp.getItem();
+                    if (rfItem != null) {
+                        long chargedPower = Math.min(
+                            rfItem.getMaxEnergyStored(mTemp) - rfItem.getEnergyStored(mTemp),
+                            mEntity.getEUVar() * mEUtoRF / 100L);
+                        chargedPower = rfItem.receiveEnergy(
+                            mTemp,
+                            chargedPower > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) chargedPower,
+                            false);
+                        chargedPower = chargedPower * 100L / mEUtoRF;
+                        mEntity.setEUVar(Math.max(mEntity.getEUVar() - chargedPower, 0));
+                        mEuStored = mEntity.getEUVar();
+                    }
+                } catch (Exception ignored) {
+
+                }
+            }
+        }
+    }
+
+    public static boolean isItemValid(final ItemStack itemstack) {
+        if (itemstack == null) {
+            return false;
+        }
+        if (GT_ModHandler.isElectricItem(itemstack)) {
+            return true;
+        }
+        return itemstack.getItem() instanceof IElectricItem;
+    }
+
+    private static boolean isItemValidRF(final ItemStack itemStack) {
+        return itemStack != null && COFHCore.isModLoaded() && itemStack.getItem() instanceof IEnergyContainerItem;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java
new file mode 100644
index 0000000000..8cbb473a42
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/FlotationRecipeHandler.java
@@ -0,0 +1,62 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import java.util.HashMap;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.Material;
+
+public class FlotationRecipeHandler {
+
+    private static final HashMap<String, Material> sMaterialMap = new HashMap<>();
+    private static final HashMap<String, ItemStack> sMilledMap = new HashMap<>();
+
+    public static boolean registerOreType(Material aMaterial) {
+        String aMaterialKey = aMaterial.getUnlocalizedName();
+        if (sMaterialMap.containsKey(aMaterialKey)) {
+            Logger.WARNING("Tried to register a Flotation material already in use. Material: " + aMaterialKey);
+            return false;
+        } else {
+            sMaterialMap.put(aMaterialKey, aMaterial);
+            sMilledMap.put(aMaterialKey, aMaterial.getMilled(1));
+        }
+        return true;
+    }
+
+    public static Material getMaterialOfMilledProduct(ItemStack aMilled) {
+        for (String aKey : sMilledMap.keySet()) {
+            ItemStack aTempMilledStack = sMilledMap.get(aKey);
+            if (GT_Utility.areStacksEqual(aTempMilledStack, aMilled, true)) {
+                return sMaterialMap.get(aKey);
+            }
+        }
+        return null;
+    }
+
+    public static ItemStack findMilledStack(GT_Recipe aRecipe) {
+        if (aRecipe == null || aRecipe.mInputs == null || aRecipe.mInputs.length <= 0) {
+            return null;
+        }
+        return findMilledStack(aRecipe.mInputs);
+    }
+
+    public static ItemStack findMilledStack(ItemStack[] aInputs) {
+        if (aInputs == null || aInputs.length <= 0) {
+            return null;
+        }
+        for (ItemStack aStack : aInputs) {
+            for (int oredictID : OreDictionary.getOreIDs(aStack)) {
+                String oredict = OreDictionary.getOreName(oredictID);
+                if (oredict.startsWith(OrePrefixes.milled.toString())) {
+                    return aStack;
+                }
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java
new file mode 100644
index 0000000000..ced9b46c3e
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/GT_MethodHelper.java
@@ -0,0 +1,19 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.ITexturedTileEntity;
+
+public class GT_MethodHelper {
+
+    public static ITexture[] getTexture(TileEntity tTileEntity, Block aBlock, ForgeDirection side) {
+        if (tTileEntity instanceof ITexturedTileEntity) {
+            return ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, side);
+        }
+        return BlockIcons.ERROR_RENDERING;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/VolumetricFlaskHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/VolumetricFlaskHelper.java
new file mode 100644
index 0000000000..2b0e2a7a4d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/VolumetricFlaskHelper.java
@@ -0,0 +1,125 @@
+package gtPlusPlus.xmod.gregtech.common.helpers;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.ItemList;
+import gregtech.common.items.GT_VolumetricFlask;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+
+public class VolumetricFlaskHelper {
+
+    public static ItemStack getVolumetricFlask(int aAmount) {
+        return ItemList.VOLUMETRIC_FLASK.get(aAmount);
+    }
+
+    public static ItemStack getLargeVolumetricFlask(int aAmount) {
+        return GregtechItemList.VOLUMETRIC_FLASK_8k.get(aAmount);
+    }
+
+    public static ItemStack getGiganticVolumetricFlask(int aAmount) {
+        return GregtechItemList.VOLUMETRIC_FLASK_32k.get(aAmount);
+    }
+
+    public static boolean isVolumetricFlask(ItemStack aStack) {
+        return isNormalVolumetricFlask(aStack) || isLargeVolumetricFlask(aStack) || isGiganticVolumetricFlask(aStack);
+    }
+
+    public static boolean isNormalVolumetricFlask(ItemStack aStack) {
+        return aStack.getItem() == ItemList.VOLUMETRIC_FLASK.getItem();
+    }
+
+    public static boolean isLargeVolumetricFlask(ItemStack aStack) {
+        return GregtechItemList.VOLUMETRIC_FLASK_8k.getItem() == aStack.getItem();
+    }
+
+    public static boolean isGiganticVolumetricFlask(ItemStack aStack) {
+        return GregtechItemList.VOLUMETRIC_FLASK_32k.getItem() == aStack.getItem();
+    }
+
+    public static int getMaxFlaskCapacity(ItemStack aStack) {
+        if (aStack != null) {
+            Item aItem = aStack.getItem();
+            if (aItem instanceof GT_VolumetricFlask) {
+                return ((GT_VolumetricFlask) aItem).getMaxCapacity();
+            }
+        }
+        return 0;
+    }
+
+    public static boolean isFlaskEmpty(ItemStack aStack) {
+        return getFlaskFluid(aStack) == null;
+    }
+
+    public static FluidStack getFlaskFluid(ItemStack aStack) {
+        if (aStack.hasTagCompound()) {
+            NBTTagCompound nbt = aStack.getTagCompound();
+            if (nbt.hasKey("Fluid", 10)) return FluidStack.loadFluidStackFromNBT(nbt.getCompoundTag("Fluid"));
+        }
+        return null;
+    }
+
+    public static void setFluid(ItemStack stack, FluidStack fluidStack) {
+        boolean removeFluid = (fluidStack == null) || (fluidStack.amount <= 0);
+        NBTTagCompound nbt = stack.getTagCompound();
+        if (nbt == null) {
+            if (removeFluid) return;
+            stack.setTagCompound(nbt = new NBTTagCompound());
+        }
+        if (removeFluid) {
+            nbt.removeTag("Fluid");
+            if (nbt.hasNoTags()) {
+                stack.setTagCompound(null);
+            }
+        } else {
+            nbt.setTag("Fluid", fluidStack.writeToNBT(new NBTTagCompound()));
+        }
+    }
+
+    public static int getFlaskCapacity(ItemStack aStack) {
+        int capacity = 1000;
+        if (aStack.hasTagCompound()) {
+            NBTTagCompound nbt = aStack.getTagCompound();
+            if (nbt.hasKey("Capacity", 3)) capacity = nbt.getInteger("Capacity");
+        }
+        return Math.min(getMaxFlaskCapacity(aStack), capacity);
+    }
+
+    public static boolean setNewFlaskCapacity(ItemStack aStack, int aCapacity) {
+        if (aStack == null || aCapacity <= 0) {
+            return false;
+        }
+        aCapacity = Math.min(aCapacity, getMaxFlaskCapacity(aStack));
+        NBTTagCompound nbt = aStack.getTagCompound();
+        if (nbt == null) {
+            aStack.setTagCompound(nbt = new NBTTagCompound());
+        }
+        nbt.setInteger("Capacity", aCapacity);
+        return true;
+    }
+
+    public static int fillFlask(ItemStack stack, FluidStack resource, boolean doFill) {
+        if (stack.stackSize != 1) return 0;
+        if ((resource == null) || (resource.amount <= 0)) {
+            return 0;
+        }
+        FluidStack fluidStack = getFlaskFluid(stack);
+        if (fluidStack == null) {
+            fluidStack = new FluidStack(resource, 0);
+        } else if (!fluidStack.isFluidEqual(resource)) {
+            return 0;
+        }
+        int amount = Math.min(getMaxFlaskCapacity(stack) - fluidStack.amount, resource.amount);
+        if ((doFill) && (amount > 0)) {
+            fluidStack.amount += amount;
+            setFluid(stack, fluidStack);
+        }
+        return amount;
+    }
+
+    public static Item generateNewFlask(String unlocalized, String english, int maxCapacity) {
+        return new GT_VolumetricFlask(unlocalized, english, maxCapacity);
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/tesseract/TesseractHelper.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/tesseract/TesseractHelper.java
new file mode 100644
index 0000000000..3717f17554
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/helpers/tesseract/TesseractHelper.java
@@ -0,0 +1,256 @@
+package gtPlusPlus.xmod.gregtech.common.helpers.tesseract;
+
+import static gtPlusPlus.core.lib.CORE.sTesseractGeneratorOwnershipMap;
+import static gtPlusPlus.core.lib.CORE.sTesseractTerminalOwnershipMap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.UUID;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.xmod.gregtech.common.tileentities.automation.GT_MetaTileEntity_TesseractGenerator;
+import gtPlusPlus.xmod.gregtech.common.tileentities.automation.GT_MetaTileEntity_TesseractTerminal;
+
+public class TesseractHelper {
+
+    /**
+     * Tesseract Generator Helpers
+     *
+     * @param player
+     * @return
+     */
+
+    // Checks if a Generator is owned by a player.
+    public static final boolean isGeneratorOwnedByPlayer(EntityPlayer player,
+        GT_MetaTileEntity_TesseractGenerator generator) {
+        if (player == null) {
+            Logger.WARNING("Failed. [isGeneratorOwnedByPlayer]");
+            return false;
+        }
+        // Utils.LOG_WARNING("Success. [isGeneratorOwnedByPlayer] 1");
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractGeneratorOwnershipMap.isEmpty() && playerIdentifier != null) {
+            // Utils.LOG_WARNING("Success. [isGeneratorOwnedByPlayer] 2");
+            Map<Integer, GT_MetaTileEntity_TesseractGenerator> generators = getGeneratorOwnershipByPlayer(player);
+            Set<Entry<Integer, GT_MetaTileEntity_TesseractGenerator>> players = generators.entrySet();
+            for (Entry<Integer, GT_MetaTileEntity_TesseractGenerator> current : players) {
+                // Utils.LOG_WARNING("Success. [isGeneratorOwnedByPlayer] 3");
+                if (current.getValue()
+                    .equals(generator)) {
+                    // Utils.LOG_WARNING("Success. [isGeneratorOwnedByPlayer] 4");
+                    return true;
+                }
+            }
+        }
+        Logger.WARNING("Failed. [isGeneratorOwnedByPlayer]");
+        return false;
+    }
+
+    // Saves A Generator to the Players UUID map along with the Freq.
+    public static final boolean setGeneratorOwnershipByPlayer(EntityPlayer player, int freq,
+        GT_MetaTileEntity_TesseractGenerator generator) {
+        if (player == null) {
+            return false;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        Logger.WARNING("Setting Generator on " + freq + " for " + player.getDisplayName() + ".");
+        if (playerIdentifier != null) {
+            Map<Integer, GT_MetaTileEntity_TesseractGenerator> playerOwned = sTesseractGeneratorOwnershipMap
+                .get(playerIdentifier);
+            if (playerOwned == null || playerOwned.isEmpty()) {
+                Map<Integer, GT_MetaTileEntity_TesseractGenerator> newOwnershipMap = new HashMap<>();
+                newOwnershipMap.put(freq, generator);
+                sTesseractGeneratorOwnershipMap.put(playerIdentifier, newOwnershipMap);
+                Logger.WARNING("Success! [Empty Map]");
+                return true;
+            } else if (sTesseractGeneratorOwnershipMap.containsKey(playerIdentifier)) {
+                Map<Integer, GT_MetaTileEntity_TesseractGenerator> ownershipMap = sTesseractGeneratorOwnershipMap
+                    .get(playerIdentifier);
+                if (!ownershipMap.containsKey(freq)) {
+                    ownershipMap.put(freq, generator);
+                }
+                ownershipMap.put(freq, generator);
+                sTesseractGeneratorOwnershipMap.put(playerIdentifier, ownershipMap);
+                Logger.WARNING("Success!");
+                return true;
+            }
+        }
+        Logger.WARNING("Failed. [setGeneratorOwnershipByPlayer]");
+        return false;
+    }
+
+    // Gets Generator based on Frequency.
+    public static final GT_MetaTileEntity_TesseractGenerator getGeneratorByFrequency(EntityPlayer player, int freq) {
+        if (player == null) {
+            return null;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        Logger.WARNING("Getting Generator on " + freq + " for " + player.getDisplayName() + ".");
+        if (!sTesseractGeneratorOwnershipMap.isEmpty() && playerIdentifier != null) {
+            // Utils.LOG_WARNING("Success. [getGeneratorByFrequency] 1");
+            Map<Integer, GT_MetaTileEntity_TesseractGenerator> generators = getGeneratorOwnershipByPlayer(player);
+            Set<Entry<Integer, GT_MetaTileEntity_TesseractGenerator>> players = generators.entrySet();
+            for (Entry<Integer, GT_MetaTileEntity_TesseractGenerator> current : players) {
+                // Utils.LOG_WARNING("Success. [getGeneratorByFrequency] 2");
+                if (current.getKey()
+                    .equals(freq)) {
+                    // Utils.LOG_WARNING("Success. [getGeneratorByFrequency] 3");
+                    Logger.WARNING("Success!");
+                    return current.getValue();
+                }
+            }
+        }
+        Logger.WARNING("Failed. [getGeneratorByFrequency]");
+        return null;
+    }
+
+    // Remove Tesseract Generator
+    public static final boolean removeGenerator(EntityPlayer player, int frequency) {
+        if (player == null) {
+            return false;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractGeneratorOwnershipMap.isEmpty() && playerIdentifier != null) {
+            sTesseractGeneratorOwnershipMap.get(playerIdentifier)
+                .remove(frequency);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     *
+     * Tesseract Terminal Helpers
+     *
+     * @param player
+     * @return
+     */
+
+    // Checks if a Terminal is owned by a player.
+    public static final boolean isTerminalOwnedByPlayer(EntityPlayer player,
+        GT_MetaTileEntity_TesseractTerminal generator) {
+        if (player == null) {
+            return false;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractTerminalOwnershipMap.isEmpty() && playerIdentifier != null) {
+            Map<Integer, GT_MetaTileEntity_TesseractTerminal> generators = getTerminalOwnershipByPlayer(player);
+            Set<Entry<Integer, GT_MetaTileEntity_TesseractTerminal>> players = generators.entrySet();
+            for (Entry<Integer, GT_MetaTileEntity_TesseractTerminal> current : players) {
+                if (current.getValue()
+                    .equals(generator)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Saves A Terminal to the Players UUID map along with the Freq.
+    public static final boolean setTerminalOwnershipByPlayer(EntityPlayer player, int freq,
+        GT_MetaTileEntity_TesseractTerminal generator) {
+        if (player == null) {
+            return false;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        if (playerIdentifier != null) {
+            Logger.WARNING("Setting Terminal on " + freq + " for " + player.getDisplayName() + ".");
+            Map<Integer, GT_MetaTileEntity_TesseractTerminal> playerOwned = sTesseractTerminalOwnershipMap
+                .get(playerIdentifier);
+            if (playerOwned == null || playerOwned.isEmpty()) {
+                Map<Integer, GT_MetaTileEntity_TesseractTerminal> newOwnershipMap = new HashMap<>();
+                newOwnershipMap.put(freq, generator);
+                sTesseractTerminalOwnershipMap.put(playerIdentifier, newOwnershipMap);
+                Logger.WARNING("Success! [Empty Map]");
+                return true;
+            } else if (sTesseractTerminalOwnershipMap.containsKey(playerIdentifier)) {
+                Map<Integer, GT_MetaTileEntity_TesseractTerminal> ownershipMap = sTesseractTerminalOwnershipMap
+                    .get(playerIdentifier);
+                if (!ownershipMap.containsKey(freq)) {
+                    ownershipMap.put(freq, generator);
+                }
+                sTesseractTerminalOwnershipMap.put(playerIdentifier, ownershipMap);
+                Logger.WARNING("Success!");
+                return true;
+            }
+        }
+        Logger.WARNING("Failed. [setTerminalOwnershipByPlayer]");
+        return false;
+    }
+
+    // Gets Terminal based on Frequency.
+    public static final GT_MetaTileEntity_TesseractTerminal getTerminalByFrequency(EntityPlayer player, int freq) {
+        if (player == null) {
+            return null;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        Logger.WARNING("Getting Terminal on " + freq + " for " + player.getDisplayName() + ".");
+        if (!sTesseractTerminalOwnershipMap.isEmpty() && playerIdentifier != null) {
+            Map<Integer, GT_MetaTileEntity_TesseractTerminal> generators = getTerminalOwnershipByPlayer(player);
+            Set<Entry<Integer, GT_MetaTileEntity_TesseractTerminal>> players = generators.entrySet();
+            for (Entry<Integer, GT_MetaTileEntity_TesseractTerminal> current : players) {
+                if (current.getKey()
+                    .equals(freq)) {
+                    Logger.WARNING("Success!");
+                    return current.getValue();
+                }
+            }
+        }
+        Logger.WARNING("Failed. [getTerminalByFrequency]");
+        return null;
+    }
+
+    // Remove Tesseract Terminal
+    public static final boolean removeTerminal(EntityPlayer player, int frequency) {
+        if (player == null) {
+            return false;
+        }
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractTerminalOwnershipMap.isEmpty() && playerIdentifier != null) {
+            sTesseractTerminalOwnershipMap.get(playerIdentifier)
+                .remove(frequency);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     *
+     * Internal Methods
+     *
+     */
+    private static Map<Integer, GT_MetaTileEntity_TesseractGenerator> getGeneratorOwnershipByPlayer(
+        EntityPlayer player) {
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractGeneratorOwnershipMap.isEmpty() && playerIdentifier != null) {
+            Set<Entry<UUID, Map<Integer, GT_MetaTileEntity_TesseractGenerator>>> players = sTesseractGeneratorOwnershipMap
+                .entrySet();
+            for (Entry<UUID, Map<Integer, GT_MetaTileEntity_TesseractGenerator>> current : players) {
+                if (current.getKey()
+                    .compareTo(playerIdentifier) == 0) {
+                    return current.getValue();
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Map<Integer, GT_MetaTileEntity_TesseractTerminal> getTerminalOwnershipByPlayer(EntityPlayer player) {
+        UUID playerIdentifier = player.getUniqueID();
+        if (!sTesseractTerminalOwnershipMap.isEmpty() && playerIdentifier != null) {
+            Set<Entry<UUID, Map<Integer, GT_MetaTileEntity_TesseractTerminal>>> players = sTesseractTerminalOwnershipMap
+                .entrySet();
+            for (Entry<UUID, Map<Integer, GT_MetaTileEntity_TesseractTerminal>> current : players) {
+                if (current.getKey()
+                    .compareTo(playerIdentifier) == 0) {
+                    return current.getValue();
+                }
+            }
+        }
+        return null;
+    }
+}