mirror of
https://github.com/MinecraftForge/MinecraftForge.git
synced 2026-11-22 13:09:59 +00:00
Merge remote-tracking branch 'origin/1.8'
This commit is contained in:
commit
c374ba5463
458 files changed
+13442
-14297
No files matched your search
@@ -8,13 +8,22 @@ import com.google.common.collect.Maps;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.block.properties.IProperty;
|
||||
import net.minecraft.block.properties.PropertyInteger;
|
||||
import net.minecraft.block.state.BlockState;
|
||||
import net.minecraft.block.state.IBlockState;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.EnumWorldBlockLayer;
|
||||
import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.fml.relauncher.Side;
|
||||
import net.minecraftforge.fml.relauncher.SideOnly;
|
||||
|
||||
/**
|
||||
* This is a base implementation for Fluid blocks.
|
||||
@@ -30,7 +39,43 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
|
||||
static
|
||||
{
|
||||
defaultDisplacements.put(Blocks.wooden_door, false);
|
||||
defaultDisplacements.put(Blocks.oak_door, false);
|
||||
defaultDisplacements.put(Blocks.spruce_door, false);
|
||||
defaultDisplacements.put(Blocks.birch_door, false);
|
||||
defaultDisplacements.put(Blocks.jungle_door, false);
|
||||
defaultDisplacements.put(Blocks.acacia_door, false);
|
||||
defaultDisplacements.put(Blocks.dark_oak_door, false);
|
||||
defaultDisplacements.put(Blocks.trapdoor, false);
|
||||
defaultDisplacements.put(Blocks.iron_trapdoor, false);
|
||||
defaultDisplacements.put(Blocks.oak_fence, false);
|
||||
defaultDisplacements.put(Blocks.spruce_fence, false);
|
||||
defaultDisplacements.put(Blocks.birch_fence, false);
|
||||
defaultDisplacements.put(Blocks.jungle_fence, false);
|
||||
defaultDisplacements.put(Blocks.dark_oak_fence, false);
|
||||
defaultDisplacements.put(Blocks.acacia_fence, false);
|
||||
defaultDisplacements.put(Blocks.nether_brick_fence, false);
|
||||
defaultDisplacements.put(Blocks.oak_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.spruce_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.birch_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.jungle_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.dark_oak_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.acacia_fence_gate, false);
|
||||
defaultDisplacements.put(Blocks.wooden_pressure_plate, false);
|
||||
defaultDisplacements.put(Blocks.stone_pressure_plate, false);
|
||||
defaultDisplacements.put(Blocks.light_weighted_pressure_plate, false);
|
||||
defaultDisplacements.put(Blocks.heavy_weighted_pressure_plate, false);
|
||||
defaultDisplacements.put(Blocks.ladder, false);
|
||||
defaultDisplacements.put(Blocks.iron_bars, false);
|
||||
defaultDisplacements.put(Blocks.glass_pane, false);
|
||||
defaultDisplacements.put(Blocks.stained_glass_pane, false);
|
||||
defaultDisplacements.put(Blocks.portal, false);
|
||||
defaultDisplacements.put(Blocks.end_portal, false);
|
||||
defaultDisplacements.put(Blocks.cobblestone_wall, false);
|
||||
defaultDisplacements.put(Blocks.barrier, false);
|
||||
defaultDisplacements.put(Blocks.standing_banner, false);
|
||||
defaultDisplacements.put(Blocks.wall_banner, false);
|
||||
defaultDisplacements.put(Blocks.cake, false);
|
||||
|
||||
defaultDisplacements.put(Blocks.iron_door, false);
|
||||
defaultDisplacements.put(Blocks.standing_sign, false);
|
||||
defaultDisplacements.put(Blocks.wall_sign, false);
|
||||
@@ -38,6 +83,7 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
protected Map<Block, Boolean> displacements = Maps.newHashMap();
|
||||
|
||||
public static final PropertyInteger LEVEL = PropertyInteger.create("level", 0, 15);
|
||||
protected int quantaPerBlock = 8;
|
||||
protected float quantaPerBlockFloat = 8F;
|
||||
protected int density = 1;
|
||||
@@ -45,7 +91,7 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
protected int temperature = 295;
|
||||
|
||||
protected int tickRate = 20;
|
||||
protected int renderPass = 1;
|
||||
protected EnumWorldBlockLayer renderLayer = EnumWorldBlockLayer.TRANSLUCENT;
|
||||
protected int maxScaledLight = 0;
|
||||
|
||||
protected final String fluidName;
|
||||
@@ -66,8 +112,20 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
fluid.setBlock(this);
|
||||
|
||||
displacements.putAll(defaultDisplacements);
|
||||
this.setDefaultState(blockState.getBaseState().withProperty(LEVEL, 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected BlockState createBlockState()
|
||||
{
|
||||
return new BlockState(this, LEVEL);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMetaFromState(IBlockState state)
|
||||
{
|
||||
return ((Integer)state.getValue(LEVEL)).intValue();
|
||||
}
|
||||
public BlockFluidBase setQuantaPerBlock(int quantaPerBlock)
|
||||
{
|
||||
if (quantaPerBlock > 16 || quantaPerBlock < 1) quantaPerBlock = 8;
|
||||
@@ -97,9 +155,9 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return this;
|
||||
}
|
||||
|
||||
public BlockFluidBase setRenderPass(int renderPass)
|
||||
public BlockFluidBase setRenderLayer(EnumWorldBlockLayer renderLayer)
|
||||
{
|
||||
this.renderPass = renderPass;
|
||||
this.renderLayer = renderLayer;
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -110,13 +168,13 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the block at (x, y, z) is displaceable. Does not displace the block.
|
||||
* Returns true if the block at (pos) is displaceable. Does not displace the block.
|
||||
*/
|
||||
public boolean canDisplace(IBlockAccess world, int x, int y, int z)
|
||||
public boolean canDisplace(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (world.getBlock(x, y, z).isAir(world, x, y, z)) return true;
|
||||
if (world.isAirBlock(pos)) return true;
|
||||
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
|
||||
if (block == this)
|
||||
{
|
||||
@@ -134,12 +192,12 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return false;
|
||||
}
|
||||
|
||||
int density = getDensity(world, x, y, z);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
int density = getDensity(world, pos);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
if (this.density > density)
|
||||
{
|
||||
return true;
|
||||
@@ -151,16 +209,17 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempt to displace the block at (x, y, z), return true if it was displaced.
|
||||
* Attempt to displace the block at (pos), return true if it was displaced.
|
||||
*/
|
||||
public boolean displaceIfPossible(World world, int x, int y, int z)
|
||||
public boolean displaceIfPossible(World world, BlockPos pos)
|
||||
{
|
||||
if (world.getBlock(x, y, z).isAir(world, x, y, z))
|
||||
if (world.isAirBlock(pos))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
Block block = world.getBlock(x, y, z);
|
||||
IBlockState state = world.getBlockState(pos);
|
||||
Block block = state.getBlock();
|
||||
if (block == this)
|
||||
{
|
||||
return false;
|
||||
@@ -170,7 +229,7 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
{
|
||||
if (displacements.get(block))
|
||||
{
|
||||
block.dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
|
||||
block.dropBlockAsItem(world, pos, state, 0);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@@ -182,13 +241,13 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return false;
|
||||
}
|
||||
|
||||
int density = getDensity(world, x, y, z);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
int density = getDensity(world, pos);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
{
|
||||
block.dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
|
||||
block.dropBlockAsItem(world, pos, state, 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
if (this.density > density)
|
||||
{
|
||||
return true;
|
||||
@@ -199,47 +258,47 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
}
|
||||
|
||||
public abstract int getQuantaValue(IBlockAccess world, int x, int y, int z);
|
||||
public abstract int getQuantaValue(IBlockAccess world, BlockPos pos);
|
||||
|
||||
@Override
|
||||
public abstract boolean canCollideCheck(int meta, boolean fullHit);
|
||||
public abstract boolean canCollideCheck(IBlockState state, boolean fullHit);
|
||||
|
||||
public abstract int getMaxRenderHeightMeta();
|
||||
|
||||
/* BLOCK FUNCTIONS */
|
||||
@Override
|
||||
public void onBlockAdded(World world, int x, int y, int z)
|
||||
public void onBlockAdded(World world, BlockPos pos, IBlockState state)
|
||||
{
|
||||
world.scheduleBlockUpdate(x, y, z, this, tickRate);
|
||||
world.scheduleUpdate(pos, this, tickRate);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onNeighborBlockChange(World world, int x, int y, int z, Block block)
|
||||
public void onNeighborBlockChange(World world, BlockPos pos, IBlockState state, Block neighborBlock)
|
||||
{
|
||||
world.scheduleBlockUpdate(x, y, z, this, tickRate);
|
||||
world.scheduleUpdate(pos, this, tickRate);
|
||||
}
|
||||
|
||||
// Used to prevent updates on chunk generation
|
||||
@Override
|
||||
public boolean func_149698_L()
|
||||
public boolean requiresUpdates()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getBlocksMovement(IBlockAccess world, int x, int y, int z)
|
||||
public boolean isPassable(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
|
||||
public AxisAlignedBB getCollisionBoundingBox(World world, BlockPos pos, IBlockState state)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Item getItemDropped(int par1, Random par2Random, int par3)
|
||||
public Item getItemDropped(IBlockState state, Random rand, int fortune)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
@@ -257,23 +316,24 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
@Override
|
||||
public void velocityToAddToEntity(World world, int x, int y, int z, Entity entity, Vec3 vec)
|
||||
public Vec3 modifyAcceleration(World world, BlockPos pos, Entity entity, Vec3 vec)
|
||||
{
|
||||
if (densityDir > 0) return;
|
||||
Vec3 vec_flow = this.getFlowVector(world, x, y, z);
|
||||
vec.xCoord += vec_flow.xCoord * (quantaPerBlock * 4);
|
||||
vec.yCoord += vec_flow.yCoord * (quantaPerBlock * 4);
|
||||
vec.zCoord += vec_flow.zCoord * (quantaPerBlock * 4);
|
||||
if (densityDir > 0) return vec;
|
||||
Vec3 vec_flow = this.getFlowVector(world, pos);
|
||||
return vec.addVector(
|
||||
vec_flow.xCoord * (quantaPerBlock * 4),
|
||||
vec_flow.yCoord * (quantaPerBlock * 4),
|
||||
vec_flow.zCoord * (quantaPerBlock * 4));
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getLightValue(IBlockAccess world, int x, int y, int z)
|
||||
public int getLightValue(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (maxScaledLight == 0)
|
||||
{
|
||||
return super.getLightValue(world, x, y, z);
|
||||
return super.getLightValue(world, pos);
|
||||
}
|
||||
int data = world.getBlockMetadata(x, y, z);
|
||||
int data = ((Integer)world.getBlockState(pos).getValue(LEVEL)).intValue();
|
||||
return (int) (data / quantaPerBlockFloat * maxScaledLight);
|
||||
}
|
||||
|
||||
@@ -290,26 +350,26 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean renderAsNormalBlock()
|
||||
public boolean isFullCube()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Never used...?
|
||||
@Override
|
||||
public float getBlockBrightness(World world, int x, int y, int z)
|
||||
public float getBlockBrightness(World world, BlockPos pos)
|
||||
{
|
||||
float lightThis = world.getLightBrightness(x, y, z);
|
||||
float lightThis = world.getLightBrightness(pos);
|
||||
float lightUp = world.getLightBrightness(x, y + 1, z);
|
||||
return lightThis > lightUp ? lightThis : lightUp;
|
||||
}
|
||||
*/
|
||||
|
||||
@Override
|
||||
public int getMixedBrightnessForBlock(IBlockAccess world, int x, int y, int z)
|
||||
public int getMixedBrightnessForBlock(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
int lightThis = world.getLightBrightnessForSkyBlocks(x, y, z, 0);
|
||||
int lightUp = world.getLightBrightnessForSkyBlocks(x, y + 1, z, 0);
|
||||
int lightThis = world.getCombinedLight(pos, 0);
|
||||
int lightUp = world.getCombinedLight(pos.up(), 0);
|
||||
int lightThisBase = lightThis & 255;
|
||||
int lightUpBase = lightUp & 255;
|
||||
int lightThisExt = lightThis >> 16 & 255;
|
||||
@@ -319,36 +379,37 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getRenderBlockPass()
|
||||
@SideOnly(Side.CLIENT)
|
||||
public EnumWorldBlockLayer getBlockLayer()
|
||||
{
|
||||
return renderPass;
|
||||
return this.renderLayer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side)
|
||||
public boolean shouldSideBeRendered(IBlockAccess world, BlockPos pos, EnumFacing side)
|
||||
{
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
if (block != this)
|
||||
{
|
||||
return !block.isOpaqueCube();
|
||||
}
|
||||
return block.getMaterial() == this.getMaterial() ? false : super.shouldSideBeRendered(world, x, y, z, side);
|
||||
return block.getMaterial() == this.getMaterial() ? false : super.shouldSideBeRendered(world, pos, side);
|
||||
}
|
||||
|
||||
/* FLUID FUNCTIONS */
|
||||
public static final int getDensity(IBlockAccess world, int x, int y, int z)
|
||||
public static final int getDensity(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
if (!(block instanceof BlockFluidBase))
|
||||
{
|
||||
return Integer.MAX_VALUE;
|
||||
}
|
||||
return ((BlockFluidBase)block).density;
|
||||
}
|
||||
|
||||
public static final int getTemperature(IBlockAccess world, int x, int y, int z)
|
||||
|
||||
public static final int getTemperature(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
if (!(block instanceof BlockFluidBase))
|
||||
{
|
||||
return Integer.MAX_VALUE;
|
||||
@@ -356,20 +417,20 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return ((BlockFluidBase)block).temperature;
|
||||
}
|
||||
|
||||
public static double getFlowDirection(IBlockAccess world, int x, int y, int z)
|
||||
public static double getFlowDirection(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
if (!block.getMaterial().isLiquid())
|
||||
{
|
||||
return -1000.0;
|
||||
}
|
||||
Vec3 vec = ((BlockFluidBase) block).getFlowVector(world, x, y, z);
|
||||
Vec3 vec = ((BlockFluidBase) block).getFlowVector(world, pos);
|
||||
return vec.xCoord == 0.0D && vec.zCoord == 0.0D ? -1000.0D : Math.atan2(vec.zCoord, vec.xCoord) - Math.PI / 2D;
|
||||
}
|
||||
|
||||
public final int getQuantaValueBelow(IBlockAccess world, int x, int y, int z, int belowThis)
|
||||
public final int getQuantaValueBelow(IBlockAccess world, BlockPos pos, int belowThis)
|
||||
{
|
||||
int quantaRemaining = getQuantaValue(world, x, y, z);
|
||||
int quantaRemaining = getQuantaValue(world, pos);
|
||||
if (quantaRemaining >= belowThis)
|
||||
{
|
||||
return -1;
|
||||
@@ -377,9 +438,9 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return quantaRemaining;
|
||||
}
|
||||
|
||||
public final int getQuantaValueAbove(IBlockAccess world, int x, int y, int z, int aboveThis)
|
||||
public final int getQuantaValueAbove(IBlockAccess world, BlockPos pos, int aboveThis)
|
||||
{
|
||||
int quantaRemaining = getQuantaValue(world, x, y, z);
|
||||
int quantaRemaining = getQuantaValue(world, pos);
|
||||
if (quantaRemaining <= aboveThis)
|
||||
{
|
||||
return -1;
|
||||
@@ -387,21 +448,21 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
return quantaRemaining;
|
||||
}
|
||||
|
||||
public final float getQuantaPercentage(IBlockAccess world, int x, int y, int z)
|
||||
public final float getQuantaPercentage(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
int quantaRemaining = getQuantaValue(world, x, y, z);
|
||||
int quantaRemaining = getQuantaValue(world, pos);
|
||||
return quantaRemaining / quantaPerBlockFloat;
|
||||
}
|
||||
|
||||
public Vec3 getFlowVector(IBlockAccess world, int x, int y, int z)
|
||||
public Vec3 getFlowVector(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
Vec3 vec = Vec3.createVectorHelper(0.0D, 0.0D, 0.0D);
|
||||
int decay = quantaPerBlock - getQuantaValue(world, x, y, z);
|
||||
Vec3 vec = new Vec3(0.0D, 0.0D, 0.0D);
|
||||
int decay = quantaPerBlock - getQuantaValue(world, pos);
|
||||
|
||||
for (int side = 0; side < 4; ++side)
|
||||
{
|
||||
int x2 = x;
|
||||
int z2 = z;
|
||||
int x2 = pos.getX();
|
||||
int z2 = pos.getZ();
|
||||
|
||||
switch (side)
|
||||
{
|
||||
@@ -411,37 +472,38 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
case 3: ++z2; break;
|
||||
}
|
||||
|
||||
int otherDecay = quantaPerBlock - getQuantaValue(world, x2, y, z2);
|
||||
BlockPos pos2 = new BlockPos(x2, pos.getY(), z2);
|
||||
int otherDecay = quantaPerBlock - getQuantaValue(world, pos2);
|
||||
if (otherDecay >= quantaPerBlock)
|
||||
{
|
||||
if (!world.getBlock(x2, y, z2).getMaterial().blocksMovement())
|
||||
if (!world.getBlockState(pos2).getBlock().getMaterial().blocksMovement())
|
||||
{
|
||||
otherDecay = quantaPerBlock - getQuantaValue(world, x2, y - 1, z2);
|
||||
otherDecay = quantaPerBlock - getQuantaValue(world, pos2.down());
|
||||
if (otherDecay >= 0)
|
||||
{
|
||||
int power = otherDecay - (decay - quantaPerBlock);
|
||||
vec = vec.addVector((x2 - x) * power, (y - y) * power, (z2 - z) * power);
|
||||
vec = vec.addVector((pos2.getX() - pos.getX()) * power, 0, (pos2.getZ() - pos.getZ()) * power);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (otherDecay >= 0)
|
||||
{
|
||||
int power = otherDecay - decay;
|
||||
vec = vec.addVector((x2 - x) * power, (y - y) * power, (z2 - z) * power);
|
||||
vec = vec.addVector((pos2.getX() - pos.getX()) * power, 0, (pos2.getZ() - pos.getZ()) * power);
|
||||
}
|
||||
}
|
||||
|
||||
if (world.getBlock(x, y + 1, z) == this)
|
||||
if (world.getBlockState(pos.up()).getBlock() == this)
|
||||
{
|
||||
boolean flag =
|
||||
isBlockSolid(world, x, y, z - 1, 2) ||
|
||||
isBlockSolid(world, x, y, z + 1, 3) ||
|
||||
isBlockSolid(world, x - 1, y, z, 4) ||
|
||||
isBlockSolid(world, x + 1, y, z, 5) ||
|
||||
isBlockSolid(world, x, y + 1, z - 1, 2) ||
|
||||
isBlockSolid(world, x, y + 1, z + 1, 3) ||
|
||||
isBlockSolid(world, x - 1, y + 1, z, 4) ||
|
||||
isBlockSolid(world, x + 1, y + 1, z, 5);
|
||||
isBlockSolid(world, pos.add( 0, 0, -1), EnumFacing.NORTH) ||
|
||||
isBlockSolid(world, pos.add( 0, 0, 1), EnumFacing.SOUTH) ||
|
||||
isBlockSolid(world, pos.add(-1, 0, 0), EnumFacing.WEST) ||
|
||||
isBlockSolid(world, pos.add( 1, 0, 0), EnumFacing.EAST) ||
|
||||
isBlockSolid(world, pos.add( 0, 1, -1), EnumFacing.NORTH) ||
|
||||
isBlockSolid(world, pos.add( 0, 1, 1), EnumFacing.SOUTH) ||
|
||||
isBlockSolid(world, pos.add(-1, 1, 0), EnumFacing.WEST) ||
|
||||
isBlockSolid(world, pos.add( 1, 1, 0), EnumFacing.EAST);
|
||||
|
||||
if (flag)
|
||||
{
|
||||
@@ -460,11 +522,11 @@ public abstract class BlockFluidBase extends Block implements IFluidBlock
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getFilledPercentage(World world, int x, int y, int z)
|
||||
public float getFilledPercentage(World world, BlockPos pos)
|
||||
{
|
||||
int quantaRemaining = getQuantaValue(world, x, y, z) + 1;
|
||||
int quantaRemaining = getQuantaValue(world, pos) + 1;
|
||||
float remaining = quantaRemaining / quantaPerBlockFloat;
|
||||
if (remaining > 1) remaining = 1.0f;
|
||||
return remaining * (density > 0 ? 1 : -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,9 @@ import java.util.Random;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.block.state.IBlockState;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
@@ -41,26 +43,27 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getQuantaValue(IBlockAccess world, int x, int y, int z)
|
||||
public int getQuantaValue(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (world.getBlock(x, y, z) == Blocks.air)
|
||||
IBlockState state = world.getBlockState(pos);
|
||||
if (state.getBlock() == Blocks.air)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (world.getBlock(x, y, z) != this)
|
||||
if (state.getBlock() != this)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int quantaRemaining = quantaPerBlock - world.getBlockMetadata(x, y, z);
|
||||
int quantaRemaining = quantaPerBlock - ((Integer)state.getValue(LEVEL)).intValue();
|
||||
return quantaRemaining;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canCollideCheck(int meta, boolean fullHit)
|
||||
public boolean canCollideCheck(IBlockState state, boolean fullHit)
|
||||
{
|
||||
return fullHit && meta == 0;
|
||||
return fullHit && ((Integer)state.getValue(LEVEL)).intValue() == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -70,42 +73,40 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getLightValue(IBlockAccess world, int x, int y, int z)
|
||||
public int getLightValue(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (maxScaledLight == 0)
|
||||
{
|
||||
return super.getLightValue(world, x, y, z);
|
||||
return super.getLightValue(world, pos);
|
||||
}
|
||||
int data = quantaPerBlock - world.getBlockMetadata(x, y, z) - 1;
|
||||
int data = quantaPerBlock - ((Integer)world.getBlockState(pos).getValue(LEVEL)).intValue() - 1;
|
||||
return (int) (data / quantaPerBlockFloat * maxScaledLight);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateTick(World world, int x, int y, int z, Random rand)
|
||||
public void updateTick(World world, BlockPos pos, IBlockState state, Random rand)
|
||||
{
|
||||
int quantaRemaining = quantaPerBlock - world.getBlockMetadata(x, y, z);
|
||||
int quantaRemaining = quantaPerBlock - ((Integer)state.getValue(LEVEL)).intValue();
|
||||
int expQuanta = -101;
|
||||
|
||||
// check adjacent block levels if non-source
|
||||
if (quantaRemaining < quantaPerBlock)
|
||||
{
|
||||
int y2 = y - densityDir;
|
||||
|
||||
if (world.getBlock(x, y2, z ) == this ||
|
||||
world.getBlock(x - 1, y2, z ) == this ||
|
||||
world.getBlock(x + 1, y2, z ) == this ||
|
||||
world.getBlock(x, y2, z - 1) == this ||
|
||||
world.getBlock(x, y2, z + 1) == this)
|
||||
if (world.getBlockState(pos.add( 0, -densityDir, 0)).getBlock() == this ||
|
||||
world.getBlockState(pos.add(-1, -densityDir, 0)).getBlock() == this ||
|
||||
world.getBlockState(pos.add( 1, -densityDir, 0)).getBlock() == this ||
|
||||
world.getBlockState(pos.add( 0, -densityDir, -1)).getBlock() == this ||
|
||||
world.getBlockState(pos.add( 0, -densityDir, 1)).getBlock() == this)
|
||||
{
|
||||
expQuanta = quantaPerBlock - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
int maxQuanta = -100;
|
||||
maxQuanta = getLargerQuanta(world, x - 1, y, z, maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, x + 1, y, z, maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, x, y, z - 1, maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, x, y, z + 1, maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, pos.add(-1, 0, 0), maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, pos.add( 1, 0, 0), maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, pos.add( 0, 0, -1), maxQuanta);
|
||||
maxQuanta = getLargerQuanta(world, pos.add( 0, 0, 1), maxQuanta);
|
||||
|
||||
expQuanta = maxQuanta - 1;
|
||||
}
|
||||
@@ -117,26 +118,26 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
|
||||
if (expQuanta <= 0)
|
||||
{
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockToAir(pos);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlockMetadataWithNotify(x, y, z, quantaPerBlock - expQuanta, 3);
|
||||
world.scheduleBlockUpdate(x, y, z, this, tickRate);
|
||||
world.notifyBlocksOfNeighborChange(x, y, z, this);
|
||||
world.setBlockState(pos, state.withProperty(LEVEL, quantaPerBlock - expQuanta), 2);
|
||||
world.scheduleUpdate(pos, this, tickRate);
|
||||
world.notifyNeighborsOfStateChange(pos, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
// This is a "source" block, set meta to zero, and send a server only update
|
||||
else if (quantaRemaining >= quantaPerBlock)
|
||||
{
|
||||
world.setBlockMetadataWithNotify(x, y, z, 0, 2);
|
||||
world.setBlockState(pos, this.getDefaultState(), 2);
|
||||
}
|
||||
|
||||
// Flow vertically if possible
|
||||
if (canDisplace(world, x, y + densityDir, z))
|
||||
if (canDisplace(world, pos.up(densityDir)))
|
||||
{
|
||||
flowIntoBlock(world, x, y + densityDir, z, 1);
|
||||
flowIntoBlock(world, pos.up(densityDir), 1);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -147,62 +148,60 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
return;
|
||||
}
|
||||
|
||||
if (isSourceBlock(world, x, y, z) || !isFlowingVertically(world, x, y, z))
|
||||
if (isSourceBlock(world, pos) || !isFlowingVertically(world, pos))
|
||||
{
|
||||
if (world.getBlock(x, y - densityDir, z) == this)
|
||||
if (world.getBlockState(pos.down(densityDir)).getBlock() == this)
|
||||
{
|
||||
flowMeta = 1;
|
||||
}
|
||||
boolean flowTo[] = getOptimalFlowDirections(world, x, y, z);
|
||||
boolean flowTo[] = getOptimalFlowDirections(world, pos);
|
||||
|
||||
if (flowTo[0]) flowIntoBlock(world, x - 1, y, z, flowMeta);
|
||||
if (flowTo[1]) flowIntoBlock(world, x + 1, y, z, flowMeta);
|
||||
if (flowTo[2]) flowIntoBlock(world, x, y, z - 1, flowMeta);
|
||||
if (flowTo[3]) flowIntoBlock(world, x, y, z + 1, flowMeta);
|
||||
if (flowTo[0]) flowIntoBlock(world, pos.add(-1, 0, 0), flowMeta);
|
||||
if (flowTo[1]) flowIntoBlock(world, pos.add( 1, 0, 0), flowMeta);
|
||||
if (flowTo[2]) flowIntoBlock(world, pos.add( 0, 0, -1), flowMeta);
|
||||
if (flowTo[3]) flowIntoBlock(world, pos.add( 0, 0, 1), flowMeta);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isFlowingVertically(IBlockAccess world, int x, int y, int z)
|
||||
public boolean isFlowingVertically(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
return world.getBlock(x, y + densityDir, z) == this ||
|
||||
(world.getBlock(x, y, z) == this && canFlowInto(world, x, y + densityDir, z));
|
||||
return world.getBlockState(pos.up(densityDir)).getBlock() == this ||
|
||||
(world.getBlockState(pos).getBlock() == this && canFlowInto(world, pos.up(densityDir)));
|
||||
}
|
||||
|
||||
public boolean isSourceBlock(IBlockAccess world, int x, int y, int z)
|
||||
public boolean isSourceBlock(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
return world.getBlock(x, y, z) == this && world.getBlockMetadata(x, y, z) == 0;
|
||||
return world.getBlockState(pos) == this && ((Integer)world.getBlockState(pos).getValue(LEVEL)).intValue() == 0;
|
||||
}
|
||||
|
||||
protected boolean[] getOptimalFlowDirections(World world, int x, int y, int z)
|
||||
protected boolean[] getOptimalFlowDirections(World world, BlockPos pos)
|
||||
{
|
||||
for (int side = 0; side < 4; side++)
|
||||
{
|
||||
flowCost[side] = 1000;
|
||||
|
||||
int x2 = x;
|
||||
int y2 = y;
|
||||
int z2 = z;
|
||||
BlockPos pos2 = pos;
|
||||
|
||||
switch (side)
|
||||
{
|
||||
case 0: --x2; break;
|
||||
case 1: ++x2; break;
|
||||
case 2: --z2; break;
|
||||
case 3: ++z2; break;
|
||||
case 0: pos2 = pos2.add(-1, 0, 0); break;
|
||||
case 1: pos2 = pos2.add( 1, 0, 0); break;
|
||||
case 2: pos2 = pos2.add( 0, 0, -1); break;
|
||||
case 3: pos2 = pos2.add( 0, 0, 1); break;
|
||||
}
|
||||
|
||||
if (!canFlowInto(world, x2, y2, z2) || isSourceBlock(world, x2, y2, z2))
|
||||
if (!canFlowInto(world, pos2) || isSourceBlock(world, pos2))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (canFlowInto(world, x2, y2 + densityDir, z2))
|
||||
if (canFlowInto(world, pos2.add(0, densityDir, 0)))
|
||||
{
|
||||
flowCost[side] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
flowCost[side] = calculateFlowCost(world, x2, y2, z2, 1, side);
|
||||
flowCost[side] = calculateFlowCost(world, pos2, 1, side);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -221,7 +220,7 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
return isOptimalFlowDirection;
|
||||
}
|
||||
|
||||
protected int calculateFlowCost(World world, int x, int y, int z, int recurseDepth, int side)
|
||||
protected int calculateFlowCost(World world, BlockPos pos, int recurseDepth, int side)
|
||||
{
|
||||
int cost = 1000;
|
||||
for (int adjSide = 0; adjSide < 4; adjSide++)
|
||||
@@ -234,24 +233,22 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
continue;
|
||||
}
|
||||
|
||||
int x2 = x;
|
||||
int y2 = y;
|
||||
int z2 = z;
|
||||
BlockPos pos2 = pos;
|
||||
|
||||
switch (adjSide)
|
||||
{
|
||||
case 0: --x2; break;
|
||||
case 1: ++x2; break;
|
||||
case 2: --z2; break;
|
||||
case 3: ++z2; break;
|
||||
case 0: pos2 = pos2.add(-1, 0, 0); break;
|
||||
case 1: pos2 = pos2.add( 1, 0, 0); break;
|
||||
case 2: pos2 = pos2.add( 0, 0, -1); break;
|
||||
case 3: pos2 = pos2.add( 0, 0, 1); break;
|
||||
}
|
||||
|
||||
if (!canFlowInto(world, x2, y2, z2) || isSourceBlock(world, x2, y2, z2))
|
||||
if (!canFlowInto(world, pos2) || isSourceBlock(world, pos2))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (canFlowInto(world, x2, y2 + densityDir, z2))
|
||||
if (canFlowInto(world, pos2.add(0, densityDir, 0)))
|
||||
{
|
||||
return recurseDepth;
|
||||
}
|
||||
@@ -261,7 +258,7 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
continue;
|
||||
}
|
||||
|
||||
int min = calculateFlowCost(world, x2, y2, z2, recurseDepth + 1, adjSide);
|
||||
int min = calculateFlowCost(world, pos2, recurseDepth + 1, adjSide);
|
||||
if (min < cost)
|
||||
{
|
||||
cost = min;
|
||||
@@ -270,20 +267,20 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
return cost;
|
||||
}
|
||||
|
||||
protected void flowIntoBlock(World world, int x, int y, int z, int meta)
|
||||
protected void flowIntoBlock(World world, BlockPos pos, int meta)
|
||||
{
|
||||
if (meta < 0) return;
|
||||
if (displaceIfPossible(world, x, y, z))
|
||||
if (displaceIfPossible(world, pos))
|
||||
{
|
||||
world.setBlock(x, y, z, this, meta, 3);
|
||||
world.setBlockState(pos, this.getBlockState().getBaseState().withProperty(LEVEL, meta), 3);
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean canFlowInto(IBlockAccess world, int x, int y, int z)
|
||||
protected boolean canFlowInto(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (world.getBlock(x, y, z).isAir(world, x, y, z)) return true;
|
||||
if (world.isAirBlock(pos)) return true;
|
||||
|
||||
Block block = world.getBlock(x, y, z);
|
||||
Block block = world.getBlockState(pos).getBlock();
|
||||
if (block == this)
|
||||
{
|
||||
return true;
|
||||
@@ -303,12 +300,12 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
return false;
|
||||
}
|
||||
|
||||
int density = getDensity(world, x, y, z);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
int density = getDensity(world, pos);
|
||||
if (density == Integer.MAX_VALUE)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
if (this.density > density)
|
||||
{
|
||||
return true;
|
||||
@@ -319,9 +316,9 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
}
|
||||
}
|
||||
|
||||
protected int getLargerQuanta(IBlockAccess world, int x, int y, int z, int compare)
|
||||
protected int getLargerQuanta(IBlockAccess world, BlockPos pos, int compare)
|
||||
{
|
||||
int quantaRemaining = getQuantaValue(world, x, y, z);
|
||||
int quantaRemaining = getQuantaValue(world, pos);
|
||||
if (quantaRemaining <= 0)
|
||||
{
|
||||
return compare;
|
||||
@@ -331,24 +328,24 @@ public class BlockFluidClassic extends BlockFluidBase
|
||||
|
||||
/* IFluidBlock */
|
||||
@Override
|
||||
public FluidStack drain(World world, int x, int y, int z, boolean doDrain)
|
||||
public FluidStack drain(World world, BlockPos pos, boolean doDrain)
|
||||
{
|
||||
if (!isSourceBlock(world, x, y, z))
|
||||
if (!isSourceBlock(world, pos))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (doDrain)
|
||||
{
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockToAir(pos);
|
||||
}
|
||||
|
||||
return stack.copy();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canDrain(World world, int x, int y, int z)
|
||||
public boolean canDrain(World world, BlockPos pos)
|
||||
{
|
||||
return isSourceBlock(world, x, y, z);
|
||||
return isSourceBlock(world, pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,18 +4,20 @@ package net.minecraftforge.fluids;
|
||||
import java.util.Random;
|
||||
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.block.state.IBlockState;
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
/**
|
||||
* This is a cellular-automata based finite fluid block implementation.
|
||||
*
|
||||
*
|
||||
* It is highly recommended that you use/extend this class for finite fluid blocks.
|
||||
*
|
||||
*
|
||||
* @author OvermindDL1, KingLemming
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class BlockFluidFinite extends BlockFluidBase
|
||||
{
|
||||
@@ -25,26 +27,25 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getQuantaValue(IBlockAccess world, int x, int y, int z)
|
||||
public int getQuantaValue(IBlockAccess world, BlockPos pos)
|
||||
{
|
||||
if (world.getBlock(x, y, z).isAir(world, x, y, z))
|
||||
IBlockState state = world.getBlockState(pos);
|
||||
if (state.getBlock().isAir(world, pos))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (world.getBlock(x, y, z) != this)
|
||||
if (state.getBlock() != this)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int quantaRemaining = world.getBlockMetadata(x, y, z) + 1;
|
||||
return quantaRemaining;
|
||||
return ((Integer)state.getValue(LEVEL)) + 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canCollideCheck(int meta, boolean fullHit)
|
||||
public boolean canCollideCheck(IBlockState state, boolean fullHit)
|
||||
{
|
||||
return fullHit && meta == quantaPerBlock - 1;
|
||||
return fullHit && ((Integer)state.getValue(LEVEL)) == quantaPerBlock - 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -54,14 +55,14 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateTick(World world, int x, int y, int z, Random rand)
|
||||
public void updateTick(World world, BlockPos pos, IBlockState state, Random rand)
|
||||
{
|
||||
boolean changed = false;
|
||||
int quantaRemaining = world.getBlockMetadata(x, y, z) + 1;
|
||||
int quantaRemaining = ((Integer)state.getValue(LEVEL)) + 1;
|
||||
|
||||
// Flow vertically if possible
|
||||
int prevRemaining = quantaRemaining;
|
||||
quantaRemaining = tryToFlowVerticallyInto(world, x, y, z, quantaRemaining);
|
||||
quantaRemaining = tryToFlowVerticallyInto(world, pos, quantaRemaining);
|
||||
|
||||
if (quantaRemaining < 1)
|
||||
{
|
||||
@@ -72,7 +73,7 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
changed = true;
|
||||
if (quantaRemaining == 1)
|
||||
{
|
||||
world.setBlockMetadataWithNotify(x, y, z, quantaRemaining - 1, 2);
|
||||
world.setBlockState(pos, state.withProperty(LEVEL, quantaRemaining - 1), 2);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -83,192 +84,110 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
|
||||
// Flow out if possible
|
||||
int lowerthan = quantaRemaining - 1;
|
||||
if (displaceIfPossible(world, x, y, z - 1)) world.setBlock(x, y, z - 1, Blocks.air);
|
||||
if (displaceIfPossible(world, x, y, z + 1)) world.setBlock(x, y, z + 1, Blocks.air);
|
||||
if (displaceIfPossible(world, x - 1, y, z )) world.setBlock(x - 1, y, z, Blocks.air);
|
||||
if (displaceIfPossible(world, x + 1, y, z )) world.setBlock(x + 1, y, z, Blocks.air);
|
||||
int north = getQuantaValueBelow(world, x, y, z - 1, lowerthan);
|
||||
int south = getQuantaValueBelow(world, x, y, z + 1, lowerthan);
|
||||
int west = getQuantaValueBelow(world, x - 1, y, z, lowerthan);
|
||||
int east = getQuantaValueBelow(world, x + 1, y, z, lowerthan);
|
||||
int total = quantaRemaining;
|
||||
int count = 1;
|
||||
|
||||
if (north >= 0)
|
||||
for (EnumFacing side : EnumFacing.Plane.HORIZONTAL)
|
||||
{
|
||||
count++;
|
||||
total += north;
|
||||
}
|
||||
BlockPos off = pos.offset(side);
|
||||
if (displaceIfPossible(world, off))
|
||||
world.setBlockToAir(off);
|
||||
|
||||
if (south >= 0)
|
||||
{
|
||||
count++;
|
||||
total += south;
|
||||
}
|
||||
|
||||
if (west >= 0)
|
||||
{
|
||||
count++;
|
||||
total += west;
|
||||
}
|
||||
|
||||
if (east >= 0)
|
||||
{
|
||||
++count;
|
||||
total += east;
|
||||
int quanta = getQuantaValueBelow(world, off, lowerthan);
|
||||
if (quanta >= 0)
|
||||
{
|
||||
count++;
|
||||
total += quanta;
|
||||
}
|
||||
}
|
||||
|
||||
if (count == 1)
|
||||
{
|
||||
if (changed)
|
||||
{
|
||||
world.setBlockMetadataWithNotify(x, y, z, quantaRemaining - 1, 2);
|
||||
world.setBlockState(pos, state.withProperty(LEVEL, quantaRemaining - 1), 2);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
int each = total / count;
|
||||
int rem = total % count;
|
||||
if (north >= 0)
|
||||
|
||||
for (EnumFacing side : EnumFacing.Plane.HORIZONTAL)
|
||||
{
|
||||
int newnorth = each;
|
||||
if (rem == count || rem > 1 && rand.nextInt(count - rem) != 0)
|
||||
BlockPos off = pos.offset(side);
|
||||
int quanta = getQuantaValueBelow(world, off, lowerthan);
|
||||
if (quanta >= 0)
|
||||
{
|
||||
++newnorth;
|
||||
--rem;
|
||||
}
|
||||
int newquanta = each;
|
||||
if (rem == count || rem > 1 && rand.nextInt(count - rem) != 0)
|
||||
{
|
||||
++newquanta;
|
||||
--rem;
|
||||
}
|
||||
|
||||
if (newnorth != north)
|
||||
{
|
||||
if (newnorth == 0)
|
||||
if (newquanta != quanta)
|
||||
{
|
||||
world.setBlock(x, y, z - 1, Blocks.air);
|
||||
if (newquanta == 0)
|
||||
{
|
||||
world.setBlockToAir(off);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlockState(off, getDefaultState().withProperty(LEVEL, newquanta - 1), 2);
|
||||
}
|
||||
world.scheduleUpdate(off, this, tickRate);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlock(x, y, z - 1, this, newnorth - 1, 2);
|
||||
}
|
||||
world.scheduleBlockUpdate(x, y, z - 1, this, tickRate);
|
||||
--count;
|
||||
}
|
||||
--count;
|
||||
}
|
||||
|
||||
if (south >= 0)
|
||||
{
|
||||
int newsouth = each;
|
||||
if (rem == count || rem > 1 && rand.nextInt(count - rem) != 0)
|
||||
{
|
||||
++newsouth;
|
||||
--rem;
|
||||
}
|
||||
|
||||
if (newsouth != south)
|
||||
{
|
||||
if (newsouth == 0)
|
||||
{
|
||||
world.setBlock(x, y, z + 1, Blocks.air);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlock(x, y, z + 1, this, newsouth - 1, 2);
|
||||
}
|
||||
world.scheduleBlockUpdate(x, y, z + 1, this, tickRate);
|
||||
}
|
||||
--count;
|
||||
}
|
||||
|
||||
if (west >= 0)
|
||||
{
|
||||
int newwest = each;
|
||||
if (rem == count || rem > 1 && rand.nextInt(count - rem) != 0)
|
||||
{
|
||||
++newwest;
|
||||
--rem;
|
||||
}
|
||||
if (newwest != west)
|
||||
{
|
||||
if (newwest == 0)
|
||||
{
|
||||
world.setBlock(x - 1, y, z, Blocks.air);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlock(x - 1, y, z, this, newwest - 1, 2);
|
||||
}
|
||||
world.scheduleBlockUpdate(x - 1, y, z, this, tickRate);
|
||||
}
|
||||
--count;
|
||||
}
|
||||
|
||||
if (east >= 0)
|
||||
{
|
||||
int neweast = each;
|
||||
if (rem == count || rem > 1 && rand.nextInt(count - rem) != 0)
|
||||
{
|
||||
++neweast;
|
||||
--rem;
|
||||
}
|
||||
|
||||
if (neweast != east)
|
||||
{
|
||||
if (neweast == 0)
|
||||
{
|
||||
world.setBlock(x + 1, y, z, Blocks.air);
|
||||
}
|
||||
else
|
||||
{
|
||||
world.setBlock(x + 1, y, z, this, neweast - 1, 2);
|
||||
}
|
||||
world.scheduleBlockUpdate(x + 1, y, z, this, tickRate);
|
||||
}
|
||||
--count;
|
||||
}
|
||||
|
||||
if (rem > 0)
|
||||
{
|
||||
++each;
|
||||
}
|
||||
world.setBlockMetadataWithNotify(x, y, z, each - 1, 2);
|
||||
world.setBlockState(pos, state.withProperty(LEVEL, each - 1), 2);
|
||||
}
|
||||
|
||||
public int tryToFlowVerticallyInto(World world, int x, int y, int z, int amtToInput)
|
||||
public int tryToFlowVerticallyInto(World world, BlockPos pos, int amtToInput)
|
||||
{
|
||||
int otherY = y + densityDir;
|
||||
if (otherY < 0 || otherY >= world.getHeight())
|
||||
IBlockState myState = world.getBlockState(pos);
|
||||
BlockPos other = pos.add(0, densityDir, 0);
|
||||
if (other.getY() < 0 || other.getY() >= world.getHeight())
|
||||
{
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockToAir(pos);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int amt = getQuantaValueBelow(world, x, otherY, z, quantaPerBlock);
|
||||
int amt = getQuantaValueBelow(world, other, quantaPerBlock);
|
||||
if (amt >= 0)
|
||||
{
|
||||
amt += amtToInput;
|
||||
if (amt > quantaPerBlock)
|
||||
{
|
||||
world.setBlock(x, otherY, z, this, quantaPerBlock - 1, 3);
|
||||
world.scheduleBlockUpdate(x, otherY, z, this, tickRate);
|
||||
world.setBlockState(other, myState.withProperty(LEVEL, quantaPerBlock - 1), 3);
|
||||
world.scheduleUpdate(other, this, tickRate);
|
||||
return amt - quantaPerBlock;
|
||||
}
|
||||
else if (amt > 0)
|
||||
{
|
||||
world.setBlock(x, otherY, z, this, amt - 1, 3);
|
||||
world.scheduleBlockUpdate(x, otherY, z, this, tickRate);
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockState(other, myState.withProperty(LEVEL, amt - 1), 3);
|
||||
world.scheduleUpdate(other, this, tickRate);
|
||||
world.setBlockToAir(pos);
|
||||
return 0;
|
||||
}
|
||||
return amtToInput;
|
||||
}
|
||||
else
|
||||
{
|
||||
int density_other = getDensity(world, x, otherY, z);
|
||||
int density_other = getDensity(world, other);
|
||||
if (density_other == Integer.MAX_VALUE)
|
||||
{
|
||||
if (displaceIfPossible(world, x, otherY, z))
|
||||
if (displaceIfPossible(world, other))
|
||||
{
|
||||
world.setBlock(x, otherY, z, this, amtToInput - 1, 3);
|
||||
world.scheduleBlockUpdate(x, otherY, z, this, tickRate);
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockState(other, myState.withProperty(LEVEL, amtToInput - 1), 3);
|
||||
world.scheduleUpdate(other, this, tickRate);
|
||||
world.setBlockToAir(pos);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
@@ -281,12 +200,11 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
{
|
||||
if (density_other < density) // then swap
|
||||
{
|
||||
BlockFluidBase block = (BlockFluidBase)world.getBlock(x, otherY, z);
|
||||
int otherData = world.getBlockMetadata(x, otherY, z);
|
||||
world.setBlock(x, otherY, z, this, amtToInput - 1, 3);
|
||||
world.setBlock(x, y, z, block, otherData, 3);
|
||||
world.scheduleBlockUpdate(x, otherY, z, this, tickRate);
|
||||
world.scheduleBlockUpdate(x, y, z, block, block.tickRate(world));
|
||||
IBlockState state = world.getBlockState(other);
|
||||
world.setBlockState(other, myState.withProperty(LEVEL, amtToInput - 1), 3);
|
||||
world.setBlockState(pos, state, 3);
|
||||
world.scheduleUpdate(other, this, tickRate);
|
||||
world.scheduleUpdate(pos, state.getBlock(), state.getBlock().tickRate(world));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -294,12 +212,11 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
{
|
||||
if (density_other > density)
|
||||
{
|
||||
BlockFluidBase block = (BlockFluidBase)world.getBlock(x, otherY, z);
|
||||
int otherData = world.getBlockMetadata(x, otherY, z);
|
||||
world.setBlock(x, otherY, z, this, amtToInput - 1, 3);
|
||||
world.setBlock(x, y, z, block, otherData, 3);
|
||||
world.scheduleBlockUpdate(x, otherY, z, this, tickRate);
|
||||
world.scheduleBlockUpdate(x, y, z, block, block.tickRate(world));
|
||||
IBlockState state = world.getBlockState(other);
|
||||
world.setBlockState(other, myState.withProperty(LEVEL, amtToInput - 1), 3);
|
||||
world.setBlockState(other, state, 3);
|
||||
world.scheduleUpdate(other, this, tickRate);
|
||||
world.scheduleUpdate(other, state.getBlock(), state.getBlock().tickRate(world));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -309,20 +226,20 @@ public class BlockFluidFinite extends BlockFluidBase
|
||||
|
||||
/* IFluidBlock */
|
||||
@Override
|
||||
public FluidStack drain(World world, int x, int y, int z, boolean doDrain)
|
||||
public FluidStack drain(World world, BlockPos pos, boolean doDrain)
|
||||
{
|
||||
if (doDrain)
|
||||
{
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.setBlockToAir(pos);
|
||||
}
|
||||
|
||||
|
||||
return new FluidStack(getFluid(),
|
||||
MathHelper.floor_float(getQuantaPercentage(world, x, y, z) * FluidContainerRegistry.BUCKET_VOLUME));
|
||||
MathHelper.floor_float(getQuantaPercentage(world, pos) * FluidContainerRegistry.BUCKET_VOLUME));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canDrain(World world, int x, int y, int z)
|
||||
public boolean canDrain(World world, BlockPos pos)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6,12 +6,13 @@ import java.util.Map;
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.util.IIcon;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.ForgeModContainer;
|
||||
import cpw.mods.fml.common.FMLLog;
|
||||
import cpw.mods.fml.common.LoaderException;
|
||||
import net.minecraftforge.fml.common.FMLLog;
|
||||
import net.minecraftforge.fml.common.LoaderException;
|
||||
import net.minecraft.item.EnumRarity;
|
||||
|
||||
/**
|
||||
@@ -41,8 +42,8 @@ public class Fluid
|
||||
protected String unlocalizedName;
|
||||
|
||||
/** The Icons for this fluid. */
|
||||
protected IIcon stillIcon;
|
||||
protected IIcon flowingIcon;
|
||||
protected TextureAtlasSprite stillIcon;
|
||||
protected TextureAtlasSprite flowingIcon;
|
||||
|
||||
/**
|
||||
* The light level emitted by this fluid.
|
||||
@@ -62,7 +63,7 @@ public class Fluid
|
||||
/**
|
||||
* Temperature of the fluid - completely arbitrary; higher temperature indicates that the fluid is
|
||||
* hotter than air.
|
||||
*
|
||||
*
|
||||
* Default value is approximately the real-life room temperature of water in degrees Kelvin.
|
||||
*/
|
||||
protected int temperature = 295;
|
||||
@@ -89,7 +90,7 @@ public class Fluid
|
||||
*
|
||||
* Used primarily in tool tips.
|
||||
*/
|
||||
protected EnumRarity rarity = EnumRarity.common;
|
||||
protected EnumRarity rarity = EnumRarity.COMMON;
|
||||
|
||||
/**
|
||||
* If there is a Block implementation of the Fluid, the Block is linked here.
|
||||
@@ -194,7 +195,7 @@ public class Fluid
|
||||
{
|
||||
return getLocalizedName();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Use the FluidStack sensitive version above
|
||||
*/
|
||||
@@ -254,7 +255,7 @@ public class Fluid
|
||||
{
|
||||
return this.isGaseous;
|
||||
}
|
||||
|
||||
|
||||
public EnumRarity getRarity()
|
||||
{
|
||||
return rarity;
|
||||
@@ -265,36 +266,37 @@ public class Fluid
|
||||
return 0xFFFFFF;
|
||||
}
|
||||
|
||||
public final Fluid setStillIcon(IIcon stillIcon)
|
||||
|
||||
public final Fluid setStillIcon(TextureAtlasSprite stillIcon)
|
||||
{
|
||||
this.stillIcon = stillIcon;
|
||||
return this;
|
||||
}
|
||||
|
||||
public final Fluid setFlowingIcon(IIcon flowingIcon)
|
||||
public final Fluid setFlowingIcon(TextureAtlasSprite flowingIcon)
|
||||
{
|
||||
this.flowingIcon = flowingIcon;
|
||||
return this;
|
||||
}
|
||||
|
||||
public final Fluid setIcons(IIcon stillIcon, IIcon flowingIcon)
|
||||
public final Fluid setIcons(TextureAtlasSprite stillIcon, TextureAtlasSprite flowingIcon)
|
||||
{
|
||||
return this.setStillIcon(stillIcon).setFlowingIcon(flowingIcon);
|
||||
}
|
||||
|
||||
public final Fluid setIcons(IIcon commonIcon)
|
||||
public final Fluid setIcons(TextureAtlasSprite commonIcon)
|
||||
{
|
||||
return this.setStillIcon(commonIcon).setFlowingIcon(commonIcon);
|
||||
}
|
||||
|
||||
public IIcon getIcon(){ return getStillIcon(); }
|
||||
public TextureAtlasSprite getIcon(){ return getStillIcon(); }
|
||||
|
||||
public IIcon getStillIcon()
|
||||
public TextureAtlasSprite getStillIcon()
|
||||
{
|
||||
return this.stillIcon;
|
||||
}
|
||||
|
||||
public IIcon getFlowingIcon()
|
||||
public TextureAtlasSprite getFlowingIcon()
|
||||
{
|
||||
return this.flowingIcon;
|
||||
}
|
||||
@@ -307,16 +309,16 @@ public class Fluid
|
||||
public boolean isGaseous(FluidStack stack){ return isGaseous(); }
|
||||
public EnumRarity getRarity(FluidStack stack){ return getRarity(); }
|
||||
public int getColor(FluidStack stack){ return getColor(); }
|
||||
public IIcon getIcon(FluidStack stack){ return getIcon(); }
|
||||
public TextureAtlasSprite getIcon(FluidStack stack){ return getIcon(); }
|
||||
/* World-based Accessors */
|
||||
public int getLuminosity(World world, int x, int y, int z){ return getLuminosity(); }
|
||||
public int getDensity(World world, int x, int y, int z){ return getDensity(); }
|
||||
public int getTemperature(World world, int x, int y, int z){ return getTemperature(); }
|
||||
public int getViscosity(World world, int x, int y, int z){ return getViscosity(); }
|
||||
public boolean isGaseous(World world, int x, int y, int z){ return isGaseous(); }
|
||||
public EnumRarity getRarity(World world, int x, int y, int z){ return getRarity(); }
|
||||
public int getColor(World world, int x, int y, int z){ return getColor(); }
|
||||
public IIcon getIcon(World world, int x, int y, int z){ return getIcon(); }
|
||||
public int getLuminosity(World world, BlockPos pos){ return getLuminosity(); }
|
||||
public int getDensity(World world, BlockPos pos){ return getDensity(); }
|
||||
public int getTemperature(World world, BlockPos pos){ return getTemperature(); }
|
||||
public int getViscosity(World world, BlockPos pos){ return getViscosity(); }
|
||||
public boolean isGaseous(World world, BlockPos pos){ return isGaseous(); }
|
||||
public EnumRarity getRarity(World world, BlockPos pos){ return getRarity(); }
|
||||
public int getColor(World world, BlockPos pos){ return getColor(); }
|
||||
public TextureAtlasSprite getIcon(World world, BlockPos pos){ return getIcon(); }
|
||||
|
||||
private static Map<String, String> legacyNames = Maps.newHashMap();
|
||||
static String convertLegacyName(String fluidName)
|
||||
|
||||
@@ -11,7 +11,7 @@ import java.util.Set;
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.common.collect.Sets;
|
||||
|
||||
import cpw.mods.fml.common.eventhandler.Event;
|
||||
import net.minecraftforge.fml.common.eventhandler.Event;
|
||||
import net.minecraft.init.Items;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
|
||||
@@ -1,66 +1,49 @@
|
||||
|
||||
package net.minecraftforge.fluids;
|
||||
|
||||
import cpw.mods.fml.common.eventhandler.Event;
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
import net.minecraftforge.fml.common.eventhandler.Event;
|
||||
|
||||
public class FluidEvent extends Event
|
||||
{
|
||||
public final FluidStack fluid;
|
||||
public final int x;
|
||||
public final int y;
|
||||
public final int z;
|
||||
public final World world;
|
||||
public final BlockPos pos;
|
||||
|
||||
public FluidEvent(FluidStack fluid, World world, int x, int y, int z)
|
||||
public FluidEvent(FluidStack fluid, World world, BlockPos pos)
|
||||
{
|
||||
this.fluid = fluid;
|
||||
this.world = world;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.pos = pos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Mods should fire this event when they move fluids around.
|
||||
*
|
||||
* @author cpw
|
||||
*
|
||||
*
|
||||
*/
|
||||
public static class FluidMotionEvent extends FluidEvent
|
||||
{
|
||||
public FluidMotionEvent(FluidStack fluid, World world, int x, int y, int z)
|
||||
public FluidMotionEvent(FluidStack fluid, World world, BlockPos pos)
|
||||
{
|
||||
super(fluid, world, x, y, z);
|
||||
super(fluid, world, pos);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Mods should fire this event when a fluid is {@link IFluidTank#fill(FluidStack, boolean)}
|
||||
* their tank implementation. {@link FluidTank} does.
|
||||
*
|
||||
* @author cpw
|
||||
*
|
||||
*
|
||||
*/
|
||||
public static class FluidFillingEvent extends FluidEvent
|
||||
{
|
||||
public final IFluidTank tank;
|
||||
public final int amount;
|
||||
|
||||
/**
|
||||
* @deprecated Will be removed in 1.8
|
||||
*
|
||||
*/
|
||||
@Deprecated
|
||||
public FluidFillingEvent(FluidStack fluid, World world, int x, int y, int z, IFluidTank tank)
|
||||
public FluidFillingEvent(FluidStack fluid, World world, BlockPos pos, IFluidTank tank, int amount)
|
||||
{
|
||||
this(fluid, world, x, y, z, tank, -1);
|
||||
}
|
||||
|
||||
public FluidFillingEvent(FluidStack fluid, World world, int x, int y, int z, IFluidTank tank, int amount)
|
||||
{
|
||||
super(fluid, world, x, y, z);
|
||||
super(fluid, world, pos);
|
||||
this.tank = tank;
|
||||
this.amount = amount;
|
||||
}
|
||||
@@ -69,28 +52,16 @@ public class FluidEvent extends Event
|
||||
/**
|
||||
* Mods should fire this event when a fluid is {@link IFluidTank#drain(int, boolean)} from their
|
||||
* tank.
|
||||
*
|
||||
* @author cpw
|
||||
*
|
||||
*
|
||||
*/
|
||||
public static class FluidDrainingEvent extends FluidEvent
|
||||
{
|
||||
public final IFluidTank tank;
|
||||
public final int amount;
|
||||
|
||||
/**
|
||||
* @deprecated Will be removed in 1.8
|
||||
*
|
||||
*/
|
||||
@Deprecated
|
||||
public FluidDrainingEvent(FluidStack fluid, World world, int x, int y, int z, IFluidTank tank)
|
||||
public FluidDrainingEvent(FluidStack fluid, World world, BlockPos pos, IFluidTank tank, int amount)
|
||||
{
|
||||
this(fluid, world, x, y, z, tank, -1);
|
||||
}
|
||||
|
||||
public FluidDrainingEvent(FluidStack fluid, World world, int x, int y, int z, IFluidTank tank, int amount)
|
||||
{
|
||||
super(fluid, world, x, y, z);
|
||||
super(fluid, world, pos);
|
||||
this.amount = amount;
|
||||
this.tank = tank;
|
||||
}
|
||||
@@ -99,21 +70,19 @@ public class FluidEvent extends Event
|
||||
/**
|
||||
* Mods should fire this event when a fluid "spills", for example, if a block containing fluid
|
||||
* is broken.
|
||||
*
|
||||
* @author cpw
|
||||
*
|
||||
*
|
||||
*/
|
||||
public static class FluidSpilledEvent extends FluidEvent
|
||||
{
|
||||
public FluidSpilledEvent(FluidStack fluid, World world, int x, int y, int z)
|
||||
public FluidSpilledEvent(FluidStack fluid, World world, BlockPos pos)
|
||||
{
|
||||
super(fluid, world, x, y, z);
|
||||
super(fluid, world, pos);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A handy shortcut for firing the various fluid events.
|
||||
*
|
||||
*
|
||||
* @param event
|
||||
*/
|
||||
public static final void fireEvent(FluidEvent event)
|
||||
|
||||
@@ -13,7 +13,7 @@ import com.google.common.collect.HashBiMap;
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
import cpw.mods.fml.common.eventhandler.Event;
|
||||
import net.minecraftforge.fml.common.eventhandler.Event;
|
||||
|
||||
/**
|
||||
* Handles Fluid registrations. Fluids MUST be registered in order to function.
|
||||
|
||||
@@ -6,9 +6,9 @@ import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
/**
|
||||
* Reference implementation of {@link IFluidTank}. Use/extend this or implement your own.
|
||||
*
|
||||
*
|
||||
* @author King Lemming, cpw (LiquidTank)
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class FluidTank implements IFluidTank
|
||||
{
|
||||
@@ -127,7 +127,7 @@ public class FluidTank implements IFluidTank
|
||||
|
||||
if (tile != null)
|
||||
{
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidFillingEvent(fluid, tile.getWorldObj(), tile.xCoord, tile.yCoord, tile.zCoord, this, fluid.amount));
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidFillingEvent(fluid, tile.getWorld(), tile.getPos(), this, fluid.amount));
|
||||
}
|
||||
return fluid.amount;
|
||||
}
|
||||
@@ -150,7 +150,7 @@ public class FluidTank implements IFluidTank
|
||||
|
||||
if (tile != null)
|
||||
{
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidFillingEvent(fluid, tile.getWorldObj(), tile.xCoord, tile.yCoord, tile.zCoord, this, filled));
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidFillingEvent(fluid, tile.getWorld(), tile.getPos(), this, filled));
|
||||
}
|
||||
return filled;
|
||||
}
|
||||
@@ -180,7 +180,7 @@ public class FluidTank implements IFluidTank
|
||||
|
||||
if (tile != null)
|
||||
{
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidDrainingEvent(fluid, tile.getWorldObj(), tile.xCoord, tile.yCoord, tile.zCoord, this, drained));
|
||||
FluidEvent.fireEvent(new FluidEvent.FluidDrainingEvent(fluid, tile.getWorld(), tile.getPos(), this, drained));
|
||||
}
|
||||
}
|
||||
return stack;
|
||||
|
||||
@@ -1,14 +1,15 @@
|
||||
package net.minecraftforge.fluids;
|
||||
|
||||
import net.minecraft.util.BlockPos;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
/**
|
||||
* Implement this interface on Block classes which represent world-placeable Fluids.
|
||||
*
|
||||
*
|
||||
* NOTE: Using/extending the reference implementations {@link BlockFluidBase} is encouraged.
|
||||
*
|
||||
*
|
||||
* @author King Lemming
|
||||
*
|
||||
*
|
||||
*/
|
||||
public interface IFluidBlock
|
||||
{
|
||||
@@ -19,33 +20,33 @@ public interface IFluidBlock
|
||||
|
||||
/**
|
||||
* Attempt to drain the block. This method should be called by devices such as pumps.
|
||||
*
|
||||
*
|
||||
* NOTE: The block is intended to handle its own state changes.
|
||||
*
|
||||
*
|
||||
* @param doDrain
|
||||
* If false, the drain will only be simulated.
|
||||
* @return
|
||||
*/
|
||||
FluidStack drain(World world, int x, int y, int z, boolean doDrain);
|
||||
FluidStack drain(World world, BlockPos pos, boolean doDrain);
|
||||
|
||||
/**
|
||||
* Check to see if a block can be drained. This method should be called by devices such as
|
||||
* pumps.
|
||||
*
|
||||
*
|
||||
* @param doDrain
|
||||
* If false, the drain will only be simulated.
|
||||
* @return
|
||||
*/
|
||||
boolean canDrain(World world, int x, int y, int z);
|
||||
boolean canDrain(World world, BlockPos pos);
|
||||
|
||||
/**
|
||||
* Returns the amount of a single block is filled. Value between 0 and 1.
|
||||
* 1 meaning the entire 1x1x1 cube is full, 0 meaning completely empty.
|
||||
*
|
||||
* If the return value is negative. It will be treated as filling the block
|
||||
*
|
||||
* If the return value is negative. It will be treated as filling the block
|
||||
* from the top down instead of bottom up.
|
||||
*
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
float getFilledPercentage(World world, int x, int y, int z);
|
||||
}
|
||||
float getFilledPercentage(World world, BlockPos pos);
|
||||
}
|
||||
@@ -1,21 +1,21 @@
|
||||
package net.minecraftforge.fluids;
|
||||
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
|
||||
/**
|
||||
* Implement this interface on TileEntities which should handle fluids, generally storing them in
|
||||
* one or more internal {@link IFluidTank} objects.
|
||||
*
|
||||
*
|
||||
* A reference implementation is provided {@link TileFluidHandler}.
|
||||
*
|
||||
*
|
||||
* @author King Lemming
|
||||
*
|
||||
*
|
||||
*/
|
||||
public interface IFluidHandler
|
||||
{
|
||||
/**
|
||||
* Fills fluid into internal tanks, distribution is left entirely to the IFluidHandler.
|
||||
*
|
||||
*
|
||||
* @param from
|
||||
* Orientation the Fluid is pumped in from.
|
||||
* @param resource
|
||||
@@ -24,11 +24,11 @@ public interface IFluidHandler
|
||||
* If false, fill will only be simulated.
|
||||
* @return Amount of resource that was (or would have been, if simulated) filled.
|
||||
*/
|
||||
int fill(ForgeDirection from, FluidStack resource, boolean doFill);
|
||||
int fill(EnumFacing from, FluidStack resource, boolean doFill);
|
||||
|
||||
/**
|
||||
* Drains fluid out of internal tanks, distribution is left entirely to the IFluidHandler.
|
||||
*
|
||||
*
|
||||
* @param from
|
||||
* Orientation the Fluid is drained to.
|
||||
* @param resource
|
||||
@@ -38,13 +38,13 @@ public interface IFluidHandler
|
||||
* @return FluidStack representing the Fluid and amount that was (or would have been, if
|
||||
* simulated) drained.
|
||||
*/
|
||||
FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain);
|
||||
FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain);
|
||||
|
||||
/**
|
||||
* Drains fluid out of internal tanks, distribution is left entirely to the IFluidHandler.
|
||||
*
|
||||
*
|
||||
* This method is not Fluid-sensitive.
|
||||
*
|
||||
*
|
||||
* @param from
|
||||
* Orientation the fluid is drained to.
|
||||
* @param maxDrain
|
||||
@@ -54,29 +54,29 @@ public interface IFluidHandler
|
||||
* @return FluidStack representing the Fluid and amount that was (or would have been, if
|
||||
* simulated) drained.
|
||||
*/
|
||||
FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain);
|
||||
FluidStack drain(EnumFacing from, int maxDrain, boolean doDrain);
|
||||
|
||||
/**
|
||||
* Returns true if the given fluid can be inserted into the given direction.
|
||||
*
|
||||
*
|
||||
* More formally, this should return true if fluid is able to enter from the given direction.
|
||||
*/
|
||||
boolean canFill(ForgeDirection from, Fluid fluid);
|
||||
boolean canFill(EnumFacing from, Fluid fluid);
|
||||
|
||||
/**
|
||||
* Returns true if the given fluid can be extracted from the given direction.
|
||||
*
|
||||
*
|
||||
* More formally, this should return true if fluid is able to leave from the given direction.
|
||||
*/
|
||||
boolean canDrain(ForgeDirection from, Fluid fluid);
|
||||
boolean canDrain(EnumFacing from, Fluid fluid);
|
||||
|
||||
/**
|
||||
* Returns an array of objects which represent the internal tanks. These objects cannot be used
|
||||
* to manipulate the internal tanks. See {@link FluidTankInfo}.
|
||||
*
|
||||
*
|
||||
* @param from
|
||||
* Orientation determining which tanks should be queried.
|
||||
* @return Info for the relevant internal tanks.
|
||||
*/
|
||||
FluidTankInfo[] getTankInfo(ForgeDirection from);
|
||||
FluidTankInfo[] getTankInfo(EnumFacing from);
|
||||
}
|
||||
@@ -6,9 +6,9 @@ import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
/**
|
||||
* Reference implementation of {@link IFluidContainerItem}. Use/extend this or implement your own.
|
||||
*
|
||||
*
|
||||
* @author King Lemming
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
{
|
||||
@@ -35,11 +35,11 @@ public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
@Override
|
||||
public FluidStack getFluid(ItemStack container)
|
||||
{
|
||||
if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
|
||||
if (!container.hasTagCompound() || !container.getTagCompound().hasKey("Fluid"))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
|
||||
return FluidStack.loadFluidStackFromNBT(container.getTagCompound().getCompoundTag("Fluid"));
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -58,12 +58,12 @@ public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
|
||||
if (!doFill)
|
||||
{
|
||||
if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
|
||||
if (!container.hasTagCompound() || !container.getTagCompound().hasKey("Fluid"))
|
||||
{
|
||||
return Math.min(capacity, resource.amount);
|
||||
}
|
||||
|
||||
FluidStack stack = FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
|
||||
FluidStack stack = FluidStack.loadFluidStackFromNBT(container.getTagCompound().getCompoundTag("Fluid"));
|
||||
|
||||
if (stack == null)
|
||||
{
|
||||
@@ -78,27 +78,27 @@ public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
return Math.min(capacity - stack.amount, resource.amount);
|
||||
}
|
||||
|
||||
if (container.stackTagCompound == null)
|
||||
if (!container.hasTagCompound())
|
||||
{
|
||||
container.stackTagCompound = new NBTTagCompound();
|
||||
container.setTagCompound(new NBTTagCompound());
|
||||
}
|
||||
|
||||
if (!container.stackTagCompound.hasKey("Fluid"))
|
||||
if (!container.getTagCompound().hasKey("Fluid"))
|
||||
{
|
||||
NBTTagCompound fluidTag = resource.writeToNBT(new NBTTagCompound());
|
||||
|
||||
if (capacity < resource.amount)
|
||||
{
|
||||
fluidTag.setInteger("Amount", capacity);
|
||||
container.stackTagCompound.setTag("Fluid", fluidTag);
|
||||
container.getTagCompound().setTag("Fluid", fluidTag);
|
||||
return capacity;
|
||||
}
|
||||
|
||||
container.stackTagCompound.setTag("Fluid", fluidTag);
|
||||
container.getTagCompound().setTag("Fluid", fluidTag);
|
||||
return resource.amount;
|
||||
}
|
||||
|
||||
NBTTagCompound fluidTag = container.stackTagCompound.getCompoundTag("Fluid");
|
||||
NBTTagCompound fluidTag = container.getTagCompound().getCompoundTag("Fluid");
|
||||
FluidStack stack = FluidStack.loadFluidStackFromNBT(fluidTag);
|
||||
|
||||
if (!stack.isFluidEqual(resource))
|
||||
@@ -117,19 +117,19 @@ public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
stack.amount = capacity;
|
||||
}
|
||||
|
||||
container.stackTagCompound.setTag("Fluid", stack.writeToNBT(fluidTag));
|
||||
container.getTagCompound().setTag("Fluid", stack.writeToNBT(fluidTag));
|
||||
return filled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public FluidStack drain(ItemStack container, int maxDrain, boolean doDrain)
|
||||
{
|
||||
if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Fluid"))
|
||||
if (!container.hasTagCompound() || !container.getTagCompound().hasKey("Fluid"))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
FluidStack stack = FluidStack.loadFluidStackFromNBT(container.stackTagCompound.getCompoundTag("Fluid"));
|
||||
FluidStack stack = FluidStack.loadFluidStackFromNBT(container.getTagCompound().getCompoundTag("Fluid"));
|
||||
if (stack == null)
|
||||
{
|
||||
return null;
|
||||
@@ -141,18 +141,18 @@ public class ItemFluidContainer extends Item implements IFluidContainerItem
|
||||
{
|
||||
if (currentAmount == stack.amount)
|
||||
{
|
||||
container.stackTagCompound.removeTag("Fluid");
|
||||
container.getTagCompound().removeTag("Fluid");
|
||||
|
||||
if (container.stackTagCompound.hasNoTags())
|
||||
if (container.getTagCompound().hasNoTags())
|
||||
{
|
||||
container.stackTagCompound = null;
|
||||
container.setTagCompound(null);
|
||||
}
|
||||
return stack;
|
||||
}
|
||||
|
||||
NBTTagCompound fluidTag = container.stackTagCompound.getCompoundTag("Fluid");
|
||||
NBTTagCompound fluidTag = container.getTagCompound().getCompoundTag("Fluid");
|
||||
fluidTag.setInteger("Amount", currentAmount - stack.amount);
|
||||
container.stackTagCompound.setTag("Fluid", fluidTag);
|
||||
container.getTagCompound().setTag("Fluid", fluidTag);
|
||||
}
|
||||
return stack;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
package net.minecraftforge.fluids;
|
||||
|
||||
//TODO: Get some test liquids and test this out -.-
|
||||
/*
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.RenderBlocks;
|
||||
@@ -8,14 +10,14 @@ import net.minecraft.client.renderer.texture.TextureMap;
|
||||
import net.minecraft.util.IIcon;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
import net.minecraftforge.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
|
||||
/**
|
||||
* Default renderer for Forge fluid blocks.
|
||||
*
|
||||
*
|
||||
* @author King Lemming
|
||||
*
|
||||
*/
|
||||
*
|
||||
* /
|
||||
public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
{
|
||||
public static RenderBlockFluid instance = new RenderBlockFluid();
|
||||
@@ -30,7 +32,7 @@ public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
{
|
||||
float total = 0;
|
||||
int count = 0;
|
||||
|
||||
|
||||
float end = 0;
|
||||
|
||||
for (int i = 0; i < flow.length; i++)
|
||||
@@ -46,10 +48,10 @@ public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (end == 0)
|
||||
end = total / count;
|
||||
|
||||
|
||||
return end;
|
||||
}
|
||||
|
||||
@@ -71,7 +73,7 @@ public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
return !world.getBlock(x, y, z).getMaterial().isSolid() && world.getBlock(x, y - block.densityDir, z) == block ? 1 : block.getQuantaPercentage(world, x, y, z) * 0.875F;
|
||||
}
|
||||
|
||||
/* ISimpleBlockRenderingHandler */
|
||||
/* ISimpleBlockRenderingHandler * /
|
||||
@Override
|
||||
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer){}
|
||||
|
||||
@@ -98,9 +100,9 @@ public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
|
||||
boolean[] renderSides = new boolean[]
|
||||
{
|
||||
block.shouldSideBeRendered(world, x, y, z - 1, 2),
|
||||
block.shouldSideBeRendered(world, x, y, z - 1, 2),
|
||||
block.shouldSideBeRendered(world, x, y, z + 1, 3),
|
||||
block.shouldSideBeRendered(world, x - 1, y, z, 4),
|
||||
block.shouldSideBeRendered(world, x - 1, y, z, 4),
|
||||
block.shouldSideBeRendered(world, x + 1, y, z, 5)
|
||||
};
|
||||
|
||||
@@ -355,3 +357,4 @@ public class RenderBlockFluid implements ISimpleBlockRenderingHandler
|
||||
return ((TextureMap)Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno");
|
||||
}
|
||||
}
|
||||
*/
|
||||
@@ -3,13 +3,13 @@ package net.minecraftforge.fluids;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import net.minecraft.util.EnumFacing;
|
||||
|
||||
/**
|
||||
* Reference Tile Entity implementation of {@link IFluidHandler}. Use/extend this or write your own.
|
||||
*
|
||||
*
|
||||
* @author King Lemming
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class TileFluidHandler extends TileEntity implements IFluidHandler
|
||||
{
|
||||
@@ -31,13 +31,13 @@ public class TileFluidHandler extends TileEntity implements IFluidHandler
|
||||
|
||||
/* IFluidHandler */
|
||||
@Override
|
||||
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
|
||||
public int fill(EnumFacing from, FluidStack resource, boolean doFill)
|
||||
{
|
||||
return tank.fill(resource, doFill);
|
||||
}
|
||||
|
||||
@Override
|
||||
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
|
||||
public FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain)
|
||||
{
|
||||
if (resource == null || !resource.isFluidEqual(tank.getFluid()))
|
||||
{
|
||||
@@ -47,25 +47,25 @@ public class TileFluidHandler extends TileEntity implements IFluidHandler
|
||||
}
|
||||
|
||||
@Override
|
||||
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
|
||||
public FluidStack drain(EnumFacing from, int maxDrain, boolean doDrain)
|
||||
{
|
||||
return tank.drain(maxDrain, doDrain);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canFill(ForgeDirection from, Fluid fluid)
|
||||
public boolean canFill(EnumFacing from, Fluid fluid)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canDrain(ForgeDirection from, Fluid fluid)
|
||||
public boolean canDrain(EnumFacing from, Fluid fluid)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public FluidTankInfo[] getTankInfo(ForgeDirection from)
|
||||
public FluidTankInfo[] getTankInfo(EnumFacing from)
|
||||
{
|
||||
return new FluidTankInfo[] { tank.getInfo() };
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user