494d98bb05
I've made a mess of changes since last upload. Main big change is change in forge file formate that merged minecraft and common folder. The other is the complete rewrite to Forge Liquid api. So far only the pump, boiler, and pipe are converted to the new system. The pipe will actual not fully work with most machines since it can't drain liquids out of machines. In future update there will be a block to do this called a pipe pump. Other than those changes nothing much is diffrent.
496 lines
12 KiB
Java
496 lines
12 KiB
Java
package dark.BasicUtilities.Liquids;
|
|
|
|
import java.util.Random;
|
|
|
|
import dark.BasicUtilities.BasicUtilitiesMain;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.BlockFluid;
|
|
import net.minecraft.block.material.Material;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLiving;
|
|
import net.minecraft.potion.Potion;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
import net.minecraftforge.liquids.ILiquid;
|
|
import universalelectricity.core.vector.Vector3;
|
|
|
|
/**
|
|
* @author Cammygames This class contains the block for oil
|
|
*
|
|
*/
|
|
public class BlockOilFlowing extends BlockFluid implements ILiquid
|
|
{
|
|
|
|
/**
|
|
* Number of horizontally adjacent liquid source blocks. Diagonal doesn't count. Only source
|
|
* blocks of the same liquid as the block using the field are counted.
|
|
*/
|
|
int numAdjacentSources = 0;
|
|
|
|
/**
|
|
* Indicates whether the flow direction is optimal. Each array index corresponds to one of the
|
|
* four cardinal directions.
|
|
*/
|
|
boolean[] isOptimalFlowDirection = new boolean[4];
|
|
|
|
/**
|
|
* The estimated cost to flow in a given direction from the current point. Each array index
|
|
* corresponds to one of the four cardinal directions.
|
|
*/
|
|
int[] flowCost = new int[4];
|
|
|
|
public BlockOilFlowing(int id)
|
|
{
|
|
super(id, Material.water);
|
|
this.setHardness(80F);
|
|
this.setLightOpacity(0);
|
|
this.setRequiresSelfNotify();
|
|
this.disableStats();
|
|
this.setBlockName("oilMoving");
|
|
}
|
|
|
|
@Override
|
|
public void onBlockAdded(World par1World, int x, int y, int z)
|
|
{
|
|
super.onBlockAdded(par1World, x, y, z);
|
|
|
|
for (byte i = 0; i < 6; i++)
|
|
{
|
|
Vector3 neighborPosition = new Vector3(x, y, z);
|
|
neighborPosition.modifyPositionFromSide(ForgeDirection.getOrientation(i));
|
|
|
|
int neighborBlockID = par1World.getBlockId(neighborPosition.intX(), neighborPosition.intY(), neighborPosition.intZ());
|
|
|
|
if (neighborBlockID == Block.fire.blockID || neighborBlockID == Block.lavaMoving.blockID || neighborBlockID == Block.lavaStill.blockID)
|
|
{
|
|
par1World.setBlockWithNotify(x, y, z, Block.fire.blockID);
|
|
par1World.playSoundEffect((double) ((float) x + 0.5F), (double) ((float) y + 0.5F), (double) ((float) z + 0.5F), "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
|
|
par1World.spawnParticle("largesmoke", (double) x + Math.random(), (double) y + 1.2D, (double) z + Math.random(), 0.0D, 0.0D, 0.0D);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (par1World.getBlockId(x, y, z) == this.blockID)
|
|
{
|
|
par1World.scheduleBlockUpdate(x, y, z, this.blockID, this.tickRate());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onNeighborBlockChange(World par1World, int x, int y, int z, int blockID)
|
|
{
|
|
super.onNeighborBlockChange(par1World, x, y, z, blockID);
|
|
|
|
if (blockID == Block.fire.blockID || blockID == Block.lavaMoving.blockID || blockID == Block.lavaStill.blockID)
|
|
{
|
|
par1World.setBlockWithNotify(x, y, z, Block.fire.blockID);
|
|
par1World.playSoundEffect((double) ((float) x + 0.5F), (double) ((float) y + 0.5F), (double) ((float) z + 0.5F), "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);
|
|
par1World.spawnParticle("largesmoke", (double) x + Math.random(), (double) y + 1.2D, (double) z + Math.random(), 0.0D, 0.0D, 0.0D);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the flow for the BlockFlowing object.
|
|
*/
|
|
private void updateFlow(World par1World, int par2, int par3, int par4)
|
|
{
|
|
int var5 = par1World.getBlockMetadata(par2, par3, par4);
|
|
par1World.setBlockAndMetadata(par2, par3, par4, this.blockID + 1, var5);
|
|
par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
|
|
}
|
|
|
|
/**
|
|
* Gets the color of the water
|
|
*/
|
|
@Override
|
|
public int colorMultiplier(IBlockAccess par1IBlockAccess, int x, int y, int z)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Ticks the block if it's been scheduled
|
|
*/
|
|
@Override
|
|
public void updateTick(World par1World, int x, int y, int z, Random par5Random)
|
|
{
|
|
int var6 = this.getFlowDecay(par1World, x, y, z);
|
|
byte var7 = 1;
|
|
boolean var8 = true;
|
|
int var10;
|
|
|
|
if (var6 > 0)
|
|
{
|
|
byte var9 = -100;
|
|
this.numAdjacentSources = 0;
|
|
int var12 = this.getSmallestFlowDecay(par1World, x - 1, y, z, var9);
|
|
var12 = this.getSmallestFlowDecay(par1World, x + 1, y, z, var12);
|
|
var12 = this.getSmallestFlowDecay(par1World, x, y, z - 1, var12);
|
|
var12 = this.getSmallestFlowDecay(par1World, x, y, z + 1, var12);
|
|
var10 = var12 + var7;
|
|
|
|
if (var10 >= 8 || var12 < 0)
|
|
{
|
|
var10 = -1;
|
|
}
|
|
|
|
if (this.getFlowDecay(par1World, x, y + 1, z) >= 0)
|
|
{
|
|
int var11 = this.getFlowDecay(par1World, x, y + 1, z);
|
|
|
|
if (var11 >= 8)
|
|
{
|
|
var10 = var11;
|
|
}
|
|
else
|
|
{
|
|
var10 = var11 + 8;
|
|
}
|
|
}
|
|
// Used to turn a flowing source with
|
|
// two solid sources into a solid
|
|
// source
|
|
/**
|
|
* if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water) { if
|
|
* (par1World.getBlockMaterial(x, y - 1, z).isSolid()) { var10 = 0; } else if
|
|
* (par1World.getBlockMaterial(x, y - 1, z) == this.blockMaterial &&
|
|
* par1World.getBlockMetadata(x, y, z) == 0) { var10 = 0; } }
|
|
**/
|
|
if (var10 == var6)
|
|
{
|
|
if (var8)
|
|
{
|
|
this.updateFlow(par1World, x, y, z);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var6 = var10;
|
|
|
|
if (var10 < 0)
|
|
{
|
|
// updates block
|
|
par1World.setBlockWithNotify(x, y, z, 0);
|
|
}
|
|
else
|
|
{
|
|
par1World.setBlockMetadataWithNotify(x, y, z, var10);
|
|
par1World.scheduleBlockUpdate(x, y, z, this.blockID, this.tickRate());
|
|
par1World.notifyBlocksOfNeighborChange(x, y, z, this.blockID);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.updateFlow(par1World, x, y, z);
|
|
}
|
|
|
|
if (this.liquidCanDisplaceBlock(par1World, x, y - 1, z))
|
|
{
|
|
if (var6 >= 8)
|
|
{
|
|
this.flowIntoBlock(par1World, x, y - 1, z, var6);
|
|
}
|
|
else
|
|
{
|
|
this.flowIntoBlock(par1World, x, y - 1, z, var6 + 8);
|
|
}
|
|
}
|
|
else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, x, y - 1, z)))
|
|
{
|
|
boolean[] var13 = this.getOptimalFlowDirections(par1World, x, y, z);
|
|
var10 = var6 + var7;
|
|
|
|
if (var6 >= 8)
|
|
{
|
|
var10 = 1;
|
|
}
|
|
|
|
if (var10 >= 8) { return; }
|
|
|
|
if (var13[0])
|
|
{
|
|
this.flowIntoBlock(par1World, x - 1, y, z, var10);
|
|
}
|
|
|
|
if (var13[1])
|
|
{
|
|
this.flowIntoBlock(par1World, x + 1, y, z, var10);
|
|
}
|
|
|
|
if (var13[2])
|
|
{
|
|
this.flowIntoBlock(par1World, x, y, z - 1, var10);
|
|
}
|
|
|
|
if (var13[3])
|
|
{
|
|
this.flowIntoBlock(par1World, x, y, z + 1, var10);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* flowIntoBlock(World world, int x, int y, int z, int newFlowDecay) - Flows into the block at
|
|
* the coordinates and changes the block type to the liquid.
|
|
*/
|
|
private void flowIntoBlock(World par1World, int par2, int par3, int par4, int par5)
|
|
{
|
|
if (this.liquidCanDisplaceBlock(par1World, par2, par3, par4))
|
|
{
|
|
int var6 = par1World.getBlockId(par2, par3, par4);
|
|
|
|
if (var6 > 0)
|
|
{
|
|
if (this.blockMaterial == Material.lava)
|
|
{
|
|
this.triggerLavaMixEffects(par1World, par2, par3, par4);
|
|
}
|
|
else
|
|
{
|
|
Block.blocksList[var6].dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
|
|
}
|
|
}
|
|
|
|
par1World.setBlockAndMetadataWithNotify(par2, par3, par4, this.blockID, par5);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* calculateFlowCost(World world, int x, int y, int z, int accumulatedCost, int
|
|
* previousDirectionOfFlow) - Used to determine the path of least resistance, this method
|
|
* returns the lowest possible flow cost for the direction of flow indicated. Each necessary
|
|
* horizontal flow adds to the flow cost.
|
|
*/
|
|
private int calculateFlowCost(World par1World, int par2, int par3, int par4, int par5, int par6)
|
|
{
|
|
int var7 = 1000;
|
|
|
|
for (int var8 = 0; var8 < 4; ++var8)
|
|
{
|
|
if ((var8 != 0 || par6 != 1) && (var8 != 1 || par6 != 0) && (var8 != 2 || par6 != 3) && (var8 != 3 || par6 != 2))
|
|
{
|
|
int var9 = par2;
|
|
int var11 = par4;
|
|
|
|
if (var8 == 0)
|
|
{
|
|
var9 = par2 - 1;
|
|
}
|
|
|
|
if (var8 == 1)
|
|
{
|
|
++var9;
|
|
}
|
|
|
|
if (var8 == 2)
|
|
{
|
|
var11 = par4 - 1;
|
|
}
|
|
|
|
if (var8 == 3)
|
|
{
|
|
++var11;
|
|
}
|
|
|
|
if (!this.blockBlocksFlow(par1World, var9, par3, var11) && (par1World.getBlockMaterial(var9, par3, var11) != this.blockMaterial || par1World.getBlockMetadata(var9, par3, var11) != 0))
|
|
{
|
|
if (!this.blockBlocksFlow(par1World, var9, par3 - 1, var11)) { return par5; }
|
|
|
|
if (par5 < 4)
|
|
{
|
|
int var12 = this.calculateFlowCost(par1World, var9, par3, var11, par5 + 1, var8);
|
|
|
|
if (var12 < var7)
|
|
{
|
|
var7 = var12;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return var7;
|
|
}
|
|
|
|
/**
|
|
* Returns a boolean array indicating which flow directions are optimal based on each
|
|
* direction's calculated flow cost. Each array index corresponds to one of the four cardinal
|
|
* directions. A value of true indicates the direction is optimal.
|
|
*/
|
|
private boolean[] getOptimalFlowDirections(World par1World, int par2, int par3, int par4)
|
|
{
|
|
int var5;
|
|
int var6;
|
|
|
|
for (var5 = 0; var5 < 4; ++var5)
|
|
{
|
|
this.flowCost[var5] = 1000;
|
|
var6 = par2;
|
|
int var8 = par4;
|
|
|
|
if (var5 == 0)
|
|
{
|
|
var6 = par2 - 1;
|
|
}
|
|
|
|
if (var5 == 1)
|
|
{
|
|
++var6;
|
|
}
|
|
|
|
if (var5 == 2)
|
|
{
|
|
var8 = par4 - 1;
|
|
}
|
|
|
|
if (var5 == 3)
|
|
{
|
|
++var8;
|
|
}
|
|
|
|
if (!this.blockBlocksFlow(par1World, var6, par3, var8) && (par1World.getBlockMaterial(var6, par3, var8) != this.blockMaterial || par1World.getBlockMetadata(var6, par3, var8) != 0))
|
|
{
|
|
if (this.blockBlocksFlow(par1World, var6, par3 - 1, var8))
|
|
{
|
|
this.flowCost[var5] = this.calculateFlowCost(par1World, var6, par3, var8, 1, var5);
|
|
}
|
|
else
|
|
{
|
|
this.flowCost[var5] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
var5 = this.flowCost[0];
|
|
|
|
for (var6 = 1; var6 < 4; ++var6)
|
|
{
|
|
if (this.flowCost[var6] < var5)
|
|
{
|
|
var5 = this.flowCost[var6];
|
|
}
|
|
}
|
|
|
|
for (var6 = 0; var6 < 4; ++var6)
|
|
{
|
|
this.isOptimalFlowDirection[var6] = this.flowCost[var6] == var5;
|
|
}
|
|
|
|
return this.isOptimalFlowDirection;
|
|
}
|
|
|
|
@Override
|
|
public int getRenderBlockPass()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns true if block at coords blocks fluids
|
|
*/
|
|
private boolean blockBlocksFlow(World par1World, int par2, int par3, int par4)
|
|
{
|
|
int var5 = par1World.getBlockId(par2, par3, par4);
|
|
|
|
if (var5 != Block.doorWood.blockID && var5 != Block.doorSteel.blockID && var5 != Block.signPost.blockID && var5 != Block.ladder.blockID && var5 != Block.reed.blockID)
|
|
{
|
|
if (var5 == 0)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Material var6 = Block.blocksList[var5].blockMaterial;
|
|
return var6 == Material.portal ? true : var6.blocksMovement();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getSmallestFlowDecay(World world, intx, int y, int z, int currentSmallestFlowDecay) - Looks
|
|
* up the flow decay at the coordinates given and returns the smaller of this value or the
|
|
* provided currentSmallestFlowDecay. If one value is valid and the other isn't, the valid value
|
|
* will be returned. Valid values are >= 0. Flow decay is the amount that a liquid has
|
|
* dissipated. 0 indicates a source block.
|
|
*/
|
|
protected int getSmallestFlowDecay(World par1World, int par2, int par3, int par4, int par5)
|
|
{
|
|
int var6 = this.getFlowDecay(par1World, par2, par3, par4);
|
|
|
|
if (var6 < 0)
|
|
{
|
|
return par5;
|
|
}
|
|
else
|
|
{
|
|
if (var6 == 0)
|
|
{
|
|
++this.numAdjacentSources;
|
|
}
|
|
|
|
if (var6 >= 8)
|
|
{
|
|
var6 = 0;
|
|
}
|
|
|
|
return par5 >= 0 && var6 >= par5 ? par5 : var6;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the block at the coordinates can be displaced by the liquid.
|
|
*/
|
|
private boolean liquidCanDisplaceBlock(World par1World, int par2, int par3, int par4)
|
|
{
|
|
Material var5 = par1World.getBlockMaterial(par2, par3, par4);
|
|
return var5 == this.blockMaterial ? false : (var5 == Material.lava ? false : !this.blockBlocksFlow(par1World, par2, par3, par4));
|
|
}
|
|
|
|
@Override
|
|
public int stillLiquidId()
|
|
{
|
|
return BasicUtilitiesMain.oilStill.blockID;
|
|
}
|
|
|
|
@Override
|
|
public boolean isMetaSensitive()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int stillLiquidMeta()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean isBlockReplaceable(World world, int i, int j, int k)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Triggered whenever an entity collides with this block (enters into the block). Args: world,
|
|
* x, y, z, entity
|
|
*/
|
|
@Override
|
|
public void onEntityCollidedWithBlock(World par1World, int x, int y, int z, Entity par5Entity)
|
|
{
|
|
if (par5Entity instanceof EntityLiving)
|
|
{
|
|
if (par5Entity.isInsideOfMaterial(this.blockMaterial))
|
|
{
|
|
((EntityLiving) par5Entity).addPotionEffect(new PotionEffect(Potion.blindness.id, 20, 2));
|
|
}
|
|
}
|
|
}
|
|
}
|