001    package net.minecraft.src;
002    
003    import cpw.mods.fml.common.Side;
004    import cpw.mods.fml.common.asm.SideOnly;
005    
006    import java.util.ArrayList;
007    import java.util.List;
008    import java.util.Random;
009    
010    import net.minecraftforge.common.IShearable;
011    
012    public class BlockLeaves extends BlockLeavesBase implements IShearable
013    {
014        /**
015         * The base index in terrain.png corresponding to the fancy version of the leaf texture. This is stored so we can
016         * switch the displayed version between fancy and fast graphics (fast is this index + 1).
017         */
018        private int baseIndexInPNG;
019        public static final String[] LEAF_TYPES = new String[] {"oak", "spruce", "birch", "jungle"};
020        int[] adjacentTreeBlocks;
021    
022        protected BlockLeaves(int par1, int par2)
023        {
024            super(par1, par2, Material.leaves, false);
025            this.baseIndexInPNG = par2;
026            this.setTickRandomly(true);
027            this.setCreativeTab(CreativeTabs.tabDecorations);
028        }
029    
030        @SideOnly(Side.CLIENT)
031        public int getBlockColor()
032        {
033            double var1 = 0.5D;
034            double var3 = 1.0D;
035            return ColorizerFoliage.getFoliageColor(var1, var3);
036        }
037    
038        @SideOnly(Side.CLIENT)
039    
040        /**
041         * Returns the color this block should be rendered. Used by leaves.
042         */
043        public int getRenderColor(int par1)
044        {
045            return (par1 & 3) == 1 ? ColorizerFoliage.getFoliageColorPine() : ((par1 & 3) == 2 ? ColorizerFoliage.getFoliageColorBirch() : ColorizerFoliage.getFoliageColorBasic());
046        }
047    
048        @SideOnly(Side.CLIENT)
049    
050        /**
051         * Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
052         * when first determining what to render.
053         */
054        public int colorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
055        {
056            int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
057    
058            if ((var5 & 3) == 1)
059            {
060                return ColorizerFoliage.getFoliageColorPine();
061            }
062            else if ((var5 & 3) == 2)
063            {
064                return ColorizerFoliage.getFoliageColorBirch();
065            }
066            else
067            {
068                int var6 = 0;
069                int var7 = 0;
070                int var8 = 0;
071    
072                for (int var9 = -1; var9 <= 1; ++var9)
073                {
074                    for (int var10 = -1; var10 <= 1; ++var10)
075                    {
076                        int var11 = par1IBlockAccess.getBiomeGenForCoords(par2 + var10, par4 + var9).getBiomeFoliageColor();
077                        var6 += (var11 & 16711680) >> 16;
078                        var7 += (var11 & 65280) >> 8;
079                        var8 += var11 & 255;
080                    }
081                }
082    
083                return (var6 / 9 & 255) << 16 | (var7 / 9 & 255) << 8 | var8 / 9 & 255;
084            }
085        }
086    
087        /**
088         * ejects contained items into the world, and notifies neighbours of an update, as appropriate
089         */
090        public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
091        {
092            byte var7 = 1;
093            int var8 = var7 + 1;
094    
095            if (par1World.checkChunksExist(par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8))
096            {
097                for (int var9 = -var7; var9 <= var7; ++var9)
098                {
099                    for (int var10 = -var7; var10 <= var7; ++var10)
100                    {
101                        for (int var11 = -var7; var11 <= var7; ++var11)
102                        {
103                            int var12 = par1World.getBlockId(par2 + var9, par3 + var10, par4 + var11);
104    
105                            if (Block.blocksList[var12] != null)
106                            {
107                                Block.blocksList[var12].beginLeavesDecay(par1World, par2 + var9, par3 + var10, par4 + var11);
108                            }
109                        }
110                    }
111                }
112            }
113        }
114    
115        /**
116         * Ticks the block if it's been scheduled
117         */
118        public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
119        {
120            if (!par1World.isRemote)
121            {
122                int var6 = par1World.getBlockMetadata(par2, par3, par4);
123    
124                if ((var6 & 8) != 0 && (var6 & 4) == 0)
125                {
126                    byte var7 = 4;
127                    int var8 = var7 + 1;
128                    byte var9 = 32;
129                    int var10 = var9 * var9;
130                    int var11 = var9 / 2;
131    
132                    if (this.adjacentTreeBlocks == null)
133                    {
134                        this.adjacentTreeBlocks = new int[var9 * var9 * var9];
135                    }
136    
137                    int var12;
138    
139                    if (par1World.checkChunksExist(par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8))
140                    {
141                        int var13;
142                        int var14;
143                        int var15;
144    
145                        for (var12 = -var7; var12 <= var7; ++var12)
146                        {
147                            for (var13 = -var7; var13 <= var7; ++var13)
148                            {
149                                for (var14 = -var7; var14 <= var7; ++var14)
150                                {
151                                    var15 = par1World.getBlockId(par2 + var12, par3 + var13, par4 + var14);
152    
153                                    Block block = Block.blocksList[var15];
154    
155                                    if (block != null && block.canSustainLeaves(par1World, par2 + var12, par3 + var13, par4 + var14))
156                                    {
157                                        this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = 0;
158                                    }
159                                    else if (block != null && block.isLeaves(par1World, par2 + var12, par3 + var13, par4 + var14))
160                                    {
161                                        this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = -2;
162                                    }
163                                    else
164                                    {
165                                        this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = -1;
166                                    }
167                                }
168                            }
169                        }
170    
171                        for (var12 = 1; var12 <= 4; ++var12)
172                        {
173                            for (var13 = -var7; var13 <= var7; ++var13)
174                            {
175                                for (var14 = -var7; var14 <= var7; ++var14)
176                                {
177                                    for (var15 = -var7; var15 <= var7; ++var15)
178                                    {
179                                        if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11] == var12 - 1)
180                                        {
181                                            if (this.adjacentTreeBlocks[(var13 + var11 - 1) * var10 + (var14 + var11) * var9 + var15 + var11] == -2)
182                                            {
183                                                this.adjacentTreeBlocks[(var13 + var11 - 1) * var10 + (var14 + var11) * var9 + var15 + var11] = var12;
184                                            }
185    
186                                            if (this.adjacentTreeBlocks[(var13 + var11 + 1) * var10 + (var14 + var11) * var9 + var15 + var11] == -2)
187                                            {
188                                                this.adjacentTreeBlocks[(var13 + var11 + 1) * var10 + (var14 + var11) * var9 + var15 + var11] = var12;
189                                            }
190    
191                                            if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 - 1) * var9 + var15 + var11] == -2)
192                                            {
193                                                this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 - 1) * var9 + var15 + var11] = var12;
194                                            }
195    
196                                            if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 + 1) * var9 + var15 + var11] == -2)
197                                            {
198                                                this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 + 1) * var9 + var15 + var11] = var12;
199                                            }
200    
201                                            if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + (var15 + var11 - 1)] == -2)
202                                            {
203                                                this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + (var15 + var11 - 1)] = var12;
204                                            }
205    
206                                            if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11 + 1] == -2)
207                                            {
208                                                this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11 + 1] = var12;
209                                            }
210                                        }
211                                    }
212                                }
213                            }
214                        }
215                    }
216    
217                    var12 = this.adjacentTreeBlocks[var11 * var10 + var11 * var9 + var11];
218    
219                    if (var12 >= 0)
220                    {
221                        par1World.setBlockMetadata(par2, par3, par4, var6 & -9);
222                    }
223                    else
224                    {
225                        this.removeLeaves(par1World, par2, par3, par4);
226                    }
227                }
228            }
229        }
230    
231        @SideOnly(Side.CLIENT)
232    
233        /**
234         * A randomly called display update to be able to add particles or other items for display
235         */
236        public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)
237        {
238            if (par1World.canLightningStrikeAt(par2, par3 + 1, par4) && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && par5Random.nextInt(15) == 1)
239            {
240                double var6 = (double)((float)par2 + par5Random.nextFloat());
241                double var8 = (double)par3 - 0.05D;
242                double var10 = (double)((float)par4 + par5Random.nextFloat());
243                par1World.spawnParticle("dripWater", var6, var8, var10, 0.0D, 0.0D, 0.0D);
244            }
245        }
246    
247        private void removeLeaves(World par1World, int par2, int par3, int par4)
248        {
249            this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
250            par1World.setBlockWithNotify(par2, par3, par4, 0);
251        }
252    
253        /**
254         * Returns the quantity of items to drop on block destruction.
255         */
256        public int quantityDropped(Random par1Random)
257        {
258            return par1Random.nextInt(20) == 0 ? 1 : 0;
259        }
260    
261        /**
262         * Returns the ID of the items to drop on destruction.
263         */
264        public int idDropped(int par1, Random par2Random, int par3)
265        {
266            return Block.sapling.blockID;
267        }
268    
269        /**
270         * Drops the block items with a specified chance of dropping the specified items
271         */
272        public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7)
273        {
274            if (!par1World.isRemote)
275            {
276                byte var8 = 20;
277    
278                if ((par5 & 3) == 3)
279                {
280                    var8 = 40;
281                }
282    
283                if (par1World.rand.nextInt(var8) == 0)
284                {
285                    int var9 = this.idDropped(par5, par1World.rand, par7);
286                    this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(var9, 1, this.damageDropped(par5)));
287                }
288    
289                if ((par5 & 3) == 0 && par1World.rand.nextInt(200) == 0)
290                {
291                    this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0));
292                }
293            }
294        }
295    
296        /**
297         * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the
298         * block and l is the block's subtype/damage.
299         */
300        public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6)
301        {
302            super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
303        }
304    
305        /**
306         * Determines the damage on the item the block drops. Used in cloth and wood.
307         */
308        protected int damageDropped(int par1)
309        {
310            return par1 & 3;
311        }
312    
313        /**
314         * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
315         * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
316         */
317        public boolean isOpaqueCube()
318        {
319            return !this.graphicsLevel;
320        }
321    
322        /**
323         * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata
324         */
325        public int getBlockTextureFromSideAndMetadata(int par1, int par2)
326        {
327            return (par2 & 3) == 1 ? this.blockIndexInTexture + 80 : ((par2 & 3) == 3 ? this.blockIndexInTexture + 144 : this.blockIndexInTexture);
328        }
329    
330        @SideOnly(Side.CLIENT)
331    
332        /**
333         * Pass true to draw this block using fancy graphics, or false for fast graphics.
334         */
335        public void setGraphicsLevel(boolean par1)
336        {
337            this.graphicsLevel = par1;
338            this.blockIndexInTexture = this.baseIndexInPNG + (par1 ? 0 : 1);
339        }
340    
341        @SideOnly(Side.CLIENT)
342    
343        /**
344         * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
345         */
346        public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List)
347        {
348            par3List.add(new ItemStack(par1, 1, 0));
349            par3List.add(new ItemStack(par1, 1, 1));
350            par3List.add(new ItemStack(par1, 1, 2));
351            par3List.add(new ItemStack(par1, 1, 3));
352        }
353        
354        @Override
355        public boolean isShearable(ItemStack item, World world, int x, int y, int z) 
356        {
357            return true;
358        }
359    
360        @Override
361        public ArrayList<ItemStack> onSheared(ItemStack item, World world, int x, int y, int z, int fortune) 
362        {
363            ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
364            ret.add(new ItemStack(this, 1, world.getBlockMetadata(x, y, z) & 3));
365            return ret;
366        }
367    
368        @Override
369        public void beginLeavesDecay(World world, int x, int y, int z)
370        {
371            world.setBlockMetadata(x, y, z, world.getBlockMetadata(x, y, z) | 8);
372        }
373    
374        @Override
375        public boolean isLeaves(World world, int x, int y, int z)
376        {
377            return true;
378        }
379    }