Package net.minecraftforge.common.extensions

Interface IForgeBlockState

  • All Known Implementing Classes:
    BlockState
    public interface IForgeBlockState

    • Method Detail

      • getBlockState

        default BlockState getBlockState()

      • getSlipperiness

        default float getSlipperiness​(IWorldReader world,
                              BlockPos pos,
                              @Nullable
                              Entity entity)
        Gets the slipperiness at the given location at the given state. Normally between 0 and 1.

        Note that entities may reduce slipperiness by a certain factor of their own; for LivingEntity, this is .91. ItemEntity uses .98, and FishingBobberEntity uses .92.

        Parameters:
        world - the world
        pos - the position in the world
        entity - the entity in question
        Returns:
        the factor by which the entity's motion should be multiplied

      • getLightValue

        default int getLightValue​(IBlockReader world,
                          BlockPos pos)
        Get a light value for this block, taking into account the given state and coordinates, normal ranges are between 0 and 15

      • isLadder

        default boolean isLadder​(IWorldReader world,
                         BlockPos pos,
                         LivingEntity entity)
        Checks if a player or entity can use this block to 'climb' like a ladder.
        Parameters:
        world - The current world
        pos - Block position in world
        entity - The entity trying to use the ladder, CAN be null.
        Returns:
        True if the block should act like a ladder

      • hasTileEntity

        default boolean hasTileEntity()
        Called throughout the code as a replacement for block instanceof BlockContainer Moving this to the Block base class allows for mods that wish to extend vanilla blocks, and also want to have a tile entity on that block, may. Return true from this function to specify this block has a tile entity.
        Returns:
        True if block has a tile entity, false otherwise

      • createTileEntity

        @Nullable
default TileEntity createTileEntity​(IBlockReader world)
        Called throughout the code as a replacement for ITileEntityProvider.createNewTileEntity Return the same thing you would from that function. This will fall back to ITileEntityProvider.createNewTileEntity(World) if this block is a ITileEntityProvider
        Parameters:
        world - The world to create the TE in
        Returns:
        A instance of a class extending TileEntity

      • canHarvestBlock

        default boolean canHarvestBlock​(IBlockReader world,
                                BlockPos pos,
                                PlayerEntity player)
        Determines if the player can harvest this block, obtaining it's drops when the block is destroyed.
        Parameters:
        world - The current world
        pos - The block's current position
        player - The player damaging the block
        Returns:
        True to spawn the drops

      • removedByPlayer

        default boolean removedByPlayer​(World world,
                                BlockPos pos,
                                PlayerEntity player,
                                boolean willHarvest,
                                FluidState fluid)
        Called when a player removes a block. This is responsible for actually destroying the block, and the block is intact at time of call. This is called regardless of whether the player can harvest the block or not. Return true if the block is actually destroyed. Note: When used in multiplayer, this is called on both client and server sides!
        Parameters:
        world - The current world
        player - The player damaging the block, may be null
        pos - Block position in world
        willHarvest - True if Block.harvestBlock will be called after this, if the return in true. Can be useful to delay the destruction of tile entities till after harvestBlock
        fluid - The current fluid and block state for the position in the world.
        Returns:
        True if the block is actually destroyed.

      • isBed

        default boolean isBed​(IBlockReader world,
                      BlockPos pos,
                      @Nullable
                      LivingEntity sleeper)
        Determines if this block is classified as a Bed, Allowing players to sleep in it, though the block has to specifically perform the sleeping functionality in it's activated event.
        Parameters:
        world - The current world
        pos - Block position in world
        sleeper - The sleeper or camera entity, null in some cases.
        Returns:
        True to treat this as a bed

      • canCreatureSpawn

        default boolean canCreatureSpawn​(IWorldReader world,
                                 BlockPos pos,
                                 EntitySpawnPlacementRegistry.PlacementType type,
                                 EntityType<?> entityType)
        Determines if a specified mob type can spawn on this block, returning false will prevent any mob from spawning on the block.
        Parameters:
        world - The current world
        pos - Block position in world
        type - The Mob Category Type
        Returns:
        True to allow a mob of the specified category to spawn, false to prevent it.

      • getRespawnPosition

        default java.util.Optional<Vector3d> getRespawnPosition​(EntityType<?> type,
                                                        IWorldReader world,
                                                        BlockPos pos,
                                                        float orientation,
                                                        @Nullable
                                                        LivingEntity entity)
        Returns the position that the entity is moved to upon respawning at this block.
        Parameters:
        world - The current world
        pos - Block position in world
        orientation - The angle the entity had when setting the respawn point
        entity - The entity respawning, often null
        Returns:
        The spawn position or the empty optional if respawning here is not possible

      • setBedOccupied

        default void setBedOccupied​(World world,
                            BlockPos pos,
                            LivingEntity sleeper,
                            boolean occupied)
        Called when a user either starts or stops sleeping in the bed.
        Parameters:
        world - The current world
        pos - Block position in world
        sleeper - The sleeper or camera entity, null in some cases.
        occupied - True if we are occupying the bed, or false if they are stopping use of the bed

      • getBedDirection

        default Direction getBedDirection​(IWorldReader world,
                                  BlockPos pos)
        Returns the direction of the block. Same values that are returned by BlockDirectional
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        Bed direction

      • isAir

        @Deprecated
default boolean isAir​(IBlockReader world,
                      BlockPos pos)
        Deprecated.
        TODO: Remove in 1.17, in favor of state only version. This is a old hook from before block states were unlimited and people used TileEntities. If you still use the location information in your TileEntity please explain why and how you can't use BlockState only version here: https://github.com/MinecraftForge/MinecraftForge/issues/7409
        Determines this block should be treated as an air block by the rest of the code. This method is primarily useful for creating pure logic-blocks that will be invisible to the player and otherwise interact as air would.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        True if the block considered air

      • canBeReplacedByLeaves

        default boolean canBeReplacedByLeaves​(IWorldReader world,
                                      BlockPos pos)
        Used during tree growth to determine if newly generated leaves can replace this block.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        true if this block can be replaced by growing leaves.

      • canBeReplacedByLogs

        default boolean canBeReplacedByLogs​(IWorldReader world,
                                    BlockPos pos)
        Used during tree growth to determine if newly generated logs can replace this block.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        true if this block can be replaced by growing leaves.

      • getExplosionResistance

        default float getExplosionResistance​(IBlockReader world,
                                     BlockPos pos,
                                     Explosion explosion)
        Location sensitive version of getExplosionResistance
        Parameters:
        world - The current world
        pos - Block position in world
        explosion - The explosion
        Returns:
        The amount of the explosion absorbed.

      • canConnectRedstone

        default boolean canConnectRedstone​(IBlockReader world,
                                   BlockPos pos,
                                   @Nullable
                                   Direction side)
        Determine if this block can make a redstone connection on the side provided, Useful to control which sides are inputs and outputs for redstone wires.
        Parameters:
        world - The current world
        pos - Block position in world
        side - The side that is trying to make the connection, CAN BE NULL
        Returns:
        True to make the connection

      • getPickBlock

        default ItemStack getPickBlock​(RayTraceResult target,
                               IBlockReader world,
                               BlockPos pos,
                               PlayerEntity player)
        Called when A user uses the creative pick block button on this block
        Parameters:
        target - The full target the player is looking at
        Returns:
        A ItemStack to add to the player's inventory, empty itemstack if nothing should be added.

      • addLandingEffects

        default boolean addLandingEffects​(ServerWorld worldserver,
                                  BlockPos pos,
                                  BlockState state2,
                                  LivingEntity entity,
                                  int numberOfParticles)
        Allows a block to override the standard EntityLivingBase.updateFallState particles, this is a server side method that spawns particles with WorldServer.spawnParticle.
        Parameters:
        worldserver - The current Server World
        pos - The position of the block.
        state2 - The state at the specific world/pos
        entity - The entity that hit landed on the block
        numberOfParticles - That vanilla world have spawned
        Returns:
        True to prevent vanilla landing particles from spawning

      • addRunningEffects

        default boolean addRunningEffects​(World world,
                                  BlockPos pos,
                                  Entity entity)
        Allows a block to override the standard vanilla running particles. This is called from Entity#handleRunningEffect and is called both, Client and server side, it's up to the implementor to client check / server check. By default vanilla spawns particles only on the client and the server methods no-op.
        Parameters:
        world - The world.
        pos - The position at the entities feet.
        entity - The entity running on the block.
        Returns:
        True to prevent vanilla running particles from spawning.

      • addHitEffects

        default boolean addHitEffects​(World world,
                              RayTraceResult target,
                              ParticleManager manager)
        Spawn a digging particle effect in the world, this is a wrapper around EffectRenderer.addBlockHitEffects to allow the block more control over the particles. Useful when you have entirely different texture sheets for different sides/locations in the world.
        Parameters:
        world - The current world
        target - The target the player is looking at {x/y/z/side/sub}
        manager - A reference to the current particle manager.
        Returns:
        True to prevent vanilla digging particles form spawning.

      • addDestroyEffects

        default boolean addDestroyEffects​(World world,
                                  BlockPos pos,
                                  ParticleManager manager)
        Spawn particles for when the block is destroyed. Due to the nature of how this is invoked, the x/y/z locations are not always guaranteed to host your block. So be sure to do proper sanity checks before assuming that the location is this block.
        Parameters:
        world - The current world
        pos - Position to spawn the particle
        manager - A reference to the current particle manager.
        Returns:
        True to prevent vanilla break particles from spawning.

      • canSustainPlant

        default boolean canSustainPlant​(IBlockReader world,
                                BlockPos pos,
                                Direction facing,
                                IPlantable plantable)
        Determines if this block can support the passed in plant, allowing it to be planted and grow. Some examples: Reeds check if its a reed, or if its sand/dirt/grass and adjacent to water Cacti checks if its a cacti, or if its sand Nether types check for soul sand Crops check for tilled soil Caves check if it's a solid surface Plains check if its grass or dirt Water check if its still water
        Parameters:
        world - The current world
        facing - The direction relative to the given position the plant wants to be, typically its UP
        plantable - The plant that wants to check
        Returns:
        True to allow the plant to be planted/stay.

      • isFertile

        default boolean isFertile​(IBlockReader world,
                          BlockPos pos)
        Checks if this soil is fertile, typically this means that growth rates of plants on this soil will be slightly sped up. Only vanilla case is tilledField when it is within range of water.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        True if the soil should be considered fertile.

      • isConduitFrame

        default boolean isConduitFrame​(IWorldReader world,
                               BlockPos pos,
                               BlockPos conduit)
        Determines if this block can be used as the frame of a conduit.
        Parameters:
        world - The current world
        pos - Block position in world
        conduit - Conduit position in world
        Returns:
        True, to support the conduit, and make it active with this block.

      • isPortalFrame

        default boolean isPortalFrame​(IBlockReader world,
                              BlockPos pos)
        Determines if this block can be used as part of a frame of a nether portal.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        True, to support being part of a nether portal frame, false otherwise.

      • getExpDrop

        default int getExpDrop​(IWorldReader world,
                       BlockPos pos,
                       int fortune,
                       int silktouch)
        Gathers how much experience this block drops when broken.
        Parameters:
        world - The world
        pos - Block position
        fortune -
        Returns:
        Amount of XP from breaking this block.

      • getEnchantPowerBonus

        default float getEnchantPowerBonus​(IWorldReader world,
                                   BlockPos pos)
        Determines the amount of enchanting power this block can provide to an enchanting table.
        Parameters:
        world - The World
        pos - Block position in world
        Returns:
        The amount of enchanting power this block produces.

      • onNeighborChange

        default void onNeighborChange​(IWorldReader world,
                              BlockPos pos,
                              BlockPos neighbor)
        Called when a tile entity on a side of this block changes is created or is destroyed.
        Parameters:
        world - The world
        pos - Block position in world
        neighbor - Block position of neighbor

      • observedNeighborChange

        @Deprecated
default void observedNeighborChange​(World world,
                                    BlockPos pos,
                                    Block changed,
                                    BlockPos changedPos)
        Deprecated.
        Called on an Observer block whenever an update for an Observer is received.
        Parameters:
        world - The current world.
        pos - The Observer block's position.
        changed - The updated block.
        changedPos - The updated block's position.

      • shouldCheckWeakPower

        default boolean shouldCheckWeakPower​(IWorldReader world,
                                     BlockPos pos,
                                     Direction side)
        Called to determine whether to allow the a block to handle its own indirect power rather than using the default rules.
        Parameters:
        world - The world
        pos - Block position in world
        side - The INPUT side of the block to be powered - ie the opposite of this block's output side
        Returns:
        Whether Block#isProvidingWeakPower should be called when determining indirect power

      • getWeakChanges

        default boolean getWeakChanges​(IWorldReader world,
                               BlockPos pos)
        If this block should be notified of weak changes. Weak changes are changes 1 block away through a solid block. Similar to comparators.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        true To be notified of changes

      • getHarvestTool

        default ToolType getHarvestTool()
        Queries the class of tool required to harvest this block, if null is returned we assume that anything can harvest this block.

      • getHarvestLevel

        default int getHarvestLevel()

      • isToolEffective

        default boolean isToolEffective​(ToolType tool)
        Checks if the specified tool type is efficient on this block, meaning that it digs at full speed.

      • getSoundType

        default SoundType getSoundType​(IWorldReader world,
                               BlockPos pos,
                               @Nullable
                               Entity entity)
        Sensitive version of getSoundType
        Parameters:
        world - The world
        pos - The position. Note that the world may not necessarily have state here!
        entity - The entity that is breaking/stepping on/placing/hitting/falling on this block, or null if no entity is in this context
        Returns:
        A SoundType to use

      • getBeaconColorMultiplier

        @Nullable
default float[] getBeaconColorMultiplier​(IWorldReader world,
                                         BlockPos pos,
                                         BlockPos beacon)
        Parameters:
        world - The world
        pos - The position of this state
        beacon - The position of the beacon
        Returns:
        A float RGB [0.0, 1.0] array to be averaged with a beacon's existing beam color, or null to do nothing to the beam

      • getFogColor

        default Vector3d getFogColor​(IWorldReader world,
                             BlockPos pos,
                             Entity entity,
                             Vector3d originalColor,
                             float partialTicks)
        Use this to change the fog color used when the entity is "inside" a material. Vec3d is used here as "r/g/b" 0 - 1 values.
        Parameters:
        world - The world.
        pos - The position at the entity viewport.
        entity - the entity
        originalColor - The current fog color, You are not expected to use this, Return as the default if applicable.
        Returns:
        The new fog color.

      • getStateAtViewpoint

        default BlockState getStateAtViewpoint​(IBlockReader world,
                                       BlockPos pos,
                                       Vector3d viewpoint)
        Used to determine the state 'viewed' by an entity (see ActiveRenderInfo#getBlockStateAtEntityViewpoint(World, Entity, float)). Can be used by fluid blocks to determine if the viewpoint is within the fluid or not.
        Parameters:
        world - the world
        pos - the position
        viewpoint - the viewpoint
        Returns:
        the block state that should be 'seen'

      • isSlimeBlock

        default boolean isSlimeBlock()
        Returns:
        true if the block is sticky block which used for pull or push adjacent blocks (use by piston)

      • isStickyBlock

        default boolean isStickyBlock()
        Returns:
        true if the block is sticky block which used for pull or push adjacent blocks (use by piston)

      • canStickTo

        default boolean canStickTo​(BlockState other)
        Determines if this block can stick to another block when pushed by a piston.
        Parameters:
        other - Other block
        Returns:
        True to link blocks

      • getFlammability

        default int getFlammability​(IBlockReader world,
                            BlockPos pos,
                            Direction face)
        Chance that fire will spread and consume this block. 300 being a 100% chance, 0, being a 0% chance.
        Parameters:
        world - The current world
        pos - Block position in world
        face - The face that the fire is coming from
        Returns:
        A number ranging from 0 to 300 relating used to determine if the block will be consumed by fire

      • isFlammable

        default boolean isFlammable​(IBlockReader world,
                            BlockPos pos,
                            Direction face)
        Called when fire is updating, checks if a block face can catch fire.
        Parameters:
        world - The current world
        pos - Block position in world
        face - The face that the fire is coming from
        Returns:
        True if the face can be on fire, false otherwise.

      • catchFire

        default void catchFire​(World world,
                       BlockPos pos,
                       @Nullable
                       Direction face,
                       @Nullable
                       LivingEntity igniter)
        If the block is flammable, this is called when it gets lit on fire.
        Parameters:
        world - The current world
        pos - Block position in world
        face - The face that the fire is coming from
        igniter - The entity that lit the fire

      • getFireSpreadSpeed

        default int getFireSpreadSpeed​(IBlockReader world,
                               BlockPos pos,
                               Direction face)
        Called when fire is updating on a neighbor block. The higher the number returned, the faster fire will spread around this block.
        Parameters:
        world - The current world
        pos - Block position in world
        face - The face that the fire is coming from
        Returns:
        A number that is used to determine the speed of fire growth around the block

      • isFireSource

        default boolean isFireSource​(IWorldReader world,
                             BlockPos pos,
                             Direction side)
        Currently only called by fire when it is on top of this block. Returning true will prevent the fire from naturally dying during updating. Also prevents firing from dying from rain.
        Parameters:
        world - The current world
        pos - Block position in world
        side - The face that the fire is coming from
        Returns:
        True if this block sustains fire, meaning it will never go out.

      • canEntityDestroy

        default boolean canEntityDestroy​(IBlockReader world,
                                 BlockPos pos,
                                 Entity entity)
        Determines if this block is can be destroyed by the specified entities normal behavior.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        True to allow the ender dragon to destroy this block

      • isBurning

        default boolean isBurning​(IBlockReader world,
                          BlockPos pos)
        Determines if this block should set fire and deal fire damage to entities coming into contact with it.
        Parameters:
        world - The current world
        pos - Block position in world
        Returns:
        True if the block should deal damage

      • getAiPathNodeType

        @Nullable
default PathNodeType getAiPathNodeType​(IBlockReader world,
                                       BlockPos pos)
        Get the PathNodeType for this block. Return null for vanilla behavior.
        Returns:
        the PathNodeType

      • getAiPathNodeType

        @Nullable
default PathNodeType getAiPathNodeType​(IBlockReader world,
                                       BlockPos pos,
                                       @Nullable
                                       MobEntity entity)
        Get the PathNodeType for this block. Return null for vanilla behavior.
        Returns:
        the PathNodeType

      • canDropFromExplosion

        default boolean canDropFromExplosion​(IBlockReader world,
                                     BlockPos pos,
                                     Explosion explosion)
        Determines if this block should drop loot when exploded.

      • onBlockExploded

        default void onBlockExploded​(World world,
                             BlockPos pos,
                             Explosion explosion)
        Called when the block is destroyed by an explosion. Useful for allowing the block to take into account tile entities, state, etc. when exploded, before it is removed.
        Parameters:
        world - The current world
        pos - Block position in world
        explosion - The explosion instance affecting the block

      • collisionExtendsVertically

        default boolean collisionExtendsVertically​(IBlockReader world,
                                           BlockPos pos,
                                           Entity collidingEntity)
        Determines if this block's collision box should be treated as though it can extend above its block space. This can be used to replicate fence and wall behavior.

      • shouldDisplayFluidOverlay

        default boolean shouldDisplayFluidOverlay​(IBlockDisplayReader world,
                                          BlockPos pos,
                                          FluidState fluidState)
        Called to determine whether this block should use the fluid overlay texture or flowing texture when it is placed under the fluid.
        Parameters:
        world - The world
        pos - Block position in world
        fluidState - The state of the fluid
        Returns:
        Whether the fluid overlay texture should be used

      • getToolModifiedState

        @Nullable
default BlockState getToolModifiedState​(World world,
                                        BlockPos pos,
                                        PlayerEntity player,
                                        ItemStack stack,
                                        ToolType toolType)
        Returns the state that this block should transform into when right clicked by a tool. For example: Used to determine if an axe can strip, a shovel can path, or a hoe can till. Return null if vanilla behavior should be disabled.
        Parameters:
        world - The world
        pos - The block position in world
        player - The player clicking the block
        stack - The stack being used by the player
        toolType - The tool type to be considered when performing the action
        Returns:
        The resulting state after the action has been performed

      • isScaffolding

        default boolean isScaffolding​(LivingEntity entity)
        Checks if a player or entity handles movement on this block like scaffolding.
        Parameters:
        entity - The entity on the scaffolding
        Returns:
        True if the block should act like scaffolding