Lots more moved

2020-07-04 21:03:30 +02:00
parent 5982f094ec
commit 1478e4c378
444 changed files with 4693 additions and 5235 deletions
@@ -0,0 +1,219 @@
+
+package appeng.fluids.util;
+
+import java.math.RoundingMode;
+import java.util.Objects;
+
+import alexiil.mc.lib.attributes.ListenerRemovalToken;
+import alexiil.mc.lib.attributes.ListenerToken;
+import alexiil.mc.lib.attributes.Simulation;
+import alexiil.mc.lib.attributes.fluid.FluidInvTankChangeListener;
+import alexiil.mc.lib.attributes.fluid.FluidVolumeUtil;
+import alexiil.mc.lib.attributes.fluid.amount.FluidAmount;
+import alexiil.mc.lib.attributes.fluid.volume.FluidKey;
+import alexiil.mc.lib.attributes.fluid.volume.FluidVolume;
+import net.minecraft.nbt.CompoundTag;
+
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.core.AELog;
+import appeng.util.Platform;
+
+public class AEFluidInventory implements IAEFluidTank {
+    private final IAEFluidStack[] fluids;
+    private final IAEFluidInventory handler;
+    private final int capacity;
+
+    public AEFluidInventory(final IAEFluidInventory handler, final int slots, final int capacity) {
+        this.fluids = new IAEFluidStack[slots];
+        this.handler = handler;
+        this.capacity = capacity;
+    }
+
+    public AEFluidInventory(final IAEFluidInventory handler, final int slots) {
+        this(handler, slots, Integer.MAX_VALUE);
+    }
+
+    @Override
+    public boolean setInvFluid(int tank, FluidVolume to, Simulation simulation) {
+        if (tank >= 0 && tank < this.getSlots()) {
+            if (simulation == Simulation.ACTION) {
+                setFluidInSlot(tank, AEFluidStack.fromFluidVolume(to, RoundingMode.DOWN));
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void setFluidInSlot(final int slot, final IAEFluidStack fluid) {
+        if (slot >= 0 && slot < this.getSlots()) {
+            if (Objects.equals(this.fluids[slot], fluid)) {
+                if (fluid != null && fluid.getStackSize() != this.fluids[slot].getStackSize()) {
+                    this.fluids[slot].setStackSize(Math.min(fluid.getStackSize(), this.capacity));
+                    this.onContentChanged(slot);
+                }
+            } else {
+                if (fluid == null) {
+                    this.fluids[slot] = null;
+                } else {
+                    this.fluids[slot] = fluid.copy();
+                    this.fluids[slot].setStackSize(Math.min(fluid.getStackSize(), this.capacity));
+                }
+
+                this.onContentChanged(slot);
+            }
+        }
+    }
+
+    private void onContentChanged(final int slot) {
+        if (this.handler != null && Platform.isServer()) {
+            this.handler.onFluidInventoryChanged(this, slot);
+        }
+    }
+
+    @Override
+    public IAEFluidStack getFluidInSlot(final int slot) {
+        if (slot >= 0 && slot < this.getSlots()) {
+            return this.fluids[slot];
+        }
+        return null;
+    }
+
+    @Override
+    public int getSlots() {
+        return this.fluids.length;
+    }
+
+    @Override
+    public int getTankCount() {
+        return this.fluids.length;
+    }
+
+    @Override
+    public FluidAmount getMaxAmount_F(int tank) {
+        return FluidAmount.of(Math.min(this.capacity, Integer.MAX_VALUE), 1000);
+    }
+
+    @Override
+    public FluidVolume getInvFluid(int tank) {
+        if (tank < 0 || tank >= fluids.length) {
+            return FluidVolumeUtil.EMPTY;
+        }
+        return fluids[tank] == null ? FluidVolumeUtil.EMPTY : fluids[tank].getFluidStack();
+    }
+
+    @Override
+    public boolean isFluidValidForTank(int tank, FluidKey fluid) {
+        return !fluid.isEmpty();
+    }
+
+    @Override
+    public ListenerToken addListener(FluidInvTankChangeListener listener, ListenerRemovalToken removalToken) {
+        return null;
+    }
+
+    public int fill(final int slot, final FluidVolume resource, final boolean doFill) {
+        if (resource.isEmpty() || resource.getAmount() <= 0) {
+            return 0;
+        }
+
+        final IAEFluidStack fluid = this.fluids[slot];
+
+        if (fluid != null && !fluid.getFluidStack().equals(resource)) {
+            return 0;
+        }
+
+        int amountToStore = this.capacity;
+
+        if (fluid != null) {
+            amountToStore -= fluid.getStackSize();
+        }
+
+        amountToStore = Math.min(amountToStore, (int) resource.getAmount_F().asLong(1000, RoundingMode.DOWN));
+
+        if (doFill) {
+            if (fluid == null) {
+                this.setFluidInSlot(slot, AEFluidStack.fromFluidVolume(resource, RoundingMode.DOWN));
+            } else {
+                fluid.setStackSize(fluid.getStackSize() + amountToStore);
+                this.onContentChanged(slot);
+            }
+        }
+
+        return amountToStore;
+    }
+
+    public FluidVolume drain(final int slot, final FluidVolume resource, final boolean doDrain) {
+        final IAEFluidStack fluid = this.fluids[slot];
+        if (resource.isEmpty() || fluid == null || !fluid.getFluidStack().equals(resource)) {
+            return null;
+        }
+        int toDrain = (int) resource.getAmount_F().asLong(1000, RoundingMode.DOWN);
+        return this.drain(slot, toDrain, doDrain);
+    }
+
+    public FluidVolume drain(final int slot, final int maxDrain, boolean doDrain) {
+        final IAEFluidStack fluid = this.fluids[slot];
+        if (fluid == null || maxDrain <= 0) {
+            return null;
+        }
+
+        int drained = maxDrain;
+        if (fluid.getStackSize() < drained) {
+            drained = (int) fluid.getStackSize();
+        }
+
+        FluidVolume stack = fluid.getFluidStack().withAmount(FluidAmount.of(drained, 1000));
+        if (doDrain) {
+            fluid.setStackSize(fluid.getStackSize() - drained);
+            if (fluid.getStackSize() <= 0) {
+                this.fluids[slot] = null;
+            }
+            this.onContentChanged(slot);
+        }
+        return stack;
+    }
+
+    public void writeToNBT(final CompoundTag data, final String name) {
+        final CompoundTag c = new CompoundTag();
+        this.writeToNBT(c);
+        data.put(name, c);
+    }
+
+    private void writeToNBT(final CompoundTag target) {
+        for (int x = 0; x < this.fluids.length; x++) {
+            try {
+                final CompoundTag c = new CompoundTag();
+
+                if (this.fluids[x] != null) {
+                    this.fluids[x].writeToNBT(c);
+                }
+
+                target.put("#" + x, c);
+            } catch (final Exception ignored) {
+            }
+        }
+    }
+
+    public void readFromNBT(final CompoundTag data, final String name) {
+        final CompoundTag c = data.getCompound(name);
+        if (!c.isEmpty()) {
+            this.readFromNBT(c);
+        }
+    }
+
+    private void readFromNBT(final CompoundTag target) {
+        for (int x = 0; x < this.fluids.length; x++) {
+            try {
+                final CompoundTag c = target.getCompound("#" + x);
+
+                if (!c.isEmpty()) {
+                    this.fluids[x] = AEFluidStack.fromNBT(c);
+                }
+            } catch (final Exception e) {
+                AELog.debug(e);
+            }
+        }
+    }
+
+}
@@ -0,0 +1,85 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 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.
+ *
+ * Applied Energistics 2 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 Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.fluids.util;
+
+import java.util.Comparator;
+
+import appeng.api.config.SortDir;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.util.Platform;
+
+/**
+ * @author BrockWS
+ * @version rv6 - 22/05/2018
+ * @since rv6 22/05/2018
+ */
+public class FluidSorters {
+    private static SortDir Direction = SortDir.ASCENDING;
+
+    public static final Comparator<IAEFluidStack> CONFIG_BASED_SORT_BY_NAME = (o1, o2) -> {
+        // FIXME: Calling .getString() to compare two untranslated strings is a problem,
+        // we need to investigate how to do this better
+        if (getDirection() == SortDir.ASCENDING) {
+            return Platform.getFluidDisplayName(o1).getString()
+                    .compareToIgnoreCase(Platform.getFluidDisplayName(o2).getString());
+        }
+        return Platform.getFluidDisplayName(o2).getString()
+                .compareToIgnoreCase(Platform.getFluidDisplayName(o1).getString());
+    };
+
+    public static final Comparator<IAEFluidStack> CONFIG_BASED_SORT_BY_MOD = new Comparator<IAEFluidStack>() {
+
+        @Override
+        public int compare(final IAEFluidStack o1, final IAEFluidStack o2) {
+            final AEFluidStack op1 = (AEFluidStack) o1;
+            final AEFluidStack op2 = (AEFluidStack) o2;
+
+            if (getDirection() == SortDir.ASCENDING) {
+                return this.secondarySort(Platform.getModId(op1).compareToIgnoreCase(Platform.getModId(op2)), o2, o1);
+            }
+            return this.secondarySort(Platform.getModId(op2).compareToIgnoreCase(Platform.getModId(op1)), o1, o2);
+        }
+
+        private int secondarySort(final int compareToIgnoreCase, final IAEFluidStack o1, final IAEFluidStack o2) {
+            if (compareToIgnoreCase == 0) {
+                // FIXME: Calling .getString() to compare two untranslated strings is a problem,
+                // we need to investigate how to do this better
+                return Platform.getFluidDisplayName(o2).getString()
+                        .compareToIgnoreCase(Platform.getFluidDisplayName(o1).getString());
+            }
+
+            return compareToIgnoreCase;
+        }
+    };
+
+    public static final Comparator<IAEFluidStack> CONFIG_BASED_SORT_BY_SIZE = (o1, o2) -> {
+        if (getDirection() == SortDir.ASCENDING) {
+            return Long.compare(o2.getStackSize(), o1.getStackSize());
+        }
+        return Long.compare(o1.getStackSize(), o2.getStackSize());
+    };
+
+    private static SortDir getDirection() {
+        return Direction;
+    }
+
+    public static void setDirection(final SortDir direction) {
+        Direction = direction;
+    }
+}
@@ -0,0 +1,24 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
+ *
+ * Applied Energistics 2 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.
+ *
+ * Applied Energistics 2 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 Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.fluids.util;
+
+@FunctionalInterface
+public interface IAEFluidInventory {
+    void onFluidInventoryChanged(final IAEFluidTank inv, final int slot);
+}
@@ -0,0 +1,15 @@
+
+package appeng.fluids.util;
+
+import alexiil.mc.lib.attributes.fluid.FixedFluidInv;
+
+import appeng.api.storage.data.IAEFluidStack;
+
+public interface IAEFluidTank extends FixedFluidInv {
+    void setFluidInSlot(final int slot, final IAEFluidStack fluid);
+
+    IAEFluidStack getFluidInSlot(final int slot);
+
+    int getSlots();
+
+}