mirror of
https://github.com/GTNewHorizons/AE2FluidCraft-Rework.git
synced 2026-11-11 07:47:55 +00:00
318 lines
13 KiB
Java
318 lines
13 KiB
Java
package com.glodblock.github.util;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.config.SecurityPermissions;
|
|
import appeng.api.networking.IGrid;
|
|
import appeng.api.networking.IGridHost;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.security.ISecurityGrid;
|
|
import appeng.api.parts.IPart;
|
|
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.*;
|
|
import org.apache.commons.lang3.tuple.MutablePair;
|
|
public final class Util {
|
|
|
|
public static EnumFacing from(ForgeDirection direction) {
|
|
switch (direction) {
|
|
case WEST: return EnumFacing.EAST;
|
|
case EAST: return EnumFacing.WEST;
|
|
case UNKNOWN: return null;
|
|
default: {
|
|
int o = direction.ordinal();
|
|
return EnumFacing.values()[o];
|
|
}
|
|
}
|
|
}
|
|
|
|
public static ForgeDirection from(EnumFacing direction) {
|
|
switch (direction) {
|
|
case WEST:
|
|
return ForgeDirection.EAST;
|
|
case EAST:
|
|
return ForgeDirection.WEST;
|
|
default: {
|
|
int o = direction.ordinal();
|
|
return ForgeDirection.values()[o];
|
|
}
|
|
}
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, IGridHost host) {
|
|
return hasPermission(player, permission, host, ForgeDirection.UNKNOWN);
|
|
}
|
|
|
|
public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, IGridHost host, ForgeDirection side) {
|
|
return host == null || hasPermission(player, permission, host.getGridNode(side));
|
|
}
|
|
|
|
public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, IGridNode host) {
|
|
return host == null || hasPermission(player, permission, host.getGrid());
|
|
}
|
|
|
|
public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, IPart part) {
|
|
return part == null || hasPermission(player, permission, part.getGridNode());
|
|
}
|
|
|
|
public static boolean hasPermission(EntityPlayer player, SecurityPermissions permission, ISecurityGrid securityGrid) {
|
|
return player == null || permission == null || securityGrid == null || securityGrid.hasPermission(player, permission);
|
|
}
|
|
|
|
public static ItemStack copyStackWithSize(ItemStack itemStack, int size) {
|
|
if (size == 0 || itemStack == null)
|
|
return null;
|
|
ItemStack copy = itemStack.copy();
|
|
copy.stackSize = size;
|
|
return copy;
|
|
}
|
|
|
|
public static AEFluidStack getAEFluidFromItem(ItemStack stack) {
|
|
if (stack != null && (stack.getItem() instanceof IFluidContainerItem || FluidContainerRegistry.isContainer(stack))) {
|
|
if (stack.getItem() instanceof IFluidContainerItem) {
|
|
FluidStack fluid = ((IFluidContainerItem) stack.getItem()).getFluid(stack);
|
|
if (fluid != null) {
|
|
AEFluidStack fluid0 = AEFluidStack.create(fluid.copy());
|
|
fluid0.setStackSize(fluid0.getStackSize() * stack.stackSize);
|
|
return fluid0;
|
|
}
|
|
}
|
|
if (FluidContainerRegistry.isContainer(stack)) {
|
|
FluidStack fluid = FluidContainerRegistry.getFluidForFilledItem(stack);
|
|
if (fluid != null) {
|
|
AEFluidStack fluid0 = AEFluidStack.create(fluid.copy());
|
|
fluid0.setStackSize(fluid0.getStackSize() * stack.stackSize);
|
|
return fluid0;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static FluidStack getFluidFromItem(ItemStack stack) {
|
|
if (stack != null && (stack.getItem() instanceof IFluidContainerItem || FluidContainerRegistry.isContainer(stack))) {
|
|
if (stack.getItem() instanceof IFluidContainerItem) {
|
|
FluidStack fluid = ((IFluidContainerItem) stack.getItem()).getFluid(stack);
|
|
if (fluid != null) {
|
|
FluidStack fluid0 = fluid.copy();
|
|
fluid0.amount *= stack.stackSize;
|
|
return fluid0;
|
|
}
|
|
}
|
|
if (FluidContainerRegistry.isContainer(stack)) {
|
|
FluidStack fluid = FluidContainerRegistry.getFluidForFilledItem(stack);
|
|
if (fluid != null) {
|
|
FluidStack fluid0 = fluid.copy();
|
|
fluid0.amount *= stack.stackSize;
|
|
return fluid0;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static boolean isFluidPacket(ItemStack stack) {
|
|
return stack != null && stack.getItem() instanceof ItemFluidPacket;
|
|
}
|
|
|
|
public static FluidStack cloneFluidStack(FluidStack fluidStack) {
|
|
if (fluidStack != null) return fluidStack.copy();
|
|
return null;
|
|
}
|
|
|
|
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"));
|
|
return fluid;
|
|
}
|
|
|
|
public static boolean areFluidsEqual(FluidStack fluid1, FluidStack fluid2) {
|
|
if (fluid1 == null || fluid2 == null) return false;
|
|
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;
|
|
}
|
|
}
|
|
}
|