forge fluid salepoint implementation

common/src/main/java/dev/ithundxr/createnumismatics/content/salepoint/widgets/SalepointFluidDisplayWidget.java

@@ -87,7 +87,7 @@ protected void doRender(@NotNull GuiGraphics graphics, int mouseX, int mouseY, f
 
             if (top) {
                 yMin = y + 2;
-                yMax = y + level * (getHeight() - 4) - 2;
+                yMax = y + level * (getHeight() - 4) + 2;
             }
 
             float zMin = 1;

common/src/main/java/dev/ithundxr/createnumismatics/handler/ConditionalMixinHandler.java

@@ -57,6 +57,7 @@ public static boolean shouldApply(String className) {
                 }
                 if (node.desc.equals(Type.getDescriptor(DevMixin.class))) {
                     shouldApply &= Utils.isDevEnv();
+                    LOGGER.debug("{} is {}being applied because we are {}in a development environment", className, shouldApply ? "" : "not ", Utils.isDevEnv() ? "" : "not ");
                 }
             }
             return shouldApply;

fabric/src/main/java/dev/ithundxr/createnumismatics/fabric/mixin/MixinAllFluids$CreateAttributeHandler.java

@@ -0,0 +1,45 @@
+/*
+ * Numismatics
+ * Copyright (c) 2024 The Railways Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package dev.ithundxr.createnumismatics.fabric.mixin;
+
+import dev.ithundxr.createnumismatics.annotation.mixin.DevMixin;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@DevMixin
+@Mixin(targets = "com.simibubi.create.AllFluids$CreateAttributeHandler")
+@SuppressWarnings("UnstableApiUsage")
+public class MixinAllFluids$CreateAttributeHandler {
+    @Shadow @Final private Component name;
+
+    // Make tea lighter than air to test salepoint rendering
+    @Inject(method = "isLighterThanAir", at = @At("HEAD"), cancellable = true, remap = false)
+    private void teaFloats(FluidVariant variant, CallbackInfoReturnable<Boolean> cir) {
+        if (this.name.getContents() instanceof TranslatableContents translatableContents && translatableContents.getKey().equals("fluid.create.tea")) {
+            cir.setReturnValue(true);
+        }
+    }
+}

fabric/src/main/resources/numismatics.mixins.json

@@ -9,6 +9,7 @@
   ],
   "mixins": [
     "ItemHandlerWrapperAccessor",
+    "MixinAllFluids$CreateAttributeHandler",
     "PortableFluidInterfaceBlockEntityMixin",
     "PortableFluidInterfaceBlockEntityMixin$InterfaceFluidHandlerMixin",
     "PortableItemInterfaceBlockEntityMixin",

forge/src/main/java/dev/ithundxr/createnumismatics/content/salepoint/containers/forge/InvalidatableWrappingFluidBufferTank.java

@@ -0,0 +1,132 @@
+/*
+ * Numismatics
+ * Copyright (c) 2024 The Railways Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package dev.ithundxr.createnumismatics.content.salepoint.containers.forge;
+
+import dev.ithundxr.createnumismatics.content.salepoint.containers.InvalidatableAbstractBuffer;
+import dev.ithundxr.createnumismatics.multiloader.fluid.MultiloaderFluidStack;
+import dev.ithundxr.createnumismatics.multiloader.fluid.forge.MultiloaderFluidStackImpl;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+import org.jetbrains.annotations.NotNull;
+
+public class InvalidatableWrappingFluidBufferTank extends InvalidatableAbstractBuffer<MultiloaderFluidStack> implements IFluidHandler {
+
+    protected FluidTank buffer;
+
+    public InvalidatableWrappingFluidBufferTank(FluidTank buffer) {
+        this.buffer = buffer;
+    }
+
+    @Override
+    protected void afterInvalidate() {
+        super.afterInvalidate();
+        buffer = null;
+    }
+
+    @Override
+    protected int copyToBufferInternal(MultiloaderFluidStack source, boolean simulate) {
+        return buffer.fill(((MultiloaderFluidStackImpl) source).getWrapped(), simulate ? FluidAction.SIMULATE : FluidAction.EXECUTE);
+    }
+
+    @Override
+    protected int removeFromBufferInternal(MultiloaderFluidStack source, boolean simulate, int maxAmount) {
+        return buffer.drain(((MultiloaderFluidStackImpl) source).getWrapped(), simulate ? FluidAction.SIMULATE : FluidAction.EXECUTE).getAmount();
+    }
+
+    @Override
+    public int getTanks() {
+        if (!isValid())
+            return 0;
+
+        return buffer.getTanks();
+    }
+
+    @Override
+    public @NotNull FluidStack getFluidInTank(int tank) {
+        if (!isValid())
+            return FluidStack.EMPTY;
+
+        return buffer.getFluidInTank(tank);
+    }
+
+    @Override
+    public int getTankCapacity(int tank) {
+        if (!isValid())
+            return 0;
+
+        return buffer.getTankCapacity(tank);
+    }
+
+    @Override
+    public boolean isFluidValid(int tank, @NotNull FluidStack stack) {
+        if (!isValid())
+            return false;
+
+        return buffer.isFluidValid(tank, stack);
+    }
+
+    @Override
+    public int fill(FluidStack resource, FluidAction action) {
+        if (!isValid())
+            return 0;
+
+        return buffer.fill(resource, action);
+    }
+
+    @Override
+    public @NotNull FluidStack drain(FluidStack resource, FluidAction action) {
+        if (!isValid())
+            return FluidStack.EMPTY;
+
+        return buffer.drain(resource, action);
+    }
+
+    @Override
+    public @NotNull FluidStack drain(int tank, FluidAction action) {
+        if (!isValid())
+            return FluidStack.EMPTY;
+
+        return buffer.drain(tank, action);
+    }
+
+    /*    @Override
+    public long insert(FluidVariant resource, long maxAmount, TransactionContext transaction) {
+        if (!isValid())
+            return 0;
+
+        return buffer.insert(resource, maxAmount, transaction);
+    }
+
+    @Override
+    public long extract(FluidVariant resource, long maxAmount, TransactionContext transaction) {
+        if (!isValid())
+            return 0;
+
+        return buffer.extract(resource, maxAmount, transaction);
+    }
+
+    @Override
+    public @NotNull Iterator<StorageView<FluidVariant>> iterator() {
+        if (!isValid())
+            return Collections.emptyListIterator();
+
+        return buffer.iterator();
+    }*/
+}

forge/src/main/java/dev/ithundxr/createnumismatics/content/salepoint/states/forge/FluidSalepointStateImpl.java

@@ -18,10 +18,104 @@
 
 package dev.ithundxr.createnumismatics.content.salepoint.states.forge;
 
+import com.simibubi.create.foundation.fluid.SmartFluidTank;
+import dev.ithundxr.createnumismatics.content.salepoint.containers.InvalidatableAbstractBuffer;
+import dev.ithundxr.createnumismatics.content.salepoint.containers.forge.InvalidatableWrappingFluidBufferTank;
 import dev.ithundxr.createnumismatics.content.salepoint.states.FluidSalepointState;
+import dev.ithundxr.createnumismatics.multiloader.fluid.MultiloaderFluidStack;
+import dev.ithundxr.createnumismatics.multiloader.fluid.forge.MultiloaderFluidStackImpl;
+import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.capability.IFluidHandler;
+import net.minecraftforge.fluids.capability.templates.FluidTank;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+import java.util.List;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class FluidSalepointStateImpl extends FluidSalepointState {
+
+    private final @NotNull FluidTank buffer = new SmartFluidTank((int) (4 * getFilterCapacity()), $ -> this.setChanged())
+        .setValidator(fs -> this.filterMatches(new MultiloaderFluidStackImpl(fs)));
+    private @NotNull InvalidatableAbstractBuffer<MultiloaderFluidStack> bufferWrapper = createBufferWrapper(buffer);
+
+    private static InvalidatableAbstractBuffer<MultiloaderFluidStack> createBufferWrapper(FluidTank buffer) {
+        return new InvalidatableWrappingFluidBufferTank(buffer);
+    }
 
-public class FluidSalepointStateImpl {
     public static FluidSalepointState create() {
-        throw new AssertionError();
+        return new FluidSalepointStateImpl();
+    }
+
+    @Override
+    protected boolean canChangeFilterToInternal(MultiloaderFluidStack filter) {
+        return buffer.isEmpty();
+    }
+
+    @Override
+    protected void setFilterInternal(MultiloaderFluidStack filter, Level salepointLevel, BlockPos salepointPos, @Nullable Player player) {
+        // buffer gets cleared when filter is set, but the filter *should* only be set when the buffer is empty
+        if (!getFilter().isFluidEqual(filter))
+            buffer.setFluid(FluidStack.EMPTY);
+    }
+
+    @Override
+    protected void saveInternal(CompoundTag tag) {
+        CompoundTag bufferTag = new CompoundTag();
+        buffer.writeToNBT(bufferTag);
+        tag.put("Buffer", bufferTag);
+    }
+
+    @Override
+    protected void loadInternal(CompoundTag tag) {
+        buffer.setFluid(FluidStack.EMPTY);
+
+        if (tag.contains("Buffer", Tag.TAG_COMPOUND)) {
+            buffer.readFromNBT(tag.getCompound("Buffer"));
+        }
+    }
+
+    @Override
+    protected boolean hasBufferFluidForPurchase() {
+        return getFilter().isFluidEqual(new MultiloaderFluidStackImpl(buffer.getFluid()))
+            && buffer.getFluidAmount() >= getFilter().getAmount();
+    }
+
+    @Override
+    protected List<MultiloaderFluidStack> removeBufferFluidForPurchase() {
+        FluidStack drained = buffer.drain(((MultiloaderFluidStackImpl) getFilter()).getWrapped(), IFluidHandler.FluidAction.EXECUTE);
+        return List.of(
+            new MultiloaderFluidStackImpl(drained)
+        );
+    }
+
+    @Override
+    public InvalidatableAbstractBuffer<MultiloaderFluidStack> getBuffer() {
+        return bufferWrapper;
+    }
+
+    @Override
+    public void onDestroy(Level level, BlockPos pos) {
+        onUnload();
+        buffer.setFluid(FluidStack.EMPTY);
+    }
+
+    @Override
+    public void onUnload() {
+        bufferWrapper.invalidate();
+    }
+
+    @Override
+    public void keepAlive() {
+        if (!bufferWrapper.isValid())
+            bufferWrapper = createBufferWrapper(buffer);
     }
 }