API tools faq
paste
Advertisement
Guest User

BlockLeaves.java

a guest
Jun 8th, 2013
236
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 15.65 KB | None | 0 0
raw download clone embed print report
  1. package net.minecraft.src;
  2.  
  3. import java.util.List;
  4. import java.util.Random;
  5.  
  6. public class BlockLeaves extends BlockLeavesBase
  7. {
  8.     public static final String[] LEAF_TYPES = new String[] {"oak", "spruce", "birch", "jungle"};
  9.     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"}};
  10.     private int field_94394_cP;
  11.     private Icon[][] iconArray = new Icon[2][];
  12.     int[] adjacentTreeBlocks;
  13.     boolean hi = false;
  14.  
  15.     protected BlockLeaves(int par1)
  16.     {
  17.         super(par1, Material.leaves, false);
  18.         this.setTickRandomly(true);
  19.         this.setCreativeTab(CreativeTabs.tabDecorations);
  20.         this.hi = false;
  21.     }
  22.  
  23.     public int getBlockColor()
  24.     {
  25.         double var1 = 0.5D;
  26.         double var3 = 1.0D;
  27.         return ColorizerFoliage.getFoliageColor(var1, var3);
  28.     }
  29.  
  30.     /**
  31.      * Returns the color this block should be rendered. Used by leaves.
  32.      */
  33.     public int getRenderColor(int par1)
  34.     {
  35.         return (par1 & 3) == 1 ? ColorizerFoliage.getFoliageColorPine() : ((par1 & 3) == 2 ? ColorizerFoliage.getFoliageColorBirch() : ColorizerFoliage.getFoliageColorBasic());
  36.     }
  37.  
  38.     /**
  39.      * Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
  40.      * when first determining what to render.
  41.      */
  42.     public int colorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
  43.     {
  44.         int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
  45.  
  46.         if ((var5 & 3) == 1)
  47.         {
  48.             return ColorizerFoliage.getFoliageColorPine();
  49.         }
  50.         else if ((var5 & 3) == 2)
  51.         {
  52.             return ColorizerFoliage.getFoliageColorBirch();
  53.         }
  54.         else
  55.         {
  56.             int var6 = 0;
  57.             int var7 = 0;
  58.             int var8 = 0;
  59.  
  60.             for (int var9 = -1; var9 <= 1; ++var9)
  61.             {
  62.                 for (int var10 = -1; var10 <= 1; ++var10)
  63.                 {
  64.                     int var11 = par1IBlockAccess.getBiomeGenForCoords(par2 + var10, par4 + var9).getBiomeFoliageColor();
  65.                     var6 += (var11 & 16711680) >> 16;
  66.                     var7 += (var11 & 65280) >> 8;
  67.                     var8 += var11 & 255;
  68.                 }
  69.             }
  70.  
  71.             return (var6 / 9 & 255) << 16 | (var7 / 9 & 255) << 8 | var8 / 9 & 255;
  72.         }
  73.     }
  74.  
  75.     /**
  76.      * ejects contained items into the world, and notifies neighbours of an update, as appropriate
  77.      */
  78.     public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
  79.     {
  80.         byte var7 = 1;
  81.         int var8 = var7 + 1;
  82.  
  83.         if (par1World.checkChunksExist(par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8))
  84.         {
  85.             for (int var9 = -var7; var9 <= var7; ++var9)
  86.             {
  87.                 for (int var10 = -var7; var10 <= var7; ++var10)
  88.                 {
  89.                     for (int var11 = -var7; var11 <= var7; ++var11)
  90.                     {
  91.                         int var12 = par1World.getBlockId(par2 + var9, par3 + var10, par4 + var11);
  92.  
  93.                         if (var12 == Block.leaves.blockID)
  94.                         {
  95.                             int var13 = par1World.getBlockMetadata(par2 + var9, par3 + var10, par4 + var11);
  96.                             par1World.setBlockMetadataWithNotify(par2 + var9, par3 + var10, par4 + var11, var13 | 8, 4);
  97.                         }
  98.                     }
  99.                 }
  100.             }
  101.         }
  102.     }
  103.  
  104.     /**
  105.      * Ticks the block if it's been scheduled
  106.      */
  107.     public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
  108.     {
  109.         if (!par1World.isRemote)
  110.         {
  111.             int var6 = par1World.getBlockMetadata(par2, par3, par4);
  112.  
  113.             if ((var6 & 8) != 0 && (var6 & 4) == 0)
  114.             {
  115.                 byte var7 = 4;
  116.                 int var8 = var7 + 1;
  117.                 byte var9 = 32;
  118.                 int var10 = var9 * var9;
  119.                 int var11 = var9 / 2;
  120.  
  121.                 if (this.adjacentTreeBlocks == null)
  122.                 {
  123.                     this.adjacentTreeBlocks = new int[var9 * var9 * var9];
  124.                 }
  125.  
  126.                 int var12;
  127.  
  128.                 if (par1World.checkChunksExist(par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8))
  129.                 {
  130.                     int var13;
  131.                     int var14;
  132.                     int var15;
  133.  
  134.                     for (var12 = -var7; var12 <= var7; ++var12)
  135.                     {
  136.                         for (var13 = -var7; var13 <= var7; ++var13)
  137.                         {
  138.                             for (var14 = -var7; var14 <= var7; ++var14)
  139.                             {
  140.                                 var15 = par1World.getBlockId(par2 + var12, par3 + var13, par4 + var14);
  141.  
  142.                                 if (var15 == Block.wood.blockID)
  143.                                 {
  144.                                     this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = 0;
  145.                                 }
  146.                                 else if (var15 == Block.leaves.blockID)
  147.                                 {
  148.                                     this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = -2;
  149.                                 }
  150.                                 else
  151.                                 {
  152.                                     this.adjacentTreeBlocks[(var12 + var11) * var10 + (var13 + var11) * var9 + var14 + var11] = -1;
  153.                                 }
  154.                             }
  155.                         }
  156.                     }
  157.  
  158.                     for (var12 = 1; var12 <= 4; ++var12)
  159.                     {
  160.                         for (var13 = -var7; var13 <= var7; ++var13)
  161.                         {
  162.                             for (var14 = -var7; var14 <= var7; ++var14)
  163.                             {
  164.                                 for (var15 = -var7; var15 <= var7; ++var15)
  165.                                 {
  166.                                     if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11] == var12 - 1)
  167.                                     {
  168.                                         if (this.adjacentTreeBlocks[(var13 + var11 - 1) * var10 + (var14 + var11) * var9 + var15 + var11] == -2)
  169.                                         {
  170.                                             this.adjacentTreeBlocks[(var13 + var11 - 1) * var10 + (var14 + var11) * var9 + var15 + var11] = var12;
  171.                                         }
  172.  
  173.                                         if (this.adjacentTreeBlocks[(var13 + var11 + 1) * var10 + (var14 + var11) * var9 + var15 + var11] == -2)
  174.                                         {
  175.                                             this.adjacentTreeBlocks[(var13 + var11 + 1) * var10 + (var14 + var11) * var9 + var15 + var11] = var12;
  176.                                         }
  177.  
  178.                                         if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 - 1) * var9 + var15 + var11] == -2)
  179.                                         {
  180.                                             this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 - 1) * var9 + var15 + var11] = var12;
  181.                                         }
  182.  
  183.                                         if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 + 1) * var9 + var15 + var11] == -2)
  184.                                         {
  185.                                             this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11 + 1) * var9 + var15 + var11] = var12;
  186.                                         }
  187.  
  188.                                         if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + (var15 + var11 - 1)] == -2)
  189.                                         {
  190.                                             this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + (var15 + var11 - 1)] = var12;
  191.                                         }
  192.  
  193.                                         if (this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11 + 1] == -2)
  194.                                         {
  195.                                             this.adjacentTreeBlocks[(var13 + var11) * var10 + (var14 + var11) * var9 + var15 + var11 + 1] = var12;
  196.                                         }
  197.                                     }
  198.                                 }
  199.                             }
  200.                         }
  201.                     }
  202.                 }
  203.  
  204.                 var12 = this.adjacentTreeBlocks[var11 * var10 + var11 * var9 + var11];
  205.  
  206.                 if (var12 >= 0)
  207.                 {
  208.                     par1World.setBlockMetadataWithNotify(par2, par3, par4, var6 & -9, 4);
  209.                 }
  210.                 else
  211.                 {
  212.                     this.removeLeaves(par1World, par2, par3, par4);
  213.                 }
  214.             }
  215.         }
  216.     }
  217.  
  218.     /**
  219.      * A randomly called display update to be able to add particles or other items for display
  220.      */
  221.     public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)
  222.     {
  223.         if (par1World.canLightningStrikeAt(par2, par3 + 1, par4) && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && par5Random.nextInt(15) == 1)
  224.         {
  225.             double var6 = (double)((float)par2 + par5Random.nextFloat());
  226.             double var8 = (double)par3 - 0.05D;
  227.             double var10 = (double)((float)par4 + par5Random.nextFloat());
  228.             par1World.spawnParticle("dripWater", var6, var8, var10, 0.0D, 0.0D, 0.0D);
  229.         }
  230.     }
  231.  
  232.     private void removeLeaves(World par1World, int par2, int par3, int par4)
  233.     {
  234.         this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
  235.         par1World.setBlockToAir(par2, par3, par4);
  236.     }
  237.  
  238.     /**
  239.      * Returns the quantity of items to drop on block destruction.
  240.      */
  241.     public int quantityDropped(Random par1Random)
  242.     {
  243.         return par1Random.nextInt(20) == 0 ? 1 : 0;
  244.     }
  245.  
  246.     /**
  247.      * Returns the ID of the items to drop on destruction.
  248.      */
  249.     public int idDropped(int par1, Random par2Random, int par3)
  250.     {
  251.         return Block.sapling.blockID;
  252.     }
  253.  
  254.     /**
  255.      * Drops the block items with a specified chance of dropping the specified items
  256.      */
  257.     public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7)
  258.     {
  259.         if (!par1World.isRemote)
  260.         {
  261.             int var8 = 20;
  262.  
  263.             if ((par5 & 3) == 3)
  264.             {
  265.                 var8 = 40;
  266.             }
  267.  
  268.             if (par7 > 0)
  269.             {
  270.                 var8 -= 2 << par7;
  271.  
  272.                 if (var8 < 10)
  273.                 {
  274.                     var8 = 10;
  275.                 }
  276.             }
  277.  
  278.             if (par1World.rand.nextInt(var8) == 0)
  279.             {
  280.                 int var9 = this.idDropped(par5, par1World.rand, par7);
  281.                 this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(var9, 1, this.damageDropped(par5)));
  282.             }
  283.  
  284.             var8 = 200;
  285.  
  286.             if (par7 > 0)
  287.             {
  288.                 var8 -= 10 << par7;
  289.  
  290.                 if (var8 < 40)
  291.                 {
  292.                     var8 = 40;
  293.                 }
  294.             }
  295.  
  296.             if ((par5 & 3) == 0 && par1World.rand.nextInt(var8) == 0)
  297.             {
  298.                 this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0));
  299.             }
  300.         }
  301.     }
  302.  
  303.     /**
  304.      * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the
  305.      * block and l is the block's subtype/damage.
  306.      */
  307.     public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6)
  308.     {
  309.         if (!par1World.isRemote && par2EntityPlayer.getCurrentEquippedItem() != null && par2EntityPlayer.getCurrentEquippedItem().itemID == Item.shears.itemID)
  310.         {
  311.             par2EntityPlayer.addStat(StatList.mineBlockStatArray[this.blockID], 1);
  312.             this.dropBlockAsItem_do(par1World, par3, par4, par5, new ItemStack(Block.leaves.blockID, 1, par6 & 3));
  313.         }
  314.         else
  315.         {
  316.             super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
  317.         }
  318.     }
  319.  
  320.     /**
  321.      * Determines the damage on the item the block drops. Used in cloth and wood.
  322.      */
  323.     public int damageDropped(int par1)
  324.     {
  325.         return par1 & 3;
  326.     }
  327.  
  328.     /**
  329.      * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
  330.      * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
  331.      */
  332.     public boolean isOpaqueCube()
  333.     {
  334.         return false;
  335.     }
  336.    
  337.     public int getRenderBlockPass()
  338.     {
  339.         return !this.hi ? 0 : 1;
  340.     }
  341.  
  342.     public boolean renderAsNormalBlock()
  343.     {
  344.         return this.hi;
  345.     }
  346.    
  347.     public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
  348.     {
  349.         int var6 = par1IBlockAccess.getBlockId(par2, par3, par4);
  350.         //return !this.hi && var6 == this.blockID ? false : super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5);
  351.         return var6 != this.blockID;
  352.     }
  353.     /**
  354.      * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata
  355.      */
  356.     public Icon getIcon(int par1, int par2)
  357.     {
  358.         return (par2 & 3) == 1 ? this.iconArray[0][1] : ((par2 & 3) == 3 ? this.iconArray[0][3] : this.iconArray[0][0]);
  359.     }
  360.  
  361.     /**
  362.      * Pass true to draw this block using fancy graphics, or false for fast graphics.
  363.      */
  364.     public void setGraphicsLevel(boolean par1)
  365.     {
  366.         this.graphicsLevel = true;
  367.         this.hi = par1;
  368.         this.field_94394_cP = par1 ? 0 : 1;
  369.     }
  370.  
  371.     /**
  372.      * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
  373.      */
  374.     public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List)
  375.     {
  376.         par3List.add(new ItemStack(par1, 1, 0));
  377.         par3List.add(new ItemStack(par1, 1, 1));
  378.         par3List.add(new ItemStack(par1, 1, 2));
  379.         par3List.add(new ItemStack(par1, 1, 3));
  380.     }
  381.  
  382.     /**
  383.      * Returns an item stack containing a single instance of the current block type. 'i' is the block's subtype/damage
  384.      * and is ignored for blocks which do not support subtypes. Blocks which cannot be harvested should return null.
  385.      */
  386.     protected ItemStack createStackedBlock(int par1)
  387.     {
  388.         return new ItemStack(this.blockID, 1, par1 & 3);
  389.     }
  390.  
  391.     /**
  392.      * When this method is called, your block should register all the icons it needs with the given IconRegister. This
  393.      * is the only chance you get to register icons.
  394.      */
  395.     public void registerIcons(IconRegister par1IconRegister)
  396.     {
  397.         for (int var2 = 0; var2 < field_94396_b.length; ++var2)
  398.         {
  399.             this.iconArray[var2] = new Icon[field_94396_b[var2].length];
  400.  
  401.             for (int var3 = 0; var3 < field_94396_b[var2].length; ++var3)
  402.             {
  403.                 this.iconArray[var2][var3] = par1IconRegister.registerIcon(field_94396_b[var2][var3]);
  404.             }
  405.         }
  406.     }
  407. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!