From 0427ab89f1753a44b30cbc35ce021cbbdc845109 Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:52:45 +0300 Subject: fix missing source folder --- javadoc/net/minecraft/block/Block.html | 4364 ++++++++++++++++++++++++++++++++ 1 file changed, 4364 insertions(+) create mode 100644 javadoc/net/minecraft/block/Block.html (limited to 'javadoc/net/minecraft/block/Block.html') diff --git a/javadoc/net/minecraft/block/Block.html b/javadoc/net/minecraft/block/Block.html new file mode 100644 index 0000000..bf6ce52 --- /dev/null +++ b/javadoc/net/minecraft/block/Block.html @@ -0,0 +1,4364 @@ + + + + + +Block (Forge API) + + + + + + + +
+ + + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + +
+
net.minecraft.block
+

Class Block

+
+
+ +
+ +
+
+ +
+
+
    +
  • + +
      +
    • + + +

      Field Detail

      + + + + + + + +
        +
      • +

        textureName

        +
        protected java.lang.String textureName
        +
        • +
      + + + +
        +
      • +

        soundTypeStone

        +
        public static final Block.SoundType soundTypeStone
        +
        • +
      + + + + + + + +
        +
      • +

        soundTypeGravel

        +
        public static final Block.SoundType soundTypeGravel
        +
        • +
      + + + +
        +
      • +

        soundTypeGrass

        +
        public static final Block.SoundType soundTypeGrass
        +
        • +
      + + + +
        +
      • +

        soundTypePiston

        +
        public static final Block.SoundType soundTypePiston
        +
        • +
      + + + +
        +
      • +

        soundTypeMetal

        +
        public static final Block.SoundType soundTypeMetal
        +
        • +
      + + + +
        +
      • +

        soundTypeGlass

        +
        public static final Block.SoundType soundTypeGlass
        +
        • +
      + + + +
        +
      • +

        soundTypeCloth

        +
        public static final Block.SoundType soundTypeCloth
        +
        • +
      + + + + + + + + + + + +
        +
      • +

        soundTypeLadder

        +
        public static final Block.SoundType soundTypeLadder
        +
        • +
      + + + +
        +
      • +

        soundTypeAnvil

        +
        public static final Block.SoundType soundTypeAnvil
        +
        • +
      + + + +
        +
      • +

        opaque

        +
        protected boolean opaque
        +
        • +
      + + + +
        +
      • +

        lightOpacity

        +
        protected int lightOpacity
        +
        • +
      + + + +
        +
      • +

        canBlockGrass

        +
        protected boolean canBlockGrass
        +
        • +
      + + + +
        +
      • +

        lightValue

        +
        protected int lightValue
        +
        • +
      + + + +
        +
      • +

        useNeighborBrightness

        +
        protected boolean useNeighborBrightness
        +
        • +
      + + + +
        +
      • +

        blockHardness

        +
        protected float blockHardness
        +
        • +
      + + + +
        +
      • +

        blockResistance

        +
        protected float blockResistance
        +
        • +
      + + + +
        +
      • +

        blockConstructorCalled

        +
        protected boolean blockConstructorCalled
        +
        • +
      + + + +
        +
      • +

        enableStats

        +
        protected boolean enableStats
        +
        • +
      + + + +
        +
      • +

        needsRandomTick

        +
        protected boolean needsRandomTick
        +
        • +
      + + + +
        +
      • +

        isBlockContainer

        +
        protected boolean isBlockContainer
        +
        • +
      + + + +
        +
      • +

        minX

        +
        protected double minX
        +
        • +
      + + + +
        +
      • +

        minY

        +
        protected double minY
        +
        • +
      + + + +
        +
      • +

        minZ

        +
        protected double minZ
        +
        • +
      + + + +
        +
      • +

        maxX

        +
        protected double maxX
        +
        • +
      + + + +
        +
      • +

        maxY

        +
        protected double maxY
        +
        • +
      + + + +
        +
      • +

        maxZ

        +
        protected double maxZ
        +
        • +
      + + + + + + + +
        +
      • +

        blockParticleGravity

        +
        public float blockParticleGravity
        +
        • +
      + + + +
        +
      • +

        blockMaterial

        +
        protected final Material blockMaterial
        +
        • +
      + + + +
        +
      • +

        slipperiness

        +
        public float slipperiness
        +
        • +
      + + + +
        +
      • +

        blockIcon

        +
        protected IIcon blockIcon
        +
        • +
      + + + + + + + +
        +
      • +

        harvesters

        +
        protected java.lang.ThreadLocal<EntityPlayer> harvesters
        +
        • +
      + + + +
        +
      • +

        captureDrops

        +
        protected java.lang.ThreadLocal<java.lang.Boolean> captureDrops
        +
        • +
      + + + +
        +
      • +

        capturedDrops

        +
        protected java.lang.ThreadLocal<java.util.List<ItemStack>> capturedDrops
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Constructor Detail

      + + + +
        +
      • +

        Block

        +
        protected Block(Material p_i45394_1_)
        +
        • +
      +
      • +
    + +
      +
    • + + +

      Method Detail

      + + + +
        +
      • +

        getIdFromBlock

        +
        public static int getIdFromBlock(Block p_149682_0_)
        +
        • +
      + + + +
        +
      • +

        getBlockById

        +
        public static Block getBlockById(int p_149729_0_)
        +
        • +
      + + + +
        +
      • +

        getBlockFromItem

        +
        public static Block getBlockFromItem(Item p_149634_0_)
        +
        • +
      + + + +
        +
      • +

        getBlockFromName

        +
        public static Block getBlockFromName(java.lang.String p_149684_0_)
        +
        • +
      + + + +
        +
      • +

        func_149730_j

        +
        public boolean func_149730_j()
        +
        • +
      + + + +
        +
      • +

        getLightOpacity

        +
        public int getLightOpacity()
        +
        • +
      + + + +
        +
      • +

        getCanBlockGrass

        +
        public boolean getCanBlockGrass()
        +
        • +
      + + + +
        +
      • +

        getLightValue

        +
        public int getLightValue()
        +
        • +
      + + + +
        +
      • +

        getUseNeighborBrightness

        +
        public boolean getUseNeighborBrightness()
        +
        • +
      + + + +
        +
      • +

        getMaterial

        +
        public Material getMaterial()
        +
        • +
      + + + +
        +
      • +

        getMapColor

        +
        public MapColor getMapColor(int p_149728_1_)
        +
        • +
      + + + +
        +
      • +

        registerBlocks

        +
        public static void registerBlocks()
        +
        • +
      + + + + + + + +
        +
      • +

        setLightOpacity

        +
        public Block setLightOpacity(int p_149713_1_)
        +
        • +
      + + + +
        +
      • +

        setLightLevel

        +
        public Block setLightLevel(float p_149715_1_)
        +
        • +
      + + + +
        +
      • +

        setResistance

        +
        public Block setResistance(float p_149752_1_)
        +
        • +
      + + + +
        +
      • +

        isBlockNormalCube

        +
        public boolean isBlockNormalCube()
        +
        • +
      + + + +
        +
      • +

        isNormalCube

        +
        public boolean isNormalCube()
        +
        • +
      + + + +
        +
      • +

        renderAsNormalBlock

        +
        public boolean renderAsNormalBlock()
        +
        • +
      + + + +
        +
      • +

        getBlocksMovement

        +
        public boolean getBlocksMovement(IBlockAccess p_149655_1_,
+                        int p_149655_2_,
+                        int p_149655_3_,
+                        int p_149655_4_)
        +
        • +
      + + + +
        +
      • +

        getRenderType

        +
        public int getRenderType()
        +
        • +
      + + + +
        +
      • +

        setHardness

        +
        public Block setHardness(float p_149711_1_)
        +
        • +
      + + + +
        +
      • +

        setBlockUnbreakable

        +
        public Block setBlockUnbreakable()
        +
        • +
      + + + +
        +
      • +

        getBlockHardness

        +
        public float getBlockHardness(World p_149712_1_,
+                     int p_149712_2_,
+                     int p_149712_3_,
+                     int p_149712_4_)
        +
        • +
      + + + +
        +
      • +

        setTickRandomly

        +
        public Block setTickRandomly(boolean p_149675_1_)
        +
        • +
      + + + +
        +
      • +

        getTickRandomly

        +
        public boolean getTickRandomly()
        +
        • +
      + + + +
        +
      • +

        hasTileEntity

        +
        @Deprecated
+public boolean hasTileEntity()
        +
        Deprecated. 
        +
        • +
      + + + +
        +
      • +

        setBlockBounds

        +
        public final void setBlockBounds(float p_149676_1_,
+                  float p_149676_2_,
+                  float p_149676_3_,
+                  float p_149676_4_,
+                  float p_149676_5_,
+                  float p_149676_6_)
        +
        • +
      + + + +
        +
      • +

        getMixedBrightnessForBlock

        +
        public int getMixedBrightnessForBlock(IBlockAccess p_149677_1_,
+                             int p_149677_2_,
+                             int p_149677_3_,
+                             int p_149677_4_)
        +
        • +
      + + + +
        +
      • +

        shouldSideBeRendered

        +
        public boolean shouldSideBeRendered(IBlockAccess p_149646_1_,
+                           int p_149646_2_,
+                           int p_149646_3_,
+                           int p_149646_4_,
+                           int p_149646_5_)
        +
        • +
      + + + +
        +
      • +

        isBlockSolid

        +
        public boolean isBlockSolid(IBlockAccess p_149747_1_,
+                   int p_149747_2_,
+                   int p_149747_3_,
+                   int p_149747_4_,
+                   int p_149747_5_)
        +
        • +
      + + + +
        +
      • +

        getIcon

        +
        public IIcon getIcon(IBlockAccess p_149673_1_,
+            int p_149673_2_,
+            int p_149673_3_,
+            int p_149673_4_,
+            int p_149673_5_)
        +
        • +
      + + + +
        +
      • +

        getIcon

        +
        public IIcon getIcon(int p_149691_1_,
+            int p_149691_2_)
        +
        • +
      + + + +
        +
      • +

        addCollisionBoxesToList

        +
        public void addCollisionBoxesToList(World p_149743_1_,
+                           int p_149743_2_,
+                           int p_149743_3_,
+                           int p_149743_4_,
+                           AxisAlignedBB p_149743_5_,
+                           java.util.List p_149743_6_,
+                           Entity p_149743_7_)
        +
        • +
      + + + +
        +
      • +

        getCollisionBoundingBoxFromPool

        +
        public AxisAlignedBB getCollisionBoundingBoxFromPool(World p_149668_1_,
+                                            int p_149668_2_,
+                                            int p_149668_3_,
+                                            int p_149668_4_)
        +
        • +
      + + + +
        +
      • +

        getBlockTextureFromSide

        +
        public final IIcon getBlockTextureFromSide(int p_149733_1_)
        +
        • +
      + + + +
        +
      • +

        getSelectedBoundingBoxFromPool

        +
        public AxisAlignedBB getSelectedBoundingBoxFromPool(World p_149633_1_,
+                                           int p_149633_2_,
+                                           int p_149633_3_,
+                                           int p_149633_4_)
        +
        • +
      + + + +
        +
      • +

        isOpaqueCube

        +
        public boolean isOpaqueCube()
        +
        • +
      + + + +
        +
      • +

        canCollideCheck

        +
        public boolean canCollideCheck(int p_149678_1_,
+                      boolean p_149678_2_)
        +
        • +
      + + + +
        +
      • +

        isCollidable

        +
        public boolean isCollidable()
        +
        • +
      + + + +
        +
      • +

        updateTick

        +
        public void updateTick(World p_149674_1_,
+              int p_149674_2_,
+              int p_149674_3_,
+              int p_149674_4_,
+              java.util.Random p_149674_5_)
        +
        • +
      + + + +
        +
      • +

        randomDisplayTick

        +
        public void randomDisplayTick(World p_149734_1_,
+                     int p_149734_2_,
+                     int p_149734_3_,
+                     int p_149734_4_,
+                     java.util.Random p_149734_5_)
        +
        • +
      + + + +
        +
      • +

        onBlockDestroyedByPlayer

        +
        public void onBlockDestroyedByPlayer(World p_149664_1_,
+                            int p_149664_2_,
+                            int p_149664_3_,
+                            int p_149664_4_,
+                            int p_149664_5_)
        +
        • +
      + + + +
        +
      • +

        onNeighborBlockChange

        +
        public void onNeighborBlockChange(World p_149695_1_,
+                         int p_149695_2_,
+                         int p_149695_3_,
+                         int p_149695_4_,
+                         Block p_149695_5_)
        +
        • +
      + + + +
        +
      • +

        tickRate

        +
        public int tickRate(World p_149738_1_)
        +
        • +
      + + + +
        +
      • +

        onBlockAdded

        +
        public void onBlockAdded(World p_149726_1_,
+                int p_149726_2_,
+                int p_149726_3_,
+                int p_149726_4_)
        +
        • +
      + + + +
        +
      • +

        breakBlock

        +
        public void breakBlock(World p_149749_1_,
+              int p_149749_2_,
+              int p_149749_3_,
+              int p_149749_4_,
+              Block p_149749_5_,
+              int p_149749_6_)
        +
        • +
      + + + +
        +
      • +

        quantityDropped

        +
        public int quantityDropped(java.util.Random p_149745_1_)
        +
        • +
      + + + +
        +
      • +

        getItemDropped

        +
        public Item getItemDropped(int p_149650_1_,
+                  java.util.Random p_149650_2_,
+                  int p_149650_3_)
        +
        • +
      + + + +
        +
      • +

        getPlayerRelativeBlockHardness

        +
        public float getPlayerRelativeBlockHardness(EntityPlayer p_149737_1_,
+                                   World p_149737_2_,
+                                   int p_149737_3_,
+                                   int p_149737_4_,
+                                   int p_149737_5_)
        +
        • +
      + + + +
        +
      • +

        dropBlockAsItem

        +
        public final void dropBlockAsItem(World p_149697_1_,
+                   int p_149697_2_,
+                   int p_149697_3_,
+                   int p_149697_4_,
+                   int p_149697_5_,
+                   int p_149697_6_)
        +
        • +
      + + + +
        +
      • +

        dropBlockAsItemWithChance

        +
        public void dropBlockAsItemWithChance(World p_149690_1_,
+                             int p_149690_2_,
+                             int p_149690_3_,
+                             int p_149690_4_,
+                             int p_149690_5_,
+                             float p_149690_6_,
+                             int p_149690_7_)
        +
        • +
      + + + +
        +
      • +

        dropBlockAsItem

        +
        protected void dropBlockAsItem(World p_149642_1_,
+                   int p_149642_2_,
+                   int p_149642_3_,
+                   int p_149642_4_,
+                   ItemStack p_149642_5_)
        +
        • +
      + + + +
        +
      • +

        dropXpOnBlockBreak

        +
        public void dropXpOnBlockBreak(World p_149657_1_,
+                      int p_149657_2_,
+                      int p_149657_3_,
+                      int p_149657_4_,
+                      int p_149657_5_)
        +
        • +
      + + + +
        +
      • +

        damageDropped

        +
        public int damageDropped(int p_149692_1_)
        +
        • +
      + + + +
        +
      • +

        getExplosionResistance

        +
        public float getExplosionResistance(Entity p_149638_1_)
        +
        • +
      + + + +
        +
      • +

        collisionRayTrace

        +
        public MovingObjectPosition collisionRayTrace(World p_149731_1_,
+                                     int p_149731_2_,
+                                     int p_149731_3_,
+                                     int p_149731_4_,
+                                     Vec3 p_149731_5_,
+                                     Vec3 p_149731_6_)
        +
        • +
      + + + +
        +
      • +

        onBlockDestroyedByExplosion

        +
        public void onBlockDestroyedByExplosion(World p_149723_1_,
+                               int p_149723_2_,
+                               int p_149723_3_,
+                               int p_149723_4_,
+                               Explosion p_149723_5_)
        +
        • +
      + + + +
        +
      • +

        canReplace

        +
        public boolean canReplace(World p_149705_1_,
+                 int p_149705_2_,
+                 int p_149705_3_,
+                 int p_149705_4_,
+                 int p_149705_5_,
+                 ItemStack p_149705_6_)
        +
        • +
      + + + +
        +
      • +

        getRenderBlockPass

        +
        public int getRenderBlockPass()
        +
        • +
      + + + +
        +
      • +

        canPlaceBlockOnSide

        +
        public boolean canPlaceBlockOnSide(World p_149707_1_,
+                          int p_149707_2_,
+                          int p_149707_3_,
+                          int p_149707_4_,
+                          int p_149707_5_)
        +
        • +
      + + + +
        +
      • +

        canPlaceBlockAt

        +
        public boolean canPlaceBlockAt(World p_149742_1_,
+                      int p_149742_2_,
+                      int p_149742_3_,
+                      int p_149742_4_)
        +
        • +
      + + + +
        +
      • +

        onBlockActivated

        +
        public boolean onBlockActivated(World p_149727_1_,
+                       int p_149727_2_,
+                       int p_149727_3_,
+                       int p_149727_4_,
+                       EntityPlayer p_149727_5_,
+                       int p_149727_6_,
+                       float p_149727_7_,
+                       float p_149727_8_,
+                       float p_149727_9_)
        +
        • +
      + + + +
        +
      • +

        onEntityWalking

        +
        public void onEntityWalking(World p_149724_1_,
+                   int p_149724_2_,
+                   int p_149724_3_,
+                   int p_149724_4_,
+                   Entity p_149724_5_)
        +
        • +
      + + + +
        +
      • +

        onBlockPlaced

        +
        public int onBlockPlaced(World p_149660_1_,
+                int p_149660_2_,
+                int p_149660_3_,
+                int p_149660_4_,
+                int p_149660_5_,
+                float p_149660_6_,
+                float p_149660_7_,
+                float p_149660_8_,
+                int p_149660_9_)
        +
        • +
      + + + +
        +
      • +

        onBlockClicked

        +
        public void onBlockClicked(World p_149699_1_,
+                  int p_149699_2_,
+                  int p_149699_3_,
+                  int p_149699_4_,
+                  EntityPlayer p_149699_5_)
        +
        • +
      + + + +
        +
      • +

        velocityToAddToEntity

        +
        public void velocityToAddToEntity(World p_149640_1_,
+                         int p_149640_2_,
+                         int p_149640_3_,
+                         int p_149640_4_,
+                         Entity p_149640_5_,
+                         Vec3 p_149640_6_)
        +
        • +
      + + + +
        +
      • +

        setBlockBoundsBasedOnState

        +
        public void setBlockBoundsBasedOnState(IBlockAccess p_149719_1_,
+                              int p_149719_2_,
+                              int p_149719_3_,
+                              int p_149719_4_)
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMinX

        +
        public final double getBlockBoundsMinX()
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMaxX

        +
        public final double getBlockBoundsMaxX()
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMinY

        +
        public final double getBlockBoundsMinY()
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMaxY

        +
        public final double getBlockBoundsMaxY()
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMinZ

        +
        public final double getBlockBoundsMinZ()
        +
        • +
      + + + +
        +
      • +

        getBlockBoundsMaxZ

        +
        public final double getBlockBoundsMaxZ()
        +
        • +
      + + + +
        +
      • +

        getBlockColor

        +
        public int getBlockColor()
        +
        • +
      + + + +
        +
      • +

        getRenderColor

        +
        public int getRenderColor(int p_149741_1_)
        +
        • +
      + + + +
        +
      • +

        colorMultiplier

        +
        public int colorMultiplier(IBlockAccess p_149720_1_,
+                  int p_149720_2_,
+                  int p_149720_3_,
+                  int p_149720_4_)
        +
        • +
      + + + +
        +
      • +

        isProvidingWeakPower

        +
        public int isProvidingWeakPower(IBlockAccess p_149709_1_,
+                       int p_149709_2_,
+                       int p_149709_3_,
+                       int p_149709_4_,
+                       int p_149709_5_)
        +
        • +
      + + + +
        +
      • +

        canProvidePower

        +
        public boolean canProvidePower()
        +
        • +
      + + + +
        +
      • +

        onEntityCollidedWithBlock

        +
        public void onEntityCollidedWithBlock(World p_149670_1_,
+                             int p_149670_2_,
+                             int p_149670_3_,
+                             int p_149670_4_,
+                             Entity p_149670_5_)
        +
        • +
      + + + +
        +
      • +

        isProvidingStrongPower

        +
        public int isProvidingStrongPower(IBlockAccess p_149748_1_,
+                         int p_149748_2_,
+                         int p_149748_3_,
+                         int p_149748_4_,
+                         int p_149748_5_)
        +
        • +
      + + + +
        +
      • +

        setBlockBoundsForItemRender

        +
        public void setBlockBoundsForItemRender()
        +
        • +
      + + + +
        +
      • +

        harvestBlock

        +
        public void harvestBlock(World p_149636_1_,
+                EntityPlayer p_149636_2_,
+                int p_149636_3_,
+                int p_149636_4_,
+                int p_149636_5_,
+                int p_149636_6_)
        +
        • +
      + + + +
        +
      • +

        canSilkHarvest

        +
        protected boolean canSilkHarvest()
        +
        • +
      + + + +
        +
      • +

        createStackedBlock

        +
        protected ItemStack createStackedBlock(int p_149644_1_)
        +
        • +
      + + + +
        +
      • +

        quantityDroppedWithBonus

        +
        public int quantityDroppedWithBonus(int p_149679_1_,
+                           java.util.Random p_149679_2_)
        +
        • +
      + + + +
        +
      • +

        canBlockStay

        +
        public boolean canBlockStay(World p_149718_1_,
+                   int p_149718_2_,
+                   int p_149718_3_,
+                   int p_149718_4_)
        +
        • +
      + + + +
        +
      • +

        onBlockPlacedBy

        +
        public void onBlockPlacedBy(World p_149689_1_,
+                   int p_149689_2_,
+                   int p_149689_3_,
+                   int p_149689_4_,
+                   EntityLivingBase p_149689_5_,
+                   ItemStack p_149689_6_)
        +
        • +
      + + + +
        +
      • +

        onPostBlockPlaced

        +
        public void onPostBlockPlaced(World p_149714_1_,
+                     int p_149714_2_,
+                     int p_149714_3_,
+                     int p_149714_4_,
+                     int p_149714_5_)
        +
        • +
      + + + +
        +
      • +

        setBlockName

        +
        public Block setBlockName(java.lang.String p_149663_1_)
        +
        • +
      + + + +
        +
      • +

        getLocalizedName

        +
        public java.lang.String getLocalizedName()
        +
        • +
      + + + +
        +
      • +

        getUnlocalizedName

        +
        public java.lang.String getUnlocalizedName()
        +
        • +
      + + + +
        +
      • +

        onBlockEventReceived

        +
        public boolean onBlockEventReceived(World p_149696_1_,
+                           int p_149696_2_,
+                           int p_149696_3_,
+                           int p_149696_4_,
+                           int p_149696_5_,
+                           int p_149696_6_)
        +
        • +
      + + + +
        +
      • +

        getEnableStats

        +
        public boolean getEnableStats()
        +
        • +
      + + + +
        +
      • +

        disableStats

        +
        protected Block disableStats()
        +
        • +
      + + + +
        +
      • +

        getMobilityFlag

        +
        public int getMobilityFlag()
        +
        • +
      + + + +
        +
      • +

        getAmbientOcclusionLightValue

        +
        public float getAmbientOcclusionLightValue()
        +
        • +
      + + + +
        +
      • +

        onFallenUpon

        +
        public void onFallenUpon(World p_149746_1_,
+                int p_149746_2_,
+                int p_149746_3_,
+                int p_149746_4_,
+                Entity p_149746_5_,
+                float p_149746_6_)
        +
        • +
      + + + +
        +
      • +

        getItem

        +
        public Item getItem(World p_149694_1_,
+           int p_149694_2_,
+           int p_149694_3_,
+           int p_149694_4_)
        +
        • +
      + + + +
        +
      • +

        getDamageValue

        +
        public int getDamageValue(World p_149643_1_,
+                 int p_149643_2_,
+                 int p_149643_3_,
+                 int p_149643_4_)
        +
        • +
      + + + +
        +
      • +

        getSubBlocks

        +
        public void getSubBlocks(Item p_149666_1_,
+                CreativeTabs p_149666_2_,
+                java.util.List p_149666_3_)
        +
        • +
      + + + + + + + +
        +
      • +

        onBlockHarvested

        +
        public void onBlockHarvested(World p_149681_1_,
+                    int p_149681_2_,
+                    int p_149681_3_,
+                    int p_149681_4_,
+                    int p_149681_5_,
+                    EntityPlayer p_149681_6_)
        +
        • +
      + + + +
        +
      • +

        getCreativeTabToDisplayOn

        +
        public CreativeTabs getCreativeTabToDisplayOn()
        +
        • +
      + + + +
        +
      • +

        onBlockPreDestroy

        +
        public void onBlockPreDestroy(World p_149725_1_,
+                     int p_149725_2_,
+                     int p_149725_3_,
+                     int p_149725_4_,
+                     int p_149725_5_)
        +
        • +
      + + + +
        +
      • +

        fillWithRain

        +
        public void fillWithRain(World p_149639_1_,
+                int p_149639_2_,
+                int p_149639_3_,
+                int p_149639_4_)
        +
        • +
      + + + +
        +
      • +

        isFlowerPot

        +
        public boolean isFlowerPot()
        +
        • +
      + + + +
        +
      • +

        func_149698_L

        +
        public boolean func_149698_L()
        +
        • +
      + + + +
        +
      • +

        canDropFromExplosion

        +
        public boolean canDropFromExplosion(Explosion p_149659_1_)
        +
        • +
      + + + +
        +
      • +

        isAssociatedBlock

        +
        public boolean isAssociatedBlock(Block p_149667_1_)
        +
        • +
      + + + +
        +
      • +

        isEqualTo

        +
        public static boolean isEqualTo(Block p_149680_0_,
+                Block p_149680_1_)
        +
        • +
      + + + +
        +
      • +

        hasComparatorInputOverride

        +
        public boolean hasComparatorInputOverride()
        +
        • +
      + + + +
        +
      • +

        getComparatorInputOverride

        +
        public int getComparatorInputOverride(World p_149736_1_,
+                             int p_149736_2_,
+                             int p_149736_3_,
+                             int p_149736_4_,
+                             int p_149736_5_)
        +
        • +
      + + + +
        +
      • +

        setBlockTextureName

        +
        public Block setBlockTextureName(java.lang.String p_149658_1_)
        +
        • +
      + + + +
        +
      • +

        getTextureName

        +
        protected java.lang.String getTextureName()
        +
        • +
      + + + +
        +
      • +

        func_149735_b

        +
        public IIcon func_149735_b(int p_149735_1_,
+                  int p_149735_2_)
        +
        • +
      + + + +
        +
      • +

        registerBlockIcons

        +
        public void registerBlockIcons(IIconRegister p_149651_1_)
        +
        • +
      + + + +
        +
      • +

        getItemIconName

        +
        public java.lang.String getItemIconName()
        +
        • +
      + + + +
        +
      • +

        getLightValue

        +
        public int getLightValue(IBlockAccess world,
+                int x,
+                int y,
+                int z)
        +
        Get a light value for the block at the specified coordinates, normal ranges are between 0 and 15
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        +
        Returns:
        The light value
        +
        • +
      + + + +
        +
      • +

        isLadder

        +
        public boolean isLadder(IBlockAccess world,
+               int x,
+               int y,
+               int z,
+               EntityLivingBase entity)
        +
        Checks if a player or entity can use this block to 'climb' like a ladder.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        entity - The entity trying to use the ladder, CAN be null.
        +
        Returns:
        True if the block should act like a ladder
        +
        • +
      + + + +
        +
      • +

        isNormalCube

        +
        public boolean isNormalCube(IBlockAccess world,
+                   int x,
+                   int y,
+                   int z)
        +
        Return true if the block is a normal, solid cube. This + determines indirect power state, entity ejection from blocks, and a few + others.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        +
        Returns:
        True if the block is a full cube
        +
        • +
      + + + +
        +
      • +

        isSideSolid

        +
        public boolean isSideSolid(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z,
+                  ForgeDirection side)
        +
        Checks if the block is a solid face on the given side, used by placement logic.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        side - The side to check
        +
        Returns:
        True if the block is solid on the specified side.
        +
        • +
      + + + +
        +
      • +

        isReplaceable

        +
        public boolean isReplaceable(IBlockAccess world,
+                    int x,
+                    int y,
+                    int z)
        +
        Determines if a new block can be replace the space occupied by this one, + Used in the player's placement code to make the block act like water, and lava.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        +
        Returns:
        True if the block is replaceable by another block
        +
        • +
      + + + +
        +
      • +

        isBurning

        +
        public boolean isBurning(IBlockAccess world,
+                int x,
+                int y,
+                int z)
        +
        Determines if this block should set fire and deal fire damage + to entities coming into contact with it.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y position
        z - Z position
        +
        Returns:
        True if the block should deal damage
        +
        • +
      + + + +
        +
      • +

        isAir

        +
        public boolean isAir(IBlockAccess world,
+            int x,
+            int y,
+            int z)
        +
        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
        x - X Position
        y - Y position
        z - Z position
        +
        Returns:
        True if the block considered air
        +
        • +
      + + + +
        +
      • +

        canHarvestBlock

        +
        public boolean canHarvestBlock(EntityPlayer player,
+                      int meta)
        +
        Determines if the player can harvest this block, obtaining it's drops when the block is destroyed.
        +
        Parameters:
        player - The player damaging the block, may be null
        meta - The block's current metadata
        +
        Returns:
        True to spawn the drops
        +
        • +
      + + + +
        +
      • +

        removedByPlayer

        +
        public boolean removedByPlayer(World world,
+                      EntityPlayer player,
+                      int x,
+                      int y,
+                      int z,
+                      boolean willHarvest)
        +
        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
        x - X Position
        y - Y position
        z - Z position
        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
        +
        Returns:
        True if the block is actually destroyed.
        +
        • +
      + + + +
        +
      • +

        removedByPlayer

        +
        @Deprecated
+public boolean removedByPlayer(World world,
+                                 EntityPlayer player,
+                                 int x,
+                                 int y,
+                                 int z)
        +
        Deprecated. 
        +
        • +
      + + + +
        +
      • +

        getFlammability

        +
        public int getFlammability(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z,
+                  ForgeDirection 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
        x - The blocks X position
        y - The blocks Y position
        z - The blocks Z position
        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

        +
        public boolean isFlammable(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z,
+                  ForgeDirection face)
        +
        Called when fire is updating, checks if a block face can catch fire.
        +
        Parameters:
        world - The current world
        x - The blocks X position
        y - The blocks Y position
        z - The blocks Z position
        face - The face that the fire is coming from
        +
        Returns:
        True if the face can be on fire, false otherwise.
        +
        • +
      + + + +
        +
      • +

        getFireSpreadSpeed

        +
        public int getFireSpreadSpeed(IBlockAccess world,
+                     int x,
+                     int y,
+                     int z,
+                     ForgeDirection 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
        x - The blocks X position
        y - The blocks Y position
        z - The blocks Z position
        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

        +
        public boolean isFireSource(World world,
+                   int x,
+                   int y,
+                   int z,
+                   ForgeDirection 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
        x - The blocks X position
        y - The blocks Y position
        z - The blocks Z position
        metadata - The blocks current metadata
        side - The face that the fire is coming from
        +
        Returns:
        True if this block sustains fire, meaning it will never go out.
        +
        • +
      + + + +
        +
      • +

        hasTileEntity

        +
        public boolean hasTileEntity(int metadata)
        +
        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.
        +
        Parameters:
        metadata - Metadata of the current block
        +
        Returns:
        True if block has a tile entity, false otherwise
        +
        • +
      + + + +
        +
      • +

        createTileEntity

        +
        public TileEntity createTileEntity(World world,
+                          int metadata)
        +
        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:
        metadata - The Metadata of the current block
        +
        Returns:
        A instance of a class extending TileEntity
        +
        • +
      + + + +
        +
      • +

        quantityDropped

        +
        public int quantityDropped(int meta,
+                  int fortune,
+                  java.util.Random random)
        +
        Metadata and fortune sensitive version, this replaces the old (int meta, Random rand) + version in 1.1.
        +
        Parameters:
        meta - Blocks Metadata
        fortune - Current item fortune level
        random - Random number generator
        +
        Returns:
        The number of items to drop
        +
        • +
      + + + +
        +
      • +

        getDrops

        +
        public java.util.ArrayList<ItemStack> getDrops(World world,
+                                      int x,
+                                      int y,
+                                      int z,
+                                      int metadata,
+                                      int fortune)
        +
        This returns a complete list of items dropped from this block.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        metadata - Current metadata
        fortune - Breakers fortune level
        +
        Returns:
        A ArrayList containing all items this block drops
        +
        • +
      + + + +
        +
      • +

        canSilkHarvest

        +
        public boolean canSilkHarvest(World world,
+                     EntityPlayer player,
+                     int x,
+                     int y,
+                     int z,
+                     int metadata)
        +
        Return true from this function if the player with silk touch can harvest this block directly, and not it's normal drops.
        +
        Parameters:
        world - The world
        player - The player doing the harvesting
        x - X Position
        y - Y Position
        z - Z Position
        metadata - The metadata
        +
        Returns:
        True if the block can be directly harvested using silk touch
        +
        • +
      + + + +
        +
      • +

        canCreatureSpawn

        +
        public boolean canCreatureSpawn(EnumCreatureType type,
+                       IBlockAccess world,
+                       int x,
+                       int y,
+                       int z)
        +
        Determines if a specified mob type can spawn on this block, returning false will + prevent any mob from spawning on the block.
        +
        Parameters:
        type - The Mob Category Type
        world - The current world
        x - The X Position
        y - The Y Position
        z - The Z Position
        +
        Returns:
        True to allow a mob of the specified category to spawn, false to prevent it.
        +
        • +
      + + + +
        +
      • +

        isBed

        +
        public boolean isBed(IBlockAccess world,
+            int x,
+            int y,
+            int z,
+            EntityLivingBase player)
        +
        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
        x - X Position
        y - Y Position
        z - Z Position
        player - The player or camera entity, null in some cases.
        +
        Returns:
        True to treat this as a bed
        +
        • +
      + + + +
        +
      • +

        getBedSpawnPosition

        +
        public ChunkCoordinates getBedSpawnPosition(IBlockAccess world,
+                                   int x,
+                                   int y,
+                                   int z,
+                                   EntityPlayer player)
        +
        Returns the position that the player is moved to upon + waking up, or respawning at the bed.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        player - The player or camera entity, null in some cases.
        +
        Returns:
        The spawn position
        +
        • +
      + + + +
        +
      • +

        setBedOccupied

        +
        public void setBedOccupied(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z,
+                  EntityPlayer player,
+                  boolean occupied)
        +
        Called when a user either starts or stops sleeping in the bed.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        player - The player 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

        +
        public int getBedDirection(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z)
        +
        Returns the direction of the block. Same values that + are returned by BlockDirectional
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        Bed direction
        +
        • +
      + + + +
        +
      • +

        isBedFoot

        +
        public boolean isBedFoot(IBlockAccess world,
+                int x,
+                int y,
+                int z)
        +
        Determines if the current block is the foot half of the bed.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        True if the current block is the foot side of a bed.
        +
        • +
      + + + +
        +
      • +

        beginLeavesDecay

        +
        public void beginLeavesDecay(World world,
+                    int x,
+                    int y,
+                    int z)
        +
        Called when a leaf should start its decay process.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        • +
      + + + +
        +
      • +

        canSustainLeaves

        +
        public boolean canSustainLeaves(IBlockAccess world,
+                       int x,
+                       int y,
+                       int z)
        +
        Determines if this block can prevent leaves connected to it from decaying.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        true if the presence this block can prevent leaves from decaying.
        +
        • +
      + + + +
        +
      • +

        isLeaves

        +
        public boolean isLeaves(IBlockAccess world,
+               int x,
+               int y,
+               int z)
        +
        Determines if this block is considered a leaf block, used to apply the leaf decay and generation system.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        true if this block is considered leaves.
        +
        • +
      + + + +
        +
      • +

        canBeReplacedByLeaves

        +
        public boolean canBeReplacedByLeaves(IBlockAccess world,
+                            int x,
+                            int y,
+                            int z)
        +
        Used during tree growth to determine if newly generated leaves can replace this block.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        true if this block can be replaced by growing leaves.
        +
        • +
      + + + +
        +
      • +

        isWood

        +
        public boolean isWood(IBlockAccess world,
+             int x,
+             int y,
+             int z)
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        true if the block is wood (logs)
        +
        • +
      + + + +
        +
      • +

        isReplaceableOreGen

        +
        public boolean isReplaceableOreGen(World world,
+                          int x,
+                          int y,
+                          int z,
+                          Block target)
        +
        Determines if the current block is replaceable by Ore veins during world generation.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        target - The generic target block the gen is looking for, Standards define stone + for overworld generation, and neatherack for the nether.
        +
        Returns:
        True to allow this block to be replaced by a ore
        +
        • +
      + + + +
        +
      • +

        getExplosionResistance

        +
        public float getExplosionResistance(Entity par1Entity,
+                           World world,
+                           int x,
+                           int y,
+                           int z,
+                           double explosionX,
+                           double explosionY,
+                           double explosionZ)
        +
        Location sensitive version of getExplosionRestance
        +
        Parameters:
        par1Entity - The entity that caused the explosion
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        explosionX - Explosion source X Position
        explosionY - Explosion source X Position
        explosionZ - Explosion source X Position
        +
        Returns:
        The amount of the explosion absorbed.
        +
        • +
      + + + +
        +
      • +

        onBlockExploded

        +
        public void onBlockExploded(World world,
+                   int x,
+                   int y,
+                   int z,
+                   Explosion explosion)
        +
        Called when the block is destroyed by an explosion. + Useful for allowing the block to take into account tile entities, + metadata, etc. when exploded, before it is removed.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        Explosion - The explosion instance affecting the block
        +
        • +
      + + + +
        +
      • +

        canConnectRedstone

        +
        public boolean canConnectRedstone(IBlockAccess world,
+                         int x,
+                         int y,
+                         int z,
+                         int 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. + + Side: + -1: UP + 0: NORTH + 1: EAST + 2: SOUTH + 3: WEST
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        side - The side that is trying to make the connection
        +
        Returns:
        True to make the connection
        +
        • +
      + + + +
        +
      • +

        canPlaceTorchOnTop

        +
        public boolean canPlaceTorchOnTop(World world,
+                         int x,
+                         int y,
+                         int z)
        +
        Determines if a torch can be placed on the top surface of this block. + Useful for creating your own block that torches can be on, such as fences.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z Position
        +
        Returns:
        True to allow the torch to be placed
        +
        • +
      + + + +
        +
      • +

        canRenderInPass

        +
        public boolean canRenderInPass(int pass)
        +
        Determines if this block should render in this pass.
        +
        Parameters:
        pass - The pass in question
        +
        Returns:
        True to render
        +
        • +
      + + + +
        +
      • +

        getPickBlock

        +
        public ItemStack getPickBlock(MovingObjectPosition target,
+                     World world,
+                     int x,
+                     int y,
+                     int z,
+                     EntityPlayer 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, Null if nothing should be added.
        +
        • +
      + + + + + + + +
        +
      • +

        isFoliage

        +
        public boolean isFoliage(IBlockAccess world,
+                int x,
+                int y,
+                int z)
        +
        Used by getTopSolidOrLiquidBlock while placing biome decorations, villages, etc + Also used to determine if the player can spawn on this block.
        +
        Returns:
        False to disallow spawning
        +
        • +
      + + + +
        +
      • +

        addHitEffects

        +
        public boolean addHitEffects(World worldObj,
+                    MovingObjectPosition target,
+                    EffectRenderer effectRenderer)
        +
        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}
        effectRenderer - A reference to the current effect renderer.
        +
        Returns:
        True to prevent vanilla digging particles form spawning.
        +
        • +
      + + + +
        +
      • +

        addDestroyEffects

        +
        public boolean addDestroyEffects(World world,
+                        int x,
+                        int y,
+                        int z,
+                        int meta,
+                        EffectRenderer effectRenderer)
        +
        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
        x - X position to spawn the particle
        y - Y position to spawn the particle
        z - Z position to spawn the particle
        meta - The metadata for the block before it was destroyed.
        effectRenderer - A reference to the current effect renderer.
        +
        Returns:
        True to prevent vanilla break particles from spawning.
        +
        • +
      + + + +
        +
      • +

        canSustainPlant

        +
        public boolean canSustainPlant(IBlockAccess world,
+                      int x,
+                      int y,
+                      int z,
+                      ForgeDirection direction,
+                      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
        x - X Position
        y - Y Position
        z - Z position
        direction - 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.
        +
        • +
      + + + +
        +
      • +

        onPlantGrow

        +
        public void onPlantGrow(World world,
+               int x,
+               int y,
+               int z,
+               int sourceX,
+               int sourceY,
+               int sourceZ)
        +
        Called when a plant grows on this block, only implemented for saplings using the WorldGen*Trees classes right now. + Modder may implement this for custom plants. + This does not use ForgeDirection, because large/huge trees can be located in non-representable direction, + so the source location is specified. + Currently this just changes the block to dirt if it was grass. + + Note: This happens DURING the generation, the generation may not be complete when this is called.
        +
        Parameters:
        world - Current world
        x - Soil X
        y - Soil Y
        z - Soil Z
        sourceX - Plant growth location X
        sourceY - Plant growth location Y
        sourceZ - Plant growth location Z
        +
        • +
      + + + +
        +
      • +

        isFertile

        +
        public boolean isFertile(World world,
+                int x,
+                int y,
+                int z)
        +
        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
        x - X Position
        y - Y Position
        z - Z position
        +
        Returns:
        True if the soil should be considered fertile.
        +
        • +
      + + + +
        +
      • +

        getLightOpacity

        +
        public int getLightOpacity(IBlockAccess world,
+                  int x,
+                  int y,
+                  int z)
        +
        Location aware and overrideable version of the lightOpacity array, + return the number to subtract from the light value when it passes through this block. + + This is not guaranteed to have the tile entity in place before this is called, so it is + Recommended that you have your tile entity call relight after being placed if you + rely on it for light info.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z position
        +
        Returns:
        The amount of light to block, 0 for air, 255 for fully opaque.
        +
        • +
      + + + +
        +
      • +

        canEntityDestroy

        +
        public boolean canEntityDestroy(IBlockAccess world,
+                       int x,
+                       int y,
+                       int z,
+                       Entity entity)
        +
        Determines if this block is can be destroyed by the specified entities normal behavior.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z position
        +
        Returns:
        True to allow the ender dragon to destroy this block
        +
        • +
      + + + +
        +
      • +

        isBeaconBase

        +
        public boolean isBeaconBase(IBlockAccess worldObj,
+                   int x,
+                   int y,
+                   int z,
+                   int beaconX,
+                   int beaconY,
+                   int beaconZ)
        +
        Determines if this block can be used as the base of a beacon.
        +
        Parameters:
        world - The current world
        x - X Position
        y - Y Position
        z - Z position
        beaconX - Beacons X Position
        beaconY - Beacons Y Position
        beaconZ - Beacons Z Position
        +
        Returns:
        True, to support the beacon, and make it active with this block.
        +
        • +
      + + + +
        +
      • +

        rotateBlock

        +
        public boolean rotateBlock(World worldObj,
+                  int x,
+                  int y,
+                  int z,
+                  ForgeDirection axis)
        +
        Rotate the block. For vanilla blocks this rotates around the axis passed in (generally, it should be the "face" that was hit). + Note: for mod blocks, this is up to the block and modder to decide. It is not mandated that it be a rotation around the + face, but could be a rotation to orient *to* that face, or a visiting of possible rotations. + The method should return true if the rotation was successful though.
        +
        Parameters:
        worldObj - The world
        x - X position
        y - Y position
        z - Z position
        axis - The axis to rotate around
        +
        Returns:
        True if the rotation was successful, False if the rotation failed, or is not possible
        +
        • +
      + + + +
        +
      • +

        getValidRotations

        +
        public ForgeDirection[] getValidRotations(World worldObj,
+                                 int x,
+                                 int y,
+                                 int z)
        +
        Get the rotations that can apply to the block at the specified coordinates. Null means no rotations are possible. + Note, this is up to the block to decide. It may not be accurate or representative.
        +
        Parameters:
        worldObj - The world
        x - X position
        y - Y position
        z - Z position
        +
        Returns:
        An array of valid axes to rotate around, or null for none or unknown
        +
        • +
      + + + +
        +
      • +

        getEnchantPowerBonus

        +
        public float getEnchantPowerBonus(World world,
+                         int x,
+                         int y,
+                         int z)
        +
        Determines the amount of enchanting power this block can provide to an enchanting table.
        +
        Parameters:
        world - The World
        x - X position
        y - Y position
        z - Z position
        +
        Returns:
        The amount of enchanting power this block produces.
        +
        • +
      + + + +
        +
      • +

        recolourBlock

        +
        public boolean recolourBlock(World world,
+                    int x,
+                    int y,
+                    int z,
+                    ForgeDirection side,
+                    int colour)
        +
        Common way to recolour a block with an external tool
        +
        Parameters:
        world - The world
        x - X
        y - Y
        z - Z
        side - The side hit with the colouring tool
        colour - The colour to change to
        +
        Returns:
        If the recolouring was successful
        +
        • +
      + + + +
        +
      • +

        getExpDrop

        +
        public int getExpDrop(IBlockAccess world,
+             int metadata,
+             int fortune)
        +
        Gathers how much experience this block drops when broken.
        +
        Parameters:
        world - The world
        metadata -
        fortune -
        +
        Returns:
        Amount of XP from breaking this block.
        +
        • +
      + + + +
        +
      • +

        onNeighborChange

        +
        public void onNeighborChange(IBlockAccess world,
+                    int x,
+                    int y,
+                    int z,
+                    int tileX,
+                    int tileY,
+                    int tileZ)
        +
        Called when a tile entity on a side of this block changes is created or is destroyed.
        +
        Parameters:
        world - The world
        x - The x position of this block instance
        y - The y position of this block instance
        z - The z position of this block instance
        tileX - The x position of the tile that changed
        tileY - The y position of the tile that changed
        tileZ - The z position of the tile that changed
        +
        • +
      + + + +
        +
      • +

        shouldCheckWeakPower

        +
        public boolean shouldCheckWeakPower(IBlockAccess world,
+                           int x,
+                           int y,
+                           int z,
+                           int 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
        x - The x position of this block instance
        y - The y position of this block instance
        z - The z position of this block instance
        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

        +
        public boolean getWeakChanges(IBlockAccess world,
+                     int x,
+                     int y,
+                     int z)
        +
        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
        x - X Position
        y - Y position
        z - Z position
        side - The side to check
        +
        Returns:
        true To be notified of changes
        +
        • +
      + + + +
        +
      • +

        setHarvestLevel

        +
        public void setHarvestLevel(java.lang.String toolClass,
+                   int level)
        +
        Sets or removes the tool and level required to harvest this block.
        +
        Parameters:
        toolClass - Class
        level - Harvest level: + Wood: 0 + Stone: 1 + Iron: 2 + Diamond: 3 + Gold: 0
        +
        • +
      + + + +
        +
      • +

        setHarvestLevel

        +
        public void setHarvestLevel(java.lang.String toolClass,
+                   int level,
+                   int metadata)
        +
        Sets or removes the tool and level required to harvest this block.
        +
        Parameters:
        toolClass - Class
        level - Harvest level: + Wood: 0 + Stone: 1 + Iron: 2 + Diamond: 3 + Gold: 0
        metadata - The specific metadata to set
        +
        • +
      + + + +
        +
      • +

        getHarvestTool

        +
        public java.lang.String getHarvestTool(int metadata)
        +
        Queries the class of tool required to harvest this block, if null is returned + we assume that anything can harvest this block.
        +
        Parameters:
        metadata -
        +
        Returns:
        +
        • +
      + + + +
        +
      • +

        getHarvestLevel

        +
        public int getHarvestLevel(int metadata)
        +
        Queries the harvest level of this item stack for the specifred tool class, + Returns -1 if this tool is not of the specified type
        +
        Parameters:
        stack - This item stack instance
        +
        Returns:
        Harvest level, or -1 if not the specified tool type.
        +
        • +
      + + + +
        +
      • +

        isToolEffective

        +
        public boolean isToolEffective(java.lang.String type,
+                      int metadata)
        +
        Checks if the specified tool type is efficient on this block, + meaning that it digs at full speed.
        +
        Parameters:
        type -
        metadata -
        +
        Returns:
        +
        • +
      + + + +
        +
      • +

        captureDrops

        +
        protected java.util.List<ItemStack> captureDrops(boolean start)
        +
        • +
      +
      • +
    +
    • +
+
+
+ + +
+ + + + + +
+
+ + + +
+ +
+
+ + +
+ + +
+ + + -- cgit v1.2.3