generated from tilera/1710mod
368 lines
13 KiB
Java
368 lines
13 KiB
Java
package mffs.base;
|
|
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
|
|
import dan200.computercraft.api.lua.ILuaContext;
|
|
import dan200.computercraft.api.lua.LuaException;
|
|
import dan200.computercraft.api.peripheral.IComputerAccess;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.item.EntityItem;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.inventory.ISidedInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTBase;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.network.NetworkManager;
|
|
import net.minecraft.network.Packet;
|
|
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.tileentity.TileEntityChest;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import universalelectricity.core.vector.Vector3;
|
|
import universalelectricity.prefab.multiblock.TileEntityMulti;
|
|
|
|
public abstract class TileEntityInventory extends TileEntityBase implements IInventory {
|
|
protected ItemStack[] inventory;
|
|
|
|
public TileEntityInventory() {
|
|
this.inventory = new ItemStack[this.getSizeInventory()];
|
|
}
|
|
|
|
// TODO: WTF
|
|
// @Override
|
|
// public List getPacketUpdate() {
|
|
// final List objects = new ArrayList();
|
|
// objects.addAll(super.getPacketUpdate());
|
|
// final NBTTagCompound nbt = new NBTTagCompound();
|
|
// this.writeToNBT(nbt);
|
|
// objects.add(nbt);
|
|
// return objects;
|
|
// }
|
|
|
|
@Override
|
|
public Packet getDescriptionPacket() {
|
|
NBTTagCompound nbt = new NBTTagCompound();
|
|
|
|
this.writeToNBT(nbt);
|
|
|
|
return new S35PacketUpdateTileEntity(
|
|
this.xCoord, this.yCoord, this.zCoord, this.getBlockMetadata(), nbt
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public void onDataPacket(NetworkManager arg0, S35PacketUpdateTileEntity arg1) {
|
|
NBTTagCompound nbt = arg1.func_148857_g();
|
|
|
|
this.readFromNBT(nbt);
|
|
}
|
|
|
|
// TODO: WTF
|
|
// @Override
|
|
// public void sendInventoryToClients() {
|
|
// final NBTTagCompound nbt = new NBTTagCompound();
|
|
// this.writeToNBT(nbt);
|
|
// PacketManager.sendPacketToClients(PacketManager.getPacket("MFFS", this,
|
|
// TilePacketType.INVENTORY.ordinal(), nbt));
|
|
// }
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(final int i) {
|
|
return this.inventory[i];
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return this.getBlockType().getLocalizedName();
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(final int i, final ItemStack itemstack) {
|
|
this.inventory[i] = itemstack;
|
|
if (itemstack != null && itemstack.stackSize > this.getInventoryStackLimit()) {
|
|
itemstack.stackSize = this.getInventoryStackLimit();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(final int i, final int j) {
|
|
if (this.inventory[i] == null) {
|
|
return null;
|
|
}
|
|
if (this.inventory[i].stackSize <= j) {
|
|
final ItemStack itemstack = this.inventory[i];
|
|
this.inventory[i] = null;
|
|
return itemstack;
|
|
}
|
|
final ItemStack itemstack2 = this.inventory[i].splitStack(j);
|
|
if (this.inventory[i].stackSize == 0) {
|
|
this.inventory[i] = null;
|
|
}
|
|
return itemstack2;
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {}
|
|
|
|
@Override
|
|
public void closeInventory() {}
|
|
|
|
@Override
|
|
public boolean isUseableByPlayer(final EntityPlayer entityplayer) {
|
|
return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) == this;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(final int slotID) {
|
|
if (this.inventory[slotID] != null) {
|
|
final ItemStack itemstack = this.inventory[slotID];
|
|
this.inventory[slotID] = null;
|
|
return itemstack;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return 64;
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(final int slotID, final ItemStack itemStack) {
|
|
return true;
|
|
}
|
|
|
|
public boolean canIncreaseStack(final int slotID, final ItemStack itemStack) {
|
|
return this.getStackInSlot(slotID) == null
|
|
|| (this.getStackInSlot(slotID).stackSize + 1 <= 64
|
|
&& this.getStackInSlot(slotID).isItemEqual(itemStack));
|
|
}
|
|
|
|
public void incrStackSize(final int slot, final ItemStack itemStack) {
|
|
if (this.getStackInSlot(slot) == null) {
|
|
this.setInventorySlotContents(slot, itemStack.copy());
|
|
} else if (this.getStackInSlot(slot).isItemEqual(itemStack)) {
|
|
final ItemStack stackInSlot = this.getStackInSlot(slot);
|
|
++stackInSlot.stackSize;
|
|
}
|
|
}
|
|
|
|
public Set<ItemStack> getCards() {
|
|
final Set<ItemStack> cards = new HashSet<>();
|
|
cards.add(this.getStackInSlot(0));
|
|
return cards;
|
|
}
|
|
|
|
public ItemStack tryPlaceInPosition(
|
|
ItemStack itemStack, final Vector3 position, final ForgeDirection dir
|
|
) {
|
|
final TileEntity tileEntity
|
|
= position.getTileEntity((IBlockAccess) this.worldObj);
|
|
final ForgeDirection direction = dir.getOpposite();
|
|
if (tileEntity != null && itemStack != null) {
|
|
if (tileEntity instanceof TileEntityMulti) {
|
|
final Vector3 mainBlockPosition
|
|
= ((TileEntityMulti) tileEntity).mainBlockPosition;
|
|
if (mainBlockPosition != null
|
|
&& !(
|
|
mainBlockPosition.getTileEntity((IBlockAccess) this.worldObj)
|
|
instanceof TileEntityMulti
|
|
)) {
|
|
return this.tryPlaceInPosition(
|
|
itemStack, mainBlockPosition, direction
|
|
);
|
|
}
|
|
} else if (tileEntity instanceof TileEntityChest) {
|
|
final TileEntityChest[] chests = { (TileEntityChest) tileEntity, null };
|
|
for (int i = 2; i < 6; ++i) {
|
|
final ForgeDirection searchDirection
|
|
= ForgeDirection.getOrientation(i);
|
|
final Vector3 searchPosition = position.clone();
|
|
searchPosition.modifyPositionFromSide(searchDirection);
|
|
if (searchPosition.getTileEntity((IBlockAccess) this.worldObj) != null
|
|
&& searchPosition.getTileEntity((IBlockAccess) this.worldObj)
|
|
.getClass()
|
|
== chests[0].getClass()) {
|
|
chests[1] = (TileEntityChest
|
|
) searchPosition.getTileEntity((IBlockAccess) this.worldObj);
|
|
break;
|
|
}
|
|
}
|
|
for (final TileEntityChest chest : chests) {
|
|
if (chest != null) {
|
|
for (int j = 0; j < chest.getSizeInventory(); ++j) {
|
|
itemStack = this.addStackToInventory(
|
|
j, (IInventory) chest, itemStack
|
|
);
|
|
if (itemStack == null) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (tileEntity instanceof ISidedInventory) {
|
|
final ISidedInventory inventory = (ISidedInventory) tileEntity;
|
|
final int[] slots
|
|
= inventory.getAccessibleSlotsFromSide(direction.ordinal());
|
|
for (int k = 0; k < slots.length; ++k) {
|
|
if (inventory.canInsertItem(
|
|
slots[k], itemStack, direction.ordinal()
|
|
)) {
|
|
itemStack = this.addStackToInventory(
|
|
slots[k], (IInventory) inventory, itemStack
|
|
);
|
|
}
|
|
if (itemStack == null) {
|
|
return null;
|
|
}
|
|
}
|
|
} else if (tileEntity instanceof IInventory) {
|
|
final IInventory inventory2 = (IInventory) tileEntity;
|
|
for (int i = 0; i < inventory2.getSizeInventory(); ++i) {
|
|
itemStack = this.addStackToInventory(i, inventory2, itemStack);
|
|
if (itemStack == null) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (itemStack.stackSize <= 0) {
|
|
return null;
|
|
}
|
|
return itemStack;
|
|
}
|
|
|
|
public ItemStack addStackToInventory(
|
|
final int slotIndex, final IInventory inventory, final ItemStack itemStack
|
|
) {
|
|
if (inventory.getSizeInventory() > slotIndex) {
|
|
ItemStack stackInInventory = inventory.getStackInSlot(slotIndex);
|
|
if (stackInInventory == null) {
|
|
inventory.setInventorySlotContents(slotIndex, itemStack);
|
|
if (inventory.getStackInSlot(slotIndex) == null) {
|
|
return itemStack;
|
|
}
|
|
return null;
|
|
} else if (stackInInventory.isItemEqual(itemStack) && stackInInventory.isStackable()) {
|
|
stackInInventory = stackInInventory.copy();
|
|
final int stackLim = Math.min(
|
|
inventory.getInventoryStackLimit(), itemStack.getMaxStackSize()
|
|
);
|
|
final int rejectedAmount = Math.max(
|
|
stackInInventory.stackSize + itemStack.stackSize - stackLim, 0
|
|
);
|
|
stackInInventory.stackSize = Math.min(
|
|
Math.max(
|
|
stackInInventory.stackSize + itemStack.stackSize - rejectedAmount,
|
|
0
|
|
),
|
|
inventory.getInventoryStackLimit()
|
|
);
|
|
itemStack.stackSize = rejectedAmount;
|
|
inventory.setInventorySlotContents(slotIndex, stackInInventory);
|
|
}
|
|
}
|
|
if (itemStack.stackSize <= 0) {
|
|
return null;
|
|
}
|
|
return itemStack;
|
|
}
|
|
|
|
public boolean mergeIntoInventory(ItemStack itemStack) {
|
|
if (!this.worldObj.isRemote) {
|
|
for (final ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS) {
|
|
if (itemStack != null) {
|
|
itemStack = this.tryPlaceInPosition(
|
|
itemStack,
|
|
new Vector3(this).modifyPositionFromSide(direction),
|
|
direction
|
|
);
|
|
}
|
|
}
|
|
if (itemStack != null) {
|
|
this.worldObj.spawnEntityInWorld((Entity) new EntityItem(
|
|
this.worldObj,
|
|
this.xCoord + 0.5,
|
|
(double) (this.yCoord + 1),
|
|
this.zCoord + 0.5,
|
|
itemStack
|
|
));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(final NBTTagCompound nbttagcompound) {
|
|
super.readFromNBT(nbttagcompound);
|
|
final NBTTagList nbtTagList = nbttagcompound.getTagList("Items", 10);
|
|
this.inventory = new ItemStack[this.getSizeInventory()];
|
|
for (int i = 0; i < nbtTagList.tagCount(); ++i) {
|
|
final NBTTagCompound nbttagcompound2
|
|
= (NBTTagCompound) nbtTagList.getCompoundTagAt(i);
|
|
final byte byte0 = nbttagcompound2.getByte("Slot");
|
|
if (byte0 >= 0 && byte0 < this.inventory.length) {
|
|
this.inventory[byte0] = ItemStack.loadItemStackFromNBT(nbttagcompound2);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(final NBTTagCompound nbttagcompound) {
|
|
super.writeToNBT(nbttagcompound);
|
|
final NBTTagList nbtTagList = new NBTTagList();
|
|
for (int i = 0; i < this.inventory.length; ++i) {
|
|
if (this.inventory[i] != null) {
|
|
final NBTTagCompound nbttagcompound2 = new NBTTagCompound();
|
|
nbttagcompound2.setByte("Slot", (byte) i);
|
|
this.inventory[i].writeToNBT(nbttagcompound2);
|
|
nbtTagList.appendTag((NBTBase) nbttagcompound2);
|
|
}
|
|
}
|
|
nbttagcompound.setTag("Items", (NBTBase) nbtTagList);
|
|
}
|
|
|
|
@Override
|
|
public String getType() {
|
|
return this.getInventoryName();
|
|
}
|
|
|
|
@Override
|
|
public String[] getMethodNames() {
|
|
return new String[] { "isActivate", "setActivate" };
|
|
}
|
|
|
|
@Override
|
|
public Object[] callMethod(
|
|
IComputerAccess computer, ILuaContext context, int method, Object[] arguments
|
|
) throws LuaException, InterruptedException {
|
|
switch (method) {
|
|
case 0: {
|
|
return new Object[] { this.isActive() };
|
|
}
|
|
case 1: {
|
|
this.setActive((boolean) arguments[0]);
|
|
return null;
|
|
}
|
|
default: {
|
|
throw new LuaException("Invalid method.");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void attach(final IComputerAccess computer) {}
|
|
|
|
@Override
|
|
public void detach(final IComputerAccess computer) {}
|
|
}
|