Merge pull request #286 from romangraef/fix_tank

[bugfix] Fix tanks item handling.

Author: Shnupbups

astromine-technologies/src/main/java/com/github/chainmailstudios/astromine/technologies/common/block/entity/TankBlockEntity.java

@@ -30,20 +30,24 @@
 import com.github.chainmailstudios.astromine.common.component.inventory.SimpleFluidInventoryComponent;
 import com.github.chainmailstudios.astromine.common.component.inventory.SimpleItemInventoryComponent;
 import com.github.chainmailstudios.astromine.common.utilities.tier.MachineTier;
-import com.github.chainmailstudios.astromine.common.volume.fraction.Fraction;
 import com.github.chainmailstudios.astromine.common.volume.fluid.FluidVolume;
+import com.github.chainmailstudios.astromine.common.volume.fraction.Fraction;
 import com.github.chainmailstudios.astromine.common.volume.handler.FluidHandler;
 import com.github.chainmailstudios.astromine.common.volume.handler.ItemHandler;
+import com.github.chainmailstudios.astromine.registry.AstromineConfig;
 import com.github.chainmailstudios.astromine.technologies.common.block.entity.machine.FluidSizeProvider;
 import com.github.chainmailstudios.astromine.technologies.common.block.entity.machine.SpeedProvider;
 import com.github.chainmailstudios.astromine.technologies.common.block.entity.machine.TierProvider;
 import com.github.chainmailstudios.astromine.technologies.registry.AstromineTechnologiesBlockEntityTypes;
-import com.github.chainmailstudios.astromine.registry.AstromineConfig;
 import net.minecraft.block.entity.BlockEntityType;
+import net.minecraft.fluid.Fluid;
 import net.minecraft.item.BucketItem;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 
+import java.util.Optional;
+
 public abstract class TankBlockEntity extends ComponentFluidInventoryBlockEntity implements TierProvider, FluidSizeProvider, SpeedProvider {
 	public TankBlockEntity(BlockEntityType<?> type) {
 		super(type);
@@ -61,52 +65,99 @@ protected ItemInventoryComponent createItemComponent() {
 		return new SimpleItemInventoryComponent(2);
 	}
 
+	// return true to consume bucket contents, false to not consume
+	private boolean handleBucketInput(FluidVolume currentTank, Fluid bucketFluid) {
+		if (getMachineTier() == MachineTier.CREATIVE) {
+			currentTank.setFluid(bucketFluid);
+		} else if (currentTank.canAccept(bucketFluid) && currentTank.hasAvailable(Fraction.bucket())) {
+			currentTank.setFluid(bucketFluid);
+			currentTank.add(Fraction.bucket());
+			return true;
+		}
+		return false;
+	}
+
+	private ItemStack handleLeftItem(FluidVolume currentTank, ItemStack inputStack) {
+		Item inputItem = inputStack.getItem();
+		if (inputItem == Items.BUCKET)
+			return inputStack; // Do not pull from empty buckets
+		if (inputStack.getCount() != 1)
+			return inputStack; // Do not operate on multiple items at once (per slot)
+		if (inputItem instanceof BucketItem) {
+			// Handle fluid items manually, since operations have to be exactly one Fraction.bucket() at a time.
+			Fluid f = ((BucketItem) inputItem).fluid;
+			if (handleBucketInput(currentTank, f))
+				return new ItemStack(Items.BUCKET);
+			else return inputStack;
+		}
+		Optional<FluidHandler> opt = FluidHandler.ofOptional(inputStack);
+		if (!opt.isPresent())
+			return inputStack; // Reject non fluid container items
+		FluidHandler stackFluids = opt.get();
+		FluidVolume stackVolume = stackFluids.getFirst();
+		if (stackVolume == null)
+			return inputStack; // Do not operate on null fluids
+		if (stackVolume.isEmpty())
+			return inputStack; // Do not operate on empty fluid containers
+
+		if (getMachineTier() == MachineTier.CREATIVE) {
+			// Creative tanks just copy the fluid without consuming or space checks
+			currentTank.setFluid(stackVolume.getFluid());
+			return inputStack;
+		}
+
+		// Fluid type is already checked in moveFrom
+		currentTank.moveFrom(stackVolume, Fraction.ofDecimal(getMachineSpeed()));
+		return inputStack;
+	}
+
+	private ItemStack handleRightItem(FluidVolume currentTank, ItemStack outputStack) {
+		Item outputItem = outputStack.getItem();
+		if (currentTank.isEmpty())
+			return outputStack; // Do not operate if we are empty
+		if (outputStack.getCount() != 1)
+			return outputStack; // Do not operate on multiple Items
+		if (outputItem instanceof BucketItem) {
+			if (outputItem != Items.BUCKET)
+				return outputStack; // Do not insert into filled buckets
+			if (currentTank.hasStored(Fraction.bucket())) {
+				currentTank.minus(Fraction.bucket());
+				return new ItemStack(currentTank.getFluid().getBucketItem());
+			}
+			return outputStack;
+		}
+		Optional<FluidHandler> opt = FluidHandler.ofOptional(outputStack);
+		if (!opt.isPresent())
+			return outputStack; // Reject non fluid container items
+		FluidHandler stackFluids = opt.get();
+		FluidVolume stackVolume = stackFluids.getFirst();
+
+		stackVolume.moveFrom(currentTank, Fraction.ofDecimal(getMachineSpeed()));
+
+		return outputStack;
+	}
+
 	@Override
 	public void tick() {
 		super.tick();
 
-		if (world == null) return;
-		if (world.isClient) return;
+		if (world == null)
+			return;
+		if (world.isClient)
+			return;
 
 		FluidHandler.ofOptional(this).ifPresent(fluids -> {
+			FluidVolume ourVolume = fluids.getFirst();
 			ItemHandler.ofOptional(this).ifPresent(items -> {
-				FluidHandler.ofOptional(items.getFirst()).ifPresent(stackFluids -> {
-					FluidVolume ourVolume = fluids.getFirst();
-					FluidVolume stackVolume = stackFluids.getFirst();
-					
-					if (ourVolume.canAccept(stackVolume.getFluid())) {
-						if (items.getFirst().getItem() instanceof BucketItem) {
-							if (items.getFirst().getItem() != Items.BUCKET && items.getFirst().getCount() == 1) {
-								if (ourVolume.hasAvailable(Fraction.bucket())) {
-									ourVolume.moveFrom(stackVolume, Fraction.bucket());
-
-									items.setFirst(new ItemStack(Items.BUCKET));
-								}
-							}
-						} else {
-							ourVolume.moveFrom(stackVolume, Fraction.ofDecimal(getMachineSpeed()));
-						}
-					}
-				});
-
-				FluidHandler.ofOptional(items.getSecond()).ifPresent(stackFluids -> {
-					FluidVolume ourVolume = fluids.getFirst();
-					FluidVolume stackVolume = stackFluids.getFirst();
-
-					if (ourVolume.canAccept(stackVolume.getFluid())) {
-						if (items.getSecond().getItem() instanceof BucketItem) {
-							if (items.getSecond().getItem() == Items.BUCKET && items.getSecond().getCount() == 1) {
-								if (ourVolume.hasStored(Fraction.bucket())) {
-									ourVolume.add(stackVolume, Fraction.bucket());
-
-									items.setSecond(new ItemStack(stackVolume.getFluid().getBucketItem()));
-								}
-							}
-						} else {
-							ourVolume.add(stackVolume, Fraction.ofDecimal(getMachineSpeed()));
-						}
-					}
-				});
+				ItemStack leftItem = items.getFirst();
+				ItemStack rightItem = items.getSecond();
+				ItemStack newLeftItem = handleLeftItem(ourVolume, leftItem);
+				ItemStack newRightItem = handleRightItem(ourVolume, rightItem);
+				if (newLeftItem != leftItem)
+					items.setFirst(newLeftItem);
+				if (newRightItem != rightItem)
+					items.setSecond(newRightItem);
+
 			});
 		});
 	}