Make FluidStacks non-nullable, and implement some TODOs.
This commit is contained in:
parent
a788e8a475
commit
a9b3b48273
18 changed files with 289 additions and 220 deletions
|
@ -44,6 +44,7 @@ import net.minecraft.resources.IResourceManager;
|
|||
import net.minecraft.util.Direction;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.registries.ForgeRegistries;
|
||||
import net.minecraftforge.versions.forge.ForgeVersion;
|
||||
import net.minecraftforge.common.model.IModelState;
|
||||
import net.minecraftforge.common.model.TRSRTransformation;
|
||||
|
@ -190,8 +191,8 @@ public final class ModelDynBucket implements IUnbakedModel
|
|||
@Override
|
||||
public ModelDynBucket process(ImmutableMap<String, String> customData)
|
||||
{
|
||||
String fluidName = customData.get("fluid");
|
||||
Fluid fluid = null; // TODO fluids FluidRegistry.getFluid(fluidName);
|
||||
ResourceLocation fluidName = new ResourceLocation(customData.get("fluid"));
|
||||
Fluid fluid = ForgeRegistries.FLUIDS.getValue(fluidName);
|
||||
|
||||
if (fluid == null) fluid = this.fluid;
|
||||
|
||||
|
|
|
@ -38,6 +38,7 @@ import net.minecraft.client.renderer.texture.ISprite;
|
|||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
import net.minecraft.client.renderer.vertex.VertexFormat;
|
||||
import net.minecraft.fluid.Fluid;
|
||||
import net.minecraft.fluid.Fluids;
|
||||
import net.minecraft.resources.IResourceManager;
|
||||
import net.minecraft.util.Direction;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
@ -66,8 +67,8 @@ import com.google.gson.JsonParser;
|
|||
public final class ModelFluid implements IUnbakedModel
|
||||
{
|
||||
private static final Logger LOGGER = LogManager.getLogger();
|
||||
public static final ModelFluid WATER = null; // TODO fluids new ModelFluid(FluidRegistry.WATER);
|
||||
public static final ModelFluid LAVA = null; // TODO fluids new ModelFluid(FluidRegistry.LAVA);
|
||||
public static final ModelFluid WATER = new ModelFluid(Fluids.WATER);
|
||||
public static final ModelFluid LAVA = new ModelFluid(Fluids.LAVA);
|
||||
|
||||
private final Fluid fluid;
|
||||
|
||||
|
|
|
@ -52,8 +52,6 @@ public class MinecraftForge
|
|||
LOGGER.info(FORGE,"MinecraftForge v{} Initialized", ForgeVersion.getVersion());
|
||||
|
||||
UsernameCache.load();
|
||||
// Load before all the mods, so MC owns the MC fluids
|
||||
// TODO Fluids FluidRegistry.validateFluidRegistry();
|
||||
ForgeHooks.initTools();
|
||||
|
||||
//For all the normal CrashReport classes to be defined. We're in MC's classloader so this should all be fine
|
||||
|
|
|
@ -103,7 +103,7 @@ public class DispenseFluidContainer extends DefaultDispenseItemBehavior
|
|||
{
|
||||
ItemStack singleStack = stack.copy();
|
||||
singleStack.setCount(1);
|
||||
IFluidHandlerItem fluidHandler = null; // TODO fluids FluidUtil.getFluidHandler(singleStack);
|
||||
IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(singleStack).orElse(null);
|
||||
if (fluidHandler == null)
|
||||
{
|
||||
return super.dispenseStack(source, stack);
|
||||
|
@ -112,7 +112,7 @@ public class DispenseFluidContainer extends DefaultDispenseItemBehavior
|
|||
FluidStack fluidStack = fluidHandler.drain(FluidAttributes.BUCKET_VOLUME, IFluidHandler.FluidAction.EXECUTE);
|
||||
Direction dispenserFacing = source.getBlockState().get(DispenserBlock.FACING);
|
||||
BlockPos blockpos = source.getBlockPos().offset(dispenserFacing);
|
||||
FluidActionResult result = fluidStack != null ? FluidUtil.tryPlaceFluid(null, source.getWorld(), Hand.MAIN_HAND, blockpos, stack, fluidStack) : FluidActionResult.FAILURE;
|
||||
FluidActionResult result = FluidUtil.tryPlaceFluid(null, source.getWorld(), Hand.MAIN_HAND, blockpos, stack, fluidStack);
|
||||
|
||||
if (result.isSuccess())
|
||||
{
|
||||
|
|
|
@ -24,6 +24,9 @@ import javax.annotation.Nullable;
|
|||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.block.Blocks;
|
||||
import net.minecraft.fluid.IFluidState;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.item.Items;
|
||||
import net.minecraft.particles.ParticleTypes;
|
||||
import net.minecraft.util.text.ITextComponent;
|
||||
import net.minecraft.util.text.TranslationTextComponent;
|
||||
|
@ -129,6 +132,7 @@ public class FluidAttributes
|
|||
private final Rarity rarity;
|
||||
|
||||
private final Supplier<Block> blockSupplier;
|
||||
private final Supplier<Item> bucketSupplier;
|
||||
|
||||
/**
|
||||
* Color used by universal bucket and the ModelFluid baked model.
|
||||
|
@ -157,6 +161,7 @@ public class FluidAttributes
|
|||
this.density = builder.density;
|
||||
this.isGaseous = builder.isGaseous;
|
||||
this.rarity = builder.rarity;
|
||||
this.bucketSupplier = builder.bucketSupplier;
|
||||
}
|
||||
|
||||
public final String getName()
|
||||
|
@ -164,6 +169,11 @@ public class FluidAttributes
|
|||
return this.fluidName;
|
||||
}
|
||||
|
||||
public ItemStack getBucket(FluidStack stack)
|
||||
{
|
||||
return bucketSupplier != null ? new ItemStack(bucketSupplier.get()) : ItemStack.EMPTY;
|
||||
}
|
||||
|
||||
public BlockState getBlock(IEnviromentBlockReader reader, BlockPos pos, IFluidState state)
|
||||
{
|
||||
return (blockSupplier != null ? blockSupplier.get() : Blocks.AIR).getDefaultState();
|
||||
|
@ -353,6 +363,7 @@ public class FluidAttributes
|
|||
private SoundEvent fillSound;
|
||||
private SoundEvent emptySound;
|
||||
private Supplier<Block> blockSupplier;
|
||||
private Supplier<Item> bucketSupplier;
|
||||
private int luminosity = 0;
|
||||
private int density = 1000;
|
||||
private int temperature = 300;
|
||||
|
@ -397,6 +408,12 @@ public class FluidAttributes
|
|||
return this;
|
||||
}
|
||||
|
||||
public final Builder bucket(Supplier<Item> supplier)
|
||||
{
|
||||
bucketSupplier = supplier;
|
||||
return this;
|
||||
}
|
||||
|
||||
public final Builder luminosity(int luminosity)
|
||||
{
|
||||
this.luminosity = luminosity;
|
||||
|
|
|
@ -20,12 +20,17 @@
|
|||
package net.minecraftforge.fluids;
|
||||
|
||||
import net.minecraft.fluid.Fluid;
|
||||
import net.minecraft.fluid.Fluids;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.CompoundNBT;
|
||||
import net.minecraft.network.PacketBuffer;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.util.text.ITextComponent;
|
||||
import net.minecraftforge.common.util.Constants;
|
||||
import net.minecraftforge.registries.ForgeRegistries;
|
||||
import net.minecraftforge.registries.IRegistryDelegate;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
|
@ -43,8 +48,11 @@ public class FluidStack
|
|||
{
|
||||
private static final Logger LOGGER = LogManager.getLogger();
|
||||
|
||||
public int amount;
|
||||
public CompoundNBT tag;
|
||||
public static final FluidStack EMPTY = new FluidStack(Fluids.EMPTY, 0);
|
||||
|
||||
private boolean isEmpty;
|
||||
private int amount;
|
||||
private CompoundNBT tag;
|
||||
private IRegistryDelegate<Fluid> fluidDelegate;
|
||||
|
||||
public FluidStack(Fluid fluid, int amount)
|
||||
|
@ -53,13 +61,13 @@ public class FluidStack
|
|||
{
|
||||
LOGGER.fatal("Null fluid supplied to fluidstack. Did you try and create a stack for an unregistered fluid?");
|
||||
throw new IllegalArgumentException("Cannot create a fluidstack from a null fluid");
|
||||
}/* TODO fluids
|
||||
else if (!FluidRegistry.isFluidRegistered(fluid))
|
||||
}
|
||||
else if (ForgeRegistries.FLUIDS.getKey(fluid) == null)
|
||||
{
|
||||
LOGGER.fatal("Failed attempt to create a FluidStack for an unregistered Fluid {} (type {})", fluid.getName(), fluid.getClass().getName());
|
||||
LOGGER.fatal("Failed attempt to create a FluidStack for an unregistered Fluid {} (type {})", fluid.getRegistryName(), fluid.getClass().getName());
|
||||
throw new IllegalArgumentException("Cannot create a fluidstack from an unregistered fluid");
|
||||
} */
|
||||
this.fluidDelegate = null; // TODO fluids FluidRegistry.makeDelegate(fluid);
|
||||
}
|
||||
this.fluidDelegate = fluid.delegate;
|
||||
this.amount = amount;
|
||||
}
|
||||
|
||||
|
@ -69,7 +77,7 @@ public class FluidStack
|
|||
|
||||
if (nbt != null)
|
||||
{
|
||||
tag = (CompoundNBT) nbt.copy();
|
||||
tag = nbt.copy();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -82,35 +90,35 @@ public class FluidStack
|
|||
* This provides a safe method for retrieving a FluidStack - if the Fluid is invalid, the stack
|
||||
* will return as null.
|
||||
*/
|
||||
@Nullable
|
||||
public static FluidStack loadFluidStackFromNBT(CompoundNBT nbt)
|
||||
{
|
||||
if (nbt == null)
|
||||
{
|
||||
return null;
|
||||
return EMPTY;
|
||||
}
|
||||
if (!nbt.contains("FluidName", Constants.NBT.TAG_STRING))
|
||||
{
|
||||
return null;
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
String fluidName = nbt.getString("FluidName");
|
||||
// TODO fluids if (FluidRegistry.getFluid(fluidName) == null)
|
||||
ResourceLocation fluidName = new ResourceLocation(nbt.getString("FluidName"));
|
||||
Fluid fluid = ForgeRegistries.FLUIDS.getValue(fluidName);
|
||||
if (fluid == null)
|
||||
{
|
||||
return null;
|
||||
}/*
|
||||
FluidStack stack = new FluidStack(FluidRegistry.getFluid(fluidName), nbt.getInteger("Amount"));
|
||||
|
||||
if (nbt.hasKey("Tag"))
|
||||
{
|
||||
stack.tag = nbt.getCompoundTag("Tag");
|
||||
return EMPTY;
|
||||
}
|
||||
return stack;*/
|
||||
FluidStack stack = new FluidStack(fluid, nbt.getInt("Amount"));
|
||||
|
||||
if (nbt.contains("Tag", Constants.NBT.TAG_COMPOUND))
|
||||
{
|
||||
stack.tag = nbt.getCompound("Tag");
|
||||
}
|
||||
return stack;
|
||||
}
|
||||
|
||||
public CompoundNBT writeToNBT(CompoundNBT nbt)
|
||||
{
|
||||
// TODO fluids bt.setString("FluidName", FluidRegistry.getFluidName(getFluid()));
|
||||
nbt.putString("FluidName", getFluid().getRegistryName().toString());
|
||||
nbt.putInt("Amount", amount);
|
||||
|
||||
if (tag != null)
|
||||
|
@ -120,11 +128,106 @@ public class FluidStack
|
|||
return nbt;
|
||||
}
|
||||
|
||||
public void writeToPacket(PacketBuffer buf)
|
||||
{
|
||||
buf.writeRegistryId(getFluid());
|
||||
buf.writeVarInt(getAmount());
|
||||
buf.writeCompoundTag(tag);
|
||||
}
|
||||
|
||||
public static FluidStack readFromPacket(PacketBuffer buf)
|
||||
{
|
||||
Fluid fluid = buf.readRegistryId();
|
||||
int amount = buf.readVarInt();
|
||||
CompoundNBT tag = buf.readCompoundTag();
|
||||
if (fluid == Fluids.EMPTY) return EMPTY;
|
||||
return new FluidStack(fluid, amount, tag);
|
||||
}
|
||||
|
||||
public final Fluid getFluid()
|
||||
{
|
||||
return isEmpty ? Fluids.EMPTY : fluidDelegate.get();
|
||||
}
|
||||
|
||||
public final Fluid getRawFluid()
|
||||
{
|
||||
return fluidDelegate.get();
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return isEmpty;
|
||||
}
|
||||
|
||||
protected void updateEmpty() {
|
||||
isEmpty = getRawFluid() == Fluids.EMPTY || amount == 0;
|
||||
}
|
||||
|
||||
public int getAmount()
|
||||
{
|
||||
return isEmpty ? 0 : amount ;
|
||||
}
|
||||
|
||||
public void setAmount(int amount)
|
||||
{
|
||||
if (getRawFluid() == Fluids.EMPTY) throw new IllegalStateException("Can't modify the empty stack.");
|
||||
if (amount < 0) throw new IllegalStateException("The amount can't be negative.");
|
||||
this.amount = amount;
|
||||
updateEmpty();
|
||||
}
|
||||
|
||||
public void grow(int amount) {
|
||||
setAmount(this.amount + amount);
|
||||
}
|
||||
|
||||
public void shrink(int amount) {
|
||||
setAmount(this.amount - amount);
|
||||
}
|
||||
|
||||
public boolean hasTag()
|
||||
{
|
||||
return tag != null;
|
||||
}
|
||||
|
||||
public CompoundNBT getTag()
|
||||
{
|
||||
return tag;
|
||||
}
|
||||
|
||||
public void setTag(CompoundNBT tag)
|
||||
{
|
||||
if (getRawFluid() == Fluids.EMPTY) throw new IllegalStateException("Can't modify the empty stack.");
|
||||
this.tag = tag;
|
||||
}
|
||||
|
||||
public CompoundNBT getOrCreateTag()
|
||||
{
|
||||
if (tag == null)
|
||||
setTag(new CompoundNBT());
|
||||
return tag;
|
||||
}
|
||||
|
||||
public CompoundNBT getChildTag(String childName)
|
||||
{
|
||||
if (tag == null)
|
||||
return null;
|
||||
return tag.getCompound(childName);
|
||||
}
|
||||
|
||||
public CompoundNBT getOrCreateChildTag(String childName)
|
||||
{
|
||||
getOrCreateTag();
|
||||
CompoundNBT child = tag.getCompound(childName);
|
||||
if (child == null)
|
||||
tag.put(childName, child = new CompoundNBT());
|
||||
return child;
|
||||
}
|
||||
|
||||
public void removeChildTag(String childName)
|
||||
{
|
||||
if (tag != null)
|
||||
tag.remove(childName);
|
||||
}
|
||||
|
||||
public ITextComponent getDisplayName()
|
||||
{
|
||||
return this.getFluid().getAttributes().getDisplayName(this);
|
||||
|
@ -150,9 +253,9 @@ public class FluidStack
|
|||
* The FluidStack for comparison
|
||||
* @return true if the Fluids (IDs and NBT Tags) are the same
|
||||
*/
|
||||
public boolean isFluidEqual(@Nullable FluidStack other)
|
||||
public boolean isFluidEqual(@Nonnull FluidStack other)
|
||||
{
|
||||
return other != null && getFluid() == other.getFluid() && isFluidStackTagEqual(other);
|
||||
return getFluid() == other.getFluid() && isFluidStackTagEqual(other);
|
||||
}
|
||||
|
||||
private boolean isFluidStackTagEqual(FluidStack other)
|
||||
|
@ -163,9 +266,9 @@ public class FluidStack
|
|||
/**
|
||||
* Determines if the NBT Tags are equal. Useful if the FluidIDs are known to be equal.
|
||||
*/
|
||||
public static boolean areFluidStackTagsEqual(@Nullable FluidStack stack1, @Nullable FluidStack stack2)
|
||||
public static boolean areFluidStackTagsEqual(@Nonnull FluidStack stack1, @Nonnull FluidStack stack2)
|
||||
{
|
||||
return stack1 == null && stack2 == null || (stack1 != null && stack2 != null && stack1.isFluidStackTagEqual(stack2));
|
||||
return stack1.isFluidStackTagEqual(stack2);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -174,7 +277,7 @@ public class FluidStack
|
|||
* @param other
|
||||
* @return true if this FluidStack contains the other FluidStack (same fluid and >= amount)
|
||||
*/
|
||||
public boolean containsFluid(@Nullable FluidStack other)
|
||||
public boolean containsFluid(@Nonnull FluidStack other)
|
||||
{
|
||||
return isFluidEqual(other) && amount >= other.amount;
|
||||
}
|
||||
|
|
|
@ -28,14 +28,13 @@ import net.minecraft.block.material.Material;
|
|||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.entity.player.PlayerEntity;
|
||||
import net.minecraft.fluid.Fluid;
|
||||
import net.minecraft.fluid.Fluids;
|
||||
import net.minecraft.item.BlockItemUseContext;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.item.ItemUseContext;
|
||||
import net.minecraft.item.Items;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.Direction;
|
||||
import net.minecraft.util.Hand;
|
||||
import net.minecraft.util.SoundCategory;
|
||||
import net.minecraft.util.SoundEvent;
|
||||
import net.minecraft.util.*;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.BlockRayTraceResult;
|
||||
import net.minecraft.util.math.Vec3d;
|
||||
|
@ -136,7 +135,7 @@ public class FluidUtil
|
|||
return getFluidHandler(containerCopy)
|
||||
.map(containerFluidHandler -> {
|
||||
FluidStack simulatedTransfer = tryFluidTransfer(containerFluidHandler, fluidSource, maxAmount, false);
|
||||
if (simulatedTransfer != null)
|
||||
if (!simulatedTransfer.isEmpty())
|
||||
{
|
||||
if (doFill)
|
||||
{
|
||||
|
@ -182,7 +181,7 @@ public class FluidUtil
|
|||
if (doDrain)
|
||||
{
|
||||
FluidStack transfer = tryFluidTransfer(fluidDestination, containerFluidHandler, maxAmount, true);
|
||||
if (transfer != null)
|
||||
if (!transfer.isEmpty())
|
||||
{
|
||||
if (player != null)
|
||||
{
|
||||
|
@ -196,7 +195,7 @@ public class FluidUtil
|
|||
else
|
||||
{
|
||||
FluidStack simulatedTransfer = tryFluidTransfer(fluidDestination, containerFluidHandler, maxAmount, false);
|
||||
if (simulatedTransfer != null)
|
||||
if (!simulatedTransfer.isEmpty())
|
||||
{
|
||||
containerFluidHandler.drain(simulatedTransfer, IFluidHandler.FluidAction.SIMULATE);
|
||||
ItemStack resultContainer = containerFluidHandler.getContainer();
|
||||
|
@ -356,15 +355,15 @@ public class FluidUtil
|
|||
* @param doTransfer True if the transfer should actually be done, false if it should be simulated.
|
||||
* @return the fluidStack that was transferred from the source to the destination. null on failure.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
public static FluidStack tryFluidTransfer(IFluidHandler fluidDestination, IFluidHandler fluidSource, int maxAmount, boolean doTransfer)
|
||||
{
|
||||
FluidStack drainable = fluidSource.drain(maxAmount, IFluidHandler.FluidAction.SIMULATE);
|
||||
if (drainable != null && drainable.amount > 0)
|
||||
if (!drainable.isEmpty())
|
||||
{
|
||||
return tryFluidTransfer_Internal(fluidDestination, fluidSource, drainable, doTransfer);
|
||||
}
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -378,15 +377,15 @@ public class FluidUtil
|
|||
* @param doTransfer True if the transfer should actually be done, false if it should be simulated.
|
||||
* @return the fluidStack that was transferred from the source to the destination. null on failure.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
public static FluidStack tryFluidTransfer(IFluidHandler fluidDestination, IFluidHandler fluidSource, FluidStack resource, boolean doTransfer)
|
||||
{
|
||||
FluidStack drainable = fluidSource.drain(resource, IFluidHandler.FluidAction.SIMULATE);
|
||||
if (drainable != null && drainable.amount > 0 && resource.isFluidEqual(drainable))
|
||||
if (!drainable.isEmpty() && resource.isFluidEqual(drainable))
|
||||
{
|
||||
return tryFluidTransfer_Internal(fluidDestination, fluidSource, drainable, doTransfer);
|
||||
}
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -396,7 +395,7 @@ public class FluidUtil
|
|||
* Modders: Instead of this method, use {@link #tryFluidTransfer(IFluidHandler, IFluidHandler, FluidStack, boolean)}
|
||||
* or {@link #tryFluidTransfer(IFluidHandler, IFluidHandler, int, boolean)}.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
private static FluidStack tryFluidTransfer_Internal(IFluidHandler fluidDestination, IFluidHandler fluidSource, FluidStack drainable, boolean doTransfer)
|
||||
{
|
||||
int fillableAmount = fluidDestination.fill(drainable, IFluidHandler.FluidAction.SIMULATE);
|
||||
|
@ -405,19 +404,19 @@ public class FluidUtil
|
|||
if (doTransfer)
|
||||
{
|
||||
FluidStack drained = fluidSource.drain(fillableAmount, IFluidHandler.FluidAction.EXECUTE);
|
||||
if (drained != null)
|
||||
if (!drained.isEmpty())
|
||||
{
|
||||
drained.amount = fluidDestination.fill(drained, IFluidHandler.FluidAction.EXECUTE);
|
||||
drained.setAmount(fluidDestination.fill(drained, IFluidHandler.FluidAction.EXECUTE));
|
||||
return drained;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
drainable.amount = fillableAmount;
|
||||
drainable.setAmount(fillableAmount);
|
||||
return drainable;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -466,16 +465,7 @@ public class FluidUtil
|
|||
{
|
||||
return tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, side);
|
||||
}
|
||||
}/* TODO fluids blocks?
|
||||
if (block instanceof IFluidBlock)
|
||||
{
|
||||
return OptionalCapabilityInstance.of(() -> new FluidBlockWrapper((IFluidBlock) block, world, blockPos));
|
||||
}
|
||||
else if (block instanceof BlockLiquid)
|
||||
{
|
||||
return OptionalCapabilityInstance.of(() -> new BlockLiquidWrapper((BlockLiquid) block, world, blockPos));
|
||||
}
|
||||
*/
|
||||
return LazyOptional.empty();
|
||||
}
|
||||
|
||||
|
@ -501,15 +491,14 @@ public class FluidUtil
|
|||
BlockState state = worldIn.getBlockState(pos);
|
||||
Block block = state.getBlock();
|
||||
|
||||
/* TODO fluid blocks?
|
||||
if (block instanceof IFluidBlock || block instanceof BlockLiquid)
|
||||
if (block instanceof IFluidBlock)
|
||||
{
|
||||
IFluidHandler targetFluidHandler = getFluidHandler(worldIn, pos, side);
|
||||
IFluidHandler targetFluidHandler = getFluidHandler(worldIn, pos, side).orElse(null);
|
||||
if (targetFluidHandler != null)
|
||||
{
|
||||
return tryFillContainer(emptyContainer, targetFluidHandler, Integer.MAX_VALUE, playerIn, true);
|
||||
}
|
||||
}*/
|
||||
}
|
||||
return FluidActionResult.FAILURE;
|
||||
}
|
||||
|
||||
|
@ -554,7 +543,7 @@ public class FluidUtil
|
|||
*/
|
||||
public static boolean tryPlaceFluid(@Nullable PlayerEntity player, World world, Hand hand, BlockPos pos, IFluidHandler fluidSource, FluidStack resource)
|
||||
{
|
||||
if (world == null || resource == null || pos == null)
|
||||
if (world == null || pos == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -614,19 +603,8 @@ public class FluidUtil
|
|||
*/
|
||||
private static IFluidHandler getFluidBlockHandler(Fluid fluid, World world, BlockPos pos)
|
||||
{
|
||||
BlockState state = fluid.getAttributes().getBlock(world, pos, fluid.getDefaultState());/* TODO fluid blocks?
|
||||
if (block instanceof IFluidBlock)
|
||||
{
|
||||
return new FluidBlockWrapper((IFluidBlock) block, world, pos);
|
||||
}
|
||||
else if (block instanceof BlockLiquid)
|
||||
{
|
||||
return new BlockLiquidWrapper((BlockLiquid) block, world, pos);
|
||||
}
|
||||
else*/
|
||||
{
|
||||
return new BlockWrapper(state, world, pos);
|
||||
}
|
||||
BlockState state = fluid.getAttributes().getBlock(world, pos, fluid.getDefaultState());
|
||||
return new BlockWrapper(state, world, pos);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -661,38 +639,25 @@ public class FluidUtil
|
|||
*/
|
||||
@Nonnull
|
||||
public static ItemStack getFilledBucket(@Nonnull FluidStack fluidStack)
|
||||
{/* TODO fluids
|
||||
{
|
||||
Fluid fluid = fluidStack.getFluid();
|
||||
|
||||
if (fluidStack.tag == null || fluidStack.tag.isEmpty())
|
||||
if (!fluidStack.hasTag() || fluidStack.getTag().isEmpty())
|
||||
{
|
||||
if (fluid == FluidRegistry.WATER)
|
||||
if (fluid == Fluids.WATER)
|
||||
{
|
||||
return new ItemStack(Items.WATER_BUCKET);
|
||||
}
|
||||
else if (fluid == FluidRegistry.LAVA)
|
||||
else if (fluid == Fluids.LAVA)
|
||||
{
|
||||
return new ItemStack(Items.LAVA_BUCKET);
|
||||
}
|
||||
else if (fluid.getName().equals("milk"))
|
||||
else if (fluid.getRegistryName().equals(new ResourceLocation("milk")))
|
||||
{
|
||||
return new ItemStack(Items.MILK_BUCKET);
|
||||
}
|
||||
}
|
||||
|
||||
if (FluidRegistry.isUniversalBucketEnabled() && FluidRegistry.getBucketFluids().contains(fluid))
|
||||
{
|
||||
UniversalBucket bucket = ForgeMod.getInstance().universalBucket;
|
||||
ItemStack filledBucket = new ItemStack(bucket);
|
||||
FluidStack fluidContents = new FluidStack(fluidStack, bucket.getCapacity());
|
||||
|
||||
NBTTagCompound tag = new NBTTagCompound();
|
||||
fluidContents.writeToNBT(tag);
|
||||
filledBucket.setTagCompound(tag);
|
||||
|
||||
return filledBucket;
|
||||
}
|
||||
*/
|
||||
return ItemStack.EMPTY;
|
||||
return fluid.getAttributes().getBucket(fluidStack);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -63,7 +63,7 @@ public interface IFluidBlock
|
|||
* If SIMULATE, the drain will only be simulated.
|
||||
* @return
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack drain(World world, BlockPos pos, IFluidHandler.FluidAction action);
|
||||
|
||||
/**
|
||||
|
|
|
@ -21,6 +21,7 @@ package net.minecraftforge.fluids;
|
|||
|
||||
import net.minecraftforge.fluids.capability.IFluidHandler.FluidAction;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
/**
|
||||
|
@ -33,7 +34,7 @@ public interface IFluidTank {
|
|||
/**
|
||||
* @return FluidStack representing the fluid in the tank, null if the tank is empty.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack getFluid();
|
||||
|
||||
/**
|
||||
|
@ -64,7 +65,7 @@ public interface IFluidTank {
|
|||
* @param action If SIMULATE, the drain will only be simulated.
|
||||
* @return Amount of fluid that was removed (or would be, if simulated) from the tank.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack drain(int maxDrain, FluidAction action);
|
||||
|
||||
/**
|
||||
|
@ -72,7 +73,7 @@ public interface IFluidTank {
|
|||
* @param action If SIMULATE, the drain will only be simulated.
|
||||
* @return FluidStack representing fluid that was removed (or would be, if simulated) from the tank.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack drain(FluidStack resource, FluidAction action);
|
||||
|
||||
}
|
||||
|
|
|
@ -55,14 +55,7 @@ public class CapabilityFluidHandler
|
|||
CompoundNBT nbt = new CompoundNBT();
|
||||
FluidTank tank = (FluidTank) instance;
|
||||
FluidStack fluid = tank.getFluid();
|
||||
if (fluid != null)
|
||||
{
|
||||
fluid.writeToNBT(nbt);
|
||||
}
|
||||
else
|
||||
{
|
||||
nbt.putString("Empty", "");
|
||||
}
|
||||
fluid.writeToNBT(nbt);
|
||||
nbt.putInt("Capacity", tank.getCapacity());
|
||||
return nbt;
|
||||
}
|
||||
|
|
|
@ -67,7 +67,7 @@ public interface IFluidHandler
|
|||
* @param tank Tank to query.
|
||||
* @return FluidStack in a given tank. NULL if the tank is empty.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack getFluidInTank(int tank);
|
||||
|
||||
/**
|
||||
|
@ -106,7 +106,7 @@ public interface IFluidHandler
|
|||
* @return FluidStack representing the Fluid and amount that was (or would have been, if
|
||||
* simulated) drained.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack drain(FluidStack resource, FluidAction action);
|
||||
|
||||
/**
|
||||
|
@ -119,7 +119,7 @@ public interface IFluidHandler
|
|||
* @return FluidStack representing the Fluid and amount that was (or would have been, if
|
||||
* simulated) drained.
|
||||
*/
|
||||
@Nullable
|
||||
@Nonnull
|
||||
FluidStack drain(int maxDrain, FluidAction action);
|
||||
|
||||
}
|
||||
|
|
|
@ -34,7 +34,7 @@ public class EmptyFluidHandler implements IFluidHandler
|
|||
@Override
|
||||
public int getTanks() { return 1; }
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) { return null; }
|
||||
|
||||
|
@ -47,17 +47,17 @@ public class EmptyFluidHandler implements IFluidHandler
|
|||
@Override
|
||||
public int fill(FluidStack resource, FluidAction action)
|
||||
{
|
||||
return resource.amount;
|
||||
return resource.getAmount();
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
|
|
|
@ -68,13 +68,13 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
return container;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
public FluidStack getFluid()
|
||||
{
|
||||
CompoundNBT tagCompound = container.getTag();
|
||||
if (tagCompound == null || !tagCompound.contains(FLUID_NBT_KEY))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
return FluidStack.loadFluidStackFromNBT(tagCompound.getCompound(FLUID_NBT_KEY));
|
||||
}
|
||||
|
@ -97,7 +97,7 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
return 1;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) {
|
||||
|
||||
|
@ -119,20 +119,20 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
@Override
|
||||
public int fill(FluidStack resource, FluidAction doFill)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount <= 0 || !canFillFluidType(resource))
|
||||
if (container.getCount() != 1 || resource == null || resource.getAmount() <= 0 || !canFillFluidType(resource))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
FluidStack contained = getFluid();
|
||||
if (contained == null)
|
||||
if (contained.isEmpty())
|
||||
{
|
||||
int fillAmount = Math.min(capacity, resource.amount);
|
||||
int fillAmount = Math.min(capacity, resource.getAmount());
|
||||
|
||||
if (doFill.execute())
|
||||
{
|
||||
FluidStack filled = resource.copy();
|
||||
filled.amount = fillAmount;
|
||||
filled.setAmount(fillAmount);
|
||||
setFluid(filled);
|
||||
}
|
||||
|
||||
|
@ -142,10 +142,10 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
{
|
||||
if (contained.isFluidEqual(resource))
|
||||
{
|
||||
int fillAmount = Math.min(capacity - contained.amount, resource.amount);
|
||||
int fillAmount = Math.min(capacity - contained.getAmount(), resource.getAmount());
|
||||
|
||||
if (doFill.execute() && fillAmount > 0) {
|
||||
contained.amount += fillAmount;
|
||||
contained.grow(fillAmount);
|
||||
setFluid(contained);
|
||||
}
|
||||
|
||||
|
@ -156,39 +156,41 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
}
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount <= 0 || !resource.isFluidEqual(getFluid()))
|
||||
if (container.getCount() != 1 || resource.isEmpty() || !resource.isFluidEqual(getFluid()))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
return drain(resource.amount, action);
|
||||
return drain(resource.getAmount(), action);
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || maxDrain <= 0)
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
FluidStack contained = getFluid();
|
||||
if (contained == null || contained.amount <= 0 || !canDrainFluidType(contained))
|
||||
if (contained.isEmpty() || !canDrainFluidType(contained))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
final int drainAmount = Math.min(contained.amount, maxDrain);
|
||||
final int drainAmount = Math.min(contained.getAmount(), maxDrain);
|
||||
|
||||
FluidStack drained = contained.copy();
|
||||
drained.amount = drainAmount;
|
||||
drained.setAmount(drainAmount);
|
||||
|
||||
if (action.execute())
|
||||
{
|
||||
contained.amount -= drainAmount;
|
||||
if (contained.amount == 0)
|
||||
contained.shrink(drainAmount);
|
||||
if (contained.getAmount() == 0)
|
||||
{
|
||||
setContainerToEmpty();
|
||||
}
|
||||
|
@ -217,7 +219,7 @@ public class FluidHandlerItemStack implements IFluidHandlerItem, ICapabilityProv
|
|||
*/
|
||||
protected void setContainerToEmpty()
|
||||
{
|
||||
container.getTag().remove(FLUID_NBT_KEY);
|
||||
container.removeChildTag(FLUID_NBT_KEY);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
@ -65,13 +65,13 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
return container;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
public FluidStack getFluid()
|
||||
{
|
||||
CompoundNBT tagCompound = container.getTag();
|
||||
if (tagCompound == null || !tagCompound.contains(FLUID_NBT_KEY))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
return FluidStack.loadFluidStackFromNBT(tagCompound.getCompound(FLUID_NBT_KEY));
|
||||
}
|
||||
|
@ -94,7 +94,7 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
return 1;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) {
|
||||
|
||||
|
@ -114,21 +114,21 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
}
|
||||
|
||||
@Override
|
||||
public int fill(FluidStack resource, FluidAction action)
|
||||
public int fill(@Nonnull FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount <= 0 || !canFillFluidType(resource))
|
||||
if (container.getCount() != 1 || resource.isEmpty() || !canFillFluidType(resource))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
FluidStack contained = getFluid();
|
||||
if (contained == null)
|
||||
if (contained.isEmpty())
|
||||
{
|
||||
int fillAmount = Math.min(capacity, resource.amount);
|
||||
int fillAmount = Math.min(capacity, resource.getAmount());
|
||||
if (fillAmount == capacity) {
|
||||
if (action.execute()) {
|
||||
FluidStack filled = resource.copy();
|
||||
filled.amount = fillAmount;
|
||||
filled.setAmount(fillAmount);
|
||||
setFluid(filled);
|
||||
}
|
||||
|
||||
|
@ -139,31 +139,33 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
return 0;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount <= 0 || !resource.isFluidEqual(getFluid()))
|
||||
if (container.getCount() != 1 || resource == null || resource.getAmount() <= 0 || !resource.isFluidEqual(getFluid()))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
return drain(resource.amount, action);
|
||||
return drain(resource.getAmount(), action);
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || maxDrain <= 0)
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
FluidStack contained = getFluid();
|
||||
if (contained == null || contained.amount <= 0 || !canDrainFluidType(contained))
|
||||
if (contained.isEmpty() || !canDrainFluidType(contained))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
final int drainAmount = Math.min(contained.amount, maxDrain);
|
||||
final int drainAmount = Math.min(contained.getAmount(), maxDrain);
|
||||
if (drainAmount == capacity) {
|
||||
FluidStack drained = contained.copy();
|
||||
|
||||
|
@ -174,7 +176,7 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
return drained;
|
||||
}
|
||||
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
public boolean canFillFluidType(FluidStack fluid)
|
||||
|
@ -194,7 +196,7 @@ public class FluidHandlerItemStackSimple implements IFluidHandlerItem, ICapabili
|
|||
*/
|
||||
protected void setContainerToEmpty()
|
||||
{
|
||||
container.getTag().remove(FLUID_NBT_KEY);
|
||||
container.removeChildTag(FLUID_NBT_KEY);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
@ -37,8 +37,8 @@ import java.util.function.Predicate;
|
|||
public class FluidTank implements IFluidHandler, IFluidTank {
|
||||
|
||||
protected Predicate<FluidStack> validator;
|
||||
@Nullable
|
||||
protected FluidStack fluid = null;
|
||||
@Nonnull
|
||||
protected FluidStack fluid = FluidStack.EMPTY;
|
||||
protected int capacity;
|
||||
|
||||
public FluidTank(int capacity)
|
||||
|
@ -76,6 +76,7 @@ public class FluidTank implements IFluidHandler, IFluidTank {
|
|||
return capacity;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public FluidStack getFluid()
|
||||
{
|
||||
return fluid;
|
||||
|
@ -83,17 +84,12 @@ public class FluidTank implements IFluidHandler, IFluidTank {
|
|||
|
||||
public int getFluidAmount()
|
||||
{
|
||||
|
||||
if (fluid == null)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return fluid.amount;
|
||||
return fluid.getAmount();
|
||||
}
|
||||
|
||||
public FluidTank readFromNBT(CompoundNBT nbt) {
|
||||
|
||||
FluidStack fluid = null;
|
||||
FluidStack fluid = FluidStack.EMPTY;
|
||||
if (!nbt.contains("Empty"))
|
||||
{
|
||||
fluid = FluidStack.loadFluidStackFromNBT(nbt);
|
||||
|
@ -121,7 +117,7 @@ public class FluidTank implements IFluidHandler, IFluidTank {
|
|||
return 1;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) {
|
||||
|
||||
|
@ -151,67 +147,65 @@ public class FluidTank implements IFluidHandler, IFluidTank {
|
|||
{
|
||||
if (fluid == null)
|
||||
{
|
||||
return Math.min(capacity, resource.amount);
|
||||
return Math.min(capacity, resource.getAmount());
|
||||
}
|
||||
if (!fluid.isFluidEqual(resource))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return Math.min(capacity - fluid.amount, resource.amount);
|
||||
return Math.min(capacity - fluid.getAmount(), resource.getAmount());
|
||||
}
|
||||
if (fluid == null)
|
||||
{
|
||||
onContentsChanged();
|
||||
fluid = new FluidStack(resource, Math.min(capacity, resource.amount));
|
||||
return fluid.amount;
|
||||
fluid = new FluidStack(resource, Math.min(capacity, resource.getAmount()));
|
||||
return fluid.getAmount();
|
||||
}
|
||||
if (!fluid.isFluidEqual(resource))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int filled = capacity - fluid.amount;
|
||||
int filled = capacity - fluid.getAmount();
|
||||
|
||||
if (resource.amount < filled)
|
||||
if (resource.getAmount() < filled)
|
||||
{
|
||||
fluid.amount += resource.amount;
|
||||
filled = resource.amount;
|
||||
fluid.grow(resource.getAmount());
|
||||
filled = resource.getAmount();
|
||||
}
|
||||
else
|
||||
{
|
||||
fluid.amount = capacity;
|
||||
fluid.setAmount(capacity);
|
||||
}
|
||||
return filled;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (resource == null || !resource.isFluidEqual(fluid))
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
return drain(resource.amount, action);
|
||||
return drain(resource.getAmount(), action);
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
if (fluid == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
int drained = maxDrain;
|
||||
if (fluid.amount < drained)
|
||||
if (fluid.getAmount() < drained)
|
||||
{
|
||||
drained = fluid.amount;
|
||||
drained = fluid.getAmount();
|
||||
}
|
||||
FluidStack stack = new FluidStack(fluid, drained);
|
||||
if (action.execute())
|
||||
{
|
||||
fluid.amount -= drained;
|
||||
if (fluid.amount <= 0)
|
||||
fluid.shrink(drained);
|
||||
if (fluid.getAmount() <= 0)
|
||||
{
|
||||
fluid = null;
|
||||
fluid = FluidStack.EMPTY;
|
||||
}
|
||||
}
|
||||
return stack;
|
||||
|
@ -229,16 +223,12 @@ public class FluidTank implements IFluidHandler, IFluidTank {
|
|||
|
||||
public boolean isEmpty()
|
||||
{
|
||||
return fluid == null || fluid.amount <= 0;
|
||||
return fluid.isEmpty();
|
||||
}
|
||||
|
||||
public int getSpace()
|
||||
{
|
||||
if (fluid == null)
|
||||
{
|
||||
return capacity;
|
||||
}
|
||||
return fluid.amount >= capacity ? 0 : capacity - fluid.amount;
|
||||
return Math.max(0, capacity - fluid.getAmount());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ public class VoidFluidHandler implements IFluidHandler
|
|||
@Override
|
||||
public int getTanks() { return 1; }
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) { return null; }
|
||||
|
||||
|
@ -51,17 +51,17 @@ public class VoidFluidHandler implements IFluidHandler
|
|||
@Override
|
||||
public int fill(FluidStack resource, FluidAction action)
|
||||
{
|
||||
return resource.amount;
|
||||
return resource.getAmount();
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
|
|
|
@ -51,7 +51,7 @@ public class BlockWrapper extends VoidFluidHandler
|
|||
public int fill(FluidStack resource, FluidAction action)
|
||||
{
|
||||
// NOTE: "Filling" means placement in this context!
|
||||
if (resource.amount < FluidAttributes.BUCKET_VOLUME)
|
||||
if (resource.getAmount() < FluidAttributes.BUCKET_VOLUME)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -22,8 +22,10 @@ package net.minecraftforge.fluids.capability.wrappers;
|
|||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
import net.minecraft.fluid.Fluids;
|
||||
import net.minecraft.item.*;
|
||||
import net.minecraft.util.Direction;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraftforge.common.capabilities.Capability;
|
||||
import net.minecraftforge.common.capabilities.ICapabilityProvider;
|
||||
import net.minecraftforge.common.util.LazyOptional;
|
||||
|
@ -57,16 +59,15 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
}
|
||||
|
||||
public boolean canFillFluidType(FluidStack fluid)
|
||||
{/* TODO fluids
|
||||
if (fluid.getFluid() == FluidRegistry.WATER || fluid.getFluid() == FluidRegistry.LAVA || fluid.getFluid().getName().equals("milk"))
|
||||
{
|
||||
if (fluid.getFluid() == Fluids.WATER || fluid.getFluid() == Fluids.LAVA || fluid.getFluid().getRegistryName().equals(new ResourceLocation("milk")))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return FluidRegistry.isUniversalBucketEnabled() && FluidRegistry.getBucketFluids().contains(fluid.getFluid());
|
||||
*/ return false;
|
||||
return fluid.getFluid().getAttributes().getBucket(fluid) != null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
public FluidStack getFluid()
|
||||
{
|
||||
Item item = container.getItem();
|
||||
|
@ -74,20 +75,15 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
{
|
||||
return new FluidStack(((BucketItem)item).getFluid(), FluidAttributes.BUCKET_VOLUME);
|
||||
}
|
||||
/* TODO fluids
|
||||
else if (item == Items.MILK_BUCKET)
|
||||
{
|
||||
return FluidRegistry.getFluidStack("milk", Fluid.BUCKET_VOLUME);
|
||||
}
|
||||
else*/
|
||||
else
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
protected void setFluid(@Nullable FluidStack fluidStack)
|
||||
protected void setFluid(@Nonnull FluidStack fluidStack)
|
||||
{
|
||||
if (fluidStack == null)
|
||||
if (fluidStack.getAmount() <= 0)
|
||||
container = new ItemStack(Items.BUCKET);
|
||||
else
|
||||
container = FluidUtil.getFilledBucket(fluidStack);
|
||||
|
@ -99,7 +95,7 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
return 1;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack getFluidInTank(int tank) {
|
||||
|
||||
|
@ -121,7 +117,7 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
@Override
|
||||
public int fill(FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount < FluidAttributes.BUCKET_VOLUME || container.getItem() instanceof MilkBucketItem || getFluid() != null || !canFillFluidType(resource))
|
||||
if (container.getCount() != 1 || resource == null || resource.getAmount() < FluidAttributes.BUCKET_VOLUME || container.getItem() instanceof MilkBucketItem || getFluid() != null || !canFillFluidType(resource))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
@ -134,13 +130,13 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
return FluidAttributes.BUCKET_VOLUME;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(FluidStack resource, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || resource == null || resource.amount < FluidAttributes.BUCKET_VOLUME)
|
||||
if (container.getCount() != 1 || resource == null || resource.getAmount() < FluidAttributes.BUCKET_VOLUME)
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
FluidStack fluidStack = getFluid();
|
||||
|
@ -148,21 +144,21 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
{
|
||||
if (action.execute())
|
||||
{
|
||||
setFluid(null);
|
||||
setFluid(FluidStack.EMPTY);
|
||||
}
|
||||
return fluidStack;
|
||||
}
|
||||
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Nonnull
|
||||
@Override
|
||||
public FluidStack drain(int maxDrain, FluidAction action)
|
||||
{
|
||||
if (container.getCount() != 1 || maxDrain < FluidAttributes.BUCKET_VOLUME)
|
||||
{
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
FluidStack fluidStack = getFluid();
|
||||
|
@ -170,12 +166,12 @@ public class FluidBucketWrapper implements IFluidHandlerItem, ICapabilityProvide
|
|||
{
|
||||
if (action.execute())
|
||||
{
|
||||
setFluid(null);
|
||||
setFluid(FluidStack.EMPTY);
|
||||
}
|
||||
return fluidStack;
|
||||
}
|
||||
|
||||
return null;
|
||||
return FluidStack.EMPTY;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
Loading…
Reference in a new issue