Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.minecraft.world
Class World

    java.lang.Object
      net.minecraft.world.World

All Implemented Interfaces:
  IBlockAccess

Direct Known Subclasses:
  WorldClient, WorldServer

    public abstract class World

extends Object
implements IBlockAccess

Field Summary
`Set` | `activeChunkSet` Positions to update
`int` | `difficultySetting` Option > Difficulty setting (0 - 3)
`boolean` | `editingBlocks` true while the world is editing blocks
`boolean` | `findingSpawnPoint` Boolean that is set to true when trying to find a spawn point
`boolean` | `isRemote` This is set to true when you are a client connected to a multiplayer world, false otherwise.
`int` | `lightningFlash` If > 0, the sky and skylight colors are illuminated by a lightning flash
`List` | `loadedEntityList` A list of all Entities in all currently-loaded chunks
`List` | `loadedTileEntityList` A list of all TileEntities in all currently-loaded chunks
`MapStorage` | `mapStorage`
`static double` | `MAX_ENTITY_RADIUS` Used in the getEntitiesWithinAABB functions to expand the search area for entities.
`MapStorage` | `perWorldStorage`
`List` | `playerEntities` Array list of players in the world.
`WorldProvider` | `provider` The WorldProvider instance that World uses.
`Random` | `rand` RNG for World.
`boolean` | `scheduledUpdatesAreImmediate` boolean; if true updates scheduled by scheduleBlockUpdate happen immediately
`int` | `skylightSubtracted` How much light is subtracted from full daylight
`Profiler` | `theProfiler`
`VillageCollection` | `villageCollectionObj`
`List` | `weatherEffects` a list of all the lightning entities

Constructor Summary
`World(ISaveHandler par1ISaveHandler, String par2Str, WorldProvider par3WorldProvider, WorldSettings par4WorldSettings, Profiler par5Profiler)`
`World(ISaveHandler par1ISaveHandler, String par2Str, WorldSettings par3WorldSettings, WorldProvider par4WorldProvider, Profiler par5Profiler)`

Method Summary
`void` | `addBlockEvent(int par1, int par2, int par3, int par4, int par5, int par6)` Adds a block event with the given Args to the blockEventCache.
`void` | `addLoadedEntities(List par1List)` adds entities to the loaded entities list, and loads thier skins.
`void` | `addTileEntity(Collection par1Collection)`
`void` | `addTileEntity(TileEntity entity)` Adds a single TileEntity to the world.
`boolean` | `addWeatherEffect(Entity par1Entity)` adds a lightning bolt to the list of lightning bolts in this world.
`void` | `addWorldAccess(IWorldAccess par1IWorldAccess)` Adds a IWorldAccess to the list of worldAccesses
`CrashReportCategory` | `addWorldInfoToCrashReport(CrashReport par1CrashReport)` Adds some basic stats of the world to the given crash report.
`boolean` | `blockExists(int par1, int par2, int par3)` Returns whether a block exists at world coordinates x, y, z
`boolean` | `blockHasTileEntity(int par1, int par2, int par3)` Checks if a block at a given position should have a tile entity.
`void` | `calculateInitialSkylight()` Called on construction of the World class to setup the initial skylight values
`void` | `calculateInitialWeatherBody()`
`int` | `calculateSkylightSubtracted(float par1)` Returns the amount of skylight subtracted for the current time
`boolean` | `canBlockFreeze(int par1, int par2, int par3, boolean par4)` checks to see if a given block is both water, and cold enough to freeze - if the par4 boolean is set, this will only return true if there is a non-water block immediately adjacent to the specified block
`boolean` | `canBlockFreezeBody(int par1, int par2, int par3, boolean par4)`
`boolean` | `canBlockSeeTheSky(int par1, int par2, int par3)` Checks if the specified block is able to see the sky
`boolean` | `canLightningStrikeAt(int par1, int par2, int par3)`
`boolean` | `canMineBlock(EntityPlayer par1EntityPlayer, int par2, int par3, int par4)` Called when checking if a certain block can be mined or not.
`boolean` | `canMineBlockBody(EntityPlayer par1EntityPlayer, int par2, int par3, int par4)`
`boolean` | `canPlaceEntityOnSide(int par1, int par2, int par3, int par4, boolean par5, int par6, Entity par7Entity)` Returns true if the given Entity can be placed on the given side of the given block position.
`boolean` | `canSnowAt(int par1, int par2, int par3)` Tests whether or not snow can be placed at a given location
`boolean` | `canSnowAtBody(int par1, int par2, int par3)`
`boolean` | `checkChunksExist(int par1, int par2, int par3, int par4, int par5, int par6)` Checks between a min and max all the chunks inbetween actually exist.
`boolean` | `checkIfAABBIsClear(AxisAlignedBB par1AxisAlignedBB)` Returns true if there are no solid, live entities in the specified AxisAlignedBB
`boolean` | `checkIfAABBIsClearExcludingEntity(AxisAlignedBB par1AxisAlignedBB, Entity par2Entity)` Returns true if there are no solid, live entities in the specified AxisAlignedBB, excluding the given entity
`void` | `checkSessionLock()` Checks whether the session lock file was modified by another process
`int` | `countEntities(Class par1Class)` Counts how many entities of an entity class exist in the world.
`Explosion` | `createExplosion(Entity par1Entity, double par2, double par4, double par6, float par8, boolean par9)` Creates an explosion.
`void` | `destroyBlockInWorldPartially(int par1, int par2, int par3, int par4, int par5)` Starts (or continues) destroying a block with given ID at the given coordinates for the given partially destroyed value
`boolean` | `doChunksNearChunkExist(int par1, int par2, int par3, int par4)` Checks if any of the chunks within distance (argument 4) blocks of the given block exist
`boolean` | `doesBlockHaveSolidTopSurface(int par1, int par2, int par3)` Returns true if the block at the given coordinate has a solid (buildable) top surface.
`Vec3` | `drawClouds(float par1)`
`Vec3` | `drawCloudsBody(float par1)`
`boolean` | `extendedLevelsInChunkCache()`
`boolean` | `extinguishFire(EntityPlayer par1EntityPlayer, int par2, int par3, int par4, int par5)` If the block in the given direction of the given coordinate is fire, extinguish it.
`ChunkPosition` | `findClosestStructure(String par1Str, int par2, int par3, int par4)` Returns the location of the closest structure of the specified type.
`Entity` | `findNearestEntityWithinAABB(Class par1Class, AxisAlignedBB par2AxisAlignedBB, Entity par3Entity)`
`float` | `func_72971_b(float par1)`
`int` | `func_82734_g(int par1, int par2)`
`IUpdatePlayerListBox` | `func_82735_a(EntityMinecart par1EntityMinecart)`
`void` | `func_82738_a(long par1)`
`void` | `func_82739_e(int par1, int par2, int par3, int par4, int par5)`
`void` | `func_82740_a(int par1, int par2, int par3, int par4, int par5, int par6)`
`void` | `func_85173_a(EntityPlayer par1EntityPlayer, String par2Str, float par3, float par4)`
`boolean` | `func_85174_u(int par1, int par2, int par3)`
`int` | `func_85175_e(int par1, int par2, int par3)`
`int` | `getActualHeight()` Returns current world height.
`List` | `getAllCollidingBoundingBoxes(AxisAlignedBB par1AxisAlignedBB)` calculates and returns a list of colliding bounding boxes within a given AABB
`BiomeGenBase` | `getBiomeGenForCoords(int par1, int par2)` Gets the biome for a given set of x/z coordinates
`BiomeGenBase` | `getBiomeGenForCoordsBody(int par1, int par2)`
`float` | `getBlockDensity(Vec3 par1Vec3, AxisAlignedBB par2AxisAlignedBB)` Gets the percentage of real blocks within within a bounding box, along a specified vector.
`int` | `getBlockId(int par1, int par2, int par3)` Returns the block ID at coords x,y,z
`int` | `getBlockLightOpacity(int par1, int par2, int par3)`
`int` | `getBlockLightValue_do(int par1, int par2, int par3, boolean par4)` Gets the light value of a block location.
`int` | `getBlockLightValue(int par1, int par2, int par3)` Gets the light value of a block location
`Material` | `getBlockMaterial(int par1, int par2, int par3)` Returns the block's material.
`int` | `getBlockMetadata(int par1, int par2, int par3)` Returns the block metadata at coords x,y,z
`TileEntity` | `getBlockTileEntity(int par1, int par2, int par3)` Returns the TileEntity associated with a given block in X,Y,Z coordinates, or null if no TileEntity exists
`float` | `getBrightness(int par1, int par2, int par3, int par4)`
`float` | `getCelestialAngle(float par1)` calls calculateCelestialAngle
`float` | `getCelestialAngleRadians(float par1)`
`Chunk` | `getChunkFromBlockCoords(int par1, int par2)` Returns a chunk looked up by block coordinates.
`Chunk` | `getChunkFromChunkCoords(int par1, int par2)` Returns back a chunk looked up by chunk coordinates Args: x, y
`IChunkProvider` | `getChunkProvider()` gets the IChunkProvider this world uses.
`EntityPlayer` | `getClosestPlayer(double par1, double par3, double par5, double par7)` Gets the closest player to the point within the specified distance (distance can be set to less than 0 to not limit the distance).
`EntityPlayer` | `getClosestPlayerToEntity(Entity par1Entity, double par2)` Gets the closest player to the entity within the specified distance (if distance is less than 0 then ignored).
`EntityPlayer` | `getClosestVulnerablePlayer(double par1, double par3, double par5, double par7)` Returns the closest vulnerable player within the given radius, or null if none is found.
`EntityPlayer` | `getClosestVulnerablePlayerToEntity(Entity par1Entity, double par2)` Returns the closest vulnerable player to this entity within the given radius, or null if none is found
`List` | `getCollidingBoundingBoxes(Entity par1Entity, AxisAlignedBB par2AxisAlignedBB)` Returns a list of bounding boxes that collide with aabb excluding the passed in entity's collision.
`Calendar` | `getCurrentDate()` returns a calendar object containing the current date
`String` | `getDebugLoadedEntities()`
`List` | `getEntitiesWithinAABB(Class par1Class, AxisAlignedBB par2AxisAlignedBB)` Returns all entities of the specified class type which intersect with the AABB.
`List` | `getEntitiesWithinAABBExcludingEntity(Entity par1Entity, AxisAlignedBB par2AxisAlignedBB)` Will get all entities within the specified AABB excluding the one passed into it.
`abstract Entity` | `getEntityByID(int var1)` Returns the Entity with the given ID, or null if it doesn't exist in this World.
`PathEntity` | `getEntityPathToXYZ(Entity par1Entity, int par2, int par3, int par4, float par5, boolean par6, boolean par7, boolean par8, boolean par9)`
`int` | `getFirstUncoveredBlock(int par1, int par2)` Returns the block ID of the first block at this (x,z) location with air above it, searching from sea level upwards.
`Vec3` | `getFogColor(float par1)`
`int` | `getFullBlockLightValue(int par1, int par2, int par3)` Does the same as getBlockLightValue_do but without checking if its not a normal block
`GameRules` | `getGameRules()` Gets the GameRules instance
`int` | `getHeight()` Returns current world height.
`int` | `getHeightValue(int par1, int par2)` Returns the y coordinate with a block in it at this x, z coordinate
`double` | `getHorizon()`
`float` | `getLightBrightness(int par1, int par2, int par3)` Returns how bright the block is shown as which is the block's light value looked up in a lookup table (light values aren't linear for brightness).
`int` | `getLightBrightnessForSkyBlocks(int par1, int par2, int par3, int par4)`
`List` | `getLoadedEntityList()`
`int` | `getMoonPhase(float par1)`
`PathEntity` | `getPathEntityToEntity(Entity par1Entity, Entity par2Entity, float par3, boolean par4, boolean par5, boolean par6, boolean par7)`
`List` | `getPendingBlockUpdates(Chunk par1Chunk, boolean par2)`
`com.google.common.collect.ImmutableSetMultimap<ChunkCoordIntPair,ForgeChunkManager.Ticket>` | `getPersistentChunks()` Get the persistent chunks for this world
`EntityPlayer` | `getPlayerEntityByName(String par1Str)` Find a player by name in this world.
`int` | `getPrecipitationHeight(int par1, int par2)` Gets the height to which rain/snow will fall.
`String` | `getProviderName()`
`float` | `getRainStrength(float par1)` Not sure about this actually.
`int` | `getSavedLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4)` Returns saved light value without taking into account the time of day.
`ISaveHandler` | `getSaveHandler()` Returns this world's current save handler
`long` | `getSeed()` Retrieve the world seed from level.dat
`int` | `getSkyBlockTypeBrightness(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4)`
`Vec3` | `getSkyColor(Entity par1Entity, float par2)`
`Vec3` | `getSkyColorBody(Entity par1Entity, float par2)`
`ChunkCoordinates` | `getSpawnPoint()` Returns the coordinates of the spawn point
`float` | `getStarBrightness(float par1)`
`float` | `getStarBrightnessBody(float par1)`
`int` | `getTopSolidOrLiquidBlock(int par1, int par2)` Finds the highest block on the x, z coordinate that is solid and returns its y coord.
`long` | `getTotalWorldTime()`
`int` | `getUniqueDataId(String par1Str)` Returns an unique new data id from the MapStorage for the given prefix and saves the idCounts map to the 'idcounts' file.
`float` | `getWeightedThunderStrength(float par1)`
`WorldChunkManager` | `getWorldChunkManager()`
`WorldInfo` | `getWorldInfo()` Gets the World's WorldInfo instance
`long` | `getWorldTime()`
`Vec3Pool` | `getWorldVec3Pool()` Return the Vec3Pool object for this world.
`boolean` | `handleMaterialAcceleration(AxisAlignedBB par1AxisAlignedBB, Material par2Material, Entity par3Entity)` handles the acceleration of an object whilst in water.
`boolean` | `isAABBInMaterial(AxisAlignedBB par1AxisAlignedBB, Material par2Material)` checks if the given AABB is in the material given.
`boolean` | `isAABBNonEmpty(AxisAlignedBB par1AxisAlignedBB)` Returns true if there are any blocks in the region constrained by an AxisAlignedBB
`boolean` | `isAirBlock(int par1, int par2, int par3)` Returns true if the block at the specified coordinates is empty
`boolean` | `isAnyLiquid(AxisAlignedBB par1AxisAlignedBB)` Returns if any of the blocks within the aabb are liquids.
`boolean` | `isBlockFreezable(int par1, int par2, int par3)` checks to see if a given block is both water and is cold enough to freeze
`boolean` | `isBlockFreezableNaturally(int par1, int par2, int par3)` checks to see if a given block is both water and has at least one immediately adjacent non-water block
`boolean` | `isBlockGettingPowered(int par1, int par2, int par3)` Whether one of the neighboring blocks is putting power into this block.
`boolean` | `isBlockHighHumidity(int par1, int par2, int par3)` Checks to see if the biome rainfall values for a given x,y,z coordinate set are extremely high
`boolean` | `isBlockIndirectlyGettingPowered(int par1, int par2, int par3)` Used to see if one of the blocks next to you or your block is getting power from a neighboring block.
`boolean` | `isBlockIndirectlyProvidingPowerTo(int par1, int par2, int par3, int par4)` Is a block next to you getting powered (if its an attachable block) or is it providing power directly to you.
`boolean` | `isBlockNormalCube(int par1, int par2, int par3)` Indicate if a material is a normal solid opaque cube.
`boolean` | `isBlockNormalCubeDefault(int par1, int par2, int par3, boolean par4)` Checks if the block is a solid, normal cube.
`boolean` | `isBlockOpaqueCube(int par1, int par2, int par3)` Returns true if the block at the specified coordinates is an opaque cube.
`boolean` | `isBlockProvidingPowerTo(int par1, int par2, int par3, int par4)` Is this block powering in the specified direction Args: x, y, z, direction
`boolean` | `isBlockSolidOnSide(int X, int Y, int Z, ForgeDirection side)` Determine if the given block is considered solid on the specified side.
`boolean` | `isBlockSolidOnSide(int X, int Y, int Z, ForgeDirection side, boolean _default)` Determine if the given block is considered solid on the specified side.
`boolean` | `isBoundingBoxBurning(AxisAlignedBB par1AxisAlignedBB)` Returns whether or not the given bounding box is on fire or not
`boolean` | `isDaytime()` Checks whether its daytime by seeing if the light subtracted from the skylight is less than 4
`boolean` | `isMaterialInBB(AxisAlignedBB par1AxisAlignedBB, Material par2Material)` Returns true if the given bounding box contains the given material
`boolean` | `isRaining()` Returns true if the current rain strength is greater than 0.2
`boolean` | `isThundering()` Returns true if the current thunder strength (weighted with the rain strength) is greater than 0.9
`void` | `joinEntityInSurroundings(Entity par1Entity)`
`WorldSavedData` | `loadItemData(Class par1Class, String par2Str)` Loads an existing MapDataBase corresponding to the given String id from disk using the MapStorage, instantiating the given Class, or returns null if none such file exists.
`void` | `markBlockForRenderUpdate(int par1, int par2, int par3)` On the client, re-renders this block.
`void` | `markBlockForRenderUpdate2(int par1, int par2, int par3)` On the client, re-renders this block.
`void` | `markBlockForUpdate(int par1, int par2, int par3)` On the client, re-renders the block.
`void` | `markBlockRangeForRenderUpdate(int par1, int par2, int par3, int par4, int par5, int par6)` On the client, re-renders all blocks in this range, inclusive.
`void` | `markBlocksDirtyVertical(int par1, int par2, int par3, int par4)` marks a vertical line of blocks as dirty
`void` | `markTileEntityForDespawn(TileEntity par1TileEntity)` adds tile entity to despawn list (renamed from markEntityForDespawn)
`Explosion` | `newExplosion(Entity par1Entity, double par2, double par4, double par6, float par8, boolean par9, boolean par10)` returns a new explosion.
`void` | `notifyBlockChange(int par1, int par2, int par3, int par4)` The block type change and need to notify other systems Args: x, y, z, blockID
`void` | `notifyBlocksOfNeighborChange(int par1, int par2, int par3, int par4)` Notifies neighboring blocks that this specified block changed Args: x, y, z, blockID
`void` | `playAuxSFX(int par1, int par2, int par3, int par4, int par5)` See description for playAuxSFX.
`void` | `playAuxSFXAtEntity(EntityPlayer par1EntityPlayer, int par2, int par3, int par4, int par5, int par6)` See description for playAuxSFX.
`void` | `playRecord(String par1Str, int par2, int par3, int par4)` Plays a record at the specified coordinates of the specified name.
`void` | `playSound(double par1, double par3, double par5, String par7Str, float par8, float par9)` par8 is loudness, all pars passed to minecraftInstance.sndManager.playSound
`void` | `playSoundAtEntity(Entity par1Entity, String par2Str, float par3, float par4)` Plays a sound at the entity's position.
`void` | `playSoundEffect(double par1, double par3, double par5, String par7Str, float par8, float par9)` Play a sound effect.
`MovingObjectPosition` | `rayTraceBlocks_do_do(Vec3 par1Vec3, Vec3 par2Vec3, boolean par3, boolean par4)`
`MovingObjectPosition` | `rayTraceBlocks_do(Vec3 par1Vec3, Vec3 par2Vec3, boolean par3)`
`MovingObjectPosition` | `rayTraceBlocks(Vec3 par1Vec3, Vec3 par2Vec3)` ray traces all blocks, including non-collideable ones
`void` | `removeBlockTileEntity(int par1, int par2, int par3)` Removes the TileEntity for a given block in X,Y,Z coordinates
`void` | `removeEntity(Entity par1Entity)` remove dat player from dem servers
`void` | `removeWorldAccess(IWorldAccess par1IWorldAccess)`
`void` | `scheduleBlockUpdate(int par1, int par2, int par3, int par4, int par5)` Schedules a tick to a block with a delay (Most commonly the tick rate)
`void` | `scheduleBlockUpdateFromLoad(int par1, int par2, int par3, int par4, int par5)` Schedules a block update from the saved information in a chunk.
`List` | `selectEntitiesWithinAABB(Class par1Class, AxisAlignedBB par2AxisAlignedBB, IEntitySelector par3IEntitySelector)`
`void` | `sendQuittingDisconnectingPacket()`
`void` | `setAllowedSpawnTypes(boolean par1, boolean par2)` Set which types of mobs are allowed to spawn (peaceful vs hostile).
`boolean` | `setBlock(int par1, int par2, int par3, int par4)` Sets the block to the specified blockID at the block coordinates Args x, y, z, blockID
`boolean` | `setBlockAndMetadata(int par1, int par2, int par3, int par4, int par5)` Sets the block ID and metadata of a block in global coordinates
`boolean` | `setBlockAndMetadataWithNotify(int par1, int par2, int par3, int par4, int par5)` Sets the block ID and metadata, then notifies neighboring blocks of the change Params: x, y, z, BlockID, Metadata
`boolean` | `setBlockAndMetadataWithUpdate(int par1, int par2, int par3, int par4, int par5, boolean par6)` Sets the block ID and metadata of a block, optionally marking it as needing update.
`boolean` | `setBlockMetadata(int par1, int par2, int par3, int par4)` Set the metadata of a block in global coordinates
`void` | `setBlockMetadataWithNotify(int par1, int par2, int par3, int par4)` Sets the blocks metadata and if set will then notify blocks that this block changed.
`void` | `setBlockTileEntity(int par1, int par2, int par3, TileEntity par4TileEntity)` Sets the TileEntity for a given block in X, Y, Z coordinates
`boolean` | `setBlockWithNotify(int par1, int par2, int par3, int par4)` Sets a block and notifies relevant systems with the block change Args: x, y, z, blockID
`void` | `setEntityDead(Entity par1Entity)` Dismounts the entity (and anything riding the entity), sets the dead flag, and removes the player entity from the player entity list.
`void` | `setEntityState(Entity par1Entity, byte par2)` sends a Packet 38 (Entity Status) to all tracked players of that entity
`void` | `setItemData(String par1Str, WorldSavedData par2WorldSavedData)` Assigns the given String id to the given MapDataBase using the MapStorage, removing any existing ones of the same id.
`void` | `setLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4, int par5)` Sets the light value either into the sky map or block map depending on if enumSkyBlock is set to sky or block.
`void` | `setRainStrength(float par1)`
`Random` | `setRandomSeed(int par1, int par2, int par3)` puts the World Random seed to a specific state dependant on the inputs
`void` | `setSpawnLocation()`
`void` | `setSpawnLocation(int par1, int par2, int par3)`
`void` | `setWorldTime(long par1)` Sets the world time.
`boolean` | `spawnEntityInWorld(Entity par1Entity)` Called to place all entities as part of a world
`void` | `spawnParticle(String par1Str, double par2, double par4, double par6, double par8, double par10, double par12)` Spawns a particle.
`void` | `tick()` Runs a single tick for the world
`boolean` | `tickUpdates(boolean par1)` Runs through the list of updates to run and ticks them
`void` | `toggleRain()`
`void` | `unloadEntities(List par1List)` Adds a list of entities to be unloaded on the next pass of World.updateEntities()
`void` | `updateAllLightTypes(int par1, int par2, int par3)`
`void` | `updateAllPlayersSleepingFlag()` Updates the flag that indicates whether or not all players in the world are sleeping.
`void` | `updateEntities()` Updates (and cleans up) entities and tile entities
`void` | `updateEntity(Entity par1Entity)` Will update the entity in the world if the chunk the entity is in is currently loaded.
`void` | `updateEntityWithOptionalForce(Entity par1Entity, boolean par2)` Will update the entity in the world if the chunk the entity is in is currently loaded or its forced to update.
`void` | `updateLightByType(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4)`
`void` | `updateTileEntityChunkAndDoNothing(int par1, int par2, int par3, TileEntity par4TileEntity)` marks the chunk that contains this tilentity as modified and then calls worldAccesses.doNothingWithTileEntity
`void` | `updateWeatherBody()`

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

Field Detail

### MAX_ENTITY_RADIUS

    public static double MAX_ENTITY_RADIUS

  Used in the getEntitiesWithinAABB functions to expand the search area for entities. Modders should change this variable to a higher value if it is less then the radius of one of there entities.

### perWorldStorage

    public final MapStorage perWorldStorage

### scheduledUpdatesAreImmediate

    public boolean scheduledUpdatesAreImmediate

  boolean; if true updates scheduled by scheduleBlockUpdate happen immediately

### loadedEntityList

    public List loadedEntityList

  A list of all Entities in all currently-loaded chunks

### loadedTileEntityList

    public List loadedTileEntityList

  A list of all TileEntities in all currently-loaded chunks

### playerEntities

    public List playerEntities

  Array list of players in the world.

### weatherEffects

    public List weatherEffects

  a list of all the lightning entities

### skylightSubtracted

    public int skylightSubtracted

  How much light is subtracted from full daylight

### lightningFlash

    public int lightningFlash

  If > 0, the sky and skylight colors are illuminated by a lightning flash

### editingBlocks

    public boolean editingBlocks

  true while the world is editing blocks

### difficultySetting

    public int difficultySetting

  Option > Difficulty setting (0 - 3)

### rand

    public Random rand

  RNG for World.

### provider

    public final WorldProvider provider

  The WorldProvider instance that World uses.

### findingSpawnPoint

    public boolean findingSpawnPoint

  Boolean that is set to true when trying to find a spawn point

### mapStorage

    public MapStorage mapStorage

### villageCollectionObj

    public VillageCollection villageCollectionObj

### theProfiler

    public final Profiler theProfiler

### activeChunkSet

    public Set activeChunkSet

  Positions to update

### isRemote

    public boolean isRemote

  This is set to true when you are a client connected to a multiplayer world, false otherwise. As of Minecraft 1.3 and the integrated server, this will always return true.

Constructor Detail

### World

    public World(ISaveHandler par1ISaveHandler,
                 String par2Str,
                 WorldProvider par3WorldProvider,
                 WorldSettings par4WorldSettings,
                 Profiler par5Profiler)

### World

    public World(ISaveHandler par1ISaveHandler,
                 String par2Str,
                 WorldSettings par3WorldSettings,
                 WorldProvider par4WorldProvider,
                 Profiler par5Profiler)

Method Detail

### getBiomeGenForCoords

    public BiomeGenBase getBiomeGenForCoords(int par1,
                                             int par2)

  Gets the biome for a given set of x/z coordinates

  Specified by:
    `getBiomeGenForCoords` in interface `IBlockAccess`

### getBiomeGenForCoordsBody

    public BiomeGenBase getBiomeGenForCoordsBody(int par1,
                                                 int par2)

### getWorldChunkManager

    public WorldChunkManager getWorldChunkManager()

### setSpawnLocation

    public void setSpawnLocation()

### getFirstUncoveredBlock

    public int getFirstUncoveredBlock(int par1,
                                      int par2)

  Returns the block ID of the first block at this (x,z) location with air above it, searching from sea level upwards.

### getBlockId

    public int getBlockId(int par1,
                          int par2,
                          int par3)

  Returns the block ID at coords x,y,z

  Specified by:
    `getBlockId` in interface `IBlockAccess`

### getBlockLightOpacity

    public int getBlockLightOpacity(int par1,
                                    int par2,
                                    int par3)

### isAirBlock

    public boolean isAirBlock(int par1,
                              int par2,
                              int par3)

  Returns true if the block at the specified coordinates is empty

  Specified by:
    `isAirBlock` in interface `IBlockAccess`

### blockHasTileEntity

    public boolean blockHasTileEntity(int par1,
                                      int par2,
                                      int par3)

  Checks if a block at a given position should have a tile entity.

### func_85175_e

    public int func_85175_e(int par1,
                            int par2,
                            int par3)

### blockExists

    public boolean blockExists(int par1,
                               int par2,
                               int par3)

  Returns whether a block exists at world coordinates x, y, z

### doChunksNearChunkExist

    public boolean doChunksNearChunkExist(int par1,
                                          int par2,
                                          int par3,
                                          int par4)

  Checks if any of the chunks within distance (argument 4) blocks of the given block exist

### checkChunksExist

    public boolean checkChunksExist(int par1,
                                    int par2,
                                    int par3,
                                    int par4,
                                    int par5,
                                    int par6)

  Checks between a min and max all the chunks inbetween actually exist. Args: minX, minY, minZ, maxX, maxY, maxZ

### getChunkFromBlockCoords

    public Chunk getChunkFromBlockCoords(int par1,
                                         int par2)

  Returns a chunk looked up by block coordinates. Args: x, z

### getChunkFromChunkCoords

    public Chunk getChunkFromChunkCoords(int par1,
                                         int par2)

  Returns back a chunk looked up by chunk coordinates Args: x, y

### setBlockAndMetadata

    public boolean setBlockAndMetadata(int par1,
                                       int par2,
                                       int par3,
                                       int par4,
                                       int par5)

  Sets the block ID and metadata of a block in global coordinates

### setBlockAndMetadataWithUpdate

    public boolean setBlockAndMetadataWithUpdate(int par1,
                                                 int par2,
                                                 int par3,
                                                 int par4,
                                                 int par5,
                                                 boolean par6)

  Sets the block ID and metadata of a block, optionally marking it as needing update. Args: X,Y,Z, blockID, metadata, needsUpdate

### setBlock

    public boolean setBlock(int par1,
                            int par2,
                            int par3,
                            int par4)

  Sets the block to the specified blockID at the block coordinates Args x, y, z, blockID

### getBlockMaterial

    public Material getBlockMaterial(int par1,
                                     int par2,
                                     int par3)

  Returns the block's material.

  Specified by:
    `getBlockMaterial` in interface `IBlockAccess`

### getBlockMetadata

    public int getBlockMetadata(int par1,
                                int par2,
                                int par3)

  Returns the block metadata at coords x,y,z

  Specified by:
    `getBlockMetadata` in interface `IBlockAccess`

### setBlockMetadataWithNotify

    public void setBlockMetadataWithNotify(int par1,
                                           int par2,
                                           int par3,
                                           int par4)

  Sets the blocks metadata and if set will then notify blocks that this block changed. Args: x, y, z, metadata

### setBlockMetadata

    public boolean setBlockMetadata(int par1,
                                    int par2,
                                    int par3,
                                    int par4)

  Set the metadata of a block in global coordinates

### setBlockWithNotify

    public boolean setBlockWithNotify(int par1,
                                      int par2,
                                      int par3,
                                      int par4)

  Sets a block and notifies relevant systems with the block change Args: x, y, z, blockID

### setBlockAndMetadataWithNotify

    public boolean setBlockAndMetadataWithNotify(int par1,
                                                 int par2,
                                                 int par3,
                                                 int par4,
                                                 int par5)

  Sets the block ID and metadata, then notifies neighboring blocks of the change Params: x, y, z, BlockID, Metadata

### markBlockForUpdate

    public void markBlockForUpdate(int par1,
                                   int par2,
                                   int par3)

  On the client, re-renders the block. On the server, sends the block to the client (which will re-render it), including the tile entity description packet if applicable. Args: x, y, z

### notifyBlockChange

    public void notifyBlockChange(int par1,
                                  int par2,
                                  int par3,
                                  int par4)

  The block type change and need to notify other systems Args: x, y, z, blockID

### markBlocksDirtyVertical

    public void markBlocksDirtyVertical(int par1,
                                        int par2,
                                        int par3,
                                        int par4)

  marks a vertical line of blocks as dirty

### markBlockForRenderUpdate2

    public void markBlockForRenderUpdate2(int par1,
                                          int par2,
                                          int par3)

  On the client, re-renders this block. On the server, does nothing. Appears to be redundant.

### markBlockRangeForRenderUpdate

    public void markBlockRangeForRenderUpdate(int par1,
                                              int par2,
                                              int par3,
                                              int par4,
                                              int par5,
                                              int par6)

  On the client, re-renders all blocks in this range, inclusive. On the server, does nothing. Args: min x, min y, min z, max x, max y, max z

### notifyBlocksOfNeighborChange

    public void notifyBlocksOfNeighborChange(int par1,
                                             int par2,
                                             int par3,
                                             int par4)

  Notifies neighboring blocks that this specified block changed Args: x, y, z, blockID

### canBlockSeeTheSky

    public boolean canBlockSeeTheSky(int par1,
                                     int par2,
                                     int par3)

  Checks if the specified block is able to see the sky

### getFullBlockLightValue

    public int getFullBlockLightValue(int par1,
                                      int par2,
                                      int par3)

  Does the same as getBlockLightValue_do but without checking if its not a normal block

### getBlockLightValue

    public int getBlockLightValue(int par1,
                                  int par2,
                                  int par3)

  Gets the light value of a block location

### getBlockLightValue_do

    public int getBlockLightValue_do(int par1,
                                     int par2,
                                     int par3,
                                     boolean par4)

  Gets the light value of a block location. This is the actual function that gets the value and has a bool flag that indicates if its a half step block to get the maximum light value of a direct neighboring block (left, right, forward, back, and up)

### getHeightValue

    public int getHeightValue(int par1,
                              int par2)

  Returns the y coordinate with a block in it at this x, z coordinate

### func_82734_g

    public int func_82734_g(int par1,
                            int par2)

### getSkyBlockTypeBrightness

    public int getSkyBlockTypeBrightness(EnumSkyBlock par1EnumSkyBlock,
                                         int par2,
                                         int par3,
                                         int par4)

### getSavedLightValue

    public int getSavedLightValue(EnumSkyBlock par1EnumSkyBlock,
                                  int par2,
                                  int par3,
                                  int par4)

  Returns saved light value without taking into account the time of day. Either looks in the sky light map or block light map based on the enumSkyBlock arg.

### setLightValue

    public void setLightValue(EnumSkyBlock par1EnumSkyBlock,
                              int par2,
                              int par3,
                              int par4,
                              int par5)

  Sets the light value either into the sky map or block map depending on if enumSkyBlock is set to sky or block. Args: enumSkyBlock, x, y, z, lightValue

### markBlockForRenderUpdate

    public void markBlockForRenderUpdate(int par1,
                                         int par2,
                                         int par3)

  On the client, re-renders this block. On the server, does nothing. Used for lighting updates.

### getLightBrightnessForSkyBlocks

    public int getLightBrightnessForSkyBlocks(int par1,
                                              int par2,
                                              int par3,
                                              int par4)

  Specified by:
    `getLightBrightnessForSkyBlocks` in interface `IBlockAccess`

### getBrightness

    public float getBrightness(int par1,
                               int par2,
                               int par3,
                               int par4)

  Specified by:
    `getBrightness` in interface `IBlockAccess`

### getLightBrightness

    public float getLightBrightness(int par1,
                                    int par2,
                                    int par3)

  Returns how bright the block is shown as which is the block's light value looked up in a lookup table (light values aren't linear for brightness). Args: x, y, z

  Specified by:
    `getLightBrightness` in interface `IBlockAccess`

### isDaytime

    public boolean isDaytime()

  Checks whether its daytime by seeing if the light subtracted from the skylight is less than 4

### rayTraceBlocks

    public MovingObjectPosition rayTraceBlocks(Vec3 par1Vec3,
                                               Vec3 par2Vec3)

  ray traces all blocks, including non-collideable ones

### rayTraceBlocks_do

    public MovingObjectPosition rayTraceBlocks_do(Vec3 par1Vec3,
                                                  Vec3 par2Vec3,
                                                  boolean par3)

### rayTraceBlocks_do_do

    public MovingObjectPosition rayTraceBlocks_do_do(Vec3 par1Vec3,
                                                     Vec3 par2Vec3,
                                                     boolean par3,
                                                     boolean par4)

### playSoundAtEntity

    public void playSoundAtEntity(Entity par1Entity,
                                  String par2Str,
                                  float par3,
                                  float par4)

  Plays a sound at the entity's position. Args: entity, sound, volume (relative to 1.0), and frequency (or pitch, also relative to 1.0).

### func_85173_a

    public void func_85173_a(EntityPlayer par1EntityPlayer,
                             String par2Str,
                             float par3,
                             float par4)

### playSoundEffect

    public void playSoundEffect(double par1,
                                double par3,
                                double par5,
                                String par7Str,
                                float par8,
                                float par9)

  Play a sound effect. Many many parameters for this function. Not sure what they do, but a classic call is : (double)i + 0.5D, (double)j + 0.5D, (double)k + 0.5D, 'random.door_open', 1.0F, world.rand.nextFloat() * 0.1F + 0.9F with i,j,k position of the block.

### playSound

    public void playSound(double par1,
                          double par3,
                          double par5,
                          String par7Str,
                          float par8,
                          float par9)

  par8 is loudness, all pars passed to minecraftInstance.sndManager.playSound

### playRecord

    public void playRecord(String par1Str,
                           int par2,
                           int par3,
                           int par4)

  Plays a record at the specified coordinates of the specified name. Args: recordName, x, y, z

### spawnParticle

    public void spawnParticle(String par1Str,
                              double par2,
                              double par4,
                              double par6,
                              double par8,
                              double par10,
                              double par12)

  Spawns a particle. Args particleName, x, y, z, velX, velY, velZ

### addWeatherEffect

    public boolean addWeatherEffect(Entity par1Entity)

  adds a lightning bolt to the list of lightning bolts in this world.

### spawnEntityInWorld

    public boolean spawnEntityInWorld(Entity par1Entity)

  Called to place all entities as part of a world

### setEntityDead

    public void setEntityDead(Entity par1Entity)

  Dismounts the entity (and anything riding the entity), sets the dead flag, and removes the player entity from the player entity list. Called by the playerLoggedOut function.

### removeEntity

    public void removeEntity(Entity par1Entity)

  remove dat player from dem servers

### addWorldAccess

    public void addWorldAccess(IWorldAccess par1IWorldAccess)

  Adds a IWorldAccess to the list of worldAccesses

### getCollidingBoundingBoxes

    public List getCollidingBoundingBoxes(Entity par1Entity,
                                          AxisAlignedBB par2AxisAlignedBB)

  Returns a list of bounding boxes that collide with aabb excluding the passed in entity's collision. Args: entity, aabb

### getAllCollidingBoundingBoxes

    public List getAllCollidingBoundingBoxes(AxisAlignedBB par1AxisAlignedBB)

  calculates and returns a list of colliding bounding boxes within a given AABB

### calculateSkylightSubtracted

    public int calculateSkylightSubtracted(float par1)

  Returns the amount of skylight subtracted for the current time

### removeWorldAccess

    public void removeWorldAccess(IWorldAccess par1IWorldAccess)

### func_72971_b

    public float func_72971_b(float par1)

### getSkyColor

    public Vec3 getSkyColor(Entity par1Entity,
                            float par2)

### getSkyColorBody

    public Vec3 getSkyColorBody(Entity par1Entity,
                                float par2)

### getCelestialAngle

    public float getCelestialAngle(float par1)

  calls calculateCelestialAngle

### getMoonPhase

    public int getMoonPhase(float par1)

### getCelestialAngleRadians

    public float getCelestialAngleRadians(float par1)

### drawClouds

    public Vec3 drawClouds(float par1)

### drawCloudsBody

    public Vec3 drawCloudsBody(float par1)

### getFogColor

    public Vec3 getFogColor(float par1)

### getPrecipitationHeight

    public int getPrecipitationHeight(int par1,
                                      int par2)

  Gets the height to which rain/snow will fall. Calculates it if not already stored.

### getTopSolidOrLiquidBlock

    public int getTopSolidOrLiquidBlock(int par1,
                                        int par2)

  Finds the highest block on the x, z coordinate that is solid and returns its y coord. Args x, z

### getStarBrightness

    public float getStarBrightness(float par1)

### getStarBrightnessBody

    public float getStarBrightnessBody(float par1)

### scheduleBlockUpdate

    public void scheduleBlockUpdate(int par1,
                                    int par2,
                                    int par3,
                                    int par4,
                                    int par5)

  Schedules a tick to a block with a delay (Most commonly the tick rate)

### func_82740_a

    public void func_82740_a(int par1,
                             int par2,
                             int par3,
                             int par4,
                             int par5,
                             int par6)

### scheduleBlockUpdateFromLoad

    public void scheduleBlockUpdateFromLoad(int par1,
                                            int par2,
                                            int par3,
                                            int par4,
                                            int par5)

  Schedules a block update from the saved information in a chunk. Called when the chunk is loaded.

### updateEntities

    public void updateEntities()

  Updates (and cleans up) entities and tile entities

### addTileEntity

    public void addTileEntity(Collection par1Collection)

### updateEntity

    public void updateEntity(Entity par1Entity)

  Will update the entity in the world if the chunk the entity is in is currently loaded. Args: entity

### updateEntityWithOptionalForce

    public void updateEntityWithOptionalForce(Entity par1Entity,
                                              boolean par2)

  Will update the entity in the world if the chunk the entity is in is currently loaded or its forced to update. Args: entity, forceUpdate

### checkIfAABBIsClear

    public boolean checkIfAABBIsClear(AxisAlignedBB par1AxisAlignedBB)

  Returns true if there are no solid, live entities in the specified AxisAlignedBB

### checkIfAABBIsClearExcludingEntity

    public boolean checkIfAABBIsClearExcludingEntity(AxisAlignedBB par1AxisAlignedBB,
                                                     Entity par2Entity)

  Returns true if there are no solid, live entities in the specified AxisAlignedBB, excluding the given entity

### isAABBNonEmpty

    public boolean isAABBNonEmpty(AxisAlignedBB par1AxisAlignedBB)

  Returns true if there are any blocks in the region constrained by an AxisAlignedBB

### isAnyLiquid

    public boolean isAnyLiquid(AxisAlignedBB par1AxisAlignedBB)

  Returns if any of the blocks within the aabb are liquids. Args: aabb

### isBoundingBoxBurning

    public boolean isBoundingBoxBurning(AxisAlignedBB par1AxisAlignedBB)

  Returns whether or not the given bounding box is on fire or not

### handleMaterialAcceleration

    public boolean handleMaterialAcceleration(AxisAlignedBB par1AxisAlignedBB,
                                              Material par2Material,
                                              Entity par3Entity)

  handles the acceleration of an object whilst in water. Not sure if it is used elsewhere.

### isMaterialInBB

    public boolean isMaterialInBB(AxisAlignedBB par1AxisAlignedBB,
                                  Material par2Material)

  Returns true if the given bounding box contains the given material

### isAABBInMaterial

    public boolean isAABBInMaterial(AxisAlignedBB par1AxisAlignedBB,
                                    Material par2Material)

  checks if the given AABB is in the material given. Used while swimming.

### createExplosion

    public Explosion createExplosion(Entity par1Entity,
                                     double par2,
                                     double par4,
                                     double par6,
                                     float par8,
                                     boolean par9)

  Creates an explosion. Args: entity, x, y, z, strength

### newExplosion

    public Explosion newExplosion(Entity par1Entity,
                                  double par2,
                                  double par4,
                                  double par6,
                                  float par8,
                                  boolean par9,
                                  boolean par10)

  returns a new explosion. Does initiation (at time of writing Explosion is not finished)

### getBlockDensity

    public float getBlockDensity(Vec3 par1Vec3,
                                 AxisAlignedBB par2AxisAlignedBB)

  Gets the percentage of real blocks within within a bounding box, along a specified vector.

### extinguishFire

    public boolean extinguishFire(EntityPlayer par1EntityPlayer,
                                  int par2,
                                  int par3,
                                  int par4,
                                  int par5)

  If the block in the given direction of the given coordinate is fire, extinguish it. Args: Player, X,Y,Z, blockDirection

### getDebugLoadedEntities

    public String getDebugLoadedEntities()

### getProviderName

    public String getProviderName()

### getBlockTileEntity

    public TileEntity getBlockTileEntity(int par1,
                                         int par2,
                                         int par3)

  Returns the TileEntity associated with a given block in X,Y,Z coordinates, or null if no TileEntity exists

  Specified by:
    `getBlockTileEntity` in interface `IBlockAccess`

### setBlockTileEntity

    public void setBlockTileEntity(int par1,
                                   int par2,
                                   int par3,
                                   TileEntity par4TileEntity)

  Sets the TileEntity for a given block in X, Y, Z coordinates

### removeBlockTileEntity

    public void removeBlockTileEntity(int par1,
                                      int par2,
                                      int par3)

  Removes the TileEntity for a given block in X,Y,Z coordinates

### markTileEntityForDespawn

    public void markTileEntityForDespawn(TileEntity par1TileEntity)

  adds tile entity to despawn list (renamed from markEntityForDespawn)

### isBlockOpaqueCube

    public boolean isBlockOpaqueCube(int par1,
                                     int par2,
                                     int par3)

  Returns true if the block at the specified coordinates is an opaque cube. Args: x, y, z

  Specified by:
    `isBlockOpaqueCube` in interface `IBlockAccess`

### isBlockNormalCube

    public boolean isBlockNormalCube(int par1,
                                     int par2,
                                     int par3)

  Indicate if a material is a normal solid opaque cube.

  Specified by:
    `isBlockNormalCube` in interface `IBlockAccess`

### func_85174_u

    public boolean func_85174_u(int par1,
                                int par2,
                                int par3)

### doesBlockHaveSolidTopSurface

    public boolean doesBlockHaveSolidTopSurface(int par1,
                                                int par2,
                                                int par3)

  Returns true if the block at the given coordinate has a solid (buildable) top surface.

  Specified by:
    `doesBlockHaveSolidTopSurface` in interface `IBlockAccess`

### isBlockNormalCubeDefault

    public boolean isBlockNormalCubeDefault(int par1,
                                            int par2,
                                            int par3,
                                            boolean par4)

  Checks if the block is a solid, normal cube. If the chunk does not exist, or is not loaded, it returns the boolean parameter.

### calculateInitialSkylight

    public void calculateInitialSkylight()

  Called on construction of the World class to setup the initial skylight values

### setAllowedSpawnTypes

    public void setAllowedSpawnTypes(boolean par1,
                                     boolean par2)

  Set which types of mobs are allowed to spawn (peaceful vs hostile).

### tick

    public void tick()

  Runs a single tick for the world

### calculateInitialWeatherBody

    public void calculateInitialWeatherBody()

### updateWeatherBody

    public void updateWeatherBody()

### toggleRain

    public void toggleRain()

### isBlockFreezable

    public boolean isBlockFreezable(int par1,
                                    int par2,
                                    int par3)

  checks to see if a given block is both water and is cold enough to freeze

### isBlockFreezableNaturally

    public boolean isBlockFreezableNaturally(int par1,
                                             int par2,
                                             int par3)

  checks to see if a given block is both water and has at least one immediately adjacent non-water block

### canBlockFreeze

    public boolean canBlockFreeze(int par1,
                                  int par2,
                                  int par3,
                                  boolean par4)

  checks to see if a given block is both water, and cold enough to freeze - if the par4 boolean is set, this will only return true if there is a non-water block immediately adjacent to the specified block

### canBlockFreezeBody

    public boolean canBlockFreezeBody(int par1,
                                      int par2,
                                      int par3,
                                      boolean par4)

### canSnowAt

    public boolean canSnowAt(int par1,
                             int par2,
                             int par3)

  Tests whether or not snow can be placed at a given location

### canSnowAtBody

    public boolean canSnowAtBody(int par1,
                                 int par2,
                                 int par3)

### updateAllLightTypes

    public void updateAllLightTypes(int par1,
                                    int par2,
                                    int par3)

### updateLightByType

    public void updateLightByType(EnumSkyBlock par1EnumSkyBlock,
                                  int par2,
                                  int par3,
                                  int par4)

### tickUpdates

    public boolean tickUpdates(boolean par1)

  Runs through the list of updates to run and ticks them

### getPendingBlockUpdates

    public List getPendingBlockUpdates(Chunk par1Chunk,
                                       boolean par2)

### getEntitiesWithinAABBExcludingEntity

    public List getEntitiesWithinAABBExcludingEntity(Entity par1Entity,
                                                     AxisAlignedBB par2AxisAlignedBB)

  Will get all entities within the specified AABB excluding the one passed into it. Args: entityToExclude, aabb

### getEntitiesWithinAABB

    public List getEntitiesWithinAABB(Class par1Class,
                                      AxisAlignedBB par2AxisAlignedBB)

  Returns all entities of the specified class type which intersect with the AABB. Args: entityClass, aabb

### selectEntitiesWithinAABB

    public List selectEntitiesWithinAABB(Class par1Class,
                                         AxisAlignedBB par2AxisAlignedBB,
                                         IEntitySelector par3IEntitySelector)

### findNearestEntityWithinAABB

    public Entity findNearestEntityWithinAABB(Class par1Class,
                                              AxisAlignedBB par2AxisAlignedBB,
                                              Entity par3Entity)

### getEntityByID

    public abstract Entity getEntityByID(int var1)

  Returns the Entity with the given ID, or null if it doesn't exist in this World.

### getLoadedEntityList

    public List getLoadedEntityList()

### updateTileEntityChunkAndDoNothing

    public void updateTileEntityChunkAndDoNothing(int par1,
                                                  int par2,
                                                  int par3,
                                                  TileEntity par4TileEntity)

  marks the chunk that contains this tilentity as modified and then calls worldAccesses.doNothingWithTileEntity

### countEntities

    public int countEntities(Class par1Class)

  Counts how many entities of an entity class exist in the world. Args: entityClass

### addLoadedEntities

    public void addLoadedEntities(List par1List)

  adds entities to the loaded entities list, and loads thier skins.

### unloadEntities

    public void unloadEntities(List par1List)

  Adds a list of entities to be unloaded on the next pass of World.updateEntities()

### canPlaceEntityOnSide

    public boolean canPlaceEntityOnSide(int par1,
                                        int par2,
                                        int par3,
                                        int par4,
                                        boolean par5,
                                        int par6,
                                        Entity par7Entity)

  Returns true if the given Entity can be placed on the given side of the given block position.

### getPathEntityToEntity

    public PathEntity getPathEntityToEntity(Entity par1Entity,
                                            Entity par2Entity,
                                            float par3,
                                            boolean par4,
                                            boolean par5,
                                            boolean par6,
                                            boolean par7)

### getEntityPathToXYZ

    public PathEntity getEntityPathToXYZ(Entity par1Entity,
                                         int par2,
                                         int par3,
                                         int par4,
                                         float par5,
                                         boolean par6,
                                         boolean par7,
                                         boolean par8,
                                         boolean par9)

### isBlockProvidingPowerTo

    public boolean isBlockProvidingPowerTo(int par1,
                                           int par2,
                                           int par3,
                                           int par4)

  Is this block powering in the specified direction Args: x, y, z, direction

  Specified by:
    `isBlockProvidingPowerTo` in interface `IBlockAccess`

### isBlockGettingPowered

    public boolean isBlockGettingPowered(int par1,
                                         int par2,
                                         int par3)

  Whether one of the neighboring blocks is putting power into this block. Args: x, y, z

### isBlockIndirectlyProvidingPowerTo

    public boolean isBlockIndirectlyProvidingPowerTo(int par1,
                                                     int par2,
                                                     int par3,
                                                     int par4)

  Is a block next to you getting powered (if its an attachable block) or is it providing power directly to you. Args: x, y, z, direction

### isBlockIndirectlyGettingPowered

    public boolean isBlockIndirectlyGettingPowered(int par1,
                                                   int par2,
                                                   int par3)

  Used to see if one of the blocks next to you or your block is getting power from a neighboring block. Used by items like TNT or Doors so they don't have redstone going straight into them. Args: x, y, z

### getClosestPlayerToEntity

    public EntityPlayer getClosestPlayerToEntity(Entity par1Entity,
                                                 double par2)

  Gets the closest player to the entity within the specified distance (if distance is less than 0 then ignored). Args: entity, dist

### getClosestPlayer

    public EntityPlayer getClosestPlayer(double par1,
                                         double par3,
                                         double par5,
                                         double par7)

  Gets the closest player to the point within the specified distance (distance can be set to less than 0 to not limit the distance). Args: x, y, z, dist

### getClosestVulnerablePlayerToEntity

    public EntityPlayer getClosestVulnerablePlayerToEntity(Entity par1Entity,
                                                           double par2)

  Returns the closest vulnerable player to this entity within the given radius, or null if none is found

### getClosestVulnerablePlayer

    public EntityPlayer getClosestVulnerablePlayer(double par1,
                                                   double par3,
                                                   double par5,
                                                   double par7)

  Returns the closest vulnerable player within the given radius, or null if none is found.

### getPlayerEntityByName

    public EntityPlayer getPlayerEntityByName(String par1Str)

  Find a player by name in this world.

### sendQuittingDisconnectingPacket

    public void sendQuittingDisconnectingPacket()

### checkSessionLock

    public void checkSessionLock()
                          throws MinecraftException

  Checks whether the session lock file was modified by another process

  Throws:
    `MinecraftException`

### func_82738_a

    public void func_82738_a(long par1)

### getSeed

    public long getSeed()

  Retrieve the world seed from level.dat

### getTotalWorldTime

    public long getTotalWorldTime()

### getWorldTime

    public long getWorldTime()

### setWorldTime

    public void setWorldTime(long par1)

  Sets the world time.

### getSpawnPoint

    public ChunkCoordinates getSpawnPoint()

  Returns the coordinates of the spawn point

### setSpawnLocation

    public void setSpawnLocation(int par1,
                                 int par2,
                                 int par3)

### joinEntityInSurroundings

    public void joinEntityInSurroundings(Entity par1Entity)

### canMineBlock

    public boolean canMineBlock(EntityPlayer par1EntityPlayer,
                                int par2,
                                int par3,
                                int par4)

  Called when checking if a certain block can be mined or not. The 'spawn safe zone' check is located here.

### canMineBlockBody

    public boolean canMineBlockBody(EntityPlayer par1EntityPlayer,
                                    int par2,
                                    int par3,
                                    int par4)

### setEntityState

    public void setEntityState(Entity par1Entity,
                               byte par2)

  sends a Packet 38 (Entity Status) to all tracked players of that entity

### getChunkProvider

    public IChunkProvider getChunkProvider()

  gets the IChunkProvider this world uses.

### addBlockEvent

    public void addBlockEvent(int par1,
                              int par2,
                              int par3,
                              int par4,
                              int par5,
                              int par6)

  Adds a block event with the given Args to the blockEventCache. During the next tick(), the block specified will have its onBlockEvent handler called with the given parameters. Args: X,Y,Z, BlockID, EventID, EventParameter

### getSaveHandler

    public ISaveHandler getSaveHandler()

  Returns this world's current save handler

### getWorldInfo

    public WorldInfo getWorldInfo()

  Gets the World's WorldInfo instance

### getGameRules

    public GameRules getGameRules()

  Gets the GameRules instance

### updateAllPlayersSleepingFlag

    public void updateAllPlayersSleepingFlag()

  Updates the flag that indicates whether or not all players in the world are sleeping.

### getWeightedThunderStrength

    public float getWeightedThunderStrength(float par1)

### getRainStrength

    public float getRainStrength(float par1)

  Not sure about this actually. Reverting this one myself.

### setRainStrength

    public void setRainStrength(float par1)

### isThundering

    public boolean isThundering()

  Returns true if the current thunder strength (weighted with the rain strength) is greater than 0.9

### isRaining

    public boolean isRaining()

  Returns true if the current rain strength is greater than 0.2

### canLightningStrikeAt

    public boolean canLightningStrikeAt(int par1,
                                        int par2,
                                        int par3)

### isBlockHighHumidity

    public boolean isBlockHighHumidity(int par1,
                                       int par2,
                                       int par3)

  Checks to see if the biome rainfall values for a given x,y,z coordinate set are extremely high

### setItemData

    public void setItemData(String par1Str,
                            WorldSavedData par2WorldSavedData)

  Assigns the given String id to the given MapDataBase using the MapStorage, removing any existing ones of the same id.

### loadItemData

    public WorldSavedData loadItemData(Class par1Class,
                                       String par2Str)

  Loads an existing MapDataBase corresponding to the given String id from disk using the MapStorage, instantiating the given Class, or returns null if none such file exists. args: Class to instantiate, String dataid

### getUniqueDataId

    public int getUniqueDataId(String par1Str)

  Returns an unique new data id from the MapStorage for the given prefix and saves the idCounts map to the 'idcounts' file.

### func_82739_e

    public void func_82739_e(int par1,
                             int par2,
                             int par3,
                             int par4,
                             int par5)

### playAuxSFX

    public void playAuxSFX(int par1,
                           int par2,
                           int par3,
                           int par4,
                           int par5)

  See description for playAuxSFX.

### playAuxSFXAtEntity

    public void playAuxSFXAtEntity(EntityPlayer par1EntityPlayer,
                                   int par2,
                                   int par3,
                                   int par4,
                                   int par5,
                                   int par6)

  See description for playAuxSFX.

### getHeight

    public int getHeight()

  Returns current world height.

  Specified by:
    `getHeight` in interface `IBlockAccess`

### getActualHeight

    public int getActualHeight()

  Returns current world height.

### func_82735_a

    public IUpdatePlayerListBox func_82735_a(EntityMinecart par1EntityMinecart)

### setRandomSeed

    public Random setRandomSeed(int par1,
                                int par2,
                                int par3)

  puts the World Random seed to a specific state dependant on the inputs

### findClosestStructure

    public ChunkPosition findClosestStructure(String par1Str,
                                              int par2,
                                              int par3,
                                              int par4)

  Returns the location of the closest structure of the specified type. If not found returns null.

### extendedLevelsInChunkCache

    public boolean extendedLevelsInChunkCache()

  Specified by:
    `extendedLevelsInChunkCache` in interface `IBlockAccess`

### getHorizon

    public double getHorizon()

### addWorldInfoToCrashReport

    public CrashReportCategory addWorldInfoToCrashReport(CrashReport par1CrashReport)

  Adds some basic stats of the world to the given crash report.

### destroyBlockInWorldPartially

    public void destroyBlockInWorldPartially(int par1,
                                             int par2,
                                             int par3,
                                             int par4,
                                             int par5)

  Starts (or continues) destroying a block with given ID at the given coordinates for the given partially destroyed value

### getWorldVec3Pool

    public Vec3Pool getWorldVec3Pool()

  Return the Vec3Pool object for this world.

  Specified by:
    `getWorldVec3Pool` in interface `IBlockAccess`

### getCurrentDate

    public Calendar getCurrentDate()

  returns a calendar object containing the current date

### addTileEntity

    public void addTileEntity(TileEntity entity)

  Adds a single TileEntity to the world.

  Parameters:
    `entity` - The TileEntity to be added.

### isBlockSolidOnSide

    public boolean isBlockSolidOnSide(int X,
                                      int Y,
                                      int Z,
                                      ForgeDirection side)

  Determine if the given block is considered solid on the specified side. Used by placement logic.

  Parameters:
    `X` - Block X Position
    `Y` - Block Y Position
    `Z` - Block Z Position
    `side` - The Side in question
  Returns:
    True if the side is solid

### isBlockSolidOnSide

    public boolean isBlockSolidOnSide(int X,
                                      int Y,
                                      int Z,
                                      ForgeDirection side,
                                      boolean _default)

  Determine if the given block is considered solid on the specified side. Used by placement logic.

  Parameters:
    `X` - Block X Position
    `Y` - Block Y Position
    `Z` - Block Z Position
    `side` - The Side in question
    `_default` - The defult to return if the block doesn't exist.
  Returns:
    True if the side is solid

### getPersistentChunks

    public com.google.common.collect.ImmutableSetMultimap<ChunkCoordIntPair,ForgeChunkManager.Ticket> getPersistentChunks()

  Get the persistent chunks for this world

  Returns:

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD