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 }