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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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 for client worlds, and false for server worlds.
    `int` | `lastLightningBolt` Set to 2 whenever a lightning bolt is generated in SSP.
    `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.
    `float` | `prevRainingStrength`
    `float` | `prevThunderingStrength`
    `WorldProvider` | `provider` The WorldProvider instance that World uses.
    `float` | `rainingStrength`
    `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`
    `float` | `thunderingStrength`
    `VillageCollection` | `villageCollectionObj`
    `List` | `weatherEffects` a list of all the lightning entities

  - ### Constructor Summary

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

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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
    `int` | `blockGetRenderType(int par1, int par2, int par3)` Returns the render type of the block at the given coordinate.
    `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)`
    `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)`
    `boolean` | `func_85174_u(int par1, int par2, int par3)`
    `void` | `func_92088_a(double par1, double par3, double par5, double par7, double par9, double par11, NBTTagCompound par13NBTTagCompound)`
    `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)`
    `float` | `getSunBrightness(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, boolean par10)` 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.
    `void` | `playSoundToNearExcept(EntityPlayer par1EntityPlayer, String par2Str, float par3, float par4)` Plays sound to all near players except the player reference given
    `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` | `releaseEntitySkin(Entity par1Entity)` Decrement the reference counter for this entity's skin image data
    `void` | `removeBlockTileEntity(int par1, int par2, int par3)` Removes the TileEntity for a given block in X,Y,Z coordinates
    `void` | `removeEntity(Entity par1Entity)` Schedule the entity for removal during the next tick.
    `void` | `removePlayerEntityDangerously(Entity par1Entity)` Do NOT use this method to remove normal entities- use normal removeEntity
    `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` | `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

    - #### prevRainingStrength

          public float prevRainingStrength

    - #### rainingStrength

          public float rainingStrength

    - #### prevThunderingStrength

          public float prevThunderingStrength

    - #### thunderingStrength

          public float thunderingStrength

    - #### lastLightningBolt

          public int lastLightningBolt

      Set to 2 whenever a lightning bolt is generated in SSP. Decrements if > 0 in updateWeather(). Value appears to be unused.

    - #### 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 for client worlds, and false for server worlds.

  - ### 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.

    - #### blockGetRenderType

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

      Returns the render type of the block at the given coordinate.

    - #### 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).

    - #### playSoundToNearExcept

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

      Plays sound to all near players except the player reference given

    - #### 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,
                       boolean par10)

      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

    - #### releaseEntitySkin

          public void releaseEntitySkin(Entity par1Entity)

      Decrement the reference counter for this entity's skin image data

    - #### removeEntity

          public void removeEntity(Entity par1Entity)

      Schedule the entity for removal during the next tick. Marks the entity dead in anticipation.

    - #### removePlayerEntityDangerously

          public void removePlayerEntityDangerously(Entity par1Entity)

      Do NOT use this method to remove normal entities- use normal removeEntity

    - #### 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)

    - #### getSunBrightness

          public float getSunBrightness(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

    - #### func_92088_a

          public void func_92088_a(double par1,
                          double par3,
                          double par5,
                          double par7,
                          double par9,
                          double par11,
                          NBTTagCompound par13NBTTagCompound)

    - #### 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: