Package com.sk89q.worldedit.world

Interface World

All Superinterfaces:
Extent, IChunkCache<IChunkGet>, InputExtent, Keyed, OutputExtent, Trimable
All Known Subinterfaces:
SimpleWorld
All Known Implementing Classes:
AbstractWorld, NullWorld, WorldWrapper
public interface World extends Extent, Keyed, IChunkCache<IChunkGet>
Represents a world (dimension).

  • Method Details

    • getName

      String getName()
      Get the name of the world. This will error if world has been unloaded by the server.
      Returns:
      a name for the world

    • getNameUnsafe

      String getNameUnsafe()
      Get the name of the world. If the world referenced has been unloaded, this will still return the name.
      Returns:
      a name for the world
      Since:
      2.2.0

    • getStoragePath

      @Nullable Path getStoragePath()
      Get the folder in which this world is stored. May return null if unknown or if this world is not serialized to disk.
      Returns:
      world storage path

    • getMinY

      int getMinY()
      Get the minimum Y.
      Specified by:
      getMinY in interface Extent
      Returns:
      the minimum Y

    • getMaxY

      int getMaxY()
      Get the maximum Y.
      Specified by:
      getMaxY in interface Extent
      Returns:
      the maximum Y

    • createLiquidMask

      Mask createLiquidMask()
      Create a mask that matches all liquids.

      Implementations should override this so that custom liquids are supported.

      Returns:
      a mask

    • useItem

      boolean useItem(BlockVector3 position, BaseItem item, Direction face)
      Use the given item on the block at the given location on the given side.
      Parameters:
      item - The item
      face - The face
      Returns:
      Whether it succeeded

    • setBlock

      @Deprecated default <B extends BlockStateHolder<B>> boolean setBlock(BlockVector3 position, B block, boolean notifyAndLight) throws WorldEditException
      Deprecated.
      Similar to OutputExtent.setBlock(BlockVector3, BlockStateHolder) but a notifyAndLight parameter indicates whether adjacent blocks should be notified that changes have been made and lighting operations should be executed.

      If it's not possible to skip lighting, or if it's not possible to avoid notifying adjacent blocks, then attempt to meet the specification as best as possible.

      On implementations where the world is not simulated, the notifyAndLight parameter has no effect either way.

      Parameters:
      position - position of the block
      block - block to set
      notifyAndLight - true to to notify and light
      Returns:
      true if the block was successfully set (return value may not be accurate)
      Throws:
      WorldEditException

    • setBlock

      <B extends BlockStateHolder<B>> boolean setBlock(BlockVector3 position, B block, SideEffectSet sideEffects) throws WorldEditException
      Similar to OutputExtent.setBlock(BlockVector3, BlockStateHolder) but a sideEffects parameter indicates which side effects should be applied to the block. This includes block updates, lighting, and others. See SideEffect for a full list.

      Not all implementations support all side effects. Use Platform.getSupportedSideEffects() for a list of supported side effects. Non-supported side effects will be ignored.

      Parameters:
      position - position of the block
      block - block to set
      sideEffects - which side effects to perform
      Returns:
      true if the block was successfully set (return value may not be accurate)
      Throws:
      WorldEditException

    • notifyAndLightBlock

      @Deprecated default boolean notifyAndLightBlock(BlockVector3 position, BlockState previousType) throws WorldEditException
      Deprecated.
      Notifies the simulation that the block at the given location has been changed and it must be re-lighted (and issue other events).
      Parameters:
      position - position of the block
      previousType - the type of the previous block that was there
      Returns:
      true if the block was successfully notified
      Throws:
      WorldEditException

    • applySideEffects

      Set<SideEffect> applySideEffects(BlockVector3 position, BlockState previousType, SideEffectSet sideEffectSet) throws WorldEditException
      Applies a set of side effects on the given block.
      Parameters:
      position - position of the block
      previousType - the type of the previous block that was there
      sideEffectSet - which side effects to perform
      Returns:
      a set of side effects that were applied
      Throws:
      WorldEditException

    • getBlockLightLevel

      default int getBlockLightLevel(BlockVector3 position)
      Get the light level at the given block.
      Parameters:
      position - the position
      Returns:
      the light level (0-15)

    • clearContainerBlockContents

      boolean clearContainerBlockContents(BlockVector3 position)
      Clear a chest's contents.
      Parameters:
      position - the position
      Returns:
      true if the container was cleared

    • dropItem

      void dropItem(Vector3 position, BaseItemStack item, int count)
      Drop an item at the given position.
      Parameters:
      position - the position
      item - the item to drop
      count - the number of individual stacks to drop (number of item entities)

    • dropItem

      void dropItem(Vector3 position, BaseItemStack item)
      Drop one stack of the item at the given position.
      Parameters:
      position - the position
      item - the item to drop
      See Also:

    • simulateBlockMine

      void simulateBlockMine(BlockVector3 position)
      Simulate a block being mined at the given position.
      Parameters:
      position - the position

    • getBlockDrops

      default Collection<BaseItemStack> getBlockDrops(BlockVector3 position)
      Return items that may drop by destroying this block.
      Parameters:
      position - the position
      Returns:
      Block drops

    • canPlaceAt

      default boolean canPlaceAt(BlockVector3 position, BlockState blockState)
      Gets whether the given BlockState can be placed here.
      Parameters:
      position - The position
      blockState - The blockstate
      Returns:
      If it can be placed

    • regenerate

      default boolean regenerate(Region region, EditSession editSession)
      Regenerate an area.
      Parameters:
      region - the region
      editSession - the EditSession
      Returns:
      true if re-generation was successful

    • regenerate

      default boolean regenerate(Region region, Extent extent)
      Regenerate an area.
      Parameters:
      region - the region
      extent - the Extent
      Returns:
      true if re-generation was successful

    • regenerate

      @NonAbstractForCompatibility(delegateName="regenerate", delegateParams={Region.class,EditSession.class}) default boolean regenerate(Region region, Extent extent, RegenOptions options)
      Regenerate an area.
      Parameters:
      region - the region
      extent - the Extent
      options - the regeneration options
      Returns:
      true if regeneration was successful

    • generateTree

      boolean generateTree(TreeGenerator.TreeType type, EditSession editSession, BlockVector3 position) throws MaxChangedBlocksException
      Generate a tree at the given position.
      Parameters:
      type - the tree type
      editSession - the EditSession
      position - the position
      Returns:
      true if generation was successful
      Throws:
      MaxChangedBlocksException - thrown if too many blocks were changed

    • checkLoadedChunk

      void checkLoadedChunk(BlockVector3 position)
      Load the chunk at the given position if it isn't loaded.
      Parameters:
      position - the position

    • fixAfterFastMode

      void fixAfterFastMode(Iterable<BlockVector2> chunks)
      Fix the given chunks after fast mode was used.

      Fast mode makes calls to setBlock(BlockVector3, BlockStateHolder, boolean) with false for the notifyAndLight parameter, which may causes lighting errors to accumulate. Use of this method, if it is implemented by the underlying world, corrects those lighting errors and may trigger block change notifications.

      Parameters:
      chunks - a list of chunk coordinates to fix

    • fixLighting

      void fixLighting(Iterable<BlockVector2> chunks)
      Relight the given chunks if possible.
      Parameters:
      chunks - a list of chunk coordinates to fix

    • playEffect

      boolean playEffect(Vector3 position, int type, int data)
      Play the given effect.
      Parameters:
      position - the position
      type - the effect type
      data - the effect data
      Returns:
      true if the effect was played

    • queueBlockBreakEffect

      boolean queueBlockBreakEffect(Platform server, BlockVector3 position, BlockType blockType, double priority)
      Queue a block break effect.
      Parameters:
      server - the server
      position - the position
      blockType - the block type
      priority - the priority
      Returns:
      true if the effect was played

    • getWeather

      WeatherType getWeather()
      Gets the weather type of the world.
      Returns:
      The weather

    • getRemainingWeatherDuration

      long getRemainingWeatherDuration()
      Gets the remaining weather duration.
      Returns:
      The weather duration

    • setWeather

      void setWeather(WeatherType weatherType)
      Sets the weather type of the world.
      Parameters:
      weatherType - The weather type

    • setWeather

      void setWeather(WeatherType weatherType, long duration)
      Sets the weather type of the world.
      Parameters:
      weatherType - The weather type
      duration - The duration of the weather

    • getSpawnPosition

      BlockVector3 getSpawnPosition()
      Gets the spawn position of this world.
      Returns:
      The spawn position

    • equals

      boolean equals(Object other)
      Overrides:
      equals in class Object

    • hashCode

      int hashCode()
      Overrides:
      hashCode in class Object

    • isWorld

      default boolean isWorld()
      Specified by:
      isWorld in interface Extent

    • getId

      default String getId()
      Description copied from interface: Keyed
      The id of this object in the registry. Must be unique, and lowercase. Certain registries (e.g Namespaced ones) may have additional restrictions.
      Specified by:
      getId in interface Keyed
      Returns:
      an id

    • refreshChunk

      void refreshChunk(int chunkX, int chunkZ)
      Refresh a specific chunk. Note: only 0 is guaranteed to send all tiles / entities Note: Only 65535 is guaranteed to send all blocks

    • get

      IChunkGet get(int x, int z)
      Specified by:
      get in interface IChunkCache<IChunkGet>

    • sendFakeChunk

      void sendFakeChunk(@Nullable Player player, ChunkPacket packet)
      Send a fake chunk to a player.
      Parameters:
      player - may be null to send to everyone
      packet - the chunk packet

    • getBiome

      @Nullable default BiomeType getBiome(BlockVector3 position)
      Description copied from interface: InputExtent
      Get the biome at the given location.

      If there is no biome available, then the ocean biome should be returned.

      As implementation varies per Minecraft version, this may not exactly get this positions biome. On versions prior to 1.15, this will get the entire column. On later versions it will get the 4x4x4 cube's biome.

      Specified by:
      getBiome in interface InputExtent
      Parameters:
      position - the (x, y, z) location to check the biome at
      Returns:
      the biome at the location
      See Also:

    • setBiome

      default boolean setBiome(int x, int y, int z, BiomeType biome)
      Specified by:
      setBiome in interface OutputExtent

    • setBiome

      default boolean setBiome(BlockVector3 position, BiomeType biome)
      Description copied from interface: OutputExtent
      Set the biome.

      As implementation varies per Minecraft version, this may set more than this position's biome. On versions prior to 1.15, this will set the entire column. On later versions it will set the 4x4x4 cube.

      Specified by:
      setBiome in interface OutputExtent
      Parameters:
      position - the (x, y, z) location to set the biome at
      biome - the biome to set to
      Returns:
      true if the biome was successfully set (return value may not be accurate)

    • flush

      void flush()