    001package net.minecraft.block;
    002
    003import cpw.mods.fml.relauncher.Side;
    004import cpw.mods.fml.relauncher.SideOnly;
    005import java.util.ArrayList;
    006import java.util.HashSet;
    007import java.util.Random;
    008import java.util.Set;
    009import net.minecraft.block.material.Material;
    010import net.minecraft.item.Item;
    011import net.minecraft.util.AxisAlignedBB;
    012import net.minecraft.util.Direction;
    013import net.minecraft.world.ChunkPosition;
    014import net.minecraft.world.IBlockAccess;
    015import net.minecraft.world.World;
    016
    017public class BlockRedstoneWire extends Block
    018{
    019    /**
    020     * When false, power transmission methods do not look at other redstone wires. Used internally during
    021     * updateCurrentStrength.
    022     */
    023    private boolean wiresProvidePower = true;
    024    private Set blocksNeedingUpdate = new HashSet();
    025
    026    public BlockRedstoneWire(int par1, int par2)
    027    {
    028        super(par1, par2, Material.circuits);
    029        this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
    030    }
    031
    032    /**
    033     * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata
    034     */
    035    public int getBlockTextureFromSideAndMetadata(int par1, int par2)
    036    {
    037        return this.blockIndexInTexture;
    038    }
    039
    040    /**
    041     * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
    042     * cleared to be reused)
    043     */
    044    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
    045    {
    046        return null;
    047    }
    048
    049    /**
    050     * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
    051     * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
    052     */
    053    public boolean isOpaqueCube()
    054    {
    055        return false;
    056    }
    057
    058    /**
    059     * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
    060     */
    061    public boolean renderAsNormalBlock()
    062    {
    063        return false;
    064    }
    065
    066    /**
    067     * The type of render function that is called for this block
    068     */
    069    public int getRenderType()
    070    {
    071        return 5;
    072    }
    073
    074    @SideOnly(Side.CLIENT)
    075
    076    /**
    077     * Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
    078     * when first determining what to render.
    079     */
    080    public int colorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    081    {
    082        return 8388608;
    083    }
    084
    085    /**
    086     * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
    087     */
    088    public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
    089    {
    090        return par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) || par1World.getBlockId(par2, par3 - 1, par4) == Block.glowStone.blockID;
    091    }
    092
    093    /**
    094     * Sets the strength of the wire current (0-15) for this block based on neighboring blocks and propagates to
    095     * neighboring redstone wires
    096     */
    097    private void updateAndPropagateCurrentStrength(World par1World, int par2, int par3, int par4)
    098    {
    099        this.calculateCurrentChanges(par1World, par2, par3, par4, par2, par3, par4);
    100        ArrayList var5 = new ArrayList(this.blocksNeedingUpdate);
    101        this.blocksNeedingUpdate.clear();
    102
    103        for (int var6 = 0; var6 < var5.size(); ++var6)
    104        {
    105            ChunkPosition var7 = (ChunkPosition)var5.get(var6);
    106            par1World.notifyBlocksOfNeighborChange(var7.x, var7.y, var7.z, this.blockID);
    107        }
    108    }
    109
    110    private void calculateCurrentChanges(World par1World, int par2, int par3, int par4, int par5, int par6, int par7)
    111    {
    112        int var8 = par1World.getBlockMetadata(par2, par3, par4);
    113        int var9 = 0;
    114        this.wiresProvidePower = false;
    115        boolean var10 = par1World.isBlockIndirectlyGettingPowered(par2, par3, par4);
    116        this.wiresProvidePower = true;
    117        int var11;
    118        int var12;
    119        int var13;
    120
    121        if (var10)
    122        {
    123            var9 = 15;
    124        }
    125        else
    126        {
    127            for (var11 = 0; var11 < 4; ++var11)
    128            {
    129                var12 = par2;
    130                var13 = par4;
    131
    132                if (var11 == 0)
    133                {
    134                    var12 = par2 - 1;
    135                }
    136
    137                if (var11 == 1)
    138                {
    139                    ++var12;
    140                }
    141
    142                if (var11 == 2)
    143                {
    144                    var13 = par4 - 1;
    145                }
    146
    147                if (var11 == 3)
    148                {
    149                    ++var13;
    150                }
    151
    152                if (var12 != par5 || par3 != par6 || var13 != par7)
    153                {
    154                    var9 = this.getMaxCurrentStrength(par1World, var12, par3, var13, var9);
    155                }
    156
    157                if (par1World.isBlockNormalCube(var12, par3, var13) && !par1World.isBlockNormalCube(par2, par3 + 1, par4))
    158                {
    159                    if (var12 != par5 || par3 + 1 != par6 || var13 != par7)
    160                    {
    161                        var9 = this.getMaxCurrentStrength(par1World, var12, par3 + 1, var13, var9);
    162                    }
    163                }
    164                else if (!par1World.isBlockNormalCube(var12, par3, var13) && (var12 != par5 || par3 - 1 != par6 || var13 != par7))
    165                {
    166                    var9 = this.getMaxCurrentStrength(par1World, var12, par3 - 1, var13, var9);
    167                }
    168            }
    169
    170            if (var9 > 0)
    171            {
    172                --var9;
    173            }
    174            else
    175            {
    176                var9 = 0;
    177            }
    178        }
    179
    180        if (var8 != var9)
    181        {
    182            par1World.editingBlocks = true;
    183            par1World.setBlockMetadataWithNotify(par2, par3, par4, var9);
    184            par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
    185            par1World.editingBlocks = false;
    186
    187            for (var11 = 0; var11 < 4; ++var11)
    188            {
    189                var12 = par2;
    190                var13 = par4;
    191                int var14 = par3 - 1;
    192
    193                if (var11 == 0)
    194                {
    195                    var12 = par2 - 1;
    196                }
    197
    198                if (var11 == 1)
    199                {
    200                    ++var12;
    201                }
    202
    203                if (var11 == 2)
    204                {
    205                    var13 = par4 - 1;
    206                }
    207
    208                if (var11 == 3)
    209                {
    210                    ++var13;
    211                }
    212
    213                if (par1World.isBlockNormalCube(var12, par3, var13))
    214                {
    215                    var14 += 2;
    216                }
    217
    218                boolean var15 = false;
    219                int var16 = this.getMaxCurrentStrength(par1World, var12, par3, var13, -1);
    220                var9 = par1World.getBlockMetadata(par2, par3, par4);
    221
    222                if (var9 > 0)
    223                {
    224                    --var9;
    225                }
    226
    227                if (var16 >= 0 && var16 != var9)
    228                {
    229                    this.calculateCurrentChanges(par1World, var12, par3, var13, par2, par3, par4);
    230                }
    231
    232                var16 = this.getMaxCurrentStrength(par1World, var12, var14, var13, -1);
    233                var9 = par1World.getBlockMetadata(par2, par3, par4);
    234
    235                if (var9 > 0)
    236                {
    237                    --var9;
    238                }
    239
    240                if (var16 >= 0 && var16 != var9)
    241                {
    242                    this.calculateCurrentChanges(par1World, var12, var14, var13, par2, par3, par4);
    243                }
    244            }
    245
    246            if (var8 < var9 || var9 == 0)
    247            {
    248                this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4));
    249                this.blocksNeedingUpdate.add(new ChunkPosition(par2 - 1, par3, par4));
    250                this.blocksNeedingUpdate.add(new ChunkPosition(par2 + 1, par3, par4));
    251                this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3 - 1, par4));
    252                this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3 + 1, par4));
    253                this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4 - 1));
    254                this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4 + 1));
    255            }
    256        }
    257    }
    258
    259    /**
    260     * Calls World.notifyBlocksOfNeighborChange() for all neighboring blocks, but only if the given block is a redstone
    261     * wire.
    262     */
    263    private void notifyWireNeighborsOfNeighborChange(World par1World, int par2, int par3, int par4)
    264    {
    265        if (par1World.getBlockId(par2, par3, par4) == this.blockID)
    266        {
    267            par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
    268            par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
    269            par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
    270            par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
    271            par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
    272            par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
    273            par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);
    274        }
    275    }
    276
    277    /**
    278     * Called whenever the block is added into the world. Args: world, x, y, z
    279     */
    280    public void onBlockAdded(World par1World, int par2, int par3, int par4)
    281    {
    282        super.onBlockAdded(par1World, par2, par3, par4);
    283
    284        if (!par1World.isRemote)
    285        {
    286            this.updateAndPropagateCurrentStrength(par1World, par2, par3, par4);
    287            par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);
    288            par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
    289            this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3, par4);
    290            this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3, par4);
    291            this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 - 1);
    292            this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 + 1);
    293
    294            if (par1World.isBlockNormalCube(par2 - 1, par3, par4))
    295            {
    296                this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 + 1, par4);
    297            }
    298            else
    299            {
    300                this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 - 1, par4);
    301            }
    302
    303            if (par1World.isBlockNormalCube(par2 + 1, par3, par4))
    304            {
    305                this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 + 1, par4);
    306            }
    307            else
    308            {
    309                this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 - 1, par4);
    310            }
    311
    312            if (par1World.isBlockNormalCube(par2, par3, par4 - 1))
    313            {
    314                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 - 1);
    315            }
    316            else
    317            {
    318                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 - 1);
    319            }
    320
    321            if (par1World.isBlockNormalCube(par2, par3, par4 + 1))
    322            {
    323                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 + 1);
    324            }
    325            else
    326            {
    327                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 + 1);
    328            }
    329        }
    330    }
    331
    332    /**
    333     * ejects contained items into the world, and notifies neighbours of an update, as appropriate
    334     */
    335    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
    336    {
    337        super.breakBlock(par1World, par2, par3, par4, par5, par6);
    338
    339        if (!par1World.isRemote)
    340        {
    341            par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);
    342            par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
    343            par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
    344            par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
    345            par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
    346            par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
    347            this.updateAndPropagateCurrentStrength(par1World, par2, par3, par4);
    348            this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3, par4);
    349            this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3, par4);
    350            this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 - 1);
    351            this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 + 1);
    352
    353            if (par1World.isBlockNormalCube(par2 - 1, par3, par4))
    354            {
    355                this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 + 1, par4);
    356            }
    357            else
    358            {
    359                this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 - 1, par4);
    360            }
    361
    362            if (par1World.isBlockNormalCube(par2 + 1, par3, par4))
    363            {
    364                this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 + 1, par4);
    365            }
    366            else
    367            {
    368                this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 - 1, par4);
    369            }
    370
    371            if (par1World.isBlockNormalCube(par2, par3, par4 - 1))
    372            {
    373                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 - 1);
    374            }
    375            else
    376            {
    377                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 - 1);
    378            }
    379
    380            if (par1World.isBlockNormalCube(par2, par3, par4 + 1))
    381            {
    382                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 + 1);
    383            }
    384            else
    385            {
    386                this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 + 1);
    387            }
    388        }
    389    }
    390
    391    /**
    392     * Returns the current strength at the specified block if it is greater than the passed value, or the passed value
    393     * otherwise. Signature: (world, x, y, z, strength)
    394     */
    395    private int getMaxCurrentStrength(World par1World, int par2, int par3, int par4, int par5)
    396    {
    397        if (par1World.getBlockId(par2, par3, par4) != this.blockID)
    398        {
    399            return par5;
    400        }
    401        else
    402        {
    403            int var6 = par1World.getBlockMetadata(par2, par3, par4);
    404            return var6 > par5 ? var6 : par5;
    405        }
    406    }
    407
    408    /**
    409     * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
    410     * their own) Args: x, y, z, neighbor blockID
    411     */
    412    public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
    413    {
    414        if (!par1World.isRemote)
    415        {
    416            int var6 = par1World.getBlockMetadata(par2, par3, par4);
    417            boolean var7 = this.canPlaceBlockAt(par1World, par2, par3, par4);
    418
    419            if (var7)
    420            {
    421                this.updateAndPropagateCurrentStrength(par1World, par2, par3, par4);
    422            }
    423            else
    424            {
    425                this.dropBlockAsItem(par1World, par2, par3, par4, var6, 0);
    426                par1World.setBlockWithNotify(par2, par3, par4, 0);
    427            }
    428
    429            super.onNeighborBlockChange(par1World, par2, par3, par4, par5);
    430        }
    431    }
    432
    433    /**
    434     * Returns the ID of the items to drop on destruction.
    435     */
    436    public int idDropped(int par1, Random par2Random, int par3)
    437    {
    438        return Item.redstone.itemID;
    439    }
    440
    441    /**
    442     * Returns true if the block is emitting direct/strong redstone power on the specified side. Args: World, X, Y, Z,
    443     * side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
    444     */
    445    public boolean isProvidingStrongPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    446    {
    447        return !this.wiresProvidePower ? false : this.isProvidingWeakPower(par1IBlockAccess, par2, par3, par4, par5);
    448    }
    449
    450    /**
    451     * Returns true if the block is emitting indirect/weak redstone power on the specified side. If isBlockNormalCube
    452     * returns true, standard redstone propagation rules will apply instead and this will not be called. Args: World, X,
    453     * Y, Z, side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
    454     */
    455    public boolean isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    456    {
    457        if (!this.wiresProvidePower)
    458        {
    459            return false;
    460        }
    461        else if (par1IBlockAccess.getBlockMetadata(par2, par3, par4) == 0)
    462        {
    463            return false;
    464        }
    465        else if (par5 == 1)
    466        {
    467            return true;
    468        }
    469        else
    470        {
    471            boolean var6 = isPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3, par4, 1) || !par1IBlockAccess.isBlockNormalCube(par2 - 1, par3, par4) && isPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3 - 1, par4, -1);
    472            boolean var7 = isPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3, par4, 3) || !par1IBlockAccess.isBlockNormalCube(par2 + 1, par3, par4) && isPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3 - 1, par4, -1);
    473            boolean var8 = isPoweredOrRepeater(par1IBlockAccess, par2, par3, par4 - 1, 2) || !par1IBlockAccess.isBlockNormalCube(par2, par3, par4 - 1) && isPoweredOrRepeater(par1IBlockAccess, par2, par3 - 1, par4 - 1, -1);
    474            boolean var9 = isPoweredOrRepeater(par1IBlockAccess, par2, par3, par4 + 1, 0) || !par1IBlockAccess.isBlockNormalCube(par2, par3, par4 + 1) && isPoweredOrRepeater(par1IBlockAccess, par2, par3 - 1, par4 + 1, -1);
    475
    476            if (!par1IBlockAccess.isBlockNormalCube(par2, par3 + 1, par4))
    477            {
    478                if (par1IBlockAccess.isBlockNormalCube(par2 - 1, par3, par4) && isPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3 + 1, par4, -1))
    479                {
    480                    var6 = true;
    481                }
    482
    483                if (par1IBlockAccess.isBlockNormalCube(par2 + 1, par3, par4) && isPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3 + 1, par4, -1))
    484                {
    485                    var7 = true;
    486                }
    487
    488                if (par1IBlockAccess.isBlockNormalCube(par2, par3, par4 - 1) && isPoweredOrRepeater(par1IBlockAccess, par2, par3 + 1, par4 - 1, -1))
    489                {
    490                    var8 = true;
    491                }
    492
    493                if (par1IBlockAccess.isBlockNormalCube(par2, par3, par4 + 1) && isPoweredOrRepeater(par1IBlockAccess, par2, par3 + 1, par4 + 1, -1))
    494                {
    495                    var9 = true;
    496                }
    497            }
    498
    499            return !var8 && !var7 && !var6 && !var9 && par5 >= 2 && par5 <= 5 ? true : (par5 == 2 && var8 && !var6 && !var7 ? true : (par5 == 3 && var9 && !var6 && !var7 ? true : (par5 == 4 && var6 && !var8 && !var9 ? true : par5 == 5 && var7 && !var8 && !var9)));
    500        }
    501    }
    502
    503    /**
    504     * Can this block provide power. Only wire currently seems to have this change based on its state.
    505     */
    506    public boolean canProvidePower()
    507    {
    508        return this.wiresProvidePower;
    509    }
    510
    511    @SideOnly(Side.CLIENT)
    512
    513    /**
    514     * A randomly called display update to be able to add particles or other items for display
    515     */
    516    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)
    517    {
    518        int var6 = par1World.getBlockMetadata(par2, par3, par4);
    519
    520        if (var6 > 0)
    521        {
    522            double var7 = (double)par2 + 0.5D + ((double)par5Random.nextFloat() - 0.5D) * 0.2D;
    523            double var9 = (double)((float)par3 + 0.0625F);
    524            double var11 = (double)par4 + 0.5D + ((double)par5Random.nextFloat() - 0.5D) * 0.2D;
    525            float var13 = (float)var6 / 15.0F;
    526            float var14 = var13 * 0.6F + 0.4F;
    527
    528            if (var6 == 0)
    529            {
    530                var14 = 0.0F;
    531            }
    532
    533            float var15 = var13 * var13 * 0.7F - 0.5F;
    534            float var16 = var13 * var13 * 0.6F - 0.7F;
    535
    536            if (var15 < 0.0F)
    537            {
    538                var15 = 0.0F;
    539            }
    540
    541            if (var16 < 0.0F)
    542            {
    543                var16 = 0.0F;
    544            }
    545
    546            par1World.spawnParticle("reddust", var7, var9, var11, (double)var14, (double)var15, (double)var16);
    547        }
    548    }
    549
    550    /**
    551     * Returns true if redstone wire can connect to the specified block. Params: World, X, Y, Z, side (not a normal
    552     * notch-side, this can be 0, 1, 2, 3 or -1)
    553     */
    554    public static boolean isPowerProviderOrWire(IBlockAccess par0IBlockAccess, int par1, int par2, int par3, int par4)
    555    {
    556        int var5 = par0IBlockAccess.getBlockId(par1, par2, par3);
    557
    558        if (var5 == Block.redstoneWire.blockID)
    559        {
    560            return true;
    561        }
    562        else if (var5 == 0)
    563        {
    564            return false;
    565        }
    566        else if (var5 != Block.redstoneRepeaterIdle.blockID && var5 != Block.redstoneRepeaterActive.blockID)
    567        {
    568            return (Block.blocksList[var5] != null && Block.blocksList[var5].canConnectRedstone(par0IBlockAccess, par1, par2, par3, par4));
    569        }
    570        else
    571        {
    572            int var6 = par0IBlockAccess.getBlockMetadata(par1, par2, par3);
    573            return par4 == (var6 & 3) || par4 == Direction.footInvisibleFaceRemap[var6 & 3];
    574        }
    575    }
    576
    577    /**
    578     * Returns true if the block coordinate passed can provide power, or is a redstone wire, or if its a repeater that
    579     * is powered.
    580     */
    581    public static boolean isPoweredOrRepeater(IBlockAccess par0IBlockAccess, int par1, int par2, int par3, int par4)
    582    {
    583        if (isPowerProviderOrWire(par0IBlockAccess, par1, par2, par3, par4))
    584        {
    585            return true;
    586        }
    587        else
    588        {
    589            int var5 = par0IBlockAccess.getBlockId(par1, par2, par3);
    590
    591            if (var5 == Block.redstoneRepeaterActive.blockID)
    592            {
    593                int var6 = par0IBlockAccess.getBlockMetadata(par1, par2, par3);
    594                return par4 == (var6 & 3);
    595            }
    596            else
    597            {
    598                return false;
    599            }
    600        }
    601    }
    602
    603    @SideOnly(Side.CLIENT)
    604
    605    /**
    606     * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
    607     */
    608    public int idPicked(World par1World, int par2, int par3, int par4)
    609    {
    610        return Item.redstone.itemID;
    611    }
    612}