mirror of
https://github.com/GTNewHorizons/AE2FluidCraft-Rework.git
synced 2026-11-11 15:57:55 +00:00
491 lines
20 KiB
Java
491 lines
20 KiB
Java
package com.glodblock.github.util;
|
|
|
|
import static com.glodblock.github.common.item.ItemBaseWirelessTerminal.infinityBoosterCard;
|
|
|
|
import java.io.IOException;
|
|
import java.util.Map;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.*;
|
|
|
|
import org.apache.commons.lang3.tuple.ImmutablePair;
|
|
import org.apache.commons.lang3.tuple.MutablePair;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.config.Actionable;
|
|
import appeng.api.config.PowerMultiplier;
|
|
import appeng.api.config.SecurityPermissions;
|
|
import appeng.api.implementations.tiles.IWirelessAccessPoint;
|
|
import appeng.api.networking.IGrid;
|
|
import appeng.api.networking.IGridHost;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.security.ISecurityGrid;
|
|
import appeng.api.networking.storage.IStorageGrid;
|
|
import appeng.api.parts.IPart;
|
|
import appeng.api.storage.IMEInventoryHandler;
|
|
import appeng.api.storage.StorageChannel;
|
|
import appeng.api.storage.data.IAEFluidStack;
|
|
import appeng.api.util.WorldCoord;
|
|
import appeng.container.AEBaseContainer;
|
|
import appeng.items.tools.powered.ToolWirelessTerminal;
|
|
import appeng.me.storage.NullInventory;
|
|
import appeng.tile.networking.TileCableBus;
|
|
import appeng.tile.networking.TileWireless;
|
|
import appeng.util.Platform;
|
|
import appeng.util.item.AEFluidStack;
|
|
|
|
import com.glodblock.github.common.item.ItemBaseWirelessTerminal;
|
|
import com.glodblock.github.common.item.ItemFluidDrop;
|
|
import com.glodblock.github.common.item.ItemFluidPacket;
|
|
import com.glodblock.github.inventory.IAEFluidTank;
|
|
import com.glodblock.github.inventory.item.IFluidPortableCell;
|
|
|
|
import cpw.mods.fml.common.ModContainer;
|
|
import cpw.mods.fml.common.registry.GameData;
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
public final class Util {
|
|
|
|
public static int drainItemPower(AEBaseContainer c, InventoryPlayer ip, int slot, int ticks, double pm,
|
|
IFluidPortableCell wt) {
|
|
final ItemStack currentItem = slot < 0 ? ip.getCurrentItem() : ip.getStackInSlot(slot);
|
|
if (wt != null) {
|
|
if (currentItem != wt.getItemStack()) {
|
|
if (currentItem != null) {
|
|
if (Platform.isSameItem(wt.getItemStack(), currentItem)) {
|
|
ip.setInventorySlotContents(ip.currentItem, wt.getItemStack());
|
|
} else {
|
|
c.setValidContainer(false);
|
|
}
|
|
} else {
|
|
c.setValidContainer(false);
|
|
}
|
|
}
|
|
} else {
|
|
c.setValidContainer(false);
|
|
}
|
|
ticks++;
|
|
if (ticks > 10 && wt != null) {
|
|
wt.extractAEPower(pm * ticks, Actionable.MODULATE, PowerMultiplier.CONFIG);
|
|
ticks = 0;
|
|
}
|
|
return ticks;
|
|
}
|
|
|
|
public static boolean hasInfinityBoosterCard(ItemStack is) {
|
|
if (ModAndClassUtil.WCT && is.getItem() instanceof ItemBaseWirelessTerminal) {
|
|
NBTTagCompound data = Platform.openNbtData(is);
|
|
return data.hasKey(infinityBoosterCard) && data.getBoolean(infinityBoosterCard);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static IGridNode getWirelessGrid(ItemStack is) {
|
|
if (is.getItem() instanceof ToolWirelessTerminal) {
|
|
String key = ((ToolWirelessTerminal) is.getItem()).getEncryptionKey(is);
|
|
IGridHost securityTerminal = (IGridHost) AEApi.instance().registries().locatable()
|
|
.getLocatableBy(Long.parseLong(key));
|
|
if (securityTerminal == null) return null;
|
|
return securityTerminal.getGridNode(ForgeDirection.UNKNOWN);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static IMEInventoryHandler<?> getWirelessInv(ItemStack is, EntityPlayer player, StorageChannel channel) {
|
|
IGridNode gridNode = getWirelessGrid(is);
|
|
if (gridNode == null) return new NullInventory<>();
|
|
IGrid grid = gridNode.getGrid();
|
|
if (grid == null) return new NullInventory<>();
|
|
boolean canConnect = false;
|
|
if (hasInfinityBoosterCard(is)) {
|
|
canConnect = true;
|
|
} else {
|
|
for (IGridNode node : grid.getMachines(TileWireless.class)) {
|
|
IWirelessAccessPoint accessPoint = (IWirelessAccessPoint) node.getMachine();
|
|
if (accessPoint.isActive() && accessPoint.getLocation().getDimension() == player.dimension) {
|
|
WorldCoord distance = accessPoint.getLocation()
|
|
.subtract((int) player.posX, (int) player.posY, (int) player.posZ);
|
|
int squaredDistance = distance.x * distance.x + distance.y * distance.y + distance.z * distance.z;
|
|
if (squaredDistance <= accessPoint.getRange() * accessPoint.getRange()) {
|
|
canConnect = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (canConnect) {
|
|
IStorageGrid gridCache = grid.getCache(IStorageGrid.class);
|
|
if (gridCache != null) {
|
|
if (channel == StorageChannel.FLUIDS) {
|
|
return gridCache.getFluidInventory();
|
|
} else {
|
|
return gridCache.getItemInventory();
|
|
}
|
|
}
|
|
}
|
|
return new NullInventory<>();
|
|
}
|
|
|
|
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 String getFluidModID(Fluid fluid) {
|
|
String name = FluidRegistry.getDefaultFluidName(fluid);
|
|
try {
|
|
return name.split(":")[0];
|
|
} catch (Exception e) {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public static ModContainer getFluidMod(Fluid fluid) {
|
|
return GameData.findModOwner(String.format("%s:%s", getFluidModID(fluid), fluid.getName()));
|
|
}
|
|
|
|
public static int getFluidID(Fluid fluid) {
|
|
return GameData.getBlockRegistry().getId(fluid.getBlock());
|
|
}
|
|
|
|
public static String getFluidModName(Fluid fluid) {
|
|
try {
|
|
ModContainer mod = getFluidMod(fluid);
|
|
return mod == null ? "Minecraft" : mod.getName();
|
|
} catch (Exception e) {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public static IAEFluidStack loadFluidStackFromNBT(final NBTTagCompound i) {
|
|
// Fuck ae2
|
|
final FluidStack t = FluidRegistry.getFluidStack(i.getString("FluidName"), 1);
|
|
if (t == null) return null;
|
|
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 void mirrorFluidToPacket(IInventory packet, IAEFluidTank fluidTank) {
|
|
for (int i = 0; i < fluidTank.getSlots(); i++) {
|
|
IAEFluidStack fluid = fluidTank.getFluidInSlot(i);
|
|
if (fluid == null) {
|
|
packet.setInventorySlotContents(i, null);
|
|
} else {
|
|
packet.setInventorySlotContents(i, ItemFluidPacket.newDisplayStack(fluid.getFluidStack()));
|
|
}
|
|
}
|
|
}
|
|
|
|
public static FluidStack getFluidFromVirtual(ItemStack virtual) {
|
|
if (virtual == null) {
|
|
return null;
|
|
}
|
|
if (virtual.getItem() instanceof ItemFluidPacket) {
|
|
return ItemFluidPacket.getFluidStack(virtual);
|
|
} else if (virtual.getItem() instanceof ItemFluidDrop) {
|
|
return ItemFluidDrop.getFluidStack(virtual);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static IPart getPart(Object te, ForgeDirection face) {
|
|
if (te instanceof TileCableBus) {
|
|
return ((TileCableBus) te).getPart(face);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void writeFluidMapToBuf(Map<Integer, IAEFluidStack> list, ByteBuf buf) throws IOException {
|
|
buf.writeInt(list.size());
|
|
for (Map.Entry<Integer, IAEFluidStack> fs : list.entrySet()) {
|
|
buf.writeInt(fs.getKey());
|
|
if (fs.getValue() == null) buf.writeBoolean(false);
|
|
else {
|
|
buf.writeBoolean(true);
|
|
fs.getValue().writeToPacket(buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void readFluidMapFromBuf(Map<Integer, IAEFluidStack> list, ByteBuf buf) throws IOException {
|
|
int size = buf.readInt();
|
|
for (int i = 0; i < size; i++) {
|
|
int id = buf.readInt();
|
|
boolean isNull = buf.readBoolean();
|
|
if (!isNull) list.put(id, null);
|
|
else {
|
|
IAEFluidStack fluid = AEFluidStack.loadFluidStackFromPacket(buf);
|
|
list.put(id, fluid);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class GuiHelper {
|
|
|
|
public enum GuiType {
|
|
TILE,
|
|
ITEM
|
|
}
|
|
|
|
private static final int value = 1 << 30;
|
|
|
|
public static int encodeType(int y, GuiType type) {
|
|
if (Math.abs(y) > (1 << 28)) {
|
|
throw new IllegalArgumentException("out of range");
|
|
}
|
|
return value | (type.ordinal() << 29) | y;
|
|
}
|
|
|
|
public static ImmutablePair<GuiType, Integer> decodeType(int y) {
|
|
if (Math.abs(y) > (1 << 28)) {
|
|
return new ImmutablePair<>(GuiType.values()[y >> 29 & 1], y - (3 << 29 & y));
|
|
} else {
|
|
return new ImmutablePair<>(GuiType.TILE, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int clamp(int value, int min, int max) {
|
|
return value < min ? min : (Math.min(value, max));
|
|
}
|
|
|
|
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 ItemStack setFluidContainerAmount(ItemStack itemStack, int amount) {
|
|
FluidStack fs = getFluidFromContainer(itemStack);
|
|
if (fs == null) return null;
|
|
fs.amount = amount;
|
|
ItemStack is = itemStack.copy();
|
|
is.stackSize = 1;
|
|
ItemStack emptyContainer = clearFluid(is);
|
|
if (emptyContainer == null) return null;
|
|
MutablePair<Integer, ItemStack> result = fillStack(emptyContainer, fs);
|
|
if (result != null) {
|
|
result.right.stackSize = itemStack.stackSize;
|
|
return result.right;
|
|
}
|
|
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<>(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<>(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 it's 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<>(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<>(filled != null ? filled.amount : 0, filledContainer);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|