TileEntity (Forge API)

java.lang.Object
- net.minecraft.tileentity.TileEntity

All Implemented Interfaces:

ICapabilityProvider, ICapabilitySerializable<NBTTagCompound>, INBTSerializable<NBTTagCompound>

Direct Known Subclasses:

BlockJukebox.TileEntityJukebox, TileEntityBanner, TileEntityBed, TileEntityCommandBlock, TileEntityComparator, TileEntityDaylightDetector, TileEntityEnchantmentTable, TileEntityEnderChest, TileEntityEndPortal, TileEntityFlowerPot, TileEntityLockable, TileEntityMobSpawner, TileEntityNote, TileEntityPiston, TileEntitySign, TileEntitySkull, TileEntityStructure, TileFluidHandler
```
public abstract class TileEntity
extends java.lang.Object
implements ICapabilitySerializable<NBTTagCompound>
```

Field Summary

Fields
Modifier and Type	Field and Description
`protected Block`	`blockType`
`static AxisAlignedBB`	`INFINITE_EXTENT_AABB` Sometimes default render bounding box: infinite in scope.
`protected BlockPos`	`pos`
`protected boolean`	`tileEntityInvalid`
`protected World`	`world`

Constructor Summary

Constructors
Constructor and Description

TileEntity()

Constructors
Constructor and Description
`TileEntity()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addInfoToCrashReport(CrashReportCategory reportCategory)`
`boolean`	`canRenderBreaking()` Checks if this tile entity knows how to render its 'breaking' overlay effect.
`static TileEntity`	`create(World worldIn, NBTTagCompound compound)`
`void`	`deserializeNBT(NBTTagCompound nbt)`
`int`	`getBlockMetadata()`
`Block`	`getBlockType()`
`<T> T`	`getCapability(Capability<T> capability, EnumFacing facing)` Retrieves the handler for the capability requested on the specific side.
`ITextComponent`	`getDisplayName()`
`double`	`getDistanceSq(double x, double y, double z)`
`static ResourceLocation`	`getKey(java.lang.Class<? extends TileEntity> clazz)`
`double`	`getMaxRenderDistanceSquared()`
`BlockPos`	`getPos()`
`AxisAlignedBB`	`getRenderBoundingBox()` Return an `AxisAlignedBB` that controls the visible scope of a `TileEntitySpecialRenderer` associated with this `TileEntity` Defaults to the collision bounding box `Block#getCollisionBoundingBoxFromPool(World, int, int, int)` associated with the block at this location.
`NBTTagCompound`	`getTileData()` Gets a `NBTTagCompound` that can be used to store custom data for this tile entity.
`SPacketUpdateTileEntity`	`getUpdatePacket()`
`NBTTagCompound`	`getUpdateTag()`
`World`	`getWorld()`
`void`	`handleUpdateTag(NBTTagCompound tag)` Called when the chunk's TE update tag, gotten from `getUpdateTag()`, is received on the client.
`boolean`	`hasCapability(Capability<?> capability, EnumFacing facing)` Determines if this object has support for the capability in question on the specific side.
`boolean`	`hasFastRenderer()` If the TileEntitySpecialRenderer associated with this TileEntity can be batched in with another renderers, and won't access the GL state.
`boolean`	`hasWorld()`
`void`	`invalidate()`
`boolean`	`isInvalid()`
`void`	`markDirty()`
`void`	`mirror(Mirror mirrorIn)`
`void`	`onChunkUnload()` Called when the chunk this TileEntity is on is Unloaded.
`void`	`onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt)` Called when you receive a TileEntityData packet for the location this TileEntity is currently in.
`void`	`onLoad()` Called when this is first added to the world (by `World.addTileEntity(TileEntity)`).
`boolean`	`onlyOpsCanSetNbt()`
`void`	`readFromNBT(NBTTagCompound compound)`
`boolean`	`receiveClientEvent(int id, int type)`
`static void`	`register(java.lang.String id, java.lang.Class<? extends TileEntity> clazz)`
`boolean`	`restrictNBTCopy()` Determines if the player can overwrite the NBT data of this tile entity while they place it using a ItemStack.
`void`	`rotate(Rotation rotationIn)`
`NBTTagCompound`	`serializeNBT()`
`void`	`setPos(BlockPos posIn)`
`void`	`setWorld(World worldIn)`
`protected void`	`setWorldCreate(World worldIn)`
`boolean`	`shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newSate)` Called from Chunk.setBlockIDWithMetadata and Chunk.fillChunk, determines if this tile entity should be re-created when the ID, or Metadata changes.
`boolean`	`shouldRenderInPass(int pass)`
`void`	`updateContainingBlockInfo()`
`void`	`validate()`
`NBTTagCompound`	`writeToNBT(NBTTagCompound compound)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - world
```
protected World world
```
  - pos
```
protected BlockPos pos
```
  - tileEntityInvalid
```
protected boolean tileEntityInvalid
```
  - blockType
```
protected Block blockType
```
  - INFINITE_EXTENT_AABB
```
public static final AxisAlignedBB INFINITE_EXTENT_AABB
```
    Sometimes default render bounding box: infinite in scope. Used to control rendering on TileEntitySpecialRenderer.
- Constructor Detail
  - TileEntity
```
public TileEntity()
```
- Method Detail
  - register
```
public static void register(java.lang.String id,
                            java.lang.Class<? extends TileEntity> clazz)
```
  - getKey
```
@Nullable
public static ResourceLocation getKey(java.lang.Class<? extends TileEntity> clazz)
```
  - getWorld
```
public World getWorld()
```
  - setWorld
```
public void setWorld(World worldIn)
```
  - hasWorld
```
public boolean hasWorld()
```
  - readFromNBT
```
public void readFromNBT(NBTTagCompound compound)
```
  - writeToNBT
```
public NBTTagCompound writeToNBT(NBTTagCompound compound)
```
  - create
```
@Nullable
public static TileEntity create(World worldIn,
                                           NBTTagCompound compound)
```
  - setWorldCreate
```
protected void setWorldCreate(World worldIn)
```
  - getBlockMetadata
```
public int getBlockMetadata()
```
  - markDirty
```
public void markDirty()
```
  - getDistanceSq
```
public double getDistanceSq(double x,
                            double y,
                            double z)
```
  - getMaxRenderDistanceSquared
```
public double getMaxRenderDistanceSquared()
```
  - getPos
```
public BlockPos getPos()
```
  - getBlockType
```
public Block getBlockType()
```
  - getUpdatePacket
```
@Nullable
public SPacketUpdateTileEntity getUpdatePacket()
```
  - getUpdateTag
```
public NBTTagCompound getUpdateTag()
```
  - isInvalid
```
public boolean isInvalid()
```
  - invalidate
```
public void invalidate()
```
  - validate
```
public void validate()
```
  - receiveClientEvent
```
public boolean receiveClientEvent(int id,
                                  int type)
```
  - updateContainingBlockInfo
```
public void updateContainingBlockInfo()
```
  - addInfoToCrashReport
```
public void addInfoToCrashReport(CrashReportCategory reportCategory)
```
  - setPos
```
public void setPos(BlockPos posIn)
```
  - onlyOpsCanSetNbt
```
public boolean onlyOpsCanSetNbt()
```
  - getDisplayName
```
@Nullable
public ITextComponent getDisplayName()
```
  - rotate
```
public void rotate(Rotation rotationIn)
```
  - mirror
```
public void mirror(Mirror mirrorIn)
```
  - onDataPacket
```
public void onDataPacket(NetworkManager net,
                         SPacketUpdateTileEntity pkt)
```
    Called when you receive a TileEntityData packet for the location this TileEntity is currently in. On the client, the NetworkManager will always be the remote server. On the server, it will be whomever is responsible for sending the packet.
    
    Parameters:
    
    net - The NetworkManager the packet originated from
    
    pkt - The data packet
  - handleUpdateTag
```
public void handleUpdateTag(NBTTagCompound tag)
```
    Called when the chunk's TE update tag, gotten from getUpdateTag(), is received on the client.
    Used to handle this tag in a special way. By default this simply calls readFromNBT(NBTTagCompound).
    
    Parameters:
    
    tag - The NBTTagCompound sent from getUpdateTag()
  - onChunkUnload
```
public void onChunkUnload()
```
    Called when the chunk this TileEntity is on is Unloaded.
  - shouldRefresh
```
public boolean shouldRefresh(World world,
                             BlockPos pos,
                             IBlockState oldState,
                             IBlockState newSate)
```
    Called from Chunk.setBlockIDWithMetadata and Chunk.fillChunk, determines if this tile entity should be re-created when the ID, or Metadata changes. Use with caution as this will leave straggler TileEntities, or create conflicts with other TileEntities if not used properly.
    
    Parameters:
    
    world - Current world
    
    pos - Tile's world position
    
    oldState - The old ID of the block
    
    newState - The new ID of the block (May be the same)
    
    Returns:
    
    true forcing the invalidation of the existing TE, false not to invalidate the existing TE
  - shouldRenderInPass
```
public boolean shouldRenderInPass(int pass)
```
  - getRenderBoundingBox
```
public AxisAlignedBB getRenderBoundingBox()
```
    Return an AxisAlignedBB that controls the visible scope of a TileEntitySpecialRenderer associated with this TileEntity Defaults to the collision bounding box Block#getCollisionBoundingBoxFromPool(World, int, int, int) associated with the block at this location.
    
    Returns:
    
    an appropriately size AxisAlignedBB for the TileEntity
  - canRenderBreaking
```
public boolean canRenderBreaking()
```
    Checks if this tile entity knows how to render its 'breaking' overlay effect. If this returns true, The TileEntitySpecialRenderer will be called again with break progress set.
    
    Returns:
    
    True to re-render tile with breaking effect.
  - getTileData
```
public NBTTagCompound getTileData()
```
    Gets a NBTTagCompound that can be used to store custom data for this tile entity. It will be written, and read from disc, so it persists over world saves.
    
    Returns:
    
    A compound tag for custom data
  - restrictNBTCopy
```
public boolean restrictNBTCopy()
```
    Determines if the player can overwrite the NBT data of this tile entity while they place it using a ItemStack. Added as a fix for MC-75630 - Exploit with signs and command blocks
    
    Returns:
    
    True to prevent NBT copy, false to allow.
  - onLoad
```
public void onLoad()
```
    Called when this is first added to the world (by World.addTileEntity(TileEntity)). Override instead of adding if (firstTick) stuff in update.
  - hasFastRenderer
```
public boolean hasFastRenderer()
```
    If the TileEntitySpecialRenderer associated with this TileEntity can be batched in with another renderers, and won't access the GL state. If TileEntity returns true, then TESR should have the same functionality as (and probably extend) the FastTESR class.
  - hasCapability
```
public boolean hasCapability(Capability<?> capability,
                             @Nullable
                             EnumFacing facing)
```
    Description copied from interface: ICapabilityProvider
    
    Determines if this object has support for the capability in question on the specific side. The return value of this MIGHT change during runtime if this object gains or looses support for a capability. Example: A Pipe getting a cover placed on one side causing it loose the Inventory attachment function for that side. This is a light weight version of getCapability, intended for metadata uses.
    
    Specified by:
    
    hasCapability in interface ICapabilityProvider
    
    Parameters:
    
    capability - The capability to check
    
    facing - The Side to check from: CAN BE NULL. Null is defined to represent 'internal' or 'self'
    
    Returns:
    
    True if this object supports the capability.
  - getCapability
```
@Nullable
public <T> T getCapability(Capability<T> capability,
                                      @Nullable
                                      EnumFacing facing)
```
    Description copied from interface: ICapabilityProvider
    
    Retrieves the handler for the capability requested on the specific side. The return value CAN be null if the object does not support the capability. The return value CAN be the same for multiple faces.
    
    Specified by:
    
    getCapability in interface ICapabilityProvider
    
    Parameters:
    
    capability - The capability to check
    
    facing - The Side to check from: CAN BE NULL. Null is defined to represent 'internal' or 'self'
    
    Returns:
    
    The requested capability. Returns null when ICapabilityProvider.hasCapability(Capability, EnumFacing) would return false.
  - deserializeNBT
```
public void deserializeNBT(NBTTagCompound nbt)
```
    Specified by:
    
    deserializeNBT in interface INBTSerializable<NBTTagCompound>
  - serializeNBT
```
public NBTTagCompound serializeNBT()
```
    Specified by:
    
    serializeNBT in interface INBTSerializable<NBTTagCompound>

Class TileEntity

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

world

pos

tileEntityInvalid

blockType

INFINITE_EXTENT_AABB

Constructor Detail

TileEntity

Method Detail

register

getKey

getWorld

setWorld

hasWorld

readFromNBT

writeToNBT

create

setWorldCreate

getBlockMetadata

markDirty

getDistanceSq

getMaxRenderDistanceSquared

getPos

getBlockType

getUpdatePacket

getUpdateTag

isInvalid

invalidate

validate

receiveClientEvent

updateContainingBlockInfo

addInfoToCrashReport

setPos

onlyOpsCanSetNbt

getDisplayName

rotate

mirror

onDataPacket

handleUpdateTag

onChunkUnload

shouldRefresh

shouldRenderInPass

getRenderBoundingBox

canRenderBreaking

getTileData

restrictNBTCopy

onLoad

hasFastRenderer

hasCapability

getCapability

deserializeNBT

serializeNBT