Package org.bukkit

Interface World

All Superinterfaces:

Metadatable, PluginMessageRecipient

public interface World
extends PluginMessageRecipient, Metadatable

Represents a world, which may contain entities, chunks and blocks

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static interface	World.ChunkLoadCallback	Deprecated. Use either the Future or the Consumer based methods
static class	World.Environment	Represents various map environment types that a world may be
static class	World.Spigot

Method Summary

Modifier and Type	Method	Description
boolean	canGenerateStructures()	Gets whether or not structures are being generated.
boolean	createExplosion(double x, double y, double z, float power)	Creates explosion at given coordinates with given power
boolean	createExplosion(double x, double y, double z, float power, boolean setFire)	Creates explosion at given coordinates with given power and optionally setting blocks on fire.
boolean	createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks)	Creates explosion at given coordinates with given power and optionally setting blocks on fire or breaking blocks.
default boolean	createExplosion(Entity source, float power)	Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source.
default boolean	createExplosion(Entity source, float power, boolean setFire)	Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source.
default boolean	createExplosion(Entity source, float power, boolean setFire, boolean breakBlocks)	Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source.
default boolean	createExplosion(Entity source, Location loc, float power)	Creates explosion at given location with given power, with the specified entity as the source.
default boolean	createExplosion(Entity source, Location loc, float power, boolean setFire)	Creates explosion at given location with given power and optionally setting blocks on fire, with the specified entity as the source.
boolean	createExplosion(Entity source, Location loc, float power, boolean setFire, boolean breakBlocks)	Creates explosion at given location with given power and optionally setting blocks on fire, with the specified entity as the source.
boolean	createExplosion(Location loc, float power)	Creates explosion at given coordinates with given power
boolean	createExplosion(Location loc, float power, boolean setFire)	Creates explosion at given coordinates with given power and optionally setting blocks on fire.
default boolean	createExplosion(Location loc, float power, boolean setFire, boolean breakBlocks)	Creates explosion at given location with given power and optionally setting blocks on fire or breaking blocks.
Item	dropItem(Location location, ItemStack item)	Drops an item at the specified Location
Item	dropItemNaturally(Location location, ItemStack item)	Drops an item at the specified Location with a random offset
boolean	generateTree(Location location, TreeType type)	Creates a tree at the given Location
boolean	generateTree(Location loc, TreeType type, BlockChangeDelegate delegate)	Creates a tree at the given Location
boolean	getAllowAnimals()	Gets whether animals can spawn in this world.
boolean	getAllowMonsters()	Gets whether monsters can spawn in this world.
int	getAmbientSpawnLimit()	Gets the limit for number of ambient mobs that can spawn in a chunk in this world
int	getAnimalSpawnLimit()	Gets the limit for number of animals that can spawn in a chunk in this world
Biome	getBiome(int x, int z)	Gets the biome for the given block coordinates.
Block	getBlockAt(int x, int y, int z)	Gets the Block at the given coordinates
Block	getBlockAt(Location location)	Gets the Block at the given Location
default Block	getBlockAtKey(long key)	Gets the Block at the given block key
Chunk	getChunkAt(int x, int z)	Gets the Chunk at the given coordinates
default Chunk	getChunkAt(long chunkKey)	Gets the chunk at the specified chunk key, which is the X and Z packed into a long.
Chunk	getChunkAt(Block block)	Gets the Chunk that contains the given Block
Chunk	getChunkAt(Location location)	Gets the Chunk at the given Location
default CompletableFuture<Chunk>	getChunkAtAsync(int x, int z)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
CompletableFuture<Chunk>	getChunkAtAsync(int x, int z, boolean gen)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(int x, int z, boolean gen, Consumer<Chunk> cb)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(int x, int z, Consumer<Chunk> cb)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(int x, int z, World.ChunkLoadCallback cb)	Deprecated. Use either the Future or the Consumer based methods
default CompletableFuture<Chunk>	getChunkAtAsync(Block block)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default CompletableFuture<Chunk>	getChunkAtAsync(Block block, boolean gen)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Block block, boolean gen, Consumer<Chunk> cb)	Requests Chunk to be loaded that contains the given Block This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Block block, Consumer<Chunk> cb)	Requests Chunk to be loaded that contains the given Block This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Block block, World.ChunkLoadCallback cb)	Deprecated. Use either the Future or the Consumer based methods
default CompletableFuture<Chunk>	getChunkAtAsync(Location loc)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default CompletableFuture<Chunk>	getChunkAtAsync(Location loc, boolean gen)	Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Location loc, boolean gen, Consumer<Chunk> cb)	Requests a Chunk to be loaded at the given Location This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Location loc, Consumer<Chunk> cb)	Requests a Chunk to be loaded at the given Location This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time.
default void	getChunkAtAsync(Location loc, World.ChunkLoadCallback cb)	Deprecated. Use either the Future or the Consumer based methods
int	getChunkCount()
Difficulty	getDifficulty()	Gets the Difficulty of the world.
ChunkSnapshot	getEmptyChunkSnapshot(int x, int z, boolean includeBiome, boolean includeBiomeTemp)	Get empty chunk snapshot (equivalent to all air blocks), optionally including valid biome data.
List<Entity>	getEntities()	Get a list of all entities in this World
<T extends Entity> Collection<T>	getEntitiesByClass(Class<T> cls)	Get a collection of all entities in this World matching the given class/interface
<T extends Entity> Collection<T>	getEntitiesByClass(Class<T>... classes)	Deprecated.
Collection<Entity>	getEntitiesByClasses(Class<?>... classes)	Get a collection of all entities in this World matching any of the given classes/interfaces
Entity	getEntity(UUID uuid)	Gets an entity in this world by its UUID
int	getEntityCount()
World.Environment	getEnvironment()	Gets the World.Environment type of this world
Collection<Chunk>	getForceLoadedChunks()	Returns all force loaded chunks in this world.
long	getFullTime()	Gets the full in-game time on this world
<T> T	getGameRuleDefault(GameRule<T> rule)	Get the default value for a given GameRule.
String[]	getGameRules()	Get an array containing the names of all the GameRules.
String	getGameRuleValue(String rule)	Deprecated. use getGameRuleValue(GameRule) instead
<T> T	getGameRuleValue(GameRule<T> rule)	Get the current value for a given GameRule.
ChunkGenerator	getGenerator()	Gets the chunk generator for this world
Block	getHighestBlockAt(int x, int z)	Gets the lowest block at the given coordinates such that the block and all blocks above it are transparent for lighting purposes.
default Block	getHighestBlockAt(int x, int z, HeightmapType heightmap)	Returns the highest Block at the specified block coordinates that match the specified heightmap's conditions.
Block	getHighestBlockAt(Location location)	Gets the lowest block at the given Location such that the block and all blocks above it are transparent for lighting purposes.
default Block	getHighestBlockAt(Location location, HeightmapType heightmap)	Returns the highest Block at the specified block coordinates that match the specified heightmap's conditions.
int	getHighestBlockYAt(int x, int z)	Gets the y coordinate of the lowest block at this position such that the block and all blocks above it are transparent for lighting purposes.
int	getHighestBlockYAt(int x, int z, HeightmapType heightmap)	Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions.
int	getHighestBlockYAt(Location location)	Gets the y coordinate of the lowest block at the given Location such that the block and all blocks above it are transparent for lighting purposes.
default int	getHighestBlockYAt(Location location, HeightmapType heightmap)	Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions.
double	getHumidity(int x, int z)	Gets the humidity for the given block coordinates.
boolean	getKeepSpawnInMemory()	Gets whether the world's spawn area should be kept loaded into memory or not.
List<LivingEntity>	getLivingEntities()	Get a list of all living entities in this World
Chunk[]	getLoadedChunks()	Gets an array of all loaded Chunks
default Location	getLocationAtKey(long key)	Gets the Location at the given block key
int	getMaxHeight()	Gets the maximum height of this world.
int	getMonsterSpawnLimit()	Gets limit for number of monsters that can spawn in a chunk in this world
String	getName()	Gets the unique name of this world
Collection<Entity>	getNearbyEntities(Location location, double x, double y, double z)	Returns a list of entities within a bounding box centered around a Location.
Collection<Entity>	getNearbyEntities(Location location, double x, double y, double z, Predicate<Entity> filter)	Returns a list of entities within a bounding box centered around a Location.
Collection<Entity>	getNearbyEntities(BoundingBox boundingBox)	Returns a list of entities within the given bounding box.
Collection<Entity>	getNearbyEntities(BoundingBox boundingBox, Predicate<Entity> filter)	Returns a list of entities within the given bounding box.
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends Entity> clazz, Location loc, double xRadius, double yRadius, double zRadius, Predicate<T> predicate)	Gets all nearby entities of the specified type, within the specified radius (bounding box)
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends T> clazz, Location loc, double radius)	Gets all nearby entities of the specified type, within the specified radius (bounding box)
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends T> clazz, Location loc, double xzRadius, double yRadius)	Gets all nearby entities of the specified type, within the specified radius, with x and x radius matching (bounding box)
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends T> clazz, Location loc, double xRadius, double yRadius, double zRadius)	Gets all nearby entities of the specified type, within the specified radius (bounding box)
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends T> clazz, Location loc, double xzRadius, double yRadius, Predicate<T> predicate)	Gets all nearby entities of the specified type, within the specified radius, with x and x radius matching (bounding box)
default <T extends Entity> Collection<T>	getNearbyEntitiesByType(Class<? extends T> clazz, Location loc, double radius, Predicate<T> predicate)	Gets all nearby entities of the specified type, within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double radius)	Gets nearby players within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double xzRadius, double yRadius)	Gets nearby players within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double xRadius, double yRadius, double zRadius)	Gets nearby players within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double xRadius, double yRadius, double zRadius, Predicate<LivingEntity> predicate)	Gets nearby players within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double xzRadius, double yRadius, Predicate<LivingEntity> predicate)	Gets nearby players within the specified radius (bounding box)
default Collection<LivingEntity>	getNearbyLivingEntities(Location loc, double radius, Predicate<LivingEntity> predicate)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double radius)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double xzRadius, double yRadius)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double xRadius, double yRadius, double zRadius)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double xRadius, double yRadius, double zRadius, Predicate<Player> predicate)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double xzRadius, double yRadius, Predicate<Player> predicate)	Gets nearby players within the specified radius (bounding box)
default Collection<Player>	getNearbyPlayers(Location loc, double radius, Predicate<Player> predicate)	Gets nearby players within the specified radius (bounding box)
int	getPlayerCount()
List<Player>	getPlayers()	Get a list of all players in this World
List<BlockPopulator>	getPopulators()	Gets a list of all applied BlockPopulators for this World
boolean	getPVP()	Gets the current PVP setting for this world.
int	getSeaLevel()	Gets the sea level for this world.
long	getSeed()	Gets the Seed for this world.
Location	getSpawnLocation()	Gets the default spawn Location of this world
double	getTemperature(int x, int z)	Gets the temperature for the given block coordinates.
int	getThunderDuration()	Get the thundering duration.
int	getTickableTileEntityCount()
long	getTicksPerAnimalSpawns()	Gets the world's ticks per animal spawns value
long	getTicksPerMonsterSpawns()	Gets the world's ticks per monster spawns value
int	getTileEntityCount()
long	getTime()	Gets the relative in-game time of this world.
UUID	getUID()	Gets the Unique ID of this world
int	getWaterAnimalSpawnLimit()	Gets the limit for number of water animals that can spawn in a chunk in this world
int	getWeatherDuration()	Get the remaining time in ticks of the current conditions.
WorldBorder	getWorldBorder()	Gets the world border for this world.
File	getWorldFolder()	Gets the folder of this world on disk.
WorldType	getWorldType()	Gets the type of this world.
boolean	hasStorm()	Returns whether the world has an ongoing storm.
boolean	isAutoSave()	Gets whether or not the world will automatically save
boolean	isChunkForceLoaded(int x, int z)	Gets whether the chunk at the specified chunk coordinates is force loaded.
boolean	isChunkGenerated(int x, int z)	Checks if the Chunk at the specified coordinates is generated
default boolean	isChunkGenerated(long chunkKey)	Checks if a Chunk has been generated at the specified chunk key, which is the X and Z packed into a long.
boolean	isChunkInUse(int x, int z)	Checks if the Chunk at the specified coordinates is loaded and in use by one or more players
boolean	isChunkLoaded(int x, int z)	Checks if the Chunk at the specified coordinates is loaded
boolean	isChunkLoaded(Chunk chunk)	Checks if the specified Chunk is loaded
boolean	isDayTime()	Check if it is currently daytime in this world
boolean	isGameRule(String rule)	Checks if string is a valid game rule
boolean	isThundering()	Returns whether there is thunder.
void	loadChunk(int x, int z)	Loads the Chunk at the specified coordinates
boolean	loadChunk(int x, int z, boolean generate)	Loads the Chunk at the specified coordinates
void	loadChunk(Chunk chunk)	Loads the specified Chunk
Location	locateNearestStructure(Location origin, StructureType structureType, int radius, boolean findUnexplored)	Find the closest nearby structure of a given StructureType.
void	playEffect(Location location, Effect effect, int data)	Plays an effect to all players within a default radius around a given location.
void	playEffect(Location location, Effect effect, int data, int radius)	Plays an effect to all players within a given radius around a location.
<T> void	playEffect(Location location, Effect effect, T data)	Plays an effect to all players within a default radius around a given location.
<T> void	playEffect(Location location, Effect effect, T data, int radius)	Plays an effect to all players within a given radius around a location.
void	playSound(Location location, String sound, float volume, float pitch)	Play a Sound at the provided Location in the World.
void	playSound(Location location, String sound, SoundCategory category, float volume, float pitch)	Play a Sound at the provided Location in the World.
void	playSound(Location location, Sound sound, float volume, float pitch)	Play a Sound at the provided Location in the World
void	playSound(Location location, Sound sound, SoundCategory category, float volume, float pitch)	Play a Sound at the provided Location in the World.
RayTraceResult	rayTrace(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks, double raySize, Predicate<Entity> filter)	Performs a ray trace that checks for both block and entity collisions.
RayTraceResult	rayTraceBlocks(Location start, Vector direction, double maxDistance)	Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.
RayTraceResult	rayTraceBlocks(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode)	Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.
RayTraceResult	rayTraceBlocks(Location start, Vector direction, double maxDistance, FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks)	Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.
RayTraceResult	rayTraceEntities(Location start, Vector direction, double maxDistance)	Performs a ray trace that checks for entity collisions.
RayTraceResult	rayTraceEntities(Location start, Vector direction, double maxDistance, double raySize)	Performs a ray trace that checks for entity collisions.
RayTraceResult	rayTraceEntities(Location start, Vector direction, double maxDistance, double raySize, Predicate<Entity> filter)	Performs a ray trace that checks for entity collisions.
RayTraceResult	rayTraceEntities(Location start, Vector direction, double maxDistance, Predicate<Entity> filter)	Performs a ray trace that checks for entity collisions.
boolean	refreshChunk(int x, int z)	Deprecated. This method is not guaranteed to work suitably across all client implementations.
boolean	regenerateChunk(int x, int z)	Deprecated. regenerating a single chunk is not likely to produce the same chunk as before as terrain decoration may be spread across chunks.
void	save()	Saves world to disk
void	setAmbientSpawnLimit(int limit)	Sets the limit for number of ambient mobs that can spawn in a chunk in this world
void	setAnimalSpawnLimit(int limit)	Sets the limit for number of animals that can spawn in a chunk in this world
void	setAutoSave(boolean value)	Sets whether or not the world will automatically save
void	setBiome(int x, int z, Biome bio)	Sets the biome for the given block coordinates
void	setChunkForceLoaded(int x, int z, boolean forced)	Sets whether the chunk at the specified chunk coordinates is force loaded.
void	setDifficulty(Difficulty difficulty)	Sets the Difficulty of the world.
void	setFullTime(long time)	Sets the in-game time on the server
<T> boolean	setGameRule(GameRule<T> rule, T newValue)	Set the given GameRule's new value.
boolean	setGameRuleValue(String rule, String value)	Deprecated. use setGameRule(GameRule, Object) instead.
void	setKeepSpawnInMemory(boolean keepLoaded)	Sets whether the world's spawn area should be kept loaded into memory or not.
void	setMonsterSpawnLimit(int limit)	Sets the limit for number of monsters that can spawn in a chunk in this world
void	setPVP(boolean pvp)	Sets the PVP setting for this world.
void	setSpawnFlags(boolean allowMonsters, boolean allowAnimals)	Sets the spawn flags for this.
boolean	setSpawnLocation(int x, int y, int z)	Sets the spawn location of the world
boolean	setSpawnLocation(Location location)	Sets the spawn location of the world.
void	setStorm(boolean hasStorm)	Set whether there is a storm.
void	setThunderDuration(int duration)	Set the thundering duration.
void	setThundering(boolean thundering)	Set whether it is thundering.
void	setTicksPerAnimalSpawns(int ticksPerAnimalSpawns)	Sets the world's ticks per animal spawns value
void	setTicksPerMonsterSpawns(int ticksPerMonsterSpawns)	Sets the world's ticks per monster spawns value
void	setTime(long time)	Sets the relative in-game time on the server.
void	setWaterAnimalSpawnLimit(int limit)	Sets the limit for number of water animals that can spawn in a chunk in this world
void	setWeatherDuration(int duration)	Set the remaining time in ticks of the current conditions.
<T extends Entity> T	spawn(Location location, Class<T> clazz)	Spawn an entity of a specific class at the given Location
<T extends Entity> T	spawn(Location location, Class<T> clazz, Consumer<T> function)	Spawn an entity of a specific class at the given Location, with the supplied function run before the entity is added to the world.
Arrow	spawnArrow(Location location, Vector direction, float speed, float spread)	Creates an Arrow entity at the given Location
<T extends Arrow> T	spawnArrow(Location location, Vector direction, float speed, float spread, Class<T> clazz)	Creates an arrow entity of the given class at the given Location
Entity	spawnEntity(Location loc, EntityType type)	Creates a entity at the given Location
FallingBlock	spawnFallingBlock(Location location, BlockData data)	Spawn a FallingBlock entity at the given Location of the specified Material.
FallingBlock	spawnFallingBlock(Location location, MaterialData data)	Spawn a FallingBlock entity at the given Location of the specified Material.
FallingBlock	spawnFallingBlock(Location location, Material material, byte data)	Deprecated. Magic value
void	spawnParticle(Particle particle, double x, double y, double z, int count)	Spawns the particle (the number of times specified by count) at the target location.
void	spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ)	Spawns the particle (the number of times specified by count) at the target location.
void	spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra)	Spawns the particle (the number of times specified by count) at the target location.
default <T> void	spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, T data)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, double x, double y, double z, int count, T data)	Spawns the particle (the number of times specified by count) at the target location.
default <T> void	spawnParticle(Particle particle, List<Player> receivers, Player source, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, List<Player> receivers, Player source, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force)	Spawns the particle (the number of times specified by count) at the target location.
void	spawnParticle(Particle particle, Location location, int count)	Spawns the particle (the number of times specified by count) at the target location.
void	spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ)	Spawns the particle (the number of times specified by count) at the target location.
void	spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra, T data)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, Location location, int count, double offsetX, double offsetY, double offsetZ, T data)	Spawns the particle (the number of times specified by count) at the target location.
<T> void	spawnParticle(Particle particle, Location location, int count, T data)	Spawns the particle (the number of times specified by count) at the target location.
World.Spigot	spigot()
LightningStrike	strikeLightning(Location loc)	Strikes lightning at the given Location
LightningStrike	strikeLightningEffect(Location loc)	Strikes lightning at the given Location without doing damage
boolean	unloadChunk(int x, int z)	Safely unloads and saves the Chunk at the specified coordinates
boolean	unloadChunk(int x, int z, boolean save)	Safely unloads and optionally saves the Chunk at the specified coordinates
boolean	unloadChunk(int x, int z, boolean save, boolean safe)	Deprecated. it is never safe to remove a chunk in use
boolean	unloadChunk(Chunk chunk)	Safely unloads and saves the Chunk at the specified coordinates
boolean	unloadChunkRequest(int x, int z)	Safely queues the Chunk at the specified coordinates for unloading
boolean	unloadChunkRequest(int x, int z, boolean safe)	Deprecated. it is never safe to remove a chunk in use

Methods inherited from interface org.bukkit.metadata.Metadatable

getMetadata, hasMetadata, removeMetadata, setMetadata

Methods inherited from interface org.bukkit.plugin.messaging.PluginMessageRecipient

getListeningPluginChannels, sendPluginMessage

Method Detail

getEntityCount

int getEntityCount()

Returns:

The amount of Entities in this world

getTileEntityCount

int getTileEntityCount()

Returns:

The amount of Tile Entities in this world

getTickableTileEntityCount

int getTickableTileEntityCount()

Returns:

The amount of Tickable Tile Entities in this world

getChunkCount

int getChunkCount()

Returns:

The amount of Chunks in this world

getPlayerCount

int getPlayerCount()

Returns:

The amount of Players in this world

getBlockAt

@NotNull
Block getBlockAt(int x,
                 int y,
                 int z)

Gets the Block at the given coordinates

Parameters:

x - X-coordinate of the block

y - Y-coordinate of the block

z - Z-coordinate of the block

Returns:

Block at the given coordinates

getBlockAt

@NotNull
Block getBlockAt(@NotNull
                 Location location)

Gets the Block at the given Location

Parameters:

location - Location of the block

Returns:

Block at the given location

getBlockAtKey

@NotNull
default Block getBlockAtKey(long key)

Gets the Block at the given block key

Parameters:

key - The block key. See Block.getBlockKey()

Returns:

Block at the key

See Also:

Block.getBlockKey(int, int, int)

getLocationAtKey

@NotNull
default Location getLocationAtKey(long key)

Gets the Location at the given block key

Parameters:

key - The block key. See Location.toBlockKey()

Returns:

Location at the key

See Also:

Block.getBlockKey(int, int, int)

getHighestBlockYAt

int getHighestBlockYAt(int x,
                       int z)

Gets the y coordinate of the lowest block at this position such that the block and all blocks above it are transparent for lighting purposes.

Parameters:

x - X-coordinate of the blocks

z - Z-coordinate of the blocks

Returns:

Y-coordinate of the described block

getHighestBlockYAt

int getHighestBlockYAt(@NotNull
                       Location location)

Gets the y coordinate of the lowest block at the given Location such that the block and all blocks above it are transparent for lighting purposes.

Parameters:

location - Location of the blocks

Returns:

Y-coordinate of the highest non-air block

getHighestBlockAt

@NotNull
Block getHighestBlockAt(int x,
                        int z)

Gets the lowest block at the given coordinates such that the block and all blocks above it are transparent for lighting purposes.

Parameters:

x - X-coordinate of the block

z - Z-coordinate of the block

Returns:

Highest non-empty block

getHighestBlockAt

@NotNull
Block getHighestBlockAt(@NotNull
                        Location location)

Gets the lowest block at the given Location such that the block and all blocks above it are transparent for lighting purposes.

Parameters:

location - Coordinates to get the highest block

Returns:

Highest non-empty block

getHighestBlockYAt

int getHighestBlockYAt(int x,
                       int z,
                       @NotNull
                       HeightmapType heightmap)
                throws UnsupportedOperationException

Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions.

implNote: Implementations are recommended to use an iterative search as a fallback before resorting to throwing an UnsupportedOperationException.

Parameters:

x - The block's x-coordinate.

z - The block's z-coordinate.

heightmap - The specified heightmap to use. See HeightmapType

Returns:

The highest block's y-coordinate at (x, z) that matches the specified heightmap's conditions.

Throws:

UnsupportedOperationException - If the heightmap type is not supported.

See Also:

HeightmapType

getHighestBlockYAt

default int getHighestBlockYAt(@NotNull
                               Location location,
                               @NotNull
                               HeightmapType heightmap)
                        throws UnsupportedOperationException

Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions. Note that the y-coordinate of the specified location is ignored.

implNote: Implementations are recommended to use an iterative search as a fallback before resorting to throwing an UnsupportedOperationException.

Parameters:

location - The specified block coordinates.

heightmap - The specified heightmap to use. See HeightmapType

Returns:

The highest block's y-coordinate at location that matches the specified heightmap's conditions.

Throws:

UnsupportedOperationException - If the heightmap type is not supported.

See Also:

HeightmapType

getHighestBlockAt

@NotNull
default Block getHighestBlockAt(int x,
                                int z,
                                @NotNull
                                HeightmapType heightmap)
                         throws UnsupportedOperationException

Returns the highest Block at the specified block coordinates that match the specified heightmap's conditions.

implNote: Implementations are recommended to use an iterative search as a fallback before resorting to throwing an UnsupportedOperationException.

Parameters:

x - The block's x-coordinate.

z - The block's z-coordinate.

heightmap - The specified heightmap to use. See HeightmapType

Returns:

The highest Block at (x, z) that matches the specified heightmap's conditions.

Throws:

UnsupportedOperationException - If the heightmap type is not supported.

See Also:

HeightmapType

getHighestBlockAt

@NotNull
default Block getHighestBlockAt(@NotNull
                                Location location,
                                @NotNull
                                HeightmapType heightmap)
                         throws UnsupportedOperationException

Returns the highest Block at the specified block coordinates that match the specified heightmap's conditions. Note that the y-coordinate of the specified location is ignored.

implNote: Implementations are recommended to use an iterative search as a fallback before resorting to throwing an UnsupportedOperationException.

Parameters:

location - The specified block coordinates.

heightmap - The specified heightmap to use. See HeightmapType

Returns:

The highest Block at location that matches the specified heightmap's conditions.

Throws:

UnsupportedOperationException - If the heightmap type is not supported.

See Also:

HeightmapType

getChunkAt

@NotNull
Chunk getChunkAt(int x,
                 int z)

Gets the Chunk at the given coordinates

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

Chunk at the given coordinates

getChunkAt

@NotNull
Chunk getChunkAt(@NotNull
                 Location location)

Gets the Chunk at the given Location

Parameters:

location - Location of the chunk

Returns:

Chunk at the given location

getChunkAt

@NotNull
Chunk getChunkAt(@NotNull
                 Block block)

Gets the Chunk that contains the given Block

Parameters:

block - Block to get the containing chunk from

Returns:

The chunk that contains the given block

getChunkAt

@NotNull
default Chunk getChunkAt(long chunkKey)

Gets the chunk at the specified chunk key, which is the X and Z packed into a long. See Chunk.getChunkKey() for easy access to the key, or you may calculate it as: long chunkKey = (long) chunkX & 0xffffffffL | ((long) chunkZ & 0xffffffffL) >> 32;

Parameters:

chunkKey - The Chunk Key to look up the chunk by

Returns:

The chunk at the specified key

isChunkGenerated

default boolean isChunkGenerated(long chunkKey)

Checks if a Chunk has been generated at the specified chunk key, which is the X and Z packed into a long.

Parameters:

chunkKey - The Chunk Key to look up the chunk by

Returns:

true if the chunk has been generated, otherwise false

getChunkAtAsync

@Deprecated
default void getChunkAtAsync(int x,
                             int z,
                             @NotNull
                             World.ChunkLoadCallback cb)

Deprecated.

Use either the Future or the Consumer based methods

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The World.ChunkLoadCallback will always be executed synchronously on the main Server Thread.

Parameters:

x - Chunk X-coordinate of the chunk - (world coordinate / 16)

z - Chunk Z-coordinate of the chunk - (world coordinate / 16)

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

@Deprecated
default void getChunkAtAsync(@NotNull
                             Location loc,
                             @NotNull
                             World.ChunkLoadCallback cb)

Deprecated.

Use either the Future or the Consumer based methods

Requests a Chunk to be loaded at the given Location This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The World.ChunkLoadCallback will always be executed synchronously on the main Server Thread.

Parameters:

loc - Location of the chunk

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

@Deprecated
default void getChunkAtAsync(@NotNull
                             Block block,
                             @NotNull
                             World.ChunkLoadCallback cb)

Deprecated.

Use either the Future or the Consumer based methods

Requests Chunk to be loaded that contains the given Block This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The World.ChunkLoadCallback will always be executed synchronously on the main Server Thread.

Parameters:

block - Block to get the containing chunk from

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(int x,
                             int z,
                             @NotNull
                             Consumer<Chunk> cb)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

x - Chunk X-coordinate of the chunk - (world coordinate / 16)

z - Chunk Z-coordinate of the chunk - (world coordinate / 16)

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(int x,
                             int z,
                             boolean gen,
                             @NotNull
                             Consumer<Chunk> cb)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

x - Chunk X-coordinate of the chunk - (world coordinate / 16)

z - Chunk Z-coordinate of the chunk - (world coordinate / 16)

gen - Should we generate a chunk if it doesn't exists or not

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(@NotNull
                             Location loc,
                             @NotNull
                             Consumer<Chunk> cb)

Requests a Chunk to be loaded at the given Location This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

loc - Location of the chunk

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(@NotNull
                             Location loc,
                             boolean gen,
                             @NotNull
                             Consumer<Chunk> cb)

Requests a Chunk to be loaded at the given Location This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

loc - Location of the chunk

gen - Should the chunk generate

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(@NotNull
                             Block block,
                             @NotNull
                             Consumer<Chunk> cb)

Requests Chunk to be loaded that contains the given Block This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

block - Block to get the containing chunk from

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

default void getChunkAtAsync(@NotNull
                             Block block,
                             boolean gen,
                             @NotNull
                             Consumer<Chunk> cb)

Requests Chunk to be loaded that contains the given Block This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The Consumer will always be executed synchronously on the main Server Thread.

Parameters:

block - Block to get the containing chunk from

gen - Should the chunk generate

cb - Callback to receive the chunk when it is loaded. will be executed synchronously

getChunkAtAsync

@NotNull
default CompletableFuture<Chunk> getChunkAtAsync(@NotNull
                                                 Location loc)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

loc - Location to load the corresponding chunk from

Returns:

Future that will resolve when the chunk is loaded

getChunkAtAsync

@NotNull
default CompletableFuture<Chunk> getChunkAtAsync(@NotNull
                                                 Location loc,
                                                 boolean gen)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

loc - Location to load the corresponding chunk from

gen - Should the chunk generate

Returns:

Future that will resolve when the chunk is loaded

getChunkAtAsync

@NotNull
default CompletableFuture<Chunk> getChunkAtAsync(@NotNull
                                                 Block block)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

block - Block to load the corresponding chunk from

Returns:

Future that will resolve when the chunk is loaded

getChunkAtAsync

@NotNull
default CompletableFuture<Chunk> getChunkAtAsync(@NotNull
                                                 Block block,
                                                 boolean gen)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

block - Block to load the corresponding chunk from

gen - Should the chunk generate

Returns:

Future that will resolve when the chunk is loaded

getChunkAtAsync

@NotNull
default CompletableFuture<Chunk> getChunkAtAsync(int x,
                                                 int z)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

x - X Coord

z - Z Coord

Returns:

Future that will resolve when the chunk is loaded

getChunkAtAsync

@NotNull
CompletableFuture<Chunk> getChunkAtAsync(int x,
                                         int z,
                                         boolean gen)

Requests a Chunk to be loaded at the given coordinates This method makes no guarantee on how fast the chunk will load, and will return the chunk to the callback at a later time. You should use this method if you need a chunk but do not need it immediately, and you wish to let the server control the speed of chunk loads, keeping performance in mind. The future will always be executed synchronously on the main Server Thread.

Parameters:

x - Chunk X-coordinate of the chunk - (world coordinate / 16)

z - Chunk Z-coordinate of the chunk - (world coordinate / 16)

gen - Should we generate a chunk if it doesn't exists or not

Returns:

Future that will resolve when the chunk is loaded

isChunkLoaded

boolean isChunkLoaded(@NotNull
                      Chunk chunk)

Checks if the specified Chunk is loaded

Parameters:

chunk - The chunk to check

Returns:

true if the chunk is loaded, otherwise false

getLoadedChunks

@NotNull
Chunk[] getLoadedChunks()

Gets an array of all loaded Chunks

Returns:

Chunk[] containing all loaded chunks

loadChunk

void loadChunk(@NotNull
               Chunk chunk)

Loads the specified Chunk

Parameters:

chunk - The chunk to load

isChunkLoaded

boolean isChunkLoaded(int x,
                      int z)

Checks if the Chunk at the specified coordinates is loaded

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

true if the chunk is loaded, otherwise false

isChunkGenerated

boolean isChunkGenerated(int x,
                         int z)

Checks if the Chunk at the specified coordinates is generated

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

true if the chunk is generated, otherwise false

isChunkInUse

boolean isChunkInUse(int x,
                     int z)

Checks if the Chunk at the specified coordinates is loaded and in use by one or more players

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

true if the chunk is loaded and in use by one or more players, otherwise false

loadChunk

void loadChunk(int x,
               int z)

Loads the Chunk at the specified coordinates

If the chunk does not exist, it will be generated.

This method is analogous to loadChunk(int, int, boolean) where generate is true.

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

loadChunk

boolean loadChunk(int x,
                  int z,
                  boolean generate)

Loads the Chunk at the specified coordinates

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

generate - Whether or not to generate a chunk if it doesn't already exist

Returns:

true if the chunk has loaded successfully, otherwise false

unloadChunk

boolean unloadChunk(@NotNull
                    Chunk chunk)

Safely unloads and saves the Chunk at the specified coordinates

This method is analogous to unloadChunk(int, int, boolean, boolean) where safe and save is true

Parameters:

chunk - the chunk to unload

Returns:

true if the chunk has unloaded successfully, otherwise false

unloadChunk

boolean unloadChunk(int x,
                    int z)

Safely unloads and saves the Chunk at the specified coordinates

This method is analogous to unloadChunk(int, int, boolean, boolean) where safe and saveis true

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

true if the chunk has unloaded successfully, otherwise false

unloadChunk

boolean unloadChunk(int x,
                    int z,
                    boolean save)

Safely unloads and optionally saves the Chunk at the specified coordinates

This method is analogous to unloadChunk(int, int, boolean, boolean) where save is true

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

save - Whether or not to save the chunk

Returns:

true if the chunk has unloaded successfully, otherwise false

unloadChunk

@Deprecated
boolean unloadChunk(int x,
                    int z,
                    boolean save,
                    boolean safe)

Deprecated.

it is never safe to remove a chunk in use

Unloads and optionally saves the Chunk at the specified coordinates

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

save - Controls whether the chunk is saved

safe - Controls whether to unload the chunk when players are nearby

Returns:

true if the chunk has unloaded successfully, otherwise false

unloadChunkRequest

boolean unloadChunkRequest(int x,
                           int z)

Safely queues the Chunk at the specified coordinates for unloading

This method is analogous to unloadChunkRequest(int, int, boolean) where safe is true

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

true is the queue attempt was successful, otherwise false

unloadChunkRequest

@Deprecated
boolean unloadChunkRequest(int x,
                           int z,
                           boolean safe)

Deprecated.

it is never safe to remove a chunk in use

Queues the Chunk at the specified coordinates for unloading

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

safe - Controls whether to queue the chunk when players are nearby

Returns:

Whether the chunk was actually queued

regenerateChunk

@Deprecated
boolean regenerateChunk(int x,
                        int z)

Deprecated.

regenerating a single chunk is not likely to produce the same chunk as before as terrain decoration may be spread across chunks. Use of this method should be avoided as it is known to produce buggy results.

Regenerates the Chunk at the specified coordinates

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

Whether the chunk was actually regenerated

refreshChunk

@Deprecated
boolean refreshChunk(int x,
                     int z)

Deprecated.

This method is not guaranteed to work suitably across all client implementations.

Resends the Chunk to all clients

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

Whether the chunk was actually refreshed

isChunkForceLoaded

boolean isChunkForceLoaded(int x,
                           int z)

Gets whether the chunk at the specified chunk coordinates is force loaded.

A force loaded chunk will not be unloaded due to lack of player activity.

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

Returns:

force load status

setChunkForceLoaded

void setChunkForceLoaded(int x,
                         int z,
                         boolean forced)

Sets whether the chunk at the specified chunk coordinates is force loaded.

A force loaded chunk will not be unloaded due to lack of player activity.

Parameters:

x - X-coordinate of the chunk

z - Z-coordinate of the chunk

forced -

getForceLoadedChunks

@NotNull
Collection<Chunk> getForceLoadedChunks()

Returns all force loaded chunks in this world.

A force loaded chunk will not be unloaded due to lack of player activity.

Returns:

unmodifiable collection of force loaded chunks

dropItem

@NotNull
Item dropItem(@NotNull
              Location location,
              @NotNull
              ItemStack item)

Drops an item at the specified Location

Parameters:

location - Location to drop the item

item - ItemStack to drop

Returns:

ItemDrop entity created as a result of this method

dropItemNaturally

@NotNull
Item dropItemNaturally(@NotNull
                       Location location,
                       @NotNull
                       ItemStack item)

Drops an item at the specified Location with a random offset

Parameters:

location - Location to drop the item

item - ItemStack to drop

Returns:

ItemDrop entity created as a result of this method

spawnArrow

@NotNull
Arrow spawnArrow(@NotNull
                 Location location,
                 @NotNull
                 Vector direction,
                 float speed,
                 float spread)

Creates an Arrow entity at the given Location

Parameters:

location - Location to spawn the arrow

direction - Direction to shoot the arrow in

speed - Speed of the arrow. A recommend speed is 0.6

spread - Spread of the arrow. A recommend spread is 12

Returns:

Arrow entity spawned as a result of this method

spawnArrow

@NotNull
<T extends Arrow> T spawnArrow(@NotNull
                               Location location,
                               @NotNull
                               Vector direction,
                               float speed,
                               float spread,
                               @NotNull
                               Class<T> clazz)

Creates an arrow entity of the given class at the given Location

Type Parameters:

T - type of arrow to spawn

Parameters:

location - Location to spawn the arrow

direction - Direction to shoot the arrow in

speed - Speed of the arrow. A recommend speed is 0.6

spread - Spread of the arrow. A recommend spread is 12

clazz - the Entity class for the arrow SpectralArrow,Arrow,TippedArrow

Returns:

Arrow entity spawned as a result of this method

generateTree

boolean generateTree(@NotNull
                     Location location,
                     @NotNull
                     TreeType type)

Creates a tree at the given Location

Parameters:

location - Location to spawn the tree

type - Type of the tree to create

Returns:

true if the tree was created successfully, otherwise false

generateTree

boolean generateTree(@NotNull
                     Location loc,
                     @NotNull
                     TreeType type,
                     @NotNull
                     BlockChangeDelegate delegate)

Creates a tree at the given Location

Parameters:

loc - Location to spawn the tree

type - Type of the tree to create

delegate - A class to call for each block changed as a result of this method

Returns:

true if the tree was created successfully, otherwise false

spawnEntity

@NotNull
Entity spawnEntity(@NotNull
                   Location loc,
                   @NotNull
                   EntityType type)

Creates a entity at the given Location

Parameters:

loc - The location to spawn the entity

type - The entity to spawn

Returns:

Resulting Entity of this method, or null if it was unsuccessful

strikeLightning

@NotNull
LightningStrike strikeLightning(@NotNull
                                Location loc)

Strikes lightning at the given Location

Parameters:

loc - The location to strike lightning

Returns:

The lightning entity.

strikeLightningEffect

@NotNull
LightningStrike strikeLightningEffect(@NotNull
                                      Location loc)

Strikes lightning at the given Location without doing damage

Parameters:

loc - The location to strike lightning

Returns:

The lightning entity.

getEntities

@NotNull
List<Entity> getEntities()

Get a list of all entities in this World

Returns:

A List of all Entities currently residing in this world

getLivingEntities

@NotNull
List<LivingEntity> getLivingEntities()

Get a list of all living entities in this World

Returns:

A List of all LivingEntities currently residing in this world

getEntitiesByClass

@Deprecated
@NotNull
<T extends Entity> Collection<T> getEntitiesByClass(@NotNull
                                                    Class<T>... classes)

Deprecated.

Get a collection of all entities in this World matching the given class/interface

Type Parameters:

T - an entity subclass

Parameters:

classes - The classes representing the types of entity to match

Returns:

A List of all Entities currently residing in this world that match the given class/interface

getEntitiesByClass

@NotNull
<T extends Entity> Collection<T> getEntitiesByClass(@NotNull
                                                    Class<T> cls)

Get a collection of all entities in this World matching the given class/interface

Type Parameters:

T - an entity subclass

Parameters:

cls - The class representing the type of entity to match

Returns:

A List of all Entities currently residing in this world that match the given class/interface

getEntitiesByClasses

@NotNull
Collection<Entity> getEntitiesByClasses(@NotNull
                                        Class<?>... classes)

Get a collection of all entities in this World matching any of the given classes/interfaces

Parameters:

classes - The classes representing the types of entity to match

Returns:

A List of all Entities currently residing in this world that match one or more of the given classes/interfaces

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double radius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

radius - Radius

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double xzRadius,
                                                         double yRadius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xzRadius - X/Z Radius

yRadius - Y Radius

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double xRadius,
                                                         double yRadius,
                                                         double zRadius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z radius

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double radius,
                                                         @Nullable
                                                         Predicate<LivingEntity> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

radius - X Radius

predicate - a predicate used to filter results

Returns:

the collection of living entities near location. This will always be a non-null collection

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double xzRadius,
                                                         double yRadius,
                                                         @Nullable
                                                         Predicate<LivingEntity> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xzRadius - X/Z Radius

yRadius - Y Radius

predicate - a predicate used to filter results

Returns:

the collection of living entities near location. This will always be a non-null collection

getNearbyLivingEntities

@NotNull
default Collection<LivingEntity> getNearbyLivingEntities(@NotNull
                                                         Location loc,
                                                         double xRadius,
                                                         double yRadius,
                                                         double zRadius,
                                                         @Nullable
                                                         Predicate<LivingEntity> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z radius

predicate - a predicate used to filter results

Returns:

the collection of living entities near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double radius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

radius - X/Y/Z Radius

Returns:

the collection of living entities near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double xzRadius,
                                            double yRadius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xzRadius - X/Z Radius

yRadius - Y Radius

Returns:

the collection of living entities near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double xRadius,
                                            double yRadius,
                                            double zRadius)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z Radius

Returns:

the collection of players near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double radius,
                                            @Nullable
                                            Predicate<Player> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

radius - X/Y/Z Radius

predicate - a predicate used to filter results

Returns:

the collection of players near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double xzRadius,
                                            double yRadius,
                                            @Nullable
                                            Predicate<Player> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xzRadius - X/Z Radius

yRadius - Y Radius

predicate - a predicate used to filter results

Returns:

the collection of players near location. This will always be a non-null collection.

getNearbyPlayers

@NotNull
default Collection<Player> getNearbyPlayers(@NotNull
                                            Location loc,
                                            double xRadius,
                                            double yRadius,
                                            double zRadius,
                                            @Nullable
                                            Predicate<Player> predicate)

Gets nearby players within the specified radius (bounding box)

Parameters:

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z Radius

predicate - a predicate used to filter results

Returns:

the collection of players near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends T> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double radius)

Gets all nearby entities of the specified type, within the specified radius (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

radius - X/Y/Z radius to search within

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends T> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double xzRadius,
                                                                 double yRadius)

Gets all nearby entities of the specified type, within the specified radius, with x and x radius matching (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

xzRadius - X/Z radius to search within

yRadius - Y radius to search within

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends T> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double xRadius,
                                                                 double yRadius,
                                                                 double zRadius)

Gets all nearby entities of the specified type, within the specified radius (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z Radius

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends T> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double radius,
                                                                 @Nullable
                                                                 Predicate<T> predicate)

Gets all nearby entities of the specified type, within the specified radius (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

radius - X/Y/Z radius to search within

predicate - a predicate used to filter results

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends T> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double xzRadius,
                                                                 double yRadius,
                                                                 @Nullable
                                                                 Predicate<T> predicate)

Gets all nearby entities of the specified type, within the specified radius, with x and x radius matching (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

xzRadius - X/Z radius to search within

yRadius - Y radius to search within

predicate - a predicate used to filter results

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntitiesByType

@NotNull
default <T extends Entity> Collection<T> getNearbyEntitiesByType(@Nullable
                                                                 Class<? extends Entity> clazz,
                                                                 @NotNull
                                                                 Location loc,
                                                                 double xRadius,
                                                                 double yRadius,
                                                                 double zRadius,
                                                                 @Nullable
                                                                 Predicate<T> predicate)

Gets all nearby entities of the specified type, within the specified radius (bounding box)

Type Parameters:

T - the entity type

Parameters:

clazz - Type to filter by

loc - Center location

xRadius - X Radius

yRadius - Y Radius

zRadius - Z Radius

predicate - a predicate used to filter results

Returns:

the collection of entities near location. This will always be a non-null collection.

getPlayers

@NotNull
List<Player> getPlayers()

Get a list of all players in this World

Returns:

A list of all Players currently residing in this world

getNearbyEntities

@NotNull
Collection<Entity> getNearbyEntities(@NotNull
                                     Location location,
                                     double x,
                                     double y,
                                     double z)

Returns a list of entities within a bounding box centered around a Location.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the size of the search bounding box.

Parameters:

location - The center of the bounding box

x - 1/2 the size of the box along x axis

y - 1/2 the size of the box along y axis

z - 1/2 the size of the box along z axis

Returns:

the collection of entities near location. This will always be a non-null collection.

getEntity

@Nullable
Entity getEntity(@NotNull
                 UUID uuid)

Gets an entity in this world by its UUID

Parameters:

uuid - the UUID of the entity

Returns:

the entity with the given UUID, or null if it isn't found

getNearbyEntities

@NotNull
Collection<Entity> getNearbyEntities(@NotNull
                                     Location location,
                                     double x,
                                     double y,
                                     double z,
                                     @Nullable
                                     Predicate<Entity> filter)

Returns a list of entities within a bounding box centered around a Location.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the size of the search bounding box.

Parameters:

location - The center of the bounding box

x - 1/2 the size of the box along x axis

y - 1/2 the size of the box along y axis

z - 1/2 the size of the box along z axis

filter - only entities that fulfill this predicate are considered, or null to consider all entities

Returns:

the collection of entities near location. This will always be a non-null collection.

getNearbyEntities

@NotNull
Collection<Entity> getNearbyEntities(@NotNull
                                     BoundingBox boundingBox)

Returns a list of entities within the given bounding box.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the size of the search bounding box.

Parameters:

boundingBox - the bounding box

Returns:

the collection of entities within the bounding box, will always be a non-null collection

getNearbyEntities

@NotNull
Collection<Entity> getNearbyEntities(@NotNull
                                     BoundingBox boundingBox,
                                     @Nullable
                                     Predicate<Entity> filter)

Returns a list of entities within the given bounding box.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the size of the search bounding box.

Parameters:

boundingBox - the bounding box

filter - only entities that fulfill this predicate are considered, or null to consider all entities

Returns:

the collection of entities within the bounding box, will always be a non-null collection

rayTraceEntities

@Nullable
RayTraceResult rayTraceEntities(@NotNull
                                Location start,
                                @NotNull
                                Vector direction,
                                double maxDistance)

Performs a ray trace that checks for entity collisions.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start position

direction - the ray direction

maxDistance - the maximum distance

Returns:

the closest ray trace hit result, or null if there is no hit

See Also:

rayTraceEntities(Location, Vector, double, double, Predicate)

rayTraceEntities

@Nullable
RayTraceResult rayTraceEntities(@NotNull
                                Location start,
                                @NotNull
                                Vector direction,
                                double maxDistance,
                                double raySize)

Performs a ray trace that checks for entity collisions.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start position

direction - the ray direction

maxDistance - the maximum distance

raySize - entity bounding boxes will be uniformly expanded (or shrinked) by this value before doing collision checks

Returns:

the closest ray trace hit result, or null if there is no hit

See Also:

rayTraceEntities(Location, Vector, double, double, Predicate)

rayTraceEntities

@Nullable
RayTraceResult rayTraceEntities(@NotNull
                                Location start,
                                @NotNull
                                Vector direction,
                                double maxDistance,
                                @Nullable
                                Predicate<Entity> filter)

Performs a ray trace that checks for entity collisions.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start position

direction - the ray direction

maxDistance - the maximum distance

filter - only entities that fulfill this predicate are considered, or null to consider all entities

Returns:

the closest ray trace hit result, or null if there is no hit

See Also:

rayTraceEntities(Location, Vector, double, double, Predicate)

rayTraceEntities

@Nullable
RayTraceResult rayTraceEntities(@NotNull
                                Location start,
                                @NotNull
                                Vector direction,
                                double maxDistance,
                                double raySize,
                                @Nullable
                                Predicate<Entity> filter)

Performs a ray trace that checks for entity collisions.

This may not consider entities in currently unloaded chunks. Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start position

direction - the ray direction

maxDistance - the maximum distance

raySize - entity bounding boxes will be uniformly expanded (or shrinked) by this value before doing collision checks

filter - only entities that fulfill this predicate are considered, or null to consider all entities

Returns:

the closest ray trace hit result, or null if there is no hit

rayTraceBlocks

@Nullable
RayTraceResult rayTraceBlocks(@NotNull
                              Location start,
                              @NotNull
                              Vector direction,
                              double maxDistance)

Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.

This takes collisions with passable blocks into account, but ignores fluids.

This may cause loading of chunks! Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start location

direction - the ray direction

maxDistance - the maximum distance

Returns:

the ray trace hit result, or null if there is no hit

See Also:

rayTraceBlocks(Location, Vector, double, FluidCollisionMode, boolean)

rayTraceBlocks

@Nullable
RayTraceResult rayTraceBlocks(@NotNull
                              Location start,
                              @NotNull
                              Vector direction,
                              double maxDistance,
                              @NotNull
                              FluidCollisionMode fluidCollisionMode)

Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.

This takes collisions with passable blocks into account.

This may cause loading of chunks! Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start location

direction - the ray direction

maxDistance - the maximum distance

fluidCollisionMode - the fluid collision mode

Returns:

the ray trace hit result, or null if there is no hit

See Also:

rayTraceBlocks(Location, Vector, double, FluidCollisionMode, boolean)

rayTraceBlocks

@Nullable
RayTraceResult rayTraceBlocks(@NotNull
                              Location start,
                              @NotNull
                              Vector direction,
                              double maxDistance,
                              @NotNull
                              FluidCollisionMode fluidCollisionMode,
                              boolean ignorePassableBlocks)

Performs a ray trace that checks for block collisions using the blocks' precise collision shapes.

If collisions with passable blocks are ignored, fluid collisions are ignored as well regardless of the fluid collision mode.

Portal blocks are only considered passable if the ray starts within them. Apart from that collisions with portal blocks will be considered even if collisions with passable blocks are otherwise ignored.

This may cause loading of chunks! Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start location

direction - the ray direction

maxDistance - the maximum distance

fluidCollisionMode - the fluid collision mode

ignorePassableBlocks - whether to ignore passable but collidable blocks (ex. tall grass, signs, fluids, ..)

Returns:

the ray trace hit result, or null if there is no hit

rayTrace

@Nullable
RayTraceResult rayTrace(@NotNull
                        Location start,
                        @NotNull
                        Vector direction,
                        double maxDistance,
                        @NotNull
                        FluidCollisionMode fluidCollisionMode,
                        boolean ignorePassableBlocks,
                        double raySize,
                        @Nullable
                        Predicate<Entity> filter)

Performs a ray trace that checks for both block and entity collisions.

Block collisions use the blocks' precise collision shapes. The raySize parameter is only taken into account for entity collision checks.

If collisions with passable blocks are ignored, fluid collisions are ignored as well regardless of the fluid collision mode.

Portal blocks are only considered passable if the ray starts within them. Apart from that collisions with portal blocks will be considered even if collisions with passable blocks are otherwise ignored.

This may cause loading of chunks! Some implementations may impose artificial restrictions on the maximum distance.

Parameters:

start - the start location

direction - the ray direction

maxDistance - the maximum distance

fluidCollisionMode - the fluid collision mode

ignorePassableBlocks - whether to ignore passable but collidable blocks (ex. tall grass, signs, fluids, ..)

raySize - entity bounding boxes will be uniformly expanded (or shrinked) by this value before doing collision checks

filter - only entities that fulfill this predicate are considered, or null to consider all entities

Returns:

the closest ray trace hit result with either a block or an entity, or null if there is no hit

getName

@NotNull
String getName()

Gets the unique name of this world

Returns:

Name of this world

getUID

@NotNull
UUID getUID()

Gets the Unique ID of this world

Returns:

Unique ID of this world.

getSpawnLocation

@NotNull
Location getSpawnLocation()

Gets the default spawn Location of this world

Returns:

The spawn location of this world

setSpawnLocation

@NotNull
boolean setSpawnLocation(@NotNull
                         Location location)

Sets the spawn location of the world.
The location provided must be equal to this world.

Parameters:

location - The Location to set the spawn for this world at.

Returns:

True if it was successfully set.

setSpawnLocation

boolean setSpawnLocation(int x,
                         int y,
                         int z)

Sets the spawn location of the world

Parameters:

x - X coordinate

y - Y coordinate

z - Z coordinate

Returns:

True if it was successfully set.

getTime

long getTime()

Gets the relative in-game time of this world.

The relative time is analogous to hours * 1000

Returns:

The current relative time

See Also:

Returns an absolute time of this world

setTime

void setTime(long time)

Sets the relative in-game time on the server.

The relative time is analogous to hours * 1000

Note that setting the relative time below the current relative time will actually move the clock forward a day. If you require to rewind time, please see setFullTime(long)

Parameters:

time - The new relative time to set the in-game time to (in hours*1000)

See Also:

Sets the absolute time of this world

getFullTime

long getFullTime()

Gets the full in-game time on this world

Returns:

The current absolute time

See Also:

Returns a relative time of this world

setFullTime

void setFullTime(long time)

Sets the in-game time on the server

Note that this sets the full time of the world, which may cause adverse effects such as breaking redstone clocks and any scheduled events

Parameters:

time - The new absolute time to set this world to

See Also:

Sets the relative time of this world

isDayTime

boolean isDayTime()

Check if it is currently daytime in this world

Returns:

True if it is daytime

hasStorm

boolean hasStorm()

Returns whether the world has an ongoing storm.

Returns:

Whether there is an ongoing storm

setStorm

void setStorm(boolean hasStorm)

Set whether there is a storm. A duration will be set for the new current conditions.

Parameters:

hasStorm - Whether there is rain and snow

getWeatherDuration

int getWeatherDuration()

Get the remaining time in ticks of the current conditions.

Returns:

Time in ticks

setWeatherDuration

void setWeatherDuration(int duration)

Set the remaining time in ticks of the current conditions.

Parameters:

duration - Time in ticks

isThundering

boolean isThundering()

Returns whether there is thunder.

Returns:

Whether there is thunder

setThundering

void setThundering(boolean thundering)

Set whether it is thundering.

Parameters:

thundering - Whether it is thundering

getThunderDuration

int getThunderDuration()

Get the thundering duration.

Returns:

Duration in ticks

setThunderDuration

void setThunderDuration(int duration)

Set the thundering duration.

Parameters:

duration - Duration in ticks

createExplosion

boolean createExplosion(double x,
                        double y,
                        double z,
                        float power)

Creates explosion at given coordinates with given power

Parameters:

x - X coordinate

y - Y coordinate

z - Z coordinate

power - The power of explosion, where 4F is TNT

Returns:

false if explosion was canceled, otherwise true

createExplosion

boolean createExplosion(double x,
                        double y,
                        double z,
                        float power,
                        boolean setFire)

Creates explosion at given coordinates with given power and optionally setting blocks on fire.

Parameters:

x - X coordinate

y - Y coordinate

z - Z coordinate

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

Returns:

false if explosion was canceled, otherwise true

createExplosion

boolean createExplosion(double x,
                        double y,
                        double z,
                        float power,
                        boolean setFire,
                        boolean breakBlocks)

Creates explosion at given coordinates with given power and optionally setting blocks on fire or breaking blocks.

Parameters:

x - X coordinate

y - Y coordinate

z - Z coordinate

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

breakBlocks - Whether or not to have blocks be destroyed

Returns:

false if explosion was canceled, otherwise true

createExplosion

boolean createExplosion(@NotNull
                        Location loc,
                        float power)

Creates explosion at given coordinates with given power

Parameters:

loc - Location to blow up

power - The power of explosion, where 4F is TNT

Returns:

false if explosion was canceled, otherwise true

createExplosion

boolean createExplosion(@NotNull
                        Location loc,
                        float power,
                        boolean setFire)

Creates explosion at given coordinates with given power and optionally setting blocks on fire.

Parameters:

loc - Location to blow up

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

Returns:

false if explosion was canceled, otherwise true

createExplosion

boolean createExplosion(@Nullable
                        Entity source,
                        @NotNull
                        Location loc,
                        float power,
                        boolean setFire,
                        boolean breakBlocks)

Creates explosion at given location with given power and optionally setting blocks on fire, with the specified entity as the source.

Parameters:

source - The source entity of the explosion

loc - Location to blow up

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

breakBlocks - Whether or not to have blocks be destroyed

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@Nullable
                                Entity source,
                                @NotNull
                                Location loc,
                                float power,
                                boolean setFire)

Creates explosion at given location with given power and optionally setting blocks on fire, with the specified entity as the source. Will destroy other blocks

Parameters:

source - The source entity of the explosion

loc - Location to blow up

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@Nullable
                                Entity source,
                                @NotNull
                                Location loc,
                                float power)

Creates explosion at given location with given power, with the specified entity as the source. Will set blocks on fire and destroy blocks.

Parameters:

source - The source entity of the explosion

loc - Location to blow up

power - The power of explosion, where 4F is TNT

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@NotNull
                                Entity source,
                                float power,
                                boolean setFire,
                                boolean breakBlocks)

Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source.

Parameters:

source - The source entity of the explosion

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

breakBlocks - Whether or not to have blocks be destroyed

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@NotNull
                                Entity source,
                                float power,
                                boolean setFire)

Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source. Will destroy blocks.

Parameters:

source - The source entity of the explosion

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@NotNull
                                Entity source,
                                float power)

Creates explosion at given entities location with given power and optionally setting blocks on fire, with the specified entity as the source.

Parameters:

source - The source entity of the explosion

power - The power of explosion, where 4F is TNT

Returns:

false if explosion was canceled, otherwise true

createExplosion

default boolean createExplosion(@NotNull
                                Location loc,
                                float power,
                                boolean setFire,
                                boolean breakBlocks)

Creates explosion at given location with given power and optionally setting blocks on fire or breaking blocks.

Parameters:

loc - Location to blow up

power - The power of explosion, where 4F is TNT

setFire - Whether or not to set blocks on fire

breakBlocks - Whether or not to have blocks be destroyed

Returns:

false if explosion was canceled, otherwise true

getEnvironment

@NotNull
World.Environment getEnvironment()

Gets the World.Environment type of this world

Returns:

This worlds Environment type

getSeed

long getSeed()

Gets the Seed for this world.

Returns:

This worlds Seed

getPVP

boolean getPVP()

Gets the current PVP setting for this world.

Returns:

True if PVP is enabled

setPVP

void setPVP(boolean pvp)

Sets the PVP setting for this world.

Parameters:

pvp - True/False whether PVP should be Enabled.

getGenerator

@Nullable
ChunkGenerator getGenerator()

Gets the chunk generator for this world

Returns:

ChunkGenerator associated with this world

save

void save()

Saves world to disk

getPopulators

@NotNull
List<BlockPopulator> getPopulators()

Gets a list of all applied BlockPopulators for this World

Returns:

List containing any or none BlockPopulators

spawn

@NotNull
<T extends Entity> T spawn(@NotNull
                           Location location,
                           @NotNull
                           Class<T> clazz)
                    throws IllegalArgumentException

Spawn an entity of a specific class at the given Location

Type Parameters:

T - the class of the Entity to spawn

Parameters:

location - the Location to spawn the entity at

clazz - the class of the Entity to spawn

Returns:

an instance of the spawned Entity

Throws:

IllegalArgumentException - if either parameter is null or the Entity requested cannot be spawned

spawn

@NotNull
<T extends Entity> T spawn(@NotNull
                           Location location,
                           @NotNull
                           Class<T> clazz,
                           @Nullable
                           Consumer<T> function)
                    throws IllegalArgumentException

Spawn an entity of a specific class at the given Location, with the supplied function run before the entity is added to the world.
Note that when the function is run, the entity will not be actually in the world. Any operation involving such as teleporting the entity is undefined until after this function returns.

Type Parameters:

T - the class of the Entity to spawn

Parameters:

location - the Location to spawn the entity at

clazz - the class of the Entity to spawn

function - the function to be run before the entity is spawned.

Returns:

an instance of the spawned Entity

Throws:

IllegalArgumentException - if either parameter is null or the Entity requested cannot be spawned

spawnFallingBlock

@NotNull
FallingBlock spawnFallingBlock(@NotNull
                               Location location,
                               @NotNull
                               MaterialData data)
                        throws IllegalArgumentException

Spawn a FallingBlock entity at the given Location of the specified Material. The material dictates what is falling. When the FallingBlock hits the ground, it will place that block.

The Material must be a block type, check with material.isBlock(). The Material may not be air.

Parameters:

location - The Location to spawn the FallingBlock

data - The block data

Returns:

The spawned FallingBlock instance

Throws:

IllegalArgumentException - if Location or MaterialData are null or Material of the MaterialData is not a block

spawnFallingBlock

@NotNull
FallingBlock spawnFallingBlock(@NotNull
                               Location location,
                               @NotNull
                               BlockData data)
                        throws IllegalArgumentException

Spawn a FallingBlock entity at the given Location of the specified Material. The material dictates what is falling. When the FallingBlock hits the ground, it will place that block.

The Material must be a block type, check with material.isBlock(). The Material may not be air.

Parameters:

location - The Location to spawn the FallingBlock

data - The block data

Returns:

The spawned FallingBlock instance

Throws:

IllegalArgumentException - if Location or BlockData are null

spawnFallingBlock

@Deprecated
@NotNull
FallingBlock spawnFallingBlock(@NotNull
                               Location location,
                               @NotNull
                               Material material,
                               byte data)
                        throws IllegalArgumentException

Deprecated.

Magic value

Spawn a FallingBlock entity at the given Location of the specified Material. The material dictates what is falling. When the FallingBlock hits the ground, it will place that block.

The Material must be a block type, check with material.isBlock(). The Material may not be air.

Parameters:

location - The Location to spawn the FallingBlock

material - The block Material type

data - The block data

Returns:

The spawned FallingBlock instance

Throws:

IllegalArgumentException - if Location or Material are null or Material is not a block

playEffect

void playEffect(@NotNull
                Location location,
                @NotNull
                Effect effect,
                int data)

Plays an effect to all players within a default radius around a given location.

Parameters:

location - the Location around which players must be to hear the sound

effect - the Effect

data - a data bit needed for some effects

playEffect

void playEffect(@NotNull
                Location location,
                @NotNull
                Effect effect,
                int data,
                int radius)

Plays an effect to all players within a given radius around a location.

Parameters:

location - the Location around which players must be to hear the effect

effect - the Effect

data - a data bit needed for some effects

radius - the radius around the location

playEffect

<T> void playEffect(@NotNull
                    Location location,
                    @NotNull
                    Effect effect,
                    @Nullable
                    T data)

Plays an effect to all players within a default radius around a given location.

Type Parameters:

T - data dependant on the type of effect

Parameters:

location - the Location around which players must be to hear the sound

effect - the Effect

data - a data bit needed for some effects

playEffect

<T> void playEffect(@NotNull
                    Location location,
                    @NotNull
                    Effect effect,
                    @Nullable
                    T data,
                    int radius)

Plays an effect to all players within a given radius around a location.

Type Parameters:

T - data dependant on the type of effect

Parameters:

location - the Location around which players must be to hear the effect

effect - the Effect

data - a data bit needed for some effects

radius - the radius around the location

getEmptyChunkSnapshot

@NotNull
ChunkSnapshot getEmptyChunkSnapshot(int x,
                                    int z,
                                    boolean includeBiome,
                                    boolean includeBiomeTemp)

Get empty chunk snapshot (equivalent to all air blocks), optionally including valid biome data. Used for representing an ungenerated chunk, or for fetching only biome data without loading a chunk.

Parameters:

x - - chunk x coordinate

z - - chunk z coordinate

includeBiome - - if true, snapshot includes per-coordinate biome type

includeBiomeTemp - - if true, snapshot includes per-coordinate raw biome temperature

Returns:

The empty snapshot.

setSpawnFlags

void setSpawnFlags(boolean allowMonsters,
                   boolean allowAnimals)

Sets the spawn flags for this.

Parameters:

allowMonsters - - if true, monsters are allowed to spawn in this world.

allowAnimals - - if true, animals are allowed to spawn in this world.

getAllowAnimals

boolean getAllowAnimals()

Gets whether animals can spawn in this world.

Returns:

whether animals can spawn in this world.

getAllowMonsters

boolean getAllowMonsters()

Gets whether monsters can spawn in this world.

Returns:

whether monsters can spawn in this world.

getBiome

@NotNull
Biome getBiome(int x,
               int z)

Gets the biome for the given block coordinates.

Parameters:

x - X coordinate of the block

z - Z coordinate of the block

Returns:

Biome of the requested block

setBiome

void setBiome(int x,
              int z,
              @NotNull
              Biome bio)

Sets the biome for the given block coordinates

Parameters:

x - X coordinate of the block

z - Z coordinate of the block

bio - new Biome type for this block

getTemperature

double getTemperature(int x,
                      int z)

Gets the temperature for the given block coordinates.

It is safe to run this method when the block does not exist, it will not create the block.

This method will return the raw temperature without adjusting for block height effects.

Parameters:

x - X coordinate of the block

z - Z coordinate of the block

Returns:

Temperature of the requested block

getHumidity

double getHumidity(int x,
                   int z)

Gets the humidity for the given block coordinates.

It is safe to run this method when the block does not exist, it will not create the block.

Parameters:

x - X coordinate of the block

z - Z coordinate of the block

Returns:

Humidity of the requested block

getMaxHeight

int getMaxHeight()

Gets the maximum height of this world.

If the max height is 100, there are only blocks from y=0 to y=99.

Returns:

Maximum height of the world

getSeaLevel

int getSeaLevel()

Gets the sea level for this world.

This is often half of getMaxHeight()

Returns:

Sea level

getKeepSpawnInMemory

boolean getKeepSpawnInMemory()

Gets whether the world's spawn area should be kept loaded into memory or not.

Returns:

true if the world's spawn area will be kept loaded into memory.

setKeepSpawnInMemory

void setKeepSpawnInMemory(boolean keepLoaded)

Sets whether the world's spawn area should be kept loaded into memory or not.

Parameters:

keepLoaded - if true then the world's spawn area will be kept loaded into memory.

isAutoSave

boolean isAutoSave()

Gets whether or not the world will automatically save

Returns:

true if the world will automatically save, otherwise false

setAutoSave

void setAutoSave(boolean value)

Sets whether or not the world will automatically save

Parameters:

value - true if the world should automatically save, otherwise false

setDifficulty

void setDifficulty(@NotNull
                   Difficulty difficulty)

Sets the Difficulty of the world.

Parameters:

difficulty - the new difficulty you want to set the world to

getDifficulty

@NotNull
Difficulty getDifficulty()

Gets the Difficulty of the world.

Returns:

The difficulty of the world.

getWorldFolder

@NotNull
File getWorldFolder()

Gets the folder of this world on disk.

Returns:

The folder of this world.

getWorldType

@Nullable
WorldType getWorldType()

Gets the type of this world.

Returns:

Type of this world.

canGenerateStructures

boolean canGenerateStructures()

Gets whether or not structures are being generated.

Returns:

True if structures are being generated.

getTicksPerAnimalSpawns

long getTicksPerAnimalSpawns()

Gets the world's ticks per animal spawns value

This value determines how many ticks there are between attempts to spawn animals.

Example Usage:

• A value of 1 will mean the server will attempt to spawn animals in this world every tick.
• A value of 400 will mean the server will attempt to spawn animals in this world every 400th tick.
• A value below 0 will be reset back to Minecraft's default.

Note: If set to 0, animal spawning will be disabled for this world. We recommend using setSpawnFlags(boolean, boolean) to control this instead.

Minecraft default: 400.

Returns:

The world's ticks per animal spawns value

setTicksPerAnimalSpawns

void setTicksPerAnimalSpawns(int ticksPerAnimalSpawns)

Sets the world's ticks per animal spawns value

This value determines how many ticks there are between attempts to spawn animals.

Example Usage:

• A value of 1 will mean the server will attempt to spawn animals in this world every tick.
• A value of 400 will mean the server will attempt to spawn animals in this world every 400th tick.
• A value below 0 will be reset back to Minecraft's default.

Note: If set to 0, animal spawning will be disabled for this world. We recommend using setSpawnFlags(boolean, boolean) to control this instead.

Minecraft default: 400.

Parameters:

ticksPerAnimalSpawns - the ticks per animal spawns value you want to set the world to

getTicksPerMonsterSpawns

long getTicksPerMonsterSpawns()

Gets the world's ticks per monster spawns value

This value determines how many ticks there are between attempts to spawn monsters.

Example Usage:

• A value of 1 will mean the server will attempt to spawn monsters in this world every tick.
• A value of 400 will mean the server will attempt to spawn monsters in this world every 400th tick.
• A value below 0 will be reset back to Minecraft's default.

Note: If set to 0, monsters spawning will be disabled for this world. We recommend using setSpawnFlags(boolean, boolean) to control this instead.

Minecraft default: 1.

Returns:

The world's ticks per monster spawns value

setTicksPerMonsterSpawns

void setTicksPerMonsterSpawns(int ticksPerMonsterSpawns)

Sets the world's ticks per monster spawns value

This value determines how many ticks there are between attempts to spawn monsters.

Example Usage:

• A value of 1 will mean the server will attempt to spawn monsters in this world on every tick.
• A value of 400 will mean the server will attempt to spawn monsters in this world every 400th tick.
• A value below 0 will be reset back to Minecraft's default.

Note: If set to 0, monsters spawning will be disabled for this world. We recommend using setSpawnFlags(boolean, boolean) to control this instead.

Minecraft default: 1.

Parameters:

ticksPerMonsterSpawns - the ticks per monster spawns value you want to set the world to

getMonsterSpawnLimit

int getMonsterSpawnLimit()

Gets limit for number of monsters that can spawn in a chunk in this world

Returns:

The monster spawn limit

setMonsterSpawnLimit

void setMonsterSpawnLimit(int limit)

Sets the limit for number of monsters that can spawn in a chunk in this world

Note: If set to a negative number the world will use the server-wide spawn limit instead.

Parameters:

limit - the new mob limit

getAnimalSpawnLimit

int getAnimalSpawnLimit()

Gets the limit for number of animals that can spawn in a chunk in this world

Returns:

The animal spawn limit

setAnimalSpawnLimit

void setAnimalSpawnLimit(int limit)

Sets the limit for number of animals that can spawn in a chunk in this world

Note: If set to a negative number the world will use the server-wide spawn limit instead.

Parameters:

limit - the new mob limit

getWaterAnimalSpawnLimit

int getWaterAnimalSpawnLimit()

Gets the limit for number of water animals that can spawn in a chunk in this world

Returns:

The water animal spawn limit

setWaterAnimalSpawnLimit

void setWaterAnimalSpawnLimit(int limit)

Sets the limit for number of water animals that can spawn in a chunk in this world

Note: If set to a negative number the world will use the server-wide spawn limit instead.

Parameters:

limit - the new mob limit

getAmbientSpawnLimit

int getAmbientSpawnLimit()

Gets the limit for number of ambient mobs that can spawn in a chunk in this world

Returns:

The ambient spawn limit

setAmbientSpawnLimit

void setAmbientSpawnLimit(int limit)

Sets the limit for number of ambient mobs that can spawn in a chunk in this world

Note: If set to a negative number the world will use the server-wide spawn limit instead.

Parameters:

limit - the new mob limit

playSound

void playSound(@NotNull
               Location location,
               @NotNull
               Sound sound,
               float volume,
               float pitch)

Play a Sound at the provided Location in the World

This function will fail silently if Location or Sound are null.

Parameters:

location - The location to play the sound

sound - The sound to play

volume - The volume of the sound

pitch - The pitch of the sound

playSound

void playSound(@NotNull
               Location location,
               @NotNull
               String sound,
               float volume,
               float pitch)

Play a Sound at the provided Location in the World.

This function will fail silently if Location or Sound are null. No sound will be heard by the players if their clients do not have the respective sound for the value passed.

Parameters:

location - the location to play the sound

sound - the internal sound name to play

volume - the volume of the sound

pitch - the pitch of the sound

playSound

void playSound(@NotNull
               Location location,
               @NotNull
               Sound sound,
               @NotNull
               SoundCategory category,
               float volume,
               float pitch)

Play a Sound at the provided Location in the World.

This function will fail silently if Location or Sound are null.

Parameters:

location - The location to play the sound

sound - The sound to play

category - the category of the sound

volume - The volume of the sound

pitch - The pitch of the sound

playSound

void playSound(@NotNull
               Location location,
               @NotNull
               String sound,
               @NotNull
               SoundCategory category,
               float volume,
               float pitch)

Play a Sound at the provided Location in the World.

This function will fail silently if Location or Sound are null. No sound will be heard by the players if their clients do not have the respective sound for the value passed.

Parameters:

location - the location to play the sound

sound - the internal sound name to play

category - the category of the sound

volume - the volume of the sound

pitch - the pitch of the sound

getGameRules

@NotNull
String[] getGameRules()

Get an array containing the names of all the GameRules.

Returns:

An array of GameRule names.

getGameRuleValue

@Deprecated
@Contract("null -> null; !null -> !null")
@Nullable
String getGameRuleValue(@Nullable
                        String rule)

Deprecated.

use getGameRuleValue(GameRule) instead

Gets the current state of the specified rule

Will return null if rule passed is null

Parameters:

rule - Rule to look up value of

Returns:

String value of rule

setGameRuleValue

@Deprecated
boolean setGameRuleValue(@NotNull
                         String rule,
                         @NotNull
                         String value)

Deprecated.

use setGameRule(GameRule, Object) instead.

Set the specified gamerule to specified value.

The rule may attempt to validate the value passed, will return true if value was set.

If rule is null, the function will return false.

Parameters:

rule - Rule to set

value - Value to set rule to

Returns:

True if rule was set

isGameRule

boolean isGameRule(@NotNull
                   String rule)

Checks if string is a valid game rule

Parameters:

rule - Rule to check

Returns:

True if rule exists

getGameRuleValue

@Nullable
<T> T getGameRuleValue(@NotNull
                       GameRule<T> rule)

Get the current value for a given GameRule.

Type Parameters:

T - the GameRule's type

Parameters:

rule - the GameRule to check

Returns:

the current value

getGameRuleDefault

@Nullable
<T> T getGameRuleDefault(@NotNull
                         GameRule<T> rule)

Get the default value for a given GameRule. This value is not guaranteed to match the current value.

Type Parameters:

T - the type of GameRule

Parameters:

rule - the rule to return a default value for

Returns:

the default value

setGameRule

<T> boolean setGameRule(@NotNull
                        GameRule<T> rule,
                        @NotNull
                        T newValue)

Set the given GameRule's new value.

Type Parameters:

T - the value type of the GameRule

Parameters:

rule - the GameRule to update

newValue - the new value

Returns:

true if the value was successfully set

getWorldBorder

@NotNull
WorldBorder getWorldBorder()

Gets the world border for this world.

Returns:

The world border for this world.

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   @NotNull
                   Location location,
                   int count)

Spawns the particle (the number of times specified by count) at the target location.

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   double x,
                   double y,
                   double z,
                   int count)

Spawns the particle (the number of times specified by count) at the target location.

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       @NotNull
                       Location location,
                       int count,
                       @Nullable
                       T data)

Spawns the particle (the number of times specified by count) at the target location.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       double x,
                       double y,
                       double z,
                       int count,
                       @Nullable
                       T data)

Spawns the particle (the number of times specified by count) at the target location.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   @NotNull
                   Location location,
                   int count,
                   double offsetX,
                   double offsetY,
                   double offsetZ)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   double x,
                   double y,
                   double z,
                   int count,
                   double offsetX,
                   double offsetY,
                   double offsetZ)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       @NotNull
                       Location location,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       @Nullable
                       T data)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       double x,
                       double y,
                       double z,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       @Nullable
                       T data)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   @NotNull
                   Location location,
                   int count,
                   double offsetX,
                   double offsetY,
                   double offsetZ,
                   double extra)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

spawnParticle

void spawnParticle(@NotNull
                   Particle particle,
                   double x,
                   double y,
                   double z,
                   int count,
                   double offsetX,
                   double offsetY,
                   double offsetZ,
                   double extra)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       @NotNull
                       Location location,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       double extra,
                       @Nullable
                       T data)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

default <T> void spawnParticle(@NotNull
                               Particle particle,
                               double x,
                               double y,
                               double z,
                               int count,
                               double offsetX,
                               double offsetY,
                               double offsetZ,
                               double extra,
                               @Nullable
                               T data)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

default <T> void spawnParticle(@NotNull
                               Particle particle,
                               @Nullable
                               List<Player> receivers,
                               @NotNull
                               Player source,
                               double x,
                               double y,
                               double z,
                               int count,
                               double offsetX,
                               double offsetY,
                               double offsetZ,
                               double extra,
                               @Nullable
                               T data)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

receivers - List of players to receive the particles, or null for all in world

source - Source of the particles to be used in visibility checks, or null if no player source

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       @Nullable
                       List<Player> receivers,
                       @Nullable
                       Player source,
                       double x,
                       double y,
                       double z,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       double extra,
                       @Nullable
                       T data,
                       boolean force)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Type

Parameters:

particle - the particle to spawn

receivers - List of players to receive the particles, or null for all in world

source - Source of the particles to be used in visibility checks, or null if no player source

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

force - allows the particle to be seen further away from the player and shows to players using any vanilla client particle settings

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       @NotNull
                       Location location,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       double extra,
                       @Nullable
                       T data,
                       boolean force)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Particle data type

Parameters:

particle - the particle to spawn

location - the location to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

force - whether to send the particle to players within an extended range and encourage their client to render it regardless of settings

spawnParticle

<T> void spawnParticle(@NotNull
                       Particle particle,
                       double x,
                       double y,
                       double z,
                       int count,
                       double offsetX,
                       double offsetY,
                       double offsetZ,
                       double extra,
                       @Nullable
                       T data,
                       boolean force)

Spawns the particle (the number of times specified by count) at the target location. The position of each particle will be randomized positively and negatively by the offset parameters on each axis.

Type Parameters:

T - Particle data type

Parameters:

particle - the particle to spawn

x - the position on the x axis to spawn at

y - the position on the y axis to spawn at

z - the position on the z axis to spawn at

count - the number of particles

offsetX - the maximum random offset on the X axis

offsetY - the maximum random offset on the Y axis

offsetZ - the maximum random offset on the Z axis

extra - the extra data for this particle, depends on the particle used (normally speed)

data - the data to use for the particle or null, the type of this depends on Particle.getDataType()

force - whether to send the particle to players within an extended range and encourage their client to render it regardless of settings

locateNearestStructure

@Nullable
Location locateNearestStructure(@NotNull
                                Location origin,
                                @NotNull
                                StructureType structureType,
                                int radius,
                                boolean findUnexplored)

Find the closest nearby structure of a given StructureType. Finding unexplored structures can, and will, block if the world is looking in chunks that gave not generated yet. This can lead to the world temporarily freezing while locating an unexplored structure.

The radius is not a rigid square radius. Each structure may alter how many chunks to check for each iteration. Do not assume that only a radius x radius chunk area will be checked. For example, StructureType.WOODLAND_MANSION can potentially check up to 20,000 blocks away (or more) regardless of the radius used.

This will not load or generate chunks. This can also lead to instances where the server can hang if you are only looking for unexplored structures. This is because it will keep looking further and further out in order to find the structure.

Parameters:

origin - where to start looking for a structure

structureType - the type of structure to find

radius - the radius, in chunks, around which to search

findUnexplored - true to only find unexplored structures

Returns:

the closest Location, or null if no structure of the specified type exists.

spigot

@NotNull
World.Spigot spigot()