001package net.minecraft.block; 002 003import cpw.mods.fml.relauncher.Side; 004import cpw.mods.fml.relauncher.SideOnly; 005 006import java.util.ArrayList; 007import java.util.List; 008import java.util.Random; 009import net.minecraft.block.material.Material; 010import net.minecraft.client.renderer.texture.IconRegister; 011import net.minecraft.creativetab.CreativeTabs; 012import net.minecraft.entity.player.EntityPlayer; 013import net.minecraft.item.Item; 014import net.minecraft.item.ItemStack; 015import net.minecraft.stats.StatList; 016import net.minecraft.util.Icon; 017import net.minecraft.world.ColorizerFoliage; 018import net.minecraft.world.IBlockAccess; 019import net.minecraft.world.World; 020 021import net.minecraftforge.common.IShearable; 022 023public class BlockLeaves extends BlockLeavesBase implements IShearable 024{ 025 public static final String[] LEAF_TYPES = new String[] {"oak", "spruce", "birch", "jungle"}; 026 public static final String[][] field_94396_b = new String[][] {{"leaves", "leaves_spruce", "leaves", "leaves_jungle"}, {"leaves_opaque", "leaves_spruce_opaque", "leaves_opaque", "leaves_jungle_opaque"}}; 027 @SideOnly(Side.CLIENT) 028 private int field_94394_cP; 029 private Icon[][] iconArray = new Icon[2][]; 030 int[] adjacentTreeBlocks; 031 032 protected BlockLeaves(int par1) 033 { 034 super(par1, Material.leaves, false); 035 this.setTickRandomly(true); 036 this.setCreativeTab(CreativeTabs.tabDecorations); 037 } 038 039 @SideOnly(Side.CLIENT) 040 public int getBlockColor() 041 { 042 double d0 = 0.5D; 043 double d1 = 1.0D; 044 return ColorizerFoliage.getFoliageColor(d0, d1); 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 l = par1IBlockAccess.getBlockMetadata(par2, par3, par4); 066 067 if ((l & 3) == 1) 068 { 069 return ColorizerFoliage.getFoliageColorPine(); 070 } 071 else if ((l & 3) == 2) 072 { 073 return ColorizerFoliage.getFoliageColorBirch(); 074 } 075 else 076 { 077 int i1 = 0; 078 int j1 = 0; 079 int k1 = 0; 080 081 for (int l1 = -1; l1 <= 1; ++l1) 082 { 083 for (int i2 = -1; i2 <= 1; ++i2) 084 { 085 int j2 = par1IBlockAccess.getBiomeGenForCoords(par2 + i2, par4 + l1).getBiomeFoliageColor(); 086 i1 += (j2 & 16711680) >> 16; 087 j1 += (j2 & 65280) >> 8; 088 k1 += j2 & 255; 089 } 090 } 091 092 return (i1 / 9 & 255) << 16 | (j1 / 9 & 255) << 8 | k1 / 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 b0 = 1; 102 int j1 = b0 + 1; 103 104 if (par1World.checkChunksExist(par2 - j1, par3 - j1, par4 - j1, par2 + j1, par3 + j1, par4 + j1)) 105 { 106 for (int k1 = -b0; k1 <= b0; ++k1) 107 { 108 for (int l1 = -b0; l1 <= b0; ++l1) 109 { 110 for (int i2 = -b0; i2 <= b0; ++i2) 111 { 112 int j2 = par1World.getBlockId(par2 + k1, par3 + l1, par4 + i2); 113 114 if (Block.blocksList[j2] != null) 115 { 116 Block.blocksList[j2].beginLeavesDecay(par1World, par2 + k1, par3 + l1, par4 + i2); 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 l = par1World.getBlockMetadata(par2, par3, par4); 132 133 if ((l & 8) != 0 && (l & 4) == 0) 134 { 135 byte b0 = 4; 136 int i1 = b0 + 1; 137 byte b1 = 32; 138 int j1 = b1 * b1; 139 int k1 = b1 / 2; 140 141 if (this.adjacentTreeBlocks == null) 142 { 143 this.adjacentTreeBlocks = new int[b1 * b1 * b1]; 144 } 145 146 int l1; 147 148 if (par1World.checkChunksExist(par2 - i1, par3 - i1, par4 - i1, par2 + i1, par3 + i1, par4 + i1)) 149 { 150 int i2; 151 int j2; 152 int k2; 153 154 for (l1 = -b0; l1 <= b0; ++l1) 155 { 156 for (i2 = -b0; i2 <= b0; ++i2) 157 { 158 for (j2 = -b0; j2 <= b0; ++j2) 159 { 160 k2 = par1World.getBlockId(par2 + l1, par3 + i2, par4 + j2); 161 162 Block block = Block.blocksList[k2]; 163 164 if (block != null && block.canSustainLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) 165 { 166 this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = 0; 167 } 168 else if (block != null && block.isLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) 169 { 170 this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -2; 171 } 172 else 173 { 174 this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -1; 175 } 176 } 177 } 178 } 179 180 for (l1 = 1; l1 <= 4; ++l1) 181 { 182 for (i2 = -b0; i2 <= b0; ++i2) 183 { 184 for (j2 = -b0; j2 <= b0; ++j2) 185 { 186 for (k2 = -b0; k2 <= b0; ++k2) 187 { 188 if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1] == l1 - 1) 189 { 190 if (this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) 191 { 192 this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1; 193 } 194 195 if (this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) 196 { 197 this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1; 198 } 199 200 if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] == -2) 201 { 202 this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] = l1; 203 } 204 205 if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] == -2) 206 { 207 this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] = l1; 208 } 209 210 if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] == -2) 211 { 212 this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] = l1; 213 } 214 215 if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] == -2) 216 { 217 this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] = l1; 218 } 219 } 220 } 221 } 222 } 223 } 224 } 225 226 l1 = this.adjacentTreeBlocks[k1 * j1 + k1 * b1 + k1]; 227 228 if (l1 >= 0) 229 { 230 par1World.setBlockMetadataWithNotify(par2, par3, par4, l & -9, 4); 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 d0 = (double)((float)par2 + par5Random.nextFloat()); 250 double d1 = (double)par3 - 0.05D; 251 double d2 = (double)((float)par4 + par5Random.nextFloat()); 252 par1World.spawnParticle("dripWater", d0, d1, d2, 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.setBlockToAir(par2, par3, par4); 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 int j1 = 20; 286 287 if ((par5 & 3) == 3) 288 { 289 j1 = 40; 290 } 291 292 if (par7 > 0) 293 { 294 j1 -= 2 << par7; 295 296 if (j1 < 10) 297 { 298 j1 = 10; 299 } 300 } 301 302 if (par1World.rand.nextInt(j1) == 0) 303 { 304 int k1 = this.idDropped(par5, par1World.rand, par7); 305 this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(k1, 1, this.damageDropped(par5))); 306 } 307 308 j1 = 200; 309 310 if (par7 > 0) 311 { 312 j1 -= 10 << par7; 313 314 if (j1 < 40) 315 { 316 j1 = 40; 317 } 318 } 319 320 if ((par5 & 3) == 0 && par1World.rand.nextInt(j1) == 0) 321 { 322 this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0)); 323 } 324 } 325 } 326 327 /** 328 * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the 329 * block and l is the block's subtype/damage. 330 */ 331 public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) 332 { 333 super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6); 334 } 335 336 /** 337 * Determines the damage on the item the block drops. Used in cloth and wood. 338 */ 339 public int damageDropped(int par1) 340 { 341 return par1 & 3; 342 } 343 344 /** 345 * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two 346 * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block. 347 */ 348 public boolean isOpaqueCube() 349 { 350 return !this.graphicsLevel; 351 } 352 353 @SideOnly(Side.CLIENT) 354 355 /** 356 * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata 357 */ 358 public Icon getIcon(int par1, int par2) 359 { 360 return (par2 & 3) == 1 ? this.iconArray[this.field_94394_cP][1] : ((par2 & 3) == 3 ? this.iconArray[this.field_94394_cP][3] : this.iconArray[this.field_94394_cP][0]); 361 } 362 363 @SideOnly(Side.CLIENT) 364 365 /** 366 * Pass true to draw this block using fancy graphics, or false for fast graphics. 367 */ 368 public void setGraphicsLevel(boolean par1) 369 { 370 this.graphicsLevel = par1; 371 this.field_94394_cP = par1 ? 0 : 1; 372 } 373 374 @SideOnly(Side.CLIENT) 375 376 /** 377 * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks) 378 */ 379 public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) 380 { 381 par3List.add(new ItemStack(par1, 1, 0)); 382 par3List.add(new ItemStack(par1, 1, 1)); 383 par3List.add(new ItemStack(par1, 1, 2)); 384 par3List.add(new ItemStack(par1, 1, 3)); 385 } 386 387 /** 388 * Returns an item stack containing a single instance of the current block type. 'i' is the block's subtype/damage 389 * and is ignored for blocks which do not support subtypes. Blocks which cannot be harvested should return null. 390 */ 391 protected ItemStack createStackedBlock(int par1) 392 { 393 return new ItemStack(this.blockID, 1, par1 & 3); 394 } 395 396 @SideOnly(Side.CLIENT) 397 398 /** 399 * When this method is called, your block should register all the icons it needs with the given IconRegister. This 400 * is the only chance you get to register icons. 401 */ 402 public void registerIcons(IconRegister par1IconRegister) 403 { 404 for (int i = 0; i < field_94396_b.length; ++i) 405 { 406 this.iconArray[i] = new Icon[field_94396_b[i].length]; 407 408 for (int j = 0; j < field_94396_b[i].length; ++j) 409 { 410 this.iconArray[i][j] = par1IconRegister.registerIcon(field_94396_b[i][j]); 411 } 412 } 413 } 414 415 @Override 416 public boolean isShearable(ItemStack item, World world, int x, int y, int z) 417 { 418 return true; 419 } 420 421 @Override 422 public ArrayList<ItemStack> onSheared(ItemStack item, World world, int x, int y, int z, int fortune) 423 { 424 ArrayList<ItemStack> ret = new ArrayList<ItemStack>(); 425 ret.add(new ItemStack(this, 1, world.getBlockMetadata(x, y, z) & 3)); 426 return ret; 427 } 428 429 @Override 430 public void beginLeavesDecay(World world, int x, int y, int z) 431 { 432 world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) | 8, 4); 433 } 434 435 @Override 436 public boolean isLeaves(World world, int x, int y, int z) 437 { 438 return true; 439 } 440}