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