From 9ab4d57f289aed3e60fa1d57dd4826337dff3ce4 Mon Sep 17 00:00:00 2001 From: ticticboooom Date: Mon, 10 May 2021 01:40:32 +0100 Subject: [PATCH] added mekanism slurry support --- .../inventory/mek/PortMekSlurryInventory.java | 135 ++++++++++++++++++ .../mm/ports/parser/MekSlurryPortParser.java | 45 ++++++ .../mm/ports/state/MekSlurryPortState.java | 95 ++++++++++++ .../ports/storage/MekSlurryPortStorage.java | 87 +++++++++++ .../mods/mm/registration/MMLoader.java | 8 +- .../mods/mm/registration/MMPorts.java | 6 +- 6 files changed, 369 insertions(+), 7 deletions(-) create mode 100644 src/main/java/com/ticticboooom/mods/mm/inventory/mek/PortMekSlurryInventory.java create mode 100644 src/main/java/com/ticticboooom/mods/mm/ports/parser/MekSlurryPortParser.java create mode 100644 src/main/java/com/ticticboooom/mods/mm/ports/state/MekSlurryPortState.java create mode 100644 src/main/java/com/ticticboooom/mods/mm/ports/storage/MekSlurryPortStorage.java diff --git a/src/main/java/com/ticticboooom/mods/mm/inventory/mek/PortMekSlurryInventory.java b/src/main/java/com/ticticboooom/mods/mm/inventory/mek/PortMekSlurryInventory.java new file mode 100644 index 0000000..b58fd36 --- /dev/null +++ b/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() { + + } +} diff --git a/src/main/java/com/ticticboooom/mods/mm/ports/parser/MekSlurryPortParser.java b/src/main/java/com/ticticboooom/mods/mm/ports/parser/MekSlurryPortParser.java new file mode 100644 index 0000000..d630767 --- /dev/null +++ b/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> 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 createStorage(JsonObject obj) { + return () -> { + DataResult> 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); + } +} diff --git a/src/main/java/com/ticticboooom/mods/mm/ports/state/MekSlurryPortState.java b/src/main/java/com/ticticboooom/mods/mm/ports/state/MekSlurryPortState.java new file mode 100644 index 0000000..fb5e969 --- /dev/null +++ b/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 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 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 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 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 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"); + } +} diff --git a/src/main/java/com/ticticboooom/mods/mm/ports/storage/MekSlurryPortStorage.java b/src/main/java/com/ticticboooom/mods/mm/ports/storage/MekSlurryPortStorage.java new file mode 100644 index 0000000..3315ce6 --- /dev/null +++ b/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 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 invLO; + + + public MekSlurryPortStorage(long capacity) { + inv = new PortMekSlurryInventory(capacity); + this.capacity = capacity; + invLO = LazyOptional.of(() -> inv); + } + + @Override + public LazyOptional getLO() { + return invLO.cast(); + } + + @Override + public boolean validate(Capability 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) { + + } +} diff --git a/src/main/java/com/ticticboooom/mods/mm/registration/MMLoader.java b/src/main/java/com/ticticboooom/mods/mm/registration/MMLoader.java index a6a60ec..df7b7d7 100644 --- a/src/main/java/com/ticticboooom/mods/mm/registration/MMLoader.java +++ b/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>> controllerTile = new Registerable<>(); Registerable> controllerBlock = new Registerable<>(); Registerable>> 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> block = new Registerable<>(); Registerable>> 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> block = new Registerable<>(); Registerable>> 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()); diff --git a/src/main/java/com/ticticboooom/mods/mm/registration/MMPorts.java b/src/main/java/com/ticticboooom/mods/mm/registration/MMPorts.java index 631e1f3..8b75f50 100644 --- a/src/main/java/com/ticticboooom/mods/mm/registration/MMPorts.java +++ b/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())); } }