add fluid terminal

src/main/java/com/glodblock/github/util/Util.java

@@ -1,5 +1,6 @@
 package com.glodblock.github.util;
 
+import appeng.api.AEApi;
 import appeng.api.config.SecurityPermissions;
 import appeng.api.networking.IGrid;
 import appeng.api.networking.IGridHost;
@@ -10,15 +11,13 @@ import appeng.api.storage.data.IAEFluidStack;
 import appeng.util.item.AEFluidStack;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidContainerRegistry;
-import net.minecraftforge.fluids.FluidRegistry;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidContainerItem;
-
+import net.minecraftforge.fluids.*;
+import org.apache.commons.lang3.tuple.MutablePair;
 public final class Util {
 
     public static EnumFacing from(ForgeDirection direction) {
@@ -35,8 +34,10 @@ public final class Util {
 
     public static ForgeDirection from(EnumFacing direction) {
         switch (direction) {
-            case WEST: return ForgeDirection.EAST;
-            case EAST: return ForgeDirection.WEST;
+            case WEST:
+                return ForgeDirection.EAST;
+            case EAST:
+                return ForgeDirection.WEST;
             default: {
                 int o = direction.ordinal();
                 return ForgeDirection.values()[o];
@@ -44,6 +45,13 @@ public final class Util {
         }
     }
 
+    public static int findItemInPlayerInvSlot(EntityPlayer player, ItemStack itemStack) {
+        for (int i = 0; i < player.inventory.mainInventory.length; i++) {
+            if (player.inventory.mainInventory[i] != null && player.inventory.mainInventory[i] == itemStack) return i;
+        }
+        return -1;
+    }
+
     public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, IGrid grid) {
         return grid == null || hasPermission(player, permission, (ISecurityGrid) grid.getCache(ISecurityGrid.class));
     }
@@ -108,14 +116,23 @@ public final class Util {
         return null;
     }
 
-    public static IAEFluidStack loadFluidStackFromNBT( final NBTTagCompound i )
-    {
+    public static String getFluidModID(Fluid fluid) {
+        String name = FluidRegistry.getDefaultFluidName(fluid);
+        try {
+            return name.split(":")[0];
+        } catch (Exception e) {
+            return "";
+        }
+
+    }
+
+    public static IAEFluidStack loadFluidStackFromNBT(final NBTTagCompound i) {
         //Fuck ae2
         final FluidStack t = FluidRegistry.getFluidStack(i.getString("FluidName"), 1);
-        final AEFluidStack fluid = AEFluidStack.create( t );
-        fluid.setStackSize( i.getLong( "Cnt" ) );
-        fluid.setCountRequestable( i.getLong( "Req" ) );
-        fluid.setCraftable( i.getBoolean( "Craft" ) );
+        final AEFluidStack fluid = AEFluidStack.create(t);
+        fluid.setStackSize(i.getLong("Cnt"));
+        fluid.setCountRequestable(i.getLong("Req"));
+        fluid.setCraftable(i.getBoolean("Craft"));
         return fluid;
     }
 
@@ -124,4 +141,156 @@ public final class Util {
         return fluid1.isFluidEqual(fluid2);
     }
 
+    public static class FluidUtil {
+        public static IAEFluidStack createAEFluidStack(Fluid fluid) {
+            return createAEFluidStack(new FluidStack(fluid,
+                FluidContainerRegistry.BUCKET_VOLUME));
+        }
+
+        public static IAEFluidStack createAEFluidStack(Fluid fluid, long amount) {
+            return createAEFluidStack(fluid.getID(), amount);
+        }
+
+        public static IAEFluidStack createAEFluidStack(FluidStack fluid) {
+            return AEApi.instance().storage().createFluidStack(fluid);
+        }
+
+        public static IAEFluidStack createAEFluidStack(int fluidId, long amount) {
+            return createAEFluidStack(new FluidStack(FluidRegistry.getFluid(fluidId), 1)).setStackSize(
+                amount);
+        }
+
+        public static boolean isEmpty(ItemStack itemStack) {
+            if (itemStack == null)
+                return false;
+            Item item = itemStack.getItem();
+            if (item instanceof IFluidContainerItem) {
+                FluidStack content = ((IFluidContainerItem) item)
+                    .getFluid(itemStack);
+                return content == null || content.amount <= 0;
+            }
+            return FluidContainerRegistry.isEmptyContainer(itemStack);
+        }
+
+        public static boolean isFilled(ItemStack itemStack) {
+            if (itemStack == null)
+                return false;
+            Item item = itemStack.getItem();
+            if (item instanceof IFluidContainerItem) {
+                FluidStack content = ((IFluidContainerItem) item)
+                    .getFluid(itemStack);
+                return content != null && content.amount > 0;
+            }
+            return FluidContainerRegistry.isFilledContainer(itemStack);
+        }
+
+        public static boolean isFluidContainer(ItemStack itemStack) {
+            if (itemStack == null)
+                return false;
+            Item item = itemStack.getItem();
+            return item instanceof IFluidContainerItem
+                || FluidContainerRegistry.isContainer(itemStack);
+        }
+
+        public static FluidStack getFluidFromContainer(ItemStack itemStack) {
+            if (itemStack == null)
+                return null;
+
+            ItemStack container = itemStack.copy();
+            Item item = container.getItem();
+            if (item instanceof IFluidContainerItem) {
+                return ((IFluidContainerItem) item).getFluid(container);
+            } else {
+                return FluidContainerRegistry.getFluidForFilledItem(container);
+            }
+        }
+
+        public static int getCapacity(ItemStack itemStack, Fluid fluid) {
+            if (itemStack == null)
+                return 0;
+            Item item = itemStack.getItem();
+            if (item instanceof IFluidContainerItem) {
+                IFluidContainerItem fluidContainerItem = (IFluidContainerItem) item;
+                int capacity = fluidContainerItem.getCapacity(itemStack);
+                FluidStack existing = fluidContainerItem.getFluid(itemStack);
+                if (existing != null) {
+                    if (!existing.getFluid().equals(fluid)) {
+                        return 0;
+                    }
+                    capacity -= existing.amount;
+                }
+                return capacity;
+            } else if (FluidContainerRegistry.isContainer(itemStack)) {
+                return FluidContainerRegistry.getContainerCapacity(new FluidStack(fluid, Integer.MAX_VALUE), itemStack);
+            }
+            return 0;
+        }
+
+        public static ItemStack clearFluid(ItemStack itemStack) {
+            if (itemStack == null)
+                return null;
+            Item item = itemStack.getItem();
+            if (item instanceof IFluidContainerItem) {
+                ((IFluidContainerItem) item).drain(itemStack,
+                    ((IFluidContainerItem) item).getFluid(itemStack).amount, true);
+                return itemStack;
+            } else if (FluidContainerRegistry.isContainer(itemStack)) {
+                return FluidContainerRegistry.drainFluidContainer(itemStack);
+            }
+            return null;
+        }
+
+        public static MutablePair<Integer, ItemStack> drainStack(
+            ItemStack itemStack, FluidStack fluid) {
+            if (itemStack == null)
+                return null;
+            Item item = itemStack.getItem();
+            if (item instanceof IFluidContainerItem) {
+                FluidStack drained = ((IFluidContainerItem) item).drain(itemStack,
+                    fluid.amount, true);
+                int amountDrained = drained != null
+                    && drained.getFluid() == fluid.getFluid() ? drained.amount
+                    : 0;
+                return new MutablePair<Integer, ItemStack>(amountDrained, itemStack);
+            } else if (FluidContainerRegistry.isContainer(itemStack)) {
+                FluidStack content = FluidContainerRegistry
+                    .getFluidForFilledItem(itemStack);
+                int amountDrained = content != null
+                    && content.getFluid() == fluid.getFluid() ? content.amount
+                    : 0;
+                return new MutablePair<Integer, ItemStack>(amountDrained,
+                    FluidContainerRegistry.drainFluidContainer(itemStack));
+            }
+
+            return null;
+        }
+
+        public static MutablePair<Integer, ItemStack> fillStack(
+            ItemStack itemStack, FluidStack fluid) {
+            if (itemStack == null || itemStack.stackSize != 1)
+                return null;
+            Item item = itemStack.getItem();
+            //If its a fluid container item instance
+            if (item instanceof IFluidContainerItem) {
+                //Call the fill method on it.
+                int filled = ((IFluidContainerItem) item).fill(itemStack, fluid,
+                    true);
+
+                //Return the filled itemstack.
+                return new MutablePair<Integer, ItemStack>(filled, itemStack);
+            } else if (FluidContainerRegistry.isContainer(itemStack)) {
+                //Fill it through the fluidcontainer registry.
+                ItemStack filledContainer = FluidContainerRegistry
+                    .fillFluidContainer(fluid, itemStack);
+                //get the filled fluidstack.
+                FluidStack filled = FluidContainerRegistry
+                    .getFluidForFilledItem(filledContainer);
+                //Return filled container and fill amount.
+                return new MutablePair<Integer, ItemStack>(
+                    filled != null ? filled.amount : 0, filledContainer);
+
+            }
+            return null;
+        }
+    }
 }