SHARE
TWEET

Untitled

Bogigaba Feb 16th, 2013 41 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package sci.craft;
  2.  
  3.  
  4. import java.util.Random;
  5.  
  6. import net.minecraft.block.Block;
  7. import net.minecraft.block.BlockStationary;
  8. import net.minecraft.block.material.Material;
  9. import net.minecraft.entity.Entity;
  10. import net.minecraft.entity.EntityLiving;
  11. import net.minecraft.potion.Potion;
  12. import net.minecraft.potion.PotionEffect;
  13. import net.minecraft.world.IBlockAccess;
  14. import net.minecraft.world.World;
  15. import net.minecraftforge.event.ForgeSubscribe;
  16.  
  17. public class MercuryStill extends BlockStationary {
  18.  
  19.     protected MercuryStill(int id, Material materail) {
  20.         super(id, Material.water);
  21.         this.blockHardness = 100F;
  22.         this.setLightOpacity(3);
  23.         this.setBlockName("mercurys");
  24.         setCreativeTab(Sci.tabB);
  25.         this.disableStats();
  26.         this.setRequiresSelfNotify();
  27.     }
  28.     public void onEntityWalking(World par1World, int par2, int par3, int par4, Entity par5Entity) {
  29.         if (par5Entity instanceof EntityLiving) {
  30.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.confusion.getId(), 400, 2));
  31.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.poison.getId(), 260, 2));
  32.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.hunger.getId(), 260, 1));
  33.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.weakness.getId(), 260, 1));
  34.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.digSlowdown.getId(), 260, 2));
  35.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.blindness.getId(), 260, 1));
  36.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.moveSlowdown.getId(), 260, 1));
  37.         }
  38.         }
  39.    
  40.     public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
  41.     {
  42.         return 0xCCCC00;
  43.     }
  44.     public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
  45.     {
  46.         return this.blockMaterial != Material.lava;
  47.     }
  48.  
  49.     /**
  50.      * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
  51.      * their own) Args: x, y, z, neighbor blockID
  52.      */
  53.     public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
  54.     {
  55.         super.onNeighborBlockChange(par1World, par2, par3, par4, par5);
  56.  
  57.         if (par1World.getBlockId(par2, par3, par4) == this.blockID)
  58.         {
  59.             this.setNotStationary(par1World, par2, par3, par4);
  60.         }
  61.     }
  62.  
  63.     /**
  64.      * Changes the block ID to that of an updating fluid.
  65.      */
  66.     private void setNotStationary(World par1World, int par2, int par3, int par4)
  67.     {
  68.         int var5 = par1World.getBlockMetadata(par2, par3, par4);
  69.         par1World.editingBlocks = true;
  70.         par1World.setBlockAndMetadata(par2, par3, par4, this.blockID - 1, var5);
  71.         par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
  72.         par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID - 1, this.tickRate());
  73.         par1World.editingBlocks = false;
  74.     }
  75.  
  76.     /**
  77.      * Ticks the block if it's been scheduled
  78.      */
  79.     public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
  80.     {
  81.         if (this.blockMaterial == Material.lava)
  82.         {
  83.             int var6 = par5Random.nextInt(3);
  84.             int var7;
  85.             int var8;
  86.  
  87.             for (var7 = 0; var7 < var6; ++var7)
  88.             {
  89.                 par2 += par5Random.nextInt(3) - 1;
  90.                 ++par3;
  91.                 par4 += par5Random.nextInt(3) - 1;
  92.                 var8 = par1World.getBlockId(par2, par3, par4);
  93.  
  94.                 if (var8 == 0)
  95.                 {
  96.                     if (this.isFlammable(par1World, par2 - 1, par3, par4) || this.isFlammable(par1World, par2 + 1, par3, par4) || this.isFlammable(par1World, par2, par3, par4 - 1) || this.isFlammable(par1World, par2, par3, par4 + 1) || this.isFlammable(par1World, par2, par3 - 1, par4) || this.isFlammable(par1World, par2, par3 + 1, par4))
  97.                     {
  98.                         par1World.setBlockWithNotify(par2, par3, par4, Block.fire.blockID);
  99.                         return;
  100.                     }
  101.                 }
  102.                 else if (Block.blocksList[var8].blockMaterial.blocksMovement())
  103.                 {
  104.                     return;
  105.                 }
  106.             }
  107.  
  108.             if (var6 == 0)
  109.             {
  110.                 var7 = par2;
  111.                 var8 = par4;
  112.  
  113.                 for (int var9 = 0; var9 < 3; ++var9)
  114.                 {
  115.                     par2 = var7 + par5Random.nextInt(3) - 1;
  116.                     par4 = var8 + par5Random.nextInt(3) - 1;
  117.  
  118.                     if (par1World.isAirBlock(par2, par3 + 1, par4) && this.isFlammable(par1World, par2, par3, par4))
  119.                     {
  120.                         par1World.setBlockWithNotify(par2, par3 + 1, par4, Block.fire.blockID);
  121.                     }
  122.                 }
  123.             }
  124.         }
  125.     }
  126.  
  127.     /**
  128.      * Checks to see if the block is flammable.
  129.      */
  130.     private boolean isFlammable(World par1World, int par2, int par3, int par4)
  131.     {
  132.         return par1World.getBlockMaterial(par2, par3, par4).getCanBurn();
  133.     }
  134.  
  135.         public String getTextureFile() {
  136.                 return CommonProxy.BLOCK_PNG;
  137.         }
  138. }
  139.  
  140.  
  141. #########################################################################################################
  142. Flowing Class
  143. #########################################################################################################
  144. package sci.craft;
  145.  
  146. import java.util.Random;
  147.  
  148. import net.minecraft.block.Block;
  149. import net.minecraft.block.BlockFlowing;
  150. import net.minecraft.block.material.Material;
  151. import net.minecraft.entity.Entity;
  152. import net.minecraft.entity.EntityLiving;
  153. import net.minecraft.potion.Potion;
  154. import net.minecraft.potion.PotionEffect;
  155. import net.minecraft.world.IBlockAccess;
  156. import net.minecraft.world.World;
  157.  
  158.  
  159. public class Mercury extends BlockFlowing {
  160.  
  161.     protected Mercury(int id, Material material) {
  162.         super(id, Material.water);
  163.         this.blockHardness = 100F;
  164.         this.setBlockName("mercury");
  165.         this.disableStats();
  166.        
  167.        // setCreativeTab(Sci.tabB);
  168.     }
  169.     public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
  170.     {
  171.         return 0xCCCC00;
  172.     }
  173.  
  174.     public void onEntityWalking(World par1World, int par2, int par3, int par4, Entity par5Entity) {
  175.         if (par5Entity instanceof EntityLiving) {
  176.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.confusion.getId(), 400, 2));
  177.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.poison.getId(), 260, 2));
  178.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.hunger.getId(), 260, 1));
  179.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.weakness.getId(), 260, 1));
  180.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.digSlowdown.getId(), 260, 2));
  181.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.blindness.getId(), 260, 1));
  182.         ((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.moveSlowdown.getId(), 260, 1));
  183.         }
  184.         }/**
  185.      * Number of horizontally adjacent liquid source blocks. Diagonal doesn't count. Only source blocks of the same
  186.      * liquid as the block using the field are counted.
  187.      */
  188.     int numAdjacentSources = 0;
  189.  
  190.     /**
  191.      * Indicates whether the flow direction is optimal. Each array index corresponds to one of the four cardinal
  192.      * directions.
  193.      */
  194.     boolean[] isOptimalFlowDirection = new boolean[4];
  195.  
  196.     /**
  197.      * The estimated cost to flow in a given direction from the current point. Each array index corresponds to one of
  198.      * the four cardinal directions.
  199.      */
  200.     int[] flowCost = new int[4];
  201.  
  202.    
  203.  
  204.     /**
  205.      * Updates the flow for the BlockFlowing object.
  206.      */
  207.     private void updateFlow(World par1World, int par2, int par3, int par4)
  208.     {
  209.         int var5 = par1World.getBlockMetadata(par2, par3, par4);
  210.         par1World.setBlockAndMetadata(par2, par3, par4, this.blockID + 1, var5);
  211.         par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
  212.     }
  213.  
  214.     public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
  215.     {
  216.         return this.blockMaterial != Material.lava;
  217.     }
  218.  
  219.     /**
  220.      * Ticks the block if it's been scheduled
  221.      */
  222.     public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
  223.     {
  224.         int var6 = this.getFlowDecay(par1World, par2, par3, par4);
  225.         byte var7 = 1;
  226.  
  227.         if (this.blockMaterial == Material.lava && !par1World.provider.isHellWorld)
  228.         {
  229.             var7 = 2;
  230.         }
  231.  
  232.         boolean var8 = true;
  233.         int var10;
  234.  
  235.         if (var6 > 0)
  236.         {
  237.             byte var9 = -100;
  238.             this.numAdjacentSources = 0;
  239.             int var12 = this.getSmallestFlowDecay(par1World, par2 - 1, par3, par4, var9);
  240.             var12 = this.getSmallestFlowDecay(par1World, par2 + 1, par3, par4, var12);
  241.             var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 - 1, var12);
  242.             var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 + 1, var12);
  243.             var10 = var12 + var7;
  244.  
  245.             if (var10 >= 8 || var12 < 0)
  246.             {
  247.                 var10 = -1;
  248.             }
  249.  
  250.             if (this.getFlowDecay(par1World, par2, par3 + 1, par4) >= 0)
  251.             {
  252.                 int var11 = this.getFlowDecay(par1World, par2, par3 + 1, par4);
  253.  
  254.                 if (var11 >= 8)
  255.                 {
  256.                     var10 = var11;
  257.                 }
  258.                 else
  259.                 {
  260.                     var10 = var11 + 8;
  261.                 }
  262.             }
  263.  
  264.             if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water)
  265.             {
  266.                 if (par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid())
  267.                 {
  268.                     var10 = 0;
  269.                 }
  270.                 else if (par1World.getBlockMaterial(par2, par3 - 1, par4) == this.blockMaterial && par1World.getBlockMetadata(par2, par3, par4) == 0)
  271.                 {
  272.                     var10 = 0;
  273.                 }
  274.             }
  275.  
  276.             if (this.blockMaterial == Material.lava && var6 < 8 && var10 < 8 && var10 > var6 && par5Random.nextInt(4) != 0)
  277.             {
  278.                 var10 = var6;
  279.                 var8 = false;
  280.             }
  281.  
  282.             if (var10 == var6)
  283.             {
  284.                 if (var8)
  285.                 {
  286.                     this.updateFlow(par1World, par2, par3, par4);
  287.                 }
  288.             }
  289.             else
  290.             {
  291.                 var6 = var10;
  292.  
  293.                 if (var10 < 0)
  294.                 {
  295.                     par1World.setBlockWithNotify(par2, par3, par4, 0);
  296.                 }
  297.                 else
  298.                 {
  299.                     par1World.setBlockMetadataWithNotify(par2, par3, par4, var10);
  300.                     par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
  301.                     par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
  302.                 }
  303.             }
  304.         }
  305.         else
  306.         {
  307.             this.updateFlow(par1World, par2, par3, par4);
  308.         }
  309.  
  310.         if (this.liquidCanDisplaceBlock(par1World, par2, par3 - 1, par4))
  311.         {
  312.             if (this.blockMaterial == Material.lava && par1World.getBlockMaterial(par2, par3 - 1, par4) == Material.water)
  313.             {
  314.                 par1World.setBlockWithNotify(par2, par3 - 1, par4, Block.stone.blockID);
  315.                 this.triggerLavaMixEffects(par1World, par2, par3 - 1, par4);
  316.                 return;
  317.             }
  318.  
  319.             if (var6 >= 8)
  320.             {
  321.                 this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6);
  322.             }
  323.             else
  324.             {
  325.                 this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6 + 8);
  326.             }
  327.         }
  328.         else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, par2, par3 - 1, par4)))
  329.         {
  330.             boolean[] var13 = this.getOptimalFlowDirections(par1World, par2, par3, par4);
  331.             var10 = var6 + var7;
  332.  
  333.             if (var6 >= 8)
  334.             {
  335.                 var10 = 1;
  336.             }
  337.  
  338.             if (var10 >= 8)
  339.             {
  340.                 return;
  341.             }
  342.  
  343.             if (var13[0])
  344.             {
  345.                 this.flowIntoBlock(par1World, par2 - 1, par3, par4, var10);
  346.             }
  347.  
  348.             if (var13[1])
  349.             {
  350.                 this.flowIntoBlock(par1World, par2 + 1, par3, par4, var10);
  351.             }
  352.  
  353.             if (var13[2])
  354.             {
  355.                 this.flowIntoBlock(par1World, par2, par3, par4 - 1, var10);
  356.             }
  357.  
  358.             if (var13[3])
  359.             {
  360.                 this.flowIntoBlock(par1World, par2, par3, par4 + 1, var10);
  361.             }
  362.         }
  363.     }
  364.  
  365.     /**
  366.      * flowIntoBlock(World world, int x, int y, int z, int newFlowDecay) - Flows into the block at the coordinates and
  367.      * changes the block type to the liquid.
  368.      */
  369.     private void flowIntoBlock(World par1World, int par2, int par3, int par4, int par5)
  370.     {
  371.         if (this.liquidCanDisplaceBlock(par1World, par2, par3, par4))
  372.         {
  373.             int var6 = par1World.getBlockId(par2, par3, par4);
  374.  
  375.             if (var6 > 0)
  376.             {
  377.                 if (this.blockMaterial == Material.lava)
  378.                 {
  379.                     this.triggerLavaMixEffects(par1World, par2, par3, par4);
  380.                 }
  381.                 else
  382.                 {
  383.                     Block.blocksList[var6].dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
  384.                 }
  385.             }
  386.  
  387.             par1World.setBlockAndMetadataWithNotify(par2, par3, par4, this.blockID, par5);
  388.         }
  389.     }
  390.  
  391.     /**
  392.      * calculateFlowCost(World world, int x, int y, int z, int accumulatedCost, int previousDirectionOfFlow) - Used to
  393.      * determine the path of least resistance, this method returns the lowest possible flow cost for the direction of
  394.      * flow indicated. Each necessary horizontal flow adds to the flow cost.
  395.      */
  396.     private int calculateFlowCost(World par1World, int par2, int par3, int par4, int par5, int par6)
  397.     {
  398.         int var7 = 1000;
  399.  
  400.         for (int var8 = 0; var8 < 4; ++var8)
  401.         {
  402.             if ((var8 != 0 || par6 != 1) && (var8 != 1 || par6 != 0) && (var8 != 2 || par6 != 3) && (var8 != 3 || par6 != 2))
  403.             {
  404.                 int var9 = par2;
  405.                 int var11 = par4;
  406.  
  407.                 if (var8 == 0)
  408.                 {
  409.                     var9 = par2 - 1;
  410.                 }
  411.  
  412.                 if (var8 == 1)
  413.                 {
  414.                     ++var9;
  415.                 }
  416.  
  417.                 if (var8 == 2)
  418.                 {
  419.                     var11 = par4 - 1;
  420.                 }
  421.  
  422.                 if (var8 == 3)
  423.                 {
  424.                     ++var11;
  425.                 }
  426.  
  427.                 if (!this.blockBlocksFlow(par1World, var9, par3, var11) && (par1World.getBlockMaterial(var9, par3, var11) != this.blockMaterial || par1World.getBlockMetadata(var9, par3, var11) != 0))
  428.                 {
  429.                     if (!this.blockBlocksFlow(par1World, var9, par3 - 1, var11))
  430.                     {
  431.                         return par5;
  432.                     }
  433.  
  434.                     if (par5 < 4)
  435.                     {
  436.                         int var12 = this.calculateFlowCost(par1World, var9, par3, var11, par5 + 1, var8);
  437.  
  438.                         if (var12 < var7)
  439.                         {
  440.                             var7 = var12;
  441.                         }
  442.                     }
  443.                 }
  444.             }
  445.         }
  446.  
  447.         return var7;
  448.     }
  449.  
  450.     /**
  451.      * Returns a boolean array indicating which flow directions are optimal based on each direction's calculated flow
  452.      * cost. Each array index corresponds to one of the four cardinal directions. A value of true indicates the
  453.      * direction is optimal.
  454.      */
  455.     private boolean[] getOptimalFlowDirections(World par1World, int par2, int par3, int par4)
  456.     {
  457.         int var5;
  458.         int var6;
  459.  
  460.         for (var5 = 0; var5 < 4; ++var5)
  461.         {
  462.             this.flowCost[var5] = 1000;
  463.             var6 = par2;
  464.             int var8 = par4;
  465.  
  466.             if (var5 == 0)
  467.             {
  468.                 var6 = par2 - 1;
  469.             }
  470.  
  471.             if (var5 == 1)
  472.             {
  473.                 ++var6;
  474.             }
  475.  
  476.             if (var5 == 2)
  477.             {
  478.                 var8 = par4 - 1;
  479.             }
  480.  
  481.             if (var5 == 3)
  482.             {
  483.                 ++var8;
  484.             }
  485.  
  486.             if (!this.blockBlocksFlow(par1World, var6, par3, var8) && (par1World.getBlockMaterial(var6, par3, var8) != this.blockMaterial || par1World.getBlockMetadata(var6, par3, var8) != 0))
  487.             {
  488.                 if (this.blockBlocksFlow(par1World, var6, par3 - 1, var8))
  489.                 {
  490.                     this.flowCost[var5] = this.calculateFlowCost(par1World, var6, par3, var8, 1, var5);
  491.                 }
  492.                 else
  493.                 {
  494.                     this.flowCost[var5] = 0;
  495.                 }
  496.             }
  497.         }
  498.  
  499.         var5 = this.flowCost[0];
  500.  
  501.         for (var6 = 1; var6 < 4; ++var6)
  502.         {
  503.             if (this.flowCost[var6] < var5)
  504.             {
  505.                 var5 = this.flowCost[var6];
  506.             }
  507.         }
  508.  
  509.         for (var6 = 0; var6 < 4; ++var6)
  510.         {
  511.             this.isOptimalFlowDirection[var6] = this.flowCost[var6] == var5;
  512.         }
  513.  
  514.         return this.isOptimalFlowDirection;
  515.     }
  516.  
  517.     /**
  518.      * Returns true if block at coords blocks fluids
  519.      */
  520.     private boolean blockBlocksFlow(World par1World, int par2, int par3, int par4)
  521.     {
  522.         int var5 = par1World.getBlockId(par2, par3, par4);
  523.  
  524.         if (var5 != Block.doorWood.blockID && var5 != Block.doorSteel.blockID && var5 != Block.signPost.blockID && var5 != Block.ladder.blockID && var5 != Block.reed.blockID)
  525.         {
  526.             if (var5 == 0)
  527.             {
  528.                 return false;
  529.             }
  530.             else
  531.             {
  532.                 Material var6 = Block.blocksList[var5].blockMaterial;
  533.                 return var6 == Material.portal ? true : var6.blocksMovement();
  534.             }
  535.         }
  536.         else
  537.         {
  538.             return true;
  539.         }
  540.     }
  541.  
  542.     /**
  543.      * getSmallestFlowDecay(World world, intx, int y, int z, int currentSmallestFlowDecay) - Looks up the flow decay at
  544.      * the coordinates given and returns the smaller of this value or the provided currentSmallestFlowDecay. If one
  545.      * value is valid and the other isn't, the valid value will be returned. Valid values are >= 0. Flow decay is the
  546.      * amount that a liquid has dissipated. 0 indicates a source block.
  547.      */
  548.     protected int getSmallestFlowDecay(World par1World, int par2, int par3, int par4, int par5)
  549.     {
  550.         int var6 = this.getFlowDecay(par1World, par2, par3, par4);
  551.  
  552.         if (var6 < 0)
  553.         {
  554.             return par5;
  555.         }
  556.         else
  557.         {
  558.             if (var6 == 0)
  559.             {
  560.                 ++this.numAdjacentSources;
  561.             }
  562.  
  563.             if (var6 >= 8)
  564.             {
  565.                 var6 = 0;
  566.             }
  567.  
  568.             return par5 >= 0 && var6 >= par5 ? par5 : var6;
  569.         }
  570.     }
  571.  
  572.     /**
  573.      * Returns true if the block at the coordinates can be displaced by the liquid.
  574.      */
  575.     private boolean liquidCanDisplaceBlock(World par1World, int par2, int par3, int par4)
  576.     {
  577.         Material var5 = par1World.getBlockMaterial(par2, par3, par4);
  578.         return var5 == this.blockMaterial ? false : (var5 == Material.lava ? false : !this.blockBlocksFlow(par1World, par2, par3, par4));
  579.     }
  580.  
  581.     /**
  582.      * Called whenever the block is added into the world. Args: world, x, y, z
  583.      */
  584.     public void onBlockAdded(World par1World, int par2, int par3, int par4)
  585.     {
  586.         super.onBlockAdded(par1World, par2, par3, par4);
  587.  
  588.         if (par1World.getBlockId(par2, par3, par4) == this.blockID)
  589.         {
  590.             par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
  591.         }
  592.     }
  593.  
  594.     public boolean func_82506_l()
  595.     {
  596.         return false;
  597.     }
  598.  
  599.  
  600.    
  601.     @Override
  602.     public String getTextureFile() {
  603.                 return CommonProxy.BLOCK_PNG;
  604.         }
  605.    
  606.    
  607.     }
RAW Paste Data
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
 
Top