package net.minecraft.tileentity; import java.util.Iterator; import java.util.List; import net.minecraft.block.Block; import net.minecraft.block.BlockChest; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.ContainerChest; import net.minecraft.inventory.IInventory; import net.minecraft.inventory.InventoryLargeChest; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.util.AxisAlignedBB; public class TileEntityChest extends TileEntity implements IInventory { private ItemStack[] chestContents = new ItemStack[36]; /** Determines if the check for adjacent chests has taken place. */ public boolean adjacentChestChecked = false; /** Contains the chest tile located adjacent to this one (if any) */ public TileEntityChest adjacentChestZNeg; /** Contains the chest tile located adjacent to this one (if any) */ public TileEntityChest adjacentChestXPos; /** Contains the chest tile located adjacent to this one (if any) */ public TileEntityChest adjacentChestXNeg; /** Contains the chest tile located adjacent to this one (if any) */ public TileEntityChest adjacentChestZPosition; /** The current angle of the lid (between 0 and 1) */ public float lidAngle; /** The angle of the lid last tick */ public float prevLidAngle; /** The number of players currently using this chest */ public int numUsingPlayers; /** Server sync counter (once per 20 ticks) */ private int ticksSinceSync; private int field_94046_i = -1; private String field_94045_s; /** * Returns the number of slots in the inventory. */ public int getSizeInventory() { return 27; } /** * Returns the stack in slot i */ public ItemStack getStackInSlot(int par1) { return this.chestContents[par1]; } /** * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a * new stack. */ public ItemStack decrStackSize(int par1, int par2) { if (this.chestContents[par1] != null) { ItemStack itemstack; if (this.chestContents[par1].stackSize <= par2) { itemstack = this.chestContents[par1]; this.chestContents[par1] = null; this.onInventoryChanged(); return itemstack; } else { itemstack = this.chestContents[par1].splitStack(par2); if (this.chestContents[par1].stackSize == 0) { this.chestContents[par1] = null; } this.onInventoryChanged(); return itemstack; } } else { return null; } } /** * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem - * like when you close a workbench GUI. */ public ItemStack getStackInSlotOnClosing(int par1) { if (this.chestContents[par1] != null) { ItemStack itemstack = this.chestContents[par1]; this.chestContents[par1] = null; return itemstack; } else { return null; } } /** * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections). */ public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { this.chestContents[par1] = par2ItemStack; if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) { par2ItemStack.stackSize = this.getInventoryStackLimit(); } this.onInventoryChanged(); } /** * Returns the name of the inventory. */ public String getInvName() { return this.isInvNameLocalized() ? this.field_94045_s : "container.chest"; } /** * If this returns false, the inventory name will be used as an unlocalized name, and translated into the player's * language. Otherwise it will be used directly. */ public boolean isInvNameLocalized() { return this.field_94045_s != null && this.field_94045_s.length() > 0; } public void func_94043_a(String par1Str) { this.field_94045_s = par1Str; } /** * Reads a tile entity from NBT. */ public void readFromNBT(NBTTagCompound par1NBTTagCompound) { super.readFromNBT(par1NBTTagCompound); NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items"); this.chestContents = new ItemStack[this.getSizeInventory()]; if (par1NBTTagCompound.hasKey("CustomName")) { this.field_94045_s = par1NBTTagCompound.getString("CustomName"); } for (int i = 0; i < nbttaglist.tagCount(); ++i) { NBTTagCompound nbttagcompound1 = (NBTTagCompound)nbttaglist.tagAt(i); int j = nbttagcompound1.getByte("Slot") & 255; if (j >= 0 && j < this.chestContents.length) { this.chestContents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1); } } } /** * Writes a tile entity to NBT. */ public void writeToNBT(NBTTagCompound par1NBTTagCompound) { super.writeToNBT(par1NBTTagCompound); NBTTagList nbttaglist = new NBTTagList(); for (int i = 0; i < this.chestContents.length; ++i) { if (this.chestContents[i] != null) { NBTTagCompound nbttagcompound1 = new NBTTagCompound(); nbttagcompound1.setByte("Slot", (byte)i); this.chestContents[i].writeToNBT(nbttagcompound1); nbttaglist.appendTag(nbttagcompound1); } } par1NBTTagCompound.setTag("Items", nbttaglist); if (this.isInvNameLocalized()) { par1NBTTagCompound.setString("CustomName", this.field_94045_s); } } /** * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't * this more of a set than a get?* */ public int getInventoryStackLimit() { return 64; } /** * Do not make give this method the name canInteractWith because it clashes with Container */ public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; } /** * Causes the TileEntity to reset all it's cached values for it's container block, blockID, metaData and in the case * of chests, the adjcacent chest check */ public void updateContainingBlockInfo() { super.updateContainingBlockInfo(); this.adjacentChestChecked = false; } private void func_90009_a(TileEntityChest par1TileEntityChest, int par2) { if (par1TileEntityChest.isInvalid()) { this.adjacentChestChecked = false; } else if (this.adjacentChestChecked) { switch (par2) { case 0: if (this.adjacentChestZPosition != par1TileEntityChest) { this.adjacentChestChecked = false; } break; case 1: if (this.adjacentChestXNeg != par1TileEntityChest) { this.adjacentChestChecked = false; } break; case 2: if (this.adjacentChestZNeg != par1TileEntityChest) { this.adjacentChestChecked = false; } break; case 3: if (this.adjacentChestXPos != par1TileEntityChest) { this.adjacentChestChecked = false; } } } } /** * Performs the check for adjacent chests to determine if this chest is double or not. */ public void checkForAdjacentChests() { if (!this.adjacentChestChecked) { this.adjacentChestChecked = true; this.adjacentChestZNeg = null; this.adjacentChestXPos = null; this.adjacentChestXNeg = null; this.adjacentChestZPosition = null; if (this.func_94044_a(this.xCoord - 1, this.yCoord, this.zCoord)) { this.adjacentChestXNeg = (TileEntityChest)this.worldObj.getBlockTileEntity(this.xCoord - 1, this.yCoord, this.zCoord); } if (this.func_94044_a(this.xCoord + 1, this.yCoord, this.zCoord)) { this.adjacentChestXPos = (TileEntityChest)this.worldObj.getBlockTileEntity(this.xCoord + 1, this.yCoord, this.zCoord); } if (this.func_94044_a(this.xCoord, this.yCoord, this.zCoord - 1)) { this.adjacentChestZNeg = (TileEntityChest)this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord - 1); } if (this.func_94044_a(this.xCoord, this.yCoord, this.zCoord + 1)) { this.adjacentChestZPosition = (TileEntityChest)this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord + 1); } if (this.adjacentChestZNeg != null) { this.adjacentChestZNeg.func_90009_a(this, 0); } if (this.adjacentChestZPosition != null) { this.adjacentChestZPosition.func_90009_a(this, 2); } if (this.adjacentChestXPos != null) { this.adjacentChestXPos.func_90009_a(this, 1); } if (this.adjacentChestXNeg != null) { this.adjacentChestXNeg.func_90009_a(this, 3); } } } private boolean func_94044_a(int par1, int par2, int par3) { Block block = Block.blocksList[this.worldObj.getBlockId(par1, par2, par3)]; return block != null && block instanceof BlockChest ? ((BlockChest)block).isTrapped == this.func_98041_l() : false; } /** * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count * ticks and creates a new spawn inside its implementation. */ public void updateEntity() { super.updateEntity(); this.checkForAdjacentChests(); ++this.ticksSinceSync; float f; if (!this.worldObj.isRemote && this.numUsingPlayers != 0 && (this.ticksSinceSync + this.xCoord + this.yCoord + this.zCoord) % 200 == 0) { this.numUsingPlayers = 0; f = 5.0F; List list = this.worldObj.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getAABBPool().getAABB((double)((float)this.xCoord - f), (double)((float)this.yCoord - f), (double)((float)this.zCoord - f), (double)((float)(this.xCoord + 1) + f), (double)((float)(this.yCoord + 1) + f), (double)((float)(this.zCoord + 1) + f))); Iterator iterator = list.iterator(); while (iterator.hasNext()) { EntityPlayer entityplayer = (EntityPlayer)iterator.next(); if (entityplayer.openContainer instanceof ContainerChest) { IInventory iinventory = ((ContainerChest)entityplayer.openContainer).getLowerChestInventory(); if (iinventory == this || iinventory instanceof InventoryLargeChest && ((InventoryLargeChest)iinventory).isPartOfLargeChest(this)) { ++this.numUsingPlayers; } } } } this.prevLidAngle = this.lidAngle; f = 0.1F; double d0; if (this.numUsingPlayers > 0 && this.lidAngle == 0.0F && this.adjacentChestZNeg == null && this.adjacentChestXNeg == null) { double d1 = (double)this.xCoord + 0.5D; d0 = (double)this.zCoord + 0.5D; if (this.adjacentChestZPosition != null) { d0 += 0.5D; } if (this.adjacentChestXPos != null) { d1 += 0.5D; } this.worldObj.playSoundEffect(d1, (double)this.yCoord + 0.5D, d0, "random.chestopen", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F); } if (this.numUsingPlayers == 0 && this.lidAngle > 0.0F || this.numUsingPlayers > 0 && this.lidAngle < 1.0F) { float f1 = this.lidAngle; if (this.numUsingPlayers > 0) { this.lidAngle += f; } else { this.lidAngle -= f; } if (this.lidAngle > 1.0F) { this.lidAngle = 1.0F; } float f2 = 0.5F; if (this.lidAngle < f2 && f1 >= f2 && this.adjacentChestZNeg == null && this.adjacentChestXNeg == null) { d0 = (double)this.xCoord + 0.5D; double d2 = (double)this.zCoord + 0.5D; if (this.adjacentChestZPosition != null) { d2 += 0.5D; } if (this.adjacentChestXPos != null) { d0 += 0.5D; } this.worldObj.playSoundEffect(d0, (double)this.yCoord + 0.5D, d2, "random.chestclosed", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F); } if (this.lidAngle < 0.0F) { this.lidAngle = 0.0F; } } } /** * Called when a client event is received with the event number and argument, see World.sendClientEvent */ public boolean receiveClientEvent(int par1, int par2) { if (par1 == 1) { this.numUsingPlayers = par2; return true; } else { return super.receiveClientEvent(par1, par2); } } public void openChest() { if (this.numUsingPlayers < 0) { this.numUsingPlayers = 0; } ++this.numUsingPlayers; this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID, 1, this.numUsingPlayers); this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID); this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType().blockID); } public void closeChest() { if (this.getBlockType() != null && this.getBlockType() instanceof BlockChest) { --this.numUsingPlayers; this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID, 1, this.numUsingPlayers); this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID); this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType().blockID); } } /** * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot. */ public boolean isStackValidForSlot(int par1, ItemStack par2ItemStack) { return true; } /** * invalidates a tile entity */ public void invalidate() { super.invalidate(); this.updateContainingBlockInfo(); this.checkForAdjacentChests(); } public int func_98041_l() { if (this.field_94046_i == -1) { if (this.worldObj == null || !(this.getBlockType() instanceof BlockChest)) { return 0; } this.field_94046_i = ((BlockChest)this.getBlockType()).isTrapped; } return this.field_94046_i; } }