added mekanism slurry support

src/main/java/com/ticticboooom/mods/mm/inventory/mek/PortMekSlurryInventory.java

@@ -0,0 +1,135 @@
+package com.ticticboooom.mods.mm.inventory.mek;
+
+import mekanism.api.Action;
+import mekanism.api.chemical.gas.GasStack;
+import mekanism.api.chemical.gas.IGasHandler;
+import mekanism.api.chemical.gas.IGasTank;
+import mekanism.api.chemical.slurry.ISlurryHandler;
+import mekanism.api.chemical.slurry.ISlurryTank;
+import mekanism.api.chemical.slurry.SlurryStack;
+
+public class PortMekSlurryInventory implements ISlurryHandler, ISlurryTank {
+    private SlurryStack stack = SlurryStack.EMPTY;
+    private long capacity;
+
+    public PortMekSlurryInventory(long capacity) {
+
+        this.capacity = capacity;
+    }
+
+    @Override
+    public int getTanks() {
+        return 1;
+    }
+
+    @Override
+    public SlurryStack getChemicalInTank(int i) {
+        return i == 0 ? stack : SlurryStack.EMPTY;
+    }
+
+    @Override
+    public void setChemicalInTank(int i, SlurryStack stack) {
+        if (i == 0) {
+            this.stack = stack;
+        }
+    }
+
+    @Override
+    public long getTankCapacity(int i) {
+        return capacity;
+    }
+
+    @Override
+    public boolean isValid(int i, SlurryStack stack) {
+        if (i != 0){
+            return false;
+        }
+        return this.stack.isEmpty() || stack.getType() == this.stack.getType();
+    }
+
+    @Override
+    public SlurryStack insertChemical(int i, SlurryStack stack, Action action) {
+        if (!isValid(i, stack)) {
+            return stack;
+        }
+        if (action.simulate()) {
+            if (this.stack.getAmount() + stack.getAmount() > capacity) {
+                return new SlurryStack(stack.getType(), this.stack.getAmount() + stack.getAmount() - capacity);
+            } else {
+                return SlurryStack.EMPTY;
+            }
+        }
+
+        if (this.stack.getAmount() + stack.getAmount() > capacity) {
+            long preAmount = this.stack.getAmount();
+            if (this.stack.isEmpty()){
+                this.stack = new SlurryStack(stack.getType(), capacity);
+            } else {
+                this.stack.setAmount(capacity);
+            }
+            return new SlurryStack(stack.getType(), preAmount  + stack.getAmount() - capacity);
+        } else {
+            if (this.stack.isEmpty()) {
+                this.stack = new SlurryStack(stack.getType(), this.stack.getAmount() + stack.getAmount());
+            } else {
+                this.stack.setAmount(this.stack.getAmount() + stack.getAmount());
+            }
+            return SlurryStack.EMPTY;
+        }
+    }
+
+
+    @Override
+    public SlurryStack extractChemical(int i, long l, Action action) {
+        if (!isValid(i, stack)) {
+            return stack;
+        }
+
+        if (action.simulate()) {
+            if (stack.getAmount() - l < 0) {
+                return new SlurryStack(stack.getType(), Math.abs(stack.getAmount() - l));
+            } else {
+                return new SlurryStack(stack.getType(), l);
+            }
+        }
+
+        if (stack.getAmount() - l < 0) {
+            long preAmount = stack.getAmount();
+            this.stack = SlurryStack.EMPTY;
+            return new SlurryStack(stack.getType(), Math.abs(preAmount - l));
+        } else {
+            stack.setAmount(stack.getAmount() - l);
+            return new SlurryStack(stack.getType(), l);
+        }
+    }
+
+    @Override
+    public SlurryStack getStack() {
+        return stack;
+    }
+
+    @Override
+    public void setStack(SlurryStack stack) {
+        this.stack = stack;
+    }
+
+    @Override
+    public void setStackUnchecked(SlurryStack stack) {
+        this.stack = stack;
+    }
+
+    @Override
+    public long getCapacity() {
+        return capacity;
+    }
+
+    @Override
+    public boolean isValid(SlurryStack stack) {
+        return isValid(0, stack);
+    }
+
+    @Override
+    public void onContentsChanged() {
+
+    }
+}

src/main/java/com/ticticboooom/mods/mm/ports/parser/MekSlurryPortParser.java

@@ -0,0 +1,45 @@
+package com.ticticboooom.mods.mm.ports.parser;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.JsonOps;
+import com.ticticboooom.mods.mm.ports.state.IPortState;
+import com.ticticboooom.mods.mm.ports.state.MekGasPortState;
+import com.ticticboooom.mods.mm.ports.state.MekSlurryPortState;
+import com.ticticboooom.mods.mm.ports.storage.IPortStorage;
+import com.ticticboooom.mods.mm.ports.storage.MekGasPortStorage;
+import com.ticticboooom.mods.mm.ports.storage.MekSlurryPortStorage;
+import lombok.SneakyThrows;
+import net.minecraft.network.PacketBuffer;
+
+import java.util.function.Supplier;
+
+public class MekSlurryPortParser implements IPortParser {
+    @Override
+    public IPortState createState(JsonObject obj) {
+        DataResult<Pair<MekSlurryPortState, JsonElement>> apply = JsonOps.INSTANCE.withDecoder(MekSlurryPortState.CODEC).apply(obj);
+        return apply.result().get().getFirst();
+    }
+
+    @SneakyThrows
+    @Override
+    public IPortState createState(PacketBuffer buf) {
+        return buf.readWithCodec(MekGasPortState.CODEC);
+    }
+
+    @Override
+    public Supplier<IPortStorage> createStorage(JsonObject obj) {
+        return () -> {
+            DataResult<Pair<MekSlurryPortStorage, JsonElement>> apply = JsonOps.INSTANCE.withDecoder(MekSlurryPortStorage.CODEC).apply(obj);
+            return apply.result().get().getFirst();
+        };
+    }
+
+    @SneakyThrows
+    @Override
+    public void write(PacketBuffer buf, IPortState state) {
+        buf.writeWithCodec(MekSlurryPortState.CODEC, (MekSlurryPortState)state);
+    }
+}

src/main/java/com/ticticboooom/mods/mm/ports/state/MekSlurryPortState.java

@@ -0,0 +1,95 @@
+package com.ticticboooom.mods.mm.ports.state;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import com.ticticboooom.mods.mm.MM;
+import com.ticticboooom.mods.mm.helper.RLUtils;
+import com.ticticboooom.mods.mm.ports.storage.IPortStorage;
+import com.ticticboooom.mods.mm.ports.storage.MekSlurryPortStorage;
+import mekanism.api.Action;
+import mekanism.api.MekanismAPI;
+import mekanism.api.chemical.gas.GasStack;
+import mekanism.api.chemical.slurry.SlurryStack;
+import mekanism.api.inventory.AutomationType;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.List;
+import java.util.Objects;
+
+public class MekSlurryPortState implements IPortState {
+
+    public static final Codec<MekSlurryPortState> CODEC = RecordCodecBuilder.create(x -> x.group(
+            Codec.STRING.fieldOf("slurry").forGetter(z -> z.slurry),
+            Codec.LONG.fieldOf("amount").forGetter(z -> z.amount)
+    ).apply(x, MekSlurryPortState::new));
+
+    private final String slurry;
+    private final long amount;
+
+    public MekSlurryPortState(String gas, long amount) {
+
+        this.slurry = gas;
+        this.amount = amount;
+    }
+
+    @Override
+    public void processRequirement(List<IPortStorage> storage) {
+        long current = amount;
+        for (IPortStorage st : storage) {
+            if (st instanceof MekSlurryPortStorage) {
+                MekSlurryPortStorage gasStorage = (MekSlurryPortStorage) st;
+                SlurryStack extract = gasStorage.getInv().extract(current, Action.EXECUTE, AutomationType.EXTERNAL);
+                current -= extract.getAmount();
+            }
+        }
+    }
+
+    @Override
+    public boolean validateRequirement(List<IPortStorage> storage) {
+        long current = amount;
+        for (IPortStorage st : storage) {
+            if (st instanceof MekSlurryPortStorage) {
+                MekSlurryPortStorage gasStorage = (MekSlurryPortStorage) st;
+                SlurryStack extract = gasStorage.getInv().extract(current, Action.SIMULATE, AutomationType.EXTERNAL);
+                current -= extract.getAmount();
+                if (current <= 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void processResult(List<IPortStorage> storage) {
+        long current = 0;
+        for (IPortStorage st : storage) {
+            if (st instanceof MekSlurryPortStorage) {
+                MekSlurryPortStorage gasStorage = (MekSlurryPortStorage) st;
+                SlurryStack extract = gasStorage.getInv().insertChemical(new SlurryStack(Objects.requireNonNull(MekanismAPI.slurryRegistry().getValue(RLUtils.toRL(slurry))), current), Action.EXECUTE);
+                current += extract.getAmount();
+            }
+        }
+    }
+
+    @Override
+    public boolean validateResult(List<IPortStorage> storage) {
+        long current = 0;
+        for (IPortStorage st : storage) {
+            if (st instanceof MekSlurryPortStorage) {
+                MekSlurryPortStorage gasStorage = (MekSlurryPortStorage) st;
+                SlurryStack extract = gasStorage.getInv().insertChemical(new SlurryStack(Objects.requireNonNull(MekanismAPI.slurryRegistry().getValue(RLUtils.toRL(slurry))), current), Action.EXECUTE);
+                current += extract.getAmount();
+                if (current >= amount) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public ResourceLocation getName() {
+        return new ResourceLocation(MM.ID, "mekanism_slurry");
+    }
+}

src/main/java/com/ticticboooom/mods/mm/ports/storage/MekSlurryPortStorage.java

@@ -0,0 +1,87 @@
+package com.ticticboooom.mods.mm.ports.storage;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import com.ticticboooom.mods.mm.MM;
+import com.ticticboooom.mods.mm.block.container.PortBlockContainer;
+import com.ticticboooom.mods.mm.block.tile.MachinePortBlockEntity;
+import com.ticticboooom.mods.mm.helper.RLUtils;
+import com.ticticboooom.mods.mm.inventory.mek.PortMekGasInventory;
+import com.ticticboooom.mods.mm.inventory.mek.PortMekSlurryInventory;
+import lombok.Getter;
+import mekanism.api.MekanismAPI;
+import mekanism.api.chemical.gas.GasStack;
+import mekanism.api.chemical.slurry.SlurryStack;
+import mekanism.common.capabilities.Capabilities;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.AbstractGui;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import java.util.Objects;
+
+public class MekSlurryPortStorage implements IPortStorage {
+    public static final Codec<MekSlurryPortStorage> CODEC  = RecordCodecBuilder.create(x -> x.group(
+            Codec.LONG.fieldOf("capacity").forGetter(z -> z.capacity)
+    ).apply(x, MekSlurryPortStorage::new));
+    @Getter
+    private final PortMekSlurryInventory inv;
+    private long capacity;
+    private final LazyOptional<PortMekSlurryInventory> invLO;
+
+
+    public MekSlurryPortStorage(long capacity) {
+        inv = new PortMekSlurryInventory(capacity);
+        this.capacity = capacity;
+        invLO = LazyOptional.of(() -> inv);
+    }
+
+    @Override
+    public <T> LazyOptional<T> getLO() {
+        return invLO.cast();
+    }
+
+    @Override
+    public <T> boolean validate(Capability<T> cap) {
+        return cap == Capabilities.SLURRY_HANDLER_CAPABILITY;
+    }
+
+    @Override
+    public CompoundNBT save(CompoundNBT nbt) {
+        nbt.putString("slurry", inv.getStack().getType().getRegistryName().toString());
+        nbt.putLong("amount", inv.getStack().getAmount());
+        return nbt;
+    }
+
+    @Override
+    public void load(CompoundNBT nbt) {
+        inv.setStack(new SlurryStack(Objects.requireNonNull(MekanismAPI.slurryRegistry().getValue(RLUtils.toRL(nbt.getString("slurry")))), nbt.getLong("amount")));
+    }
+
+    @Override
+    public void render(MatrixStack stack, int mouseX, int mouseY, int left, int top, Screen screen) {
+        Minecraft.getInstance().textureManager.bind(new ResourceLocation(MM.ID, "textures/gui/port_gui.png"));
+        screen.blit(stack, left, top, 0, 0,  175, 256);
+        int barOffsetX = 175 - 30;
+        int barOffsetY = 20;
+        screen.blit(stack, left + barOffsetX, top + barOffsetY, 175, 18, 18, 108);
+        float amount = 0;
+        if (inv.getStack().getAmount() > 0) {
+            amount = (float)inv.getStack().getAmount() / inv.getTankCapacity(0);
+        }
+        screen.blit(stack, left + barOffsetX, top + barOffsetY, 193, 18, 18, (int) (108 * amount));
+        AbstractGui.drawString(stack, Minecraft.getInstance().font,inv.getStack().getType().getTextComponent().getString(), left + 30, top + 60, 0xfefefe);
+        AbstractGui.drawString(stack, Minecraft.getInstance().font, inv.getStack().getAmount() + "mB", left + 30, top + 80, 0xfefefe);
+
+    }
+
+    @Override
+    public void setupContainer(PortBlockContainer container, PlayerInventory inv, MachinePortBlockEntity tile) {
+
+    }
+}

src/main/java/com/ticticboooom/mods/mm/registration/MMLoader.java

@@ -67,12 +67,13 @@ public class MMLoader {
 
         for (JsonObject obj : load) {
             String controllerId = obj.get("controllerId").getAsString();
+            String controllerName = obj.get("name").getAsString();
             {
                 Registerable<RegistryObject<TileEntityType<?>>> controllerTile = new Registerable<>();
                 Registerable<RegistryObject<ControllerBlock>> controllerBlock = new Registerable<>();
                 Registerable<RegistryObject<ContainerType<ControllerBlockContainer>>> cont = new Registerable<>();
                 cont.set(CONTAINER_REG.register(controllerId + "_controller", () -> IForgeContainerType.create((i, o, u) -> new ControllerBlockContainer(cont.get().get(), i, o, u))));
-                controllerBlock.set(BLOCKS_REG.register(controllerId + "_controller", () -> new ControllerBlock(controllerTile.get())));
+                controllerBlock.set(BLOCKS_REG.register(controllerId + "_controller", () -> new ControllerBlock(controllerTile.get(), controllerName, controllerId)));
                 controllerTile.set(TILES_REG.register(controllerId + "_controller", () -> TileEntityType.Builder.of(() -> new ControllerBlockEntity(controllerTile.get(), cont.get(), controllerId), controllerBlock.get().get()).build(null)));
                 ITEMS_REG.register(controllerId + "_controller", () -> new BlockItem(controllerBlock.get().get(), new Item.Properties().tab(MASTERFUL_ITEM_GROUP)));
                 BLOCKS.add(controllerBlock.get());
@@ -84,6 +85,7 @@ public class MMLoader {
                 JsonObject portObj = port.getAsJsonObject();
                 String type = portObj.get("type").getAsString();
                 String id = portObj.get("id").getAsString();
+                String name = portObj.get("name").getAsString();
 
                 ResourceLocation resourceLocation = RLUtils.toRL(type);
                 MasterfulPortType value = MMPorts.PORTS.get(resourceLocation);
@@ -94,7 +96,7 @@ public class MMLoader {
                     Registerable<RegistryObject<MachinePortBlock>> block = new Registerable<>();
                     Registerable<RegistryObject<ContainerType<?>>> cont = new Registerable<>();
                     cont.set(CONTAINER_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_input", () -> IForgeContainerType.create((i, o, u) -> new PortBlockContainer(cont.get().get(), i, o, u))));
-                    block.set(BLOCKS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_input", () -> new MachinePortBlock(tile.get())));
+                    block.set(BLOCKS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_input", () -> new MachinePortBlock(tile.get(), name, controllerId)));
                     tile.set(TILES_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_input", () -> TileEntityType.Builder.of(() -> new MachinePortBlockEntity(tile.get().get(),cont.get().get(), data.get(), true), block.get().get()).build(null)));
                     ITEMS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_input", () -> new BlockItem(block.get().get(), new Item.Properties().tab(MASTERFUL_ITEM_GROUP)));
                     PORT_CONTAINERS.add(cont.get());
@@ -106,7 +108,7 @@ public class MMLoader {
                     Registerable<RegistryObject<MachinePortBlock>> block = new Registerable<>();
                     Registerable<RegistryObject<ContainerType<?>>> cont = new Registerable<>();
                     cont.set(CONTAINER_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_output", () -> IForgeContainerType.create((i, o, u) -> new PortBlockContainer(cont.get().get(), i, o, u))));
-                    block.set(BLOCKS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_output", () -> new MachinePortBlock(tile.get())));
+                    block.set(BLOCKS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_output", () -> new MachinePortBlock(tile.get(), name, controllerId)));
                     tile.set(TILES_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_output", () -> TileEntityType.Builder.of(() -> new MachinePortBlockEntity(tile.get().get(), cont.get().get(), data.get(), false), block.get().get()).build(null)));
                     ITEMS_REG.register(controllerId + "_" + id + "_port_" + resourceLocation.getPath() + "_output", () -> new BlockItem(block.get().get(), new Item.Properties().tab(MASTERFUL_ITEM_GROUP)));
                     PORT_CONTAINERS.add(cont.get());

src/main/java/com/ticticboooom/mods/mm/registration/MMPorts.java

@@ -2,10 +2,7 @@ package com.ticticboooom.mods.mm.registration;
 
 import com.ticticboooom.mods.mm.MM;
 import com.ticticboooom.mods.mm.ports.MasterfulPortType;
-import com.ticticboooom.mods.mm.ports.parser.EnergyPortParser;
-import com.ticticboooom.mods.mm.ports.parser.FluidPortParser;
-import com.ticticboooom.mods.mm.ports.parser.ItemPortParser;
-import com.ticticboooom.mods.mm.ports.parser.MekGasPortParser;
+import com.ticticboooom.mods.mm.ports.parser.*;
 import net.minecraft.util.ResourceLocation;
 
 import java.util.HashMap;
@@ -19,5 +16,6 @@ public class MMPorts {
         PORTS.put(new ResourceLocation(MM.ID, "fluids"), new MasterfulPortType(new ResourceLocation(MM.ID, "fluids"), new FluidPortParser()));
         PORTS.put(new ResourceLocation(MM.ID, "energy"),new MasterfulPortType(new ResourceLocation(MM.ID, "energy"), new EnergyPortParser()));
         PORTS.put(new ResourceLocation(MM.ID, "mekanism_gas"),new MasterfulPortType(new ResourceLocation(MM.ID, "mekanism_gas"), new MekGasPortParser()));
+        PORTS.put(new ResourceLocation(MM.ID, "mekanism_slurry"),new MasterfulPortType(new ResourceLocation(MM.ID, "mekanism_slurry"), new MekSlurryPortParser()));
     }
 }