From a89aa53b46908e7f5cd94184c512e6c035c1879d Mon Sep 17 00:00:00 2001 From: QmelZ <59574967+QmelZ@users.noreply.github.com> Date: Tue, 31 Mar 2026 14:43:48 +0300 Subject: [PATCH 01/16] rebase --- src/meld/core/Melting.java | 78 +++++++++++++++++++++++++++++ src/meld/world/blocks/MeldNode.java | 11 ++-- 2 files changed, 85 insertions(+), 4 deletions(-) create mode 100644 src/meld/core/Melting.java diff --git a/src/meld/core/Melting.java b/src/meld/core/Melting.java new file mode 100644 index 0000000..e2de6d4 --- /dev/null +++ b/src/meld/core/Melting.java @@ -0,0 +1,78 @@ +package meld.core; + +import java.util.*; +import arc.*; +import arc.math.geom.*; +import arc.struct.*; +import arc.util.*; +import meld.content.*; +import mindustry.*; +import mindustry.content.*; +import mindustry.game.*; +import mindustry.world.*; +import mindustry.world.blocks.environment.*; + +// TODO: fix melting stopping when leaving world +// TODO: make a way to add more melting patterns +public class Melting implements Runnable{ + private static final Floor stable = MeldEnvironment.meldCrystal; + private static final Floor unstable = MeldEnvironment.meldCrystalScattered; + private static final Floor melted = MeldEnvironment.meldSwampland; + + private boolean running = false; + private final ObjectSet toMelt = new ObjectSet<>(); + private final ObjectSet toSpread = new ObjectSet<>(); + + public Melting(){ + Events.on(EventType.ResetEvent.class, _it -> running = false); + } + + public void start(Tile start){ + start.getLinkedTiles(toSpread::add); + + if(!running){ + running = true; + run(); + } + } + + @Override + public void run(){ + toMelt + // TODO: this check might not be necessary + .select(it -> it.floor() != melted) + .each(it -> { + it.setFloor(melted); + Fx.smoke.at(it); + + var build = it.build; + if(build != null) build.kill(); + }) + ; + + toMelt.clear(); + toMelt.addAll(toSpread); + toSpread.clear(); + + toMelt.each(it -> + toSpread.addAll( + nearby(it).select(n -> isValid(it, n)) + ) + ); + + if(toMelt.isEmpty() && toSpread.isEmpty()) running = false; + if(running) Time.run(5, this); + } + + private Seq nearby(Tile tile){ + return Seq.with(0, 1, 2, 3) + .map(tile::nearby) + .select(Objects::nonNull) + ; + } + + private boolean isValid(Tile current, Tile nearby){ + if(nearby.floor() == unstable) return true; + return nearby.floor() == stable && current.floor() == stable; + } +} diff --git a/src/meld/world/blocks/MeldNode.java b/src/meld/world/blocks/MeldNode.java index a96e769..de904dc 100644 --- a/src/meld/world/blocks/MeldNode.java +++ b/src/meld/world/blocks/MeldNode.java @@ -1,5 +1,8 @@ package meld.world.blocks; +import arc.func.*; +import meld.*; +import meld.core.*; import mindustry.content.Blocks; import mindustry.world.blocks.storage.CoreBlock; @@ -12,11 +15,11 @@ public MeldNode(String name) { public class MeldNodeBuild extends CoreBuild{ @Override public void killed() { + /// start melting before killing + /// otherwise {@link mindustry.world.Tile#getLinkedTiles(Cons)} won't work + Meld.melting.start(tileOn()); + super.killed(); - //Spawn melting overlays on all tiles touching the edges of this block - eachEdge(t -> { - t.setOverlay(Blocks.pebbles); - }); } } } From 44b731b6288434d1cf6a8ccea5844b3c8248aaf7 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 11:16:57 +0200 Subject: [PATCH 02/16] merge? --- src/meld/content/MeldBlocks.java | 84 +++++++++++++++- .../world/blocks/crafting/ModularCrafter.java | 88 ++++++++++++++--- .../modules/StupidConsumeHighestModule.java | 34 +++++++ .../modules/StupidConsumeItemModule.java | 54 ++++++++++ .../modules/StupidConsumeLiquidModule.java | 50 ++++++++++ .../modules/StupidConsumePayloadModule.java | 81 +++++++++++++++ .../modules/StupidCraftingModule.java | 26 +++++ .../modules/StupidProduceItemModule.java | 59 +++++++++++ .../modules/StupidProduceLiquidModule.java | 54 ++++++++++ .../modules/StupidProducePayloadModule.java | 98 +++++++++++++++++++ 10 files changed, 612 insertions(+), 16 deletions(-) create mode 100644 src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidCraftingModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java create mode 100644 src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index 1c9a9c4..998ddba 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -1,5 +1,6 @@ package meld.content; +import arc.*; import arc.graphics.Color; import arc.math.Interp; import meld.*; @@ -10,6 +11,7 @@ import meld.world.blocks.*; import meld.world.blocks.crafting.ModularCrafter; import meld.world.blocks.crafting.RecipeCrafter; +import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.recipe.ItemRecipe; import meld.world.blocks.crafting.recipe.SpoolRecipe; import meld.world.blocks.crafting.modules.*; @@ -23,8 +25,7 @@ import meld.world.blocks.production.SingleBeamDrill; import meld.world.meta.*; import mindustry.Vars; -import mindustry.content.Fx; -import mindustry.content.StatusEffects; +import mindustry.content.*; import mindustry.entities.bullet.*; import mindustry.entities.effect.MultiEffect; import mindustry.entities.effect.ParticleEffect; @@ -663,6 +664,85 @@ public static void load(){ consume(new ConsumeAspects(outletRate/2, MeldLiquids.outletEfficiencies, MeldLiquids.outletDensities)); }}; + new ModularCrafter("stupid-crafter"){{ + requirements(Category.crafting, with(MeldItems.debris, 40)); + size = 3; + + modules.addAll( + new StupidCraftingModule(0){{ + requestPins = new int[]{1, 2, 3, 4, 5, 6}; + }}, + + new StupidConsumeItemModule(1, -1){{ + items = ItemStack.with(Items.copper, 2); + time = 60f; + }}, + new StupidConsumeLiquidModule(2){{ + liquids = LiquidStack.with(Liquids.water, 1f); + }}, + new StupidConsumePayloadModule(3, -3){{ + payloads = PayloadStack.with(Blocks.plastaniumWallLarge, 1); + time = 180f; + }}, + + new StupidProduceItemModule(4, 0, -4){{ + items = ItemStack.with(Items.titanium, 2); + time = 60f; + }}, + new StupidProduceLiquidModule(5, 0){{ + liquids = LiquidStack.with(Liquids.cryofluid, 1f); + }}, + new StupidProducePayloadModule(6, 0, -6){{ + payloads = PayloadStack.with(Blocks.plastaniumWall, 2); + time = 60f; + }} + ); + }}; + + new ModularCrafter("stupid-silicon-smelter"){ + @Override + public void load(){ + super.load(); + region = Core.atlas.find("silicon-smelter"); + fullIcon = Core.atlas.find("silicon-smelter"); + uiIcon = Core.atlas.find("silicon-smelter"); + } + + { + requirements(Category.crafting, with(MeldItems.debris, 40)); + size = 2; + + modules.addAll( + new StupidCraftingModule(0){{ + requestPins = new int[]{1, 2, 3}; + }}, + new StupidProduceItemModule(1, 0, -1){{ + items = ItemStack.with(Items.silicon, 1); + time = 60f; + }}, + + new StupidConsumeItemModule(2, -2){{ + items = ItemStack.with(Items.sand, 1); + time = 20f; + }}, + + new StupidConsumeHighestModule(3){{ + requestPins = new int[]{4, 5}; + }}, + new StupidConsumeItemModule(4, -4){{ + items = ItemStack.with(Items.coal, 1); + time = 40f; + }}, + new StupidConsumeItemModule(5, -5){{ + items = ItemStack.with(Items.pyratite, 1); + time = 60f; + + efficiencyIncrease = 2.5f; + }} + ); + } + }; + earthboundInfuser = new ModularCrafter("earthbound-infuser"){{ requirements(Category.crafting, with( MeldItems.debris, 40, diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index a56528b..48230a5 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -1,44 +1,59 @@ package meld.world.blocks.crafting; +import arc.math.*; +import arc.math.geom.*; +import arc.scene.ui.layout.*; import arc.struct.*; -import arc.util.Log; -import arc.util.Time; +import arc.struct.IntFloatMap.*; +import arc.util.*; import arc.util.io.Reads; import arc.util.io.Writes; +import mindustry.ctype.*; import mindustry.game.Team; import mindustry.gen.Building; -import mindustry.type.Item; -import mindustry.type.ItemStack; -import mindustry.type.Liquid; +import mindustry.type.*; import mindustry.world.Block; +import mindustry.world.blocks.payloads.*; import mindustry.world.blocks.production.GenericCrafter; -import mindustry.world.meta.Attribute; +import mindustry.world.blocks.units.UnitAssemblerModule.*; +import mindustry.world.meta.*; -import java.util.HashMap; +import java.util.*; -public class ModularCrafter extends Block { +import static mindustry.Vars.*; +import static mindustry.Vars.tilesize; + +public class ModularCrafter extends PayloadBlock{ //Modules updates every update, listeners are for modules with specific events public Seq modules = new Seq(); public ObjectMap> listeners = new ObjectMap>(); - //list of items/liquids which this block accepts + //Lists of stuff which this block accepts + //note: could be a single HashSet. public Seq acceptedLiquids = new Seq<>(); public Seq acceptedItems = new Seq<>(); + public Seq acceptedPayloads = new Seq<>(); - //List of items/liquids which get dumped + //Lists of stuff which gets dumped public Seq dumpedLiquids = new Seq<>(); public Seq dumpedItems = new Seq<>(); + public Seq dumpedPayloads = new Seq<>(); public boolean replaceBars = true; + public int payloadCapacity = 3; - //Default float data array + /// Default float data array public IntFloatMap defaultData = new IntFloatMap(); + /// When true, shows a table with the data map in the block's display. + public boolean debugTable = true; + public ModularCrafter(String name) { super(name); update = true; solid = true; + sync = true; } @Override @@ -57,6 +72,12 @@ public void setBars() { } } + @Override + public void init(){ + super.init(); + modules.each(m -> m.setup(this)); + } + public static void trigger(ModularCrafter block, ModularCrafterBuild build, Object event){ Seq events = block.listeners.get(event); if(events != null) events.each(c -> c.update(build)); @@ -91,6 +112,10 @@ public static abstract class CrafterModule{ public void update(ModularCrafterBuild build){ } + + public void setup(ModularCrafter block){ + + } } public static abstract class CraftingModule extends CrafterModule{ @@ -166,10 +191,40 @@ public static class ModIN{ public static final float ON = 1, OFF = 0; - public class ModularCrafterBuild extends Building { - + public class ModularCrafterBuild extends PayloadBlockBuild{ public ModularCrafter modular; public IntFloatMap data = new IntFloatMap(); + public PayloadSeq payloads = new PayloadSeq(); + + @Override + public void draw(){ + super.draw(); + + drawPayload(); + } + + @Override + public void display(Table table){ + super.display(table); + + if(debugTable){ + table.row(); + table.table(d -> { + Runnable rebuild = () -> { + d.clearChildren(); + d.table(debug -> { + data.iterator().forEachRemaining(entry -> { + debug.add(entry.key + ": " + StatValues.fixValue(entry.value)).left(); + debug.row(); + }); + }).left(); + d.table().growX(); //ugh + }; + d.update(rebuild); + rebuild.run(); + }).growX(); //It doesn't actually grow for some fucking reason. See ugh above. + } + } @Override public void created() { @@ -190,7 +245,7 @@ public void dumpOutputs(){ public void setPin(int pin, float value){ data.put(pin, value); - }; + } public float getPin(int pin){ return data.get(pin); @@ -206,6 +261,11 @@ public boolean acceptItem(Building source, Item item) { return (this.block.consumesItem(item) || acceptedItems.contains(item)) && this.items.get(item) < this.getMaximumAccepted(item); } + @Override + public boolean acceptPayload(Building source, Payload payload){ + return this.payload == null && acceptedPayloads.contains(payload.content()) && payloads.get(payload.content()) < payloadCapacity; + } + @Override public Building create(Block block, Team team) { modular = (ModularCrafter) block; diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java new file mode 100644 index 0000000..b591b39 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java @@ -0,0 +1,34 @@ +package meld.world.blocks.crafting.modules; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public class StupidConsumeHighestModule extends CrafterModule{ + public int[] requestPins; + /// Pin to provide efficiency on. + public int providePin; + + public StupidConsumeHighestModule(int providePin){ + this.providePin = providePin; + } + + public void update(ModularCrafterBuild build){ + float provide = build.getPin(providePin); + + //Get highest + float max = 0f; + int maxPin = 0; + for(int i : requestPins){ + if(build.getPin(i) > max){ + max = build.getPin(i); + maxPin = i; + } + } + + if(max > provide){ + //Just swap pin contents + build.setPin(maxPin, provide); + build.setPin(providePin, max); + } + + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java new file mode 100644 index 0000000..6b25e88 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java @@ -0,0 +1,54 @@ +package meld.world.blocks.crafting.modules; + +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.type.*; + +public class StupidConsumeItemModule extends CrafterModule{ + public ItemStack[] items; + /// Pin to provide efficiency on. + public int providePin; + /// Pin to store consumption progress. + public int progressPin; + public float time = 60f; + + public float baseEfficiency = 0f; + public float efficiencyIncrease = 1f; + + public StupidConsumeItemModule(int providePin, int progressPin){ + this.providePin = providePin; + this.progressPin = progressPin; + } + + @Override + public void update(ModularCrafterBuild build){ + float provide = build.getPin(providePin); + float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float progress = build.getPin(progressPin); + + if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + + //if efficiency has been used + if(consumed > 0f && build.items.has(items)){ + build.setPin(providePin, baseEfficiency + efficiencyIncrease); + progress += consumed * Time.delta; + + //consumption + while(progress > time && build.items.has(items)){ + + build.items.remove(items); + progress -= time; + } + build.setPin(progressPin, progress); + } + } + + @Override + public void setup(ModularCrafter block){ + block.hasItems = true; + for(ItemStack stack : items){ + block.acceptedItems.add(stack.item); + } + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java new file mode 100644 index 0000000..462a9b5 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java @@ -0,0 +1,50 @@ +package meld.world.blocks.crafting.modules; + +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.type.*; + +public class StupidConsumeLiquidModule extends CrafterModule{ + public LiquidStack[] liquids; + public float baseEfficiency = 0; + public float efficiencyIncrease = 1; + /// Pin to provide efficiency on. + public int providePin; + + public StupidConsumeLiquidModule(int providePin){ + this.providePin = providePin; + } + + @Override + public void update(ModularCrafterBuild build){ + float provide = build.getPin(providePin); + //Get the amount of efficiency that was eaten + float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + + if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + + //if efficiency has been used + if(consumed > 0f){ + float min = 10000f; + for(LiquidStack stack : liquids){ + min = Math.min(build.liquids.get(stack.liquid) / (stack.amount * consumed * Time.delta), min); + } + + if(min > 0.00001f){ + for(LiquidStack stack : liquids){ + build.liquids.remove(stack.liquid, stack.amount * min); + } + build.setPin(providePin, baseEfficiency + efficiencyIncrease * min); + } + } + } + + @Override + public void setup(ModularCrafter block){ + block.hasLiquids = true; + for(LiquidStack stack : liquids){ + block.acceptedLiquids.add(stack.liquid); + } + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java new file mode 100644 index 0000000..a34dd90 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java @@ -0,0 +1,81 @@ +package meld.world.blocks.crafting.modules; + +import arc.math.*; +import arc.math.geom.*; +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.ai.types.*; +import mindustry.content.*; +import mindustry.entities.*; +import mindustry.gen.*; +import mindustry.type.*; +import mindustry.world.blocks.payloads.*; + +import java.util.*; + +public class StupidConsumePayloadModule extends CrafterModule{ + public PayloadStack[] payloads; + /// Pin to store consumption progress. + public int progressPin; + /// Pin to provide efficiency on. + public int providePin; + public float time = 60f; + + public float baseEfficiency = 0f; + public float efficiencyIncrease = 1f; + + public StupidConsumePayloadModule(int providePin, int progressPin){ + this.providePin = providePin; + this.progressPin = progressPin; + } + + @Override + public void update(ModularCrafterBuild build){ + float provide = build.getPin(providePin); + float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float progress = build.getPin(progressPin); + + if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + + if(build.payload != null && contains(payloads, build.payload) && build.moveInPayload()){ + build.payloads.add(build.payload.content()); + build.payload = null; + } + + //if efficiency has been used + if(consumed > 0f && has(build, payloads)){ + build.setPin(providePin, baseEfficiency + efficiencyIncrease); + progress += consumed * Time.delta; + + //consumption + while(progress > time && has(build, payloads)){ + for(PayloadStack stack : payloads){ + build.payloads.remove(stack.item, stack.amount); + } + progress -= time; + } + build.setPin(progressPin, progress); + } + } + + public static boolean contains(PayloadStack[] payloads, Payload pay){ + for(PayloadStack stack : payloads){ + if(stack.item == pay.content()) return true; + } + return false; + } + + public static boolean has(ModularCrafterBuild build, PayloadStack[] payloadStacks){ + return Arrays.stream(payloadStacks).allMatch(stack -> build.payloads.contains(stack)); + } + + @Override + public void setup(ModularCrafter block){ + block.acceptsPayload = true; + block.acceptsUnitPayloads = true; + for(PayloadStack stack : payloads){ + block.acceptedPayloads.add(stack.item); + } + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java b/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java new file mode 100644 index 0000000..6e02711 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java @@ -0,0 +1,26 @@ +package meld.world.blocks.crafting.modules; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public class StupidCraftingModule extends CrafterModule{ + public int[] requestPins; + public int outputPin; + + public StupidCraftingModule(int outputPin){ + this.outputPin = outputPin; + } + + public void update(ModularCrafterBuild build){ + float efficiency = build.timeScale(); + //Sum up the efficiency + for(int i : requestPins) efficiency *= build.getPin(i); + + if(efficiency > 0){ + //Subtract the usable efficiency + for(int i : requestPins) build.setPin(i, build.getPin(i) - efficiency); + } + + build.setPin(outputPin, efficiency); + } +} + diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java new file mode 100644 index 0000000..1f0ea72 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java @@ -0,0 +1,59 @@ +package meld.world.blocks.crafting.modules; + +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.type.*; + +import java.util.*; + +import static java.lang.Math.min; + +public class StupidProduceItemModule extends CrafterModule{ + public ItemStack[] items; + /// Pin used to read production efficiency. + public int efficiencyPin; + /// Pin used to store crafting progress. + public int progressPin; + /// Pin used to store whether this module can output. Assigned every tick. + public int workingPin; + public float time = 60f; + + public StupidProduceItemModule(int workingPin, int efficiencyPin, int progressPin){ + this.efficiencyPin = efficiencyPin; + this.workingPin = workingPin; + this.progressPin = progressPin; + } + + @Override + public void update(ModularCrafterBuild build){ + if(!fits(build, items)){ + build.setPin(workingPin, 0f); + return; + } + build.setPin(workingPin, 1f); + + float progress = build.getPin(progressPin); + progress += build.getPin(efficiencyPin) * Time.delta; + + while(progress > time && fits(build, items)){ + for(ItemStack stack : items){ + build.items.add(stack.item, stack.amount); + } + progress -= time; + } + build.setPin(progressPin, progress); + } + + public static boolean fits(ModularCrafterBuild build, ItemStack[] itemStacks){ + return Arrays.stream(itemStacks).allMatch(stack -> build.items.get(stack.item) + stack.amount <= build.block.itemCapacity); + } + + @Override + public void setup(ModularCrafter block){ + block.hasItems = true; + for(ItemStack stack : items){ + block.dumpedItems.add(stack.item); + } + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java new file mode 100644 index 0000000..6a7db33 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java @@ -0,0 +1,54 @@ +package meld.world.blocks.crafting.modules; + +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.type.*; + +public class StupidProduceLiquidModule extends CrafterModule{ + public LiquidStack[] liquids; + /// Pin used to read production efficiency. + public int efficiencyPin; + /// Pin used to store whether this module can output. Assigned every tick. + public int workingPin; + + public boolean dumpExtraLiquid = false; + + public StupidProduceLiquidModule(int workingPin, int efficiencyPin){ + this.efficiencyPin = efficiencyPin; + this.workingPin = workingPin; + } + + //Entirely GenericCrafter copy-paste, probably Sucks Ass. + @Override + public void update(ModularCrafterBuild build){ + //check full + for(LiquidStack stack : liquids){ + if(build.liquids.get(stack.liquid) < build.block.liquidCapacity - 0.001f){ + //if there's still space left, it's not full for all liquids + build.setPin(workingPin, 1f); + }else if(!dumpExtraLiquid){ + build.setPin(workingPin, 0f); + return; + } + } + + //continuously output based on efficiency + for(LiquidStack stack : liquids){ + build.handleLiquid(build, stack.liquid, + Math.min( + stack.amount * build.getPin(efficiencyPin) * Time.delta, + build.block.liquidCapacity - build.liquids.get(stack.liquid) + ) + ); + } + } + + @Override + public void setup(ModularCrafter block){ + block.hasLiquids = true; + for(LiquidStack stack : liquids){ + block.dumpedLiquids.add(stack.liquid); + } + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java new file mode 100644 index 0000000..67fc73e --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java @@ -0,0 +1,98 @@ +package meld.world.blocks.crafting.modules; + +import arc.*; +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.game.EventType.*; +import mindustry.gen.*; +import mindustry.type.*; +import mindustry.world.*; +import mindustry.world.blocks.payloads.*; + +import java.util.*; + +public class StupidProducePayloadModule extends CrafterModule{ + public PayloadStack[] payloads; + /// Pin used to read production efficiency. + public int efficiencyPin; + /// Pin used to store crafting progress. + public int progressPin; + /// Pin used to store whether this module can output. Assigned every tick. + public int workingPin; + public float time = 60f; + + public StupidProducePayloadModule(int workingPin, int efficiencyPin, int progressPin){ + this.efficiencyPin = efficiencyPin; + this.workingPin = workingPin; + this.progressPin = progressPin; + } + + @Override + public void update(ModularCrafterBuild build){ + if(outputFits(build)){ + //consumption + float progress = build.getPin(progressPin); + progress += build.getPin(efficiencyPin) * Time.delta; + + while(progress > time && outputFits(build)){ + for(PayloadStack stack : payloads){ + build.payloads.add(stack.item, stack.amount); + } + progress -= time; + } + build.setPin(progressPin, progress); + //whether other modules should work + build.setPin(workingPin, 1f); + }else{ + build.setPin(workingPin, 0f); + } + + //output + if(build.payload == null && build.payloads.any()){ + for(PayloadStack stack : payloads){ + if(build.payloads.contains(stack.item)){ + build.payloads.remove(stack.item); + + if(stack.item instanceof UnitType type){ + build.payload = new UnitPayload(type.create(build.team)); + Unit p = ((UnitPayload)build.payload).unit; + /*if(commandPos != null && p.isCommandable()){ + p.command().commandPosition(commandPos); + }*/ + Events.fire(new UnitCreateEvent(p, build)); + }else if(stack.item instanceof Block block){ + build.payload = new BuildPayload(block, build.team); + } + build.payVector.setZero(); + build.payRotation = build.rotdeg(); + break; + } + } + } + + if(build.payload != null && outputs(build.payload)){ + build.moveOutPayload(); + } + } + + public boolean outputs(Payload pay){ + for(PayloadStack stack : payloads){ + if(stack.item == pay.content()) return true; + } + return false; + } + + public boolean outputFits(ModularCrafterBuild build){ + return Arrays.stream(payloads).allMatch(stack -> build.payloads.get(stack.item) + stack.amount <= build.block.itemCapacity); + } + + @Override + public void setup(ModularCrafter block){ + block.rotate = true; + block.outputsPayload = true; + for(PayloadStack stack : payloads){ + block.dumpedPayloads.add(stack.item); + } + } +} From 1fa1c72f8bcaabef84c67307e084667511138628 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:20:35 +0200 Subject: [PATCH 03/16] merge? --- src/meld/world/blocks/crafting/modules/StupidCraftingModule.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java b/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java index 6e02711..8b7a339 100644 --- a/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java @@ -2,6 +2,7 @@ import meld.world.blocks.crafting.ModularCrafter.*; +//TODO remake this to be the same as the consumption modules public class StupidCraftingModule extends CrafterModule{ public int[] requestPins; public int outputPin; From e0511a38beca32b21455245cb29a62d275eb4d61 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:22:01 +0200 Subject: [PATCH 04/16] merge? --- .../world/blocks/crafting/modules/StupidProduceItemModule.java | 3 +-- .../blocks/crafting/modules/StupidProduceLiquidModule.java | 1 + .../blocks/crafting/modules/StupidProducePayloadModule.java | 1 + 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java index 1f0ea72..292ef5f 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java @@ -7,8 +7,7 @@ import java.util.*; -import static java.lang.Math.min; - +//TODO remake this to be the same as the consumption modules public class StupidProduceItemModule extends CrafterModule{ public ItemStack[] items; /// Pin used to read production efficiency. diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java index 6a7db33..a1ea39f 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java @@ -5,6 +5,7 @@ import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; +//TODO remake this to be the same as the consumption modules public class StupidProduceLiquidModule extends CrafterModule{ public LiquidStack[] liquids; /// Pin used to read production efficiency. diff --git a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java index 67fc73e..4fd4b37 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java @@ -12,6 +12,7 @@ import java.util.*; +//TODO remake this to be the same as the consumption modules public class StupidProducePayloadModule extends CrafterModule{ public PayloadStack[] payloads; /// Pin used to read production efficiency. From de4db910edf67938f4967b3b3218b953c0155fe5 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:35:19 +0200 Subject: [PATCH 05/16] make red go away --- src/meld/world/blocks/MeldNode.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/meld/world/blocks/MeldNode.java b/src/meld/world/blocks/MeldNode.java index de904dc..0d9df8c 100644 --- a/src/meld/world/blocks/MeldNode.java +++ b/src/meld/world/blocks/MeldNode.java @@ -17,7 +17,10 @@ public class MeldNodeBuild extends CoreBuild{ public void killed() { /// start melting before killing /// otherwise {@link mindustry.world.Tile#getLinkedTiles(Cons)} won't work - Meld.melting.start(tileOn()); + //Spawn melting overlays on all tiles touching the edges of this block + eachEdge(t -> { + t.setOverlay(Blocks.pebbles); + }); super.killed(); } From 62abe44013745eb029ac4f33c9cc544e22bc70c0 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:36:45 +0200 Subject: [PATCH 06/16] make red go away --- src/meld/world/blocks/MeldNode.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/meld/world/blocks/MeldNode.java b/src/meld/world/blocks/MeldNode.java index 0d9df8c..36a7b4d 100644 --- a/src/meld/world/blocks/MeldNode.java +++ b/src/meld/world/blocks/MeldNode.java @@ -15,14 +15,13 @@ public MeldNode(String name) { public class MeldNodeBuild extends CoreBuild{ @Override public void killed() { + super.killed(); /// start melting before killing /// otherwise {@link mindustry.world.Tile#getLinkedTiles(Cons)} won't work //Spawn melting overlays on all tiles touching the edges of this block eachEdge(t -> { t.setOverlay(Blocks.pebbles); }); - - super.killed(); } } } From e05f6da44a395fe9591c5665efca7779051ed040 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:37:55 +0200 Subject: [PATCH 07/16] make diff go away --- src/meld/world/blocks/MeldNode.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/meld/world/blocks/MeldNode.java b/src/meld/world/blocks/MeldNode.java index 36a7b4d..2a3981c 100644 --- a/src/meld/world/blocks/MeldNode.java +++ b/src/meld/world/blocks/MeldNode.java @@ -16,8 +16,6 @@ public class MeldNodeBuild extends CoreBuild{ @Override public void killed() { super.killed(); - /// start melting before killing - /// otherwise {@link mindustry.world.Tile#getLinkedTiles(Cons)} won't work //Spawn melting overlays on all tiles touching the edges of this block eachEdge(t -> { t.setOverlay(Blocks.pebbles); From 00c80d02197cf6d6cc3e57a2f13324517c2cd345 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 14:42:38 +0200 Subject: [PATCH 08/16] make diff go away --- src/meld/core/Melting.java | 78 ----------------------------- src/meld/world/blocks/MeldNode.java | 3 -- 2 files changed, 81 deletions(-) delete mode 100644 src/meld/core/Melting.java diff --git a/src/meld/core/Melting.java b/src/meld/core/Melting.java deleted file mode 100644 index e2de6d4..0000000 --- a/src/meld/core/Melting.java +++ /dev/null @@ -1,78 +0,0 @@ -package meld.core; - -import java.util.*; -import arc.*; -import arc.math.geom.*; -import arc.struct.*; -import arc.util.*; -import meld.content.*; -import mindustry.*; -import mindustry.content.*; -import mindustry.game.*; -import mindustry.world.*; -import mindustry.world.blocks.environment.*; - -// TODO: fix melting stopping when leaving world -// TODO: make a way to add more melting patterns -public class Melting implements Runnable{ - private static final Floor stable = MeldEnvironment.meldCrystal; - private static final Floor unstable = MeldEnvironment.meldCrystalScattered; - private static final Floor melted = MeldEnvironment.meldSwampland; - - private boolean running = false; - private final ObjectSet toMelt = new ObjectSet<>(); - private final ObjectSet toSpread = new ObjectSet<>(); - - public Melting(){ - Events.on(EventType.ResetEvent.class, _it -> running = false); - } - - public void start(Tile start){ - start.getLinkedTiles(toSpread::add); - - if(!running){ - running = true; - run(); - } - } - - @Override - public void run(){ - toMelt - // TODO: this check might not be necessary - .select(it -> it.floor() != melted) - .each(it -> { - it.setFloor(melted); - Fx.smoke.at(it); - - var build = it.build; - if(build != null) build.kill(); - }) - ; - - toMelt.clear(); - toMelt.addAll(toSpread); - toSpread.clear(); - - toMelt.each(it -> - toSpread.addAll( - nearby(it).select(n -> isValid(it, n)) - ) - ); - - if(toMelt.isEmpty() && toSpread.isEmpty()) running = false; - if(running) Time.run(5, this); - } - - private Seq nearby(Tile tile){ - return Seq.with(0, 1, 2, 3) - .map(tile::nearby) - .select(Objects::nonNull) - ; - } - - private boolean isValid(Tile current, Tile nearby){ - if(nearby.floor() == unstable) return true; - return nearby.floor() == stable && current.floor() == stable; - } -} diff --git a/src/meld/world/blocks/MeldNode.java b/src/meld/world/blocks/MeldNode.java index 2a3981c..a96e769 100644 --- a/src/meld/world/blocks/MeldNode.java +++ b/src/meld/world/blocks/MeldNode.java @@ -1,8 +1,5 @@ package meld.world.blocks; -import arc.func.*; -import meld.*; -import meld.core.*; import mindustry.content.Blocks; import mindustry.world.blocks.storage.CoreBlock; From 16644dd886f9092a93dec5365d805fb0f8dbdf63 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 16:59:55 +0200 Subject: [PATCH 09/16] refactor producers to be consistent with other StupidModules --- src/meld/content/MeldBlocks.java | 53 +++++++++---------- .../modules/StupidConsumeAllModule.java | 31 +++++++++++ .../modules/StupidConsumeHighestModule.java | 18 +++---- .../modules/StupidConsumeItemModule.java | 15 +++--- .../modules/StupidConsumeLiquidModule.java | 17 +++--- .../modules/StupidConsumePayloadModule.java | 17 +++--- .../modules/StupidCraftingModule.java | 27 ---------- .../modules/StupidProduceItemModule.java | 22 +++----- .../modules/StupidProduceLiquidModule.java | 29 +++++----- .../modules/StupidProducePayloadModule.java | 20 +++---- 10 files changed, 119 insertions(+), 130 deletions(-) create mode 100644 src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java delete mode 100644 src/meld/world/blocks/crafting/modules/StupidCraftingModule.java diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index 998ddba..5d52c5a 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -11,7 +11,6 @@ import meld.world.blocks.*; import meld.world.blocks.crafting.ModularCrafter; import meld.world.blocks.crafting.RecipeCrafter; -import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.recipe.ItemRecipe; import meld.world.blocks.crafting.recipe.SpoolRecipe; import meld.world.blocks.crafting.modules.*; @@ -669,8 +668,8 @@ public static void load(){ size = 3; modules.addAll( - new StupidCraftingModule(0){{ - requestPins = new int[]{1, 2, 3, 4, 5, 6}; + new StupidConsumeAllModule(0){{ + inputPins = new int[]{1, 2, 3, 4, 5, 6}; }}, new StupidConsumeItemModule(1, -1){{ @@ -685,14 +684,14 @@ public static void load(){ time = 180f; }}, - new StupidProduceItemModule(4, 0, -4){{ + new StupidProduceItemModule(0, -4){{ items = ItemStack.with(Items.titanium, 2); time = 60f; }}, - new StupidProduceLiquidModule(5, 0){{ + new StupidProduceLiquidModule(0){{ liquids = LiquidStack.with(Liquids.cryofluid, 1f); }}, - new StupidProducePayloadModule(6, 0, -6){{ + new StupidProducePayloadModule(0, -6){{ payloads = PayloadStack.with(Blocks.plastaniumWall, 2); time = 60f; }} @@ -713,32 +712,30 @@ public void load(){ size = 2; modules.addAll( - new StupidCraftingModule(0){{ - requestPins = new int[]{1, 2, 3}; - }}, - new StupidProduceItemModule(1, 0, -1){{ + new StupidProduceItemModule( 0, -1){{ items = ItemStack.with(Items.silicon, 1); time = 60f; }}, + new StupidConsumeAllModule(0){{ + inputPins = new int[]{2, 3}; + }}, + new StupidConsumeItemModule(2, -2){{ + items = ItemStack.with(Items.sand, 1); + time = 20f; + }}, + new StupidConsumeHighestModule(3){{ + inputPins = new int[]{4, 5}; + }}, + new StupidConsumeItemModule(4, -4){{ + items = ItemStack.with(Items.coal, 1); + time = 40f; + }}, + new StupidConsumeItemModule(5, -5){{ + items = ItemStack.with(Items.pyratite, 1); + time = 60f; - new StupidConsumeItemModule(2, -2){{ - items = ItemStack.with(Items.sand, 1); - time = 20f; - }}, - - new StupidConsumeHighestModule(3){{ - requestPins = new int[]{4, 5}; - }}, - new StupidConsumeItemModule(4, -4){{ - items = ItemStack.with(Items.coal, 1); - time = 40f; - }}, - new StupidConsumeItemModule(5, -5){{ - items = ItemStack.with(Items.pyratite, 1); - time = 60f; - - efficiencyIncrease = 2.5f; - }} + efficiencyIncrease = 2.5f; + }} ); } }; diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java new file mode 100644 index 0000000..56262d1 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java @@ -0,0 +1,31 @@ +package meld.world.blocks.crafting.modules; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public class StupidConsumeAllModule extends CrafterModule{ + public int[] inputPins; + /// Pin to provide efficiency on. + public int[] outputPins; + + public StupidConsumeAllModule(int... outputPins){ + this.outputPins = outputPins; + } + + public void update(ModularCrafterBuild build){ + float input = 1f; + for(int i : inputPins) input *= build.getPin(i); + + //Find the least consumed efficiency, it signals inactivity + float output = 0f; + for(int o : outputPins) output = Math.max(output, build.getPin(o)); + + //If consuming would give us more efficiency, do so + if(input > output){ + //Subtract the usable efficiency + for(int i : inputPins) build.setPin(i, build.getPin(i) - input); + for(int o : outputPins) build.setPin(o, input); + } + + } +} + diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java index b591b39..377c9f9 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java @@ -3,31 +3,31 @@ import meld.world.blocks.crafting.ModularCrafter.*; public class StupidConsumeHighestModule extends CrafterModule{ - public int[] requestPins; + public int[] inputPins; /// Pin to provide efficiency on. - public int providePin; + public int outputPin; - public StupidConsumeHighestModule(int providePin){ - this.providePin = providePin; + public StupidConsumeHighestModule(int outputPin){ + this.outputPin = outputPin; } public void update(ModularCrafterBuild build){ - float provide = build.getPin(providePin); + float output = build.getPin(outputPin); //Get highest float max = 0f; int maxPin = 0; - for(int i : requestPins){ + for(int i : inputPins){ if(build.getPin(i) > max){ max = build.getPin(i); maxPin = i; } } - if(max > provide){ + if(max > output){ //Just swap pin contents - build.setPin(maxPin, provide); - build.setPin(providePin, max); + build.setPin(maxPin, output); + build.setPin(outputPin, max); } } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java index 6b25e88..6f5c971 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java @@ -8,7 +8,7 @@ public class StupidConsumeItemModule extends CrafterModule{ public ItemStack[] items; /// Pin to provide efficiency on. - public int providePin; + public int outputPin; /// Pin to store consumption progress. public int progressPin; public float time = 60f; @@ -16,22 +16,23 @@ public class StupidConsumeItemModule extends CrafterModule{ public float baseEfficiency = 0f; public float efficiencyIncrease = 1f; - public StupidConsumeItemModule(int providePin, int progressPin){ - this.providePin = providePin; + public StupidConsumeItemModule(int outputPin, int progressPin){ + this.outputPin = outputPin; this.progressPin = progressPin; } @Override public void update(ModularCrafterBuild build){ - float provide = build.getPin(providePin); - float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float output = build.getPin(outputPin); float progress = build.getPin(progressPin); + //Get the amount of efficiency that was eaten + float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); - if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); //if efficiency has been used if(consumed > 0f && build.items.has(items)){ - build.setPin(providePin, baseEfficiency + efficiencyIncrease); + build.setPin(outputPin, baseEfficiency + efficiencyIncrease); progress += consumed * Time.delta; //consumption diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java index 462a9b5..c74de96 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java @@ -7,22 +7,23 @@ public class StupidConsumeLiquidModule extends CrafterModule{ public LiquidStack[] liquids; + /// Pin to provide efficiency on. + public int outputPin; + public float baseEfficiency = 0; public float efficiencyIncrease = 1; - /// Pin to provide efficiency on. - public int providePin; - public StupidConsumeLiquidModule(int providePin){ - this.providePin = providePin; + public StupidConsumeLiquidModule(int outputPin){ + this.outputPin = outputPin; } @Override public void update(ModularCrafterBuild build){ - float provide = build.getPin(providePin); + float output = build.getPin(outputPin); //Get the amount of efficiency that was eaten - float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); - if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); //if efficiency has been used if(consumed > 0f){ @@ -35,7 +36,7 @@ public void update(ModularCrafterBuild build){ for(LiquidStack stack : liquids){ build.liquids.remove(stack.liquid, stack.amount * min); } - build.setPin(providePin, baseEfficiency + efficiencyIncrease * min); + build.setPin(outputPin, baseEfficiency + efficiencyIncrease * min); } } } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java index a34dd90..7834ce8 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java @@ -16,27 +16,28 @@ public class StupidConsumePayloadModule extends CrafterModule{ public PayloadStack[] payloads; + /// Pin to provide efficiency on. + public int outputPin; /// Pin to store consumption progress. public int progressPin; - /// Pin to provide efficiency on. - public int providePin; public float time = 60f; public float baseEfficiency = 0f; public float efficiencyIncrease = 1f; - public StupidConsumePayloadModule(int providePin, int progressPin){ - this.providePin = providePin; + public StupidConsumePayloadModule(int outputPin, int progressPin){ + this.outputPin = outputPin; this.progressPin = progressPin; } @Override public void update(ModularCrafterBuild build){ - float provide = build.getPin(providePin); - float consumed = (efficiencyIncrease - provide - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float output = build.getPin(outputPin); + //Get the amount of efficiency that was eaten + float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); float progress = build.getPin(progressPin); - if(provide < baseEfficiency) build.setPin(providePin, baseEfficiency); + if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); if(build.payload != null && contains(payloads, build.payload) && build.moveInPayload()){ build.payloads.add(build.payload.content()); @@ -45,7 +46,7 @@ public void update(ModularCrafterBuild build){ //if efficiency has been used if(consumed > 0f && has(build, payloads)){ - build.setPin(providePin, baseEfficiency + efficiencyIncrease); + build.setPin(outputPin, baseEfficiency + efficiencyIncrease); progress += consumed * Time.delta; //consumption diff --git a/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java b/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java deleted file mode 100644 index 8b7a339..0000000 --- a/src/meld/world/blocks/crafting/modules/StupidCraftingModule.java +++ /dev/null @@ -1,27 +0,0 @@ -package meld.world.blocks.crafting.modules; - -import meld.world.blocks.crafting.ModularCrafter.*; - -//TODO remake this to be the same as the consumption modules -public class StupidCraftingModule extends CrafterModule{ - public int[] requestPins; - public int outputPin; - - public StupidCraftingModule(int outputPin){ - this.outputPin = outputPin; - } - - public void update(ModularCrafterBuild build){ - float efficiency = build.timeScale(); - //Sum up the efficiency - for(int i : requestPins) efficiency *= build.getPin(i); - - if(efficiency > 0){ - //Subtract the usable efficiency - for(int i : requestPins) build.setPin(i, build.getPin(i) - efficiency); - } - - build.setPin(outputPin, efficiency); - } -} - diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java index 292ef5f..b7ff12e 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java @@ -4,36 +4,28 @@ import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; - import java.util.*; -//TODO remake this to be the same as the consumption modules public class StupidProduceItemModule extends CrafterModule{ public ItemStack[] items; - /// Pin used to read production efficiency. - public int efficiencyPin; + /// Pin to consume efficiency from. + public int inputPin; /// Pin used to store crafting progress. public int progressPin; - /// Pin used to store whether this module can output. Assigned every tick. - public int workingPin; public float time = 60f; - public StupidProduceItemModule(int workingPin, int efficiencyPin, int progressPin){ - this.efficiencyPin = efficiencyPin; - this.workingPin = workingPin; + public StupidProduceItemModule(int inputPin, int progressPin){ + this.inputPin = inputPin; this.progressPin = progressPin; } @Override public void update(ModularCrafterBuild build){ - if(!fits(build, items)){ - build.setPin(workingPin, 0f); - return; - } - build.setPin(workingPin, 1f); + if(!fits(build, items)) return; float progress = build.getPin(progressPin); - progress += build.getPin(efficiencyPin) * Time.delta; + progress += build.getPin(inputPin) * build.timeScale() * Time.delta; + build.setPin(inputPin, 0f); while(progress > time && fits(build, items)){ for(ItemStack stack : items){ diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java index a1ea39f..d06d5aa 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java @@ -5,44 +5,45 @@ import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; -//TODO remake this to be the same as the consumption modules public class StupidProduceLiquidModule extends CrafterModule{ public LiquidStack[] liquids; - /// Pin used to read production efficiency. - public int efficiencyPin; - /// Pin used to store whether this module can output. Assigned every tick. - public int workingPin; + /// Pin to consume efficiency from. + public int inputPin; public boolean dumpExtraLiquid = false; - public StupidProduceLiquidModule(int workingPin, int efficiencyPin){ - this.efficiencyPin = efficiencyPin; - this.workingPin = workingPin; + public StupidProduceLiquidModule(int inputPin){ + this.inputPin = inputPin; } //Entirely GenericCrafter copy-paste, probably Sucks Ass. @Override public void update(ModularCrafterBuild build){ //check full + boolean allFull = true; for(LiquidStack stack : liquids){ - if(build.liquids.get(stack.liquid) < build.block.liquidCapacity - 0.001f){ + if(build.liquids.get(stack.liquid) >= build.block.liquidCapacity - 0.001f){ + if(!dumpExtraLiquid) return; + }else{ //if there's still space left, it's not full for all liquids - build.setPin(workingPin, 1f); - }else if(!dumpExtraLiquid){ - build.setPin(workingPin, 0f); - return; + allFull = false; } } + //if there is no space left for any liquid, it can't produce + if(allFull) return; + //continuously output based on efficiency for(LiquidStack stack : liquids){ build.handleLiquid(build, stack.liquid, Math.min( - stack.amount * build.getPin(efficiencyPin) * Time.delta, + stack.amount * build.getPin(inputPin) * build.timeScale() * Time.delta, build.block.liquidCapacity - build.liquids.get(stack.liquid) ) ); } + + build.setPin(inputPin, 0f); } @Override diff --git a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java index 4fd4b37..46c997f 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java @@ -12,29 +12,25 @@ import java.util.*; -//TODO remake this to be the same as the consumption modules public class StupidProducePayloadModule extends CrafterModule{ public PayloadStack[] payloads; - /// Pin used to read production efficiency. - public int efficiencyPin; + /// Pin to consume efficiency from. + public int inputPin; /// Pin used to store crafting progress. public int progressPin; - /// Pin used to store whether this module can output. Assigned every tick. - public int workingPin; public float time = 60f; - public StupidProducePayloadModule(int workingPin, int efficiencyPin, int progressPin){ - this.efficiencyPin = efficiencyPin; - this.workingPin = workingPin; + public StupidProducePayloadModule(int inputPin, int progressPin){ + this.inputPin = inputPin; this.progressPin = progressPin; } @Override public void update(ModularCrafterBuild build){ if(outputFits(build)){ - //consumption float progress = build.getPin(progressPin); - progress += build.getPin(efficiencyPin) * Time.delta; + progress += build.getPin(inputPin) * build.timeScale() * Time.delta; + build.setPin(inputPin, 0f); while(progress > time && outputFits(build)){ for(PayloadStack stack : payloads){ @@ -43,10 +39,6 @@ public void update(ModularCrafterBuild build){ progress -= time; } build.setPin(progressPin, progress); - //whether other modules should work - build.setPin(workingPin, 1f); - }else{ - build.setPin(workingPin, 0f); } //output From 3c1769f62e5ff3edf9ceb712cecca8ff7790bddd Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Thu, 2 Apr 2026 23:06:01 +0200 Subject: [PATCH 10/16] some fixes after testing --- src/meld/content/MeldBlocks.java | 29 ++++++++---------- .../world/blocks/crafting/ModularCrafter.java | 9 ++++-- .../modules/StupidConsumeHighestModule.java | 30 ++++++++++--------- .../modules/StupidProduceLiquidModule.java | 1 + .../modules/StupidProducePayloadModule.java | 2 +- 5 files changed, 38 insertions(+), 33 deletions(-) diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index 5d52c5a..d9c6575 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -668,30 +668,27 @@ public static void load(){ size = 3; modules.addAll( - new StupidConsumeAllModule(0){{ - inputPins = new int[]{1, 2, 3, 4, 5, 6}; - }}, - new StupidConsumeItemModule(1, -1){{ items = ItemStack.with(Items.copper, 2); time = 60f; }}, - new StupidConsumeLiquidModule(2){{ + new StupidProduceItemModule(1, -2){{ + items = ItemStack.with(Items.titanium, 2); + time = 60f; + }}, + /* + new StupidConsumeLiquidModule(2){{ TODO does not work properly liquids = LiquidStack.with(Liquids.water, 1f); }}, + new StupidProduceLiquidModule(5){{ + liquids = LiquidStack.with(Liquids.cryofluid, 1f); + }}, + */ new StupidConsumePayloadModule(3, -3){{ payloads = PayloadStack.with(Blocks.plastaniumWallLarge, 1); time = 180f; }}, - - new StupidProduceItemModule(0, -4){{ - items = ItemStack.with(Items.titanium, 2); - time = 60f; - }}, - new StupidProduceLiquidModule(0){{ - liquids = LiquidStack.with(Liquids.cryofluid, 1f); - }}, - new StupidProducePayloadModule(0, -6){{ + new StupidProducePayloadModule(3, -4){{ payloads = PayloadStack.with(Blocks.plastaniumWall, 2); time = 60f; }} @@ -712,11 +709,11 @@ public void load(){ size = 2; modules.addAll( - new StupidProduceItemModule( 0, -1){{ + new StupidProduceItemModule( 1, -1){{ items = ItemStack.with(Items.silicon, 1); time = 60f; }}, - new StupidConsumeAllModule(0){{ + new StupidConsumeAllModule(1){{ inputPins = new int[]{2, 3}; }}, new StupidConsumeItemModule(2, -2){{ diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index 48230a5..a565e3d 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -26,8 +26,8 @@ public class ModularCrafter extends PayloadBlock{ //Modules updates every update, listeners are for modules with specific events - public Seq modules = new Seq(); - public ObjectMap> listeners = new ObjectMap>(); + public Seq modules = new Seq<>(); + public ObjectMap> listeners = new ObjectMap<>(); //Lists of stuff which this block accepts //note: could be a single HashSet. @@ -108,6 +108,11 @@ public enum Defaults{ } } + @Override + public boolean outputsItems(){ + return !dumpedItems.isEmpty(); + } + public static abstract class CrafterModule{ public void update(ModularCrafterBuild build){ diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java index 377c9f9..c9df4ee 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java @@ -5,29 +5,31 @@ public class StupidConsumeHighestModule extends CrafterModule{ public int[] inputPins; /// Pin to provide efficiency on. - public int outputPin; + public int[] outputPins; - public StupidConsumeHighestModule(int outputPin){ - this.outputPin = outputPin; + public StupidConsumeHighestModule(int... outputPins){ + this.outputPins = outputPins; } public void update(ModularCrafterBuild build){ - float output = build.getPin(outputPin); - - //Get highest - float max = 0f; - int maxPin = 0; + //Get the highest input pin + float input = 0f; + int inputPin = 0; for(int i : inputPins){ - if(build.getPin(i) > max){ - max = build.getPin(i); - maxPin = i; + if(build.getPin(i) > input){ + input = build.getPin(i); + inputPin = i; } } - if(max > output){ + //Find the least consumed output, it signals inactivity + float output = 0f; + for(int o : outputPins) output = Math.max(output, build.getPin(o)); + + if(input > output){ //Just swap pin contents - build.setPin(maxPin, output); - build.setPin(outputPin, max); + build.setPin(inputPin, output); + for(int o : outputPins) build.setPin(o, input); } } diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java index d06d5aa..6978c72 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java @@ -49,6 +49,7 @@ public void update(ModularCrafterBuild build){ @Override public void setup(ModularCrafter block){ block.hasLiquids = true; + block.outputsLiquid = true; for(LiquidStack stack : liquids){ block.dumpedLiquids.add(stack.liquid); } diff --git a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java index 46c997f..334ad8c 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java @@ -77,7 +77,7 @@ public boolean outputs(Payload pay){ } public boolean outputFits(ModularCrafterBuild build){ - return Arrays.stream(payloads).allMatch(stack -> build.payloads.get(stack.item) + stack.amount <= build.block.itemCapacity); + return Arrays.stream(payloads).allMatch(stack -> build.payloads.get(stack.item) + stack.amount <= build.modular.payloadCapacity); } @Override From 6e2b56bd702336e04c393fa0a822349f9d5188e5 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Fri, 3 Apr 2026 09:24:00 +0200 Subject: [PATCH 11/16] attributes, renames --- src/meld/content/MeldBlocks.java | 38 +++++++++------ .../world/blocks/crafting/ModularCrafter.java | 15 ++---- .../crafting/modules/AttributeModule.java | 27 ----------- .../modules/rework/AttributeModule.java | 46 +++++++++++++++++++ .../ConsumeAllModule.java} | 6 +-- .../ConsumeHighestModule.java} | 6 +-- .../ConsumeItemModule.java} | 6 +-- .../ConsumePayloadModule.java} | 12 ++--- .../rework/EfficiencySourceModule.java | 18 ++++++++ .../ProduceItemModule.java} | 6 +-- .../ProducePayloadModule.java} | 6 +-- .../StupidConsumeLiquidModule.java | 2 +- .../StupidProduceLiquidModule.java | 2 +- 13 files changed, 112 insertions(+), 78 deletions(-) delete mode 100644 src/meld/world/blocks/crafting/modules/AttributeModule.java create mode 100644 src/meld/world/blocks/crafting/modules/rework/AttributeModule.java rename src/meld/world/blocks/crafting/modules/{StupidConsumeAllModule.java => rework/ConsumeAllModule.java} (83%) rename src/meld/world/blocks/crafting/modules/{StupidConsumeHighestModule.java => rework/ConsumeHighestModule.java} (83%) rename src/meld/world/blocks/crafting/modules/{StupidConsumeItemModule.java => rework/ConsumeItemModule.java} (90%) rename src/meld/world/blocks/crafting/modules/{StupidConsumePayloadModule.java => rework/ConsumePayloadModule.java} (87%) create mode 100644 src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java rename src/meld/world/blocks/crafting/modules/{StupidProduceItemModule.java => rework/ProduceItemModule.java} (88%) rename src/meld/world/blocks/crafting/modules/{StupidProducePayloadModule.java => rework/ProducePayloadModule.java} (94%) rename src/meld/world/blocks/crafting/modules/{ => rework}/StupidConsumeLiquidModule.java (96%) rename src/meld/world/blocks/crafting/modules/{ => rework}/StupidProduceLiquidModule.java (97%) diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index d9c6575..25e7ecf 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -11,6 +11,7 @@ import meld.world.blocks.*; import meld.world.blocks.crafting.ModularCrafter; import meld.world.blocks.crafting.RecipeCrafter; +import meld.world.blocks.crafting.modules.rework.*; import meld.world.blocks.crafting.recipe.ItemRecipe; import meld.world.blocks.crafting.recipe.SpoolRecipe; import meld.world.blocks.crafting.modules.*; @@ -593,7 +594,7 @@ public static void load(){ dumpedLiquids.addAll(MeldLiquids.pollutantMixture, MeldLiquids.fumes); //Should make all the modules trigger in order - hookAll(BlockEvent.Defaults.proximityUpdate, + /*hookAll(BlockEvent.Defaults.proximityUpdate, new AttributeModule(){{ attribute = MeldAttributes.aetherAttr; baseEfficiency = 0; @@ -610,7 +611,7 @@ public static void load(){ efficiencyPin = 1; }} - ); + );*/ modules.addAll( new ProduceLiquidModule(new LiquidStack(MeldLiquids.pollutantMixture, 1), 0), @@ -668,11 +669,11 @@ public static void load(){ size = 3; modules.addAll( - new StupidConsumeItemModule(1, -1){{ + new ConsumeItemModule(1, -1){{ items = ItemStack.with(Items.copper, 2); time = 60f; }}, - new StupidProduceItemModule(1, -2){{ + new ProduceItemModule(1, -2){{ items = ItemStack.with(Items.titanium, 2); time = 60f; }}, @@ -684,11 +685,11 @@ public static void load(){ liquids = LiquidStack.with(Liquids.cryofluid, 1f); }}, */ - new StupidConsumePayloadModule(3, -3){{ + new ConsumePayloadModule(3, -3){{ payloads = PayloadStack.with(Blocks.plastaniumWallLarge, 1); time = 180f; }}, - new StupidProducePayloadModule(3, -4){{ + new ProducePayloadModule(3, -4){{ payloads = PayloadStack.with(Blocks.plastaniumWall, 2); time = 60f; }} @@ -709,27 +710,34 @@ public void load(){ size = 2; modules.addAll( - new StupidProduceItemModule( 1, -1){{ + new ProduceItemModule( 1, -1){{ items = ItemStack.with(Items.silicon, 1); time = 60f; }}, - new StupidConsumeAllModule(1){{ + new ConsumeAllModule(1){{ inputPins = new int[]{2, 3}; }}, - new StupidConsumeItemModule(2, -2){{ + new ConsumeItemModule(2, -2){{ items = ItemStack.with(Items.sand, 1); time = 20f; }}, - new StupidConsumeHighestModule(3){{ + new ConsumeHighestModule(3){{ inputPins = new int[]{4, 5}; }}, - new StupidConsumeItemModule(4, -4){{ + new ConsumeItemModule(4, -4){{ items = ItemStack.with(Items.coal, 1); time = 40f; }}, - new StupidConsumeItemModule(5, -5){{ + new AttributeModule(5, -5){{ + attribute = Attribute.heat; + baseEfficiency = 0f; + maxBoost = 2f; + }}, + //This is assigned to the same pin as the attribute, and updates after, which means + //it will only "top off" the efficiency that the attributes don't reach. + new ConsumeItemModule(5, -6){{ items = ItemStack.with(Items.pyratite, 1); - time = 60f; + time = 20f; efficiencyIncrease = 2.5f; }} @@ -753,7 +761,7 @@ public void load(){ dumpedItems.add(MeldItems.carbolith); - //Should make all the modules trigger in order + /*//Should make all the modules trigger in order hookAll(BlockEvent.Defaults.proximityUpdate, new AttributeModule(){{ attribute = Attribute.steam; @@ -763,7 +771,7 @@ public void load(){ efficiencyPin = 0; }} - ); + );*/ ItemRecipe carbolith = new ItemRecipe(with(MeldItems.debris, 1), with(MeldItems.carbolith, 1)); diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index a565e3d..7bd643a 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -80,7 +80,7 @@ public void init(){ public static void trigger(ModularCrafter block, ModularCrafterBuild build, Object event){ Seq events = block.listeners.get(event); - if(events != null) events.each(c -> c.update(build)); + if(events != null) events.each(c -> c.on_event(build)); } public void hook(Object event, CrafterModule module){ @@ -92,15 +92,6 @@ public void hook(Object event, CrafterModule module){ events.add(module); } - public void hookAll(Object event, CrafterModule... module){ - Seq events = listeners.get(event); - if(events == null) { - listeners.put(event, Seq.with(module)); - return; - } - events.add(module); - } - public static class BlockEvent{ public enum Defaults{ update, @@ -121,6 +112,10 @@ public void update(ModularCrafterBuild build){ public void setup(ModularCrafter block){ } + + public void on_event(ModularCrafterBuild build){ + + } } public static abstract class CraftingModule extends CrafterModule{ diff --git a/src/meld/world/blocks/crafting/modules/AttributeModule.java b/src/meld/world/blocks/crafting/modules/AttributeModule.java deleted file mode 100644 index 600085e..0000000 --- a/src/meld/world/blocks/crafting/modules/AttributeModule.java +++ /dev/null @@ -1,27 +0,0 @@ -package meld.world.blocks.crafting.modules; - -import arc.util.Log; -import meld.world.blocks.crafting.ModularCrafter; -import mindustry.world.meta.Attribute; - -public class AttributeModule extends ModularCrafter.CrafterModule { - public int efficiencyPin; - - public Attribute attribute; - public float baseEfficiency = 1; - public float boostScale = 1; - public float maxBoost = 1; - public float minEfficiency = -1; - - @Override - public void update(ModularCrafter.ModularCrafterBuild build) { - float efficiency = baseEfficiency + Math.min(maxBoost, boostScale * build.block.sumAttribute(attribute, build.tileX(), build.tileY()) + attribute.env()); - - if(minEfficiency != -1 && efficiency < minEfficiency) { - build.setPin(efficiencyPin, 0); - return; - } - - build.data.put(efficiencyPin, efficiency); - } -} \ No newline at end of file diff --git a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java new file mode 100644 index 0000000..716e1a8 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java @@ -0,0 +1,46 @@ +package meld.world.blocks.crafting.modules.rework; + +import meld.world.blocks.crafting.ModularCrafter; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.world.meta.Attribute; + +public class AttributeModule extends CrafterModule { + /// Pin to provide efficiency on. + public int outputPin; + /// Pin to store the efficiency that should be output. Don't let other modules touch it. + public int storagePin; + + public Attribute attribute; + public float baseEfficiency = 1; + public float boostScale = 1; + public float maxBoost = 1; + /// The minimum attribute efficiency needed for it to affect output. + public float minEfficiency = -1; + + public AttributeModule(int outputPin, int storagePin){ + this.outputPin = outputPin; + this.storagePin = storagePin; + } + + @Override + public void update(ModularCrafter.ModularCrafterBuild build) { + build.setPin(outputPin, build.getPin(storagePin)); + } + + @Override + public void setup(ModularCrafter block){ + block.hook(BlockEvent.Defaults.proximityUpdate, this); + } + + @Override + public void on_event(ModularCrafterBuild build){ + float efficiency = baseEfficiency + Math.min(maxBoost, boostScale * build.block.sumAttribute(attribute, build.tileX(), build.tileY()) + attribute.env()); + + if(efficiency < minEfficiency) { + build.setPin(storagePin, 0); + return; + } + + build.setPin(storagePin, efficiency); + } +} \ No newline at end of file diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java similarity index 83% rename from src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java rename to src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java index 56262d1..282caed 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeAllModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java @@ -1,13 +1,13 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import meld.world.blocks.crafting.ModularCrafter.*; -public class StupidConsumeAllModule extends CrafterModule{ +public class ConsumeAllModule extends CrafterModule{ public int[] inputPins; /// Pin to provide efficiency on. public int[] outputPins; - public StupidConsumeAllModule(int... outputPins){ + public ConsumeAllModule(int... outputPins){ this.outputPins = outputPins; } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java similarity index 83% rename from src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java rename to src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java index c9df4ee..dff687c 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeHighestModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java @@ -1,13 +1,13 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import meld.world.blocks.crafting.ModularCrafter.*; -public class StupidConsumeHighestModule extends CrafterModule{ +public class ConsumeHighestModule extends CrafterModule{ public int[] inputPins; /// Pin to provide efficiency on. public int[] outputPins; - public StupidConsumeHighestModule(int... outputPins){ + public ConsumeHighestModule(int... outputPins){ this.outputPins = outputPins; } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java similarity index 90% rename from src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java rename to src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java index 6f5c971..5d9cd40 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java @@ -1,11 +1,11 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; -public class StupidConsumeItemModule extends CrafterModule{ +public class ConsumeItemModule extends CrafterModule{ public ItemStack[] items; /// Pin to provide efficiency on. public int outputPin; @@ -16,7 +16,7 @@ public class StupidConsumeItemModule extends CrafterModule{ public float baseEfficiency = 0f; public float efficiencyIncrease = 1f; - public StupidConsumeItemModule(int outputPin, int progressPin){ + public ConsumeItemModule(int outputPin, int progressPin){ this.outputPin = outputPin; this.progressPin = progressPin; } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java similarity index 87% rename from src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java rename to src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java index 7834ce8..99036d9 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java @@ -1,20 +1,14 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; -import arc.math.*; -import arc.math.geom.*; import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; -import mindustry.ai.types.*; -import mindustry.content.*; -import mindustry.entities.*; -import mindustry.gen.*; import mindustry.type.*; import mindustry.world.blocks.payloads.*; import java.util.*; -public class StupidConsumePayloadModule extends CrafterModule{ +public class ConsumePayloadModule extends CrafterModule{ public PayloadStack[] payloads; /// Pin to provide efficiency on. public int outputPin; @@ -25,7 +19,7 @@ public class StupidConsumePayloadModule extends CrafterModule{ public float baseEfficiency = 0f; public float efficiencyIncrease = 1f; - public StupidConsumePayloadModule(int outputPin, int progressPin){ + public ConsumePayloadModule(int outputPin, int progressPin){ this.outputPin = outputPin; this.progressPin = progressPin; } diff --git a/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java b/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java new file mode 100644 index 0000000..d631ecf --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java @@ -0,0 +1,18 @@ +package meld.world.blocks.crafting.modules.rework; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public class EfficiencySourceModule extends CrafterModule{ + /// Pin to provide efficiency on. + public int outputPin; + public float baseEfficiency = 1f; + + public EfficiencySourceModule(int outputPin){ + this.outputPin = outputPin; + } + + @Override + public void update(ModularCrafterBuild build){ + build.setPin(outputPin, baseEfficiency); + } +} diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java similarity index 88% rename from src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java rename to src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java index b7ff12e..c48bac2 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import arc.util.*; import meld.world.blocks.crafting.*; @@ -6,7 +6,7 @@ import mindustry.type.*; import java.util.*; -public class StupidProduceItemModule extends CrafterModule{ +public class ProduceItemModule extends CrafterModule{ public ItemStack[] items; /// Pin to consume efficiency from. public int inputPin; @@ -14,7 +14,7 @@ public class StupidProduceItemModule extends CrafterModule{ public int progressPin; public float time = 60f; - public StupidProduceItemModule(int inputPin, int progressPin){ + public ProduceItemModule(int inputPin, int progressPin){ this.inputPin = inputPin; this.progressPin = progressPin; } diff --git a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java similarity index 94% rename from src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java rename to src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java index 334ad8c..565bdd8 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import arc.*; import arc.util.*; @@ -12,7 +12,7 @@ import java.util.*; -public class StupidProducePayloadModule extends CrafterModule{ +public class ProducePayloadModule extends CrafterModule{ public PayloadStack[] payloads; /// Pin to consume efficiency from. public int inputPin; @@ -20,7 +20,7 @@ public class StupidProducePayloadModule extends CrafterModule{ public int progressPin; public float time = 60f; - public StupidProducePayloadModule(int inputPin, int progressPin){ + public ProducePayloadModule(int inputPin, int progressPin){ this.inputPin = inputPin; this.progressPin = progressPin; } diff --git a/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java similarity index 96% rename from src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java rename to src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java index c74de96..4fcb145 100644 --- a/src/meld/world/blocks/crafting/modules/StupidConsumeLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import arc.util.*; import meld.world.blocks.crafting.*; diff --git a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java similarity index 97% rename from src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java rename to src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java index 6978c72..7e8dab9 100644 --- a/src/meld/world/blocks/crafting/modules/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules; +package meld.world.blocks.crafting.modules.rework; import arc.util.*; import meld.world.blocks.crafting.*; From 980b19fa8926ca9938dca5eb103ae569fc998154 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Fri, 3 Apr 2026 14:09:18 +0200 Subject: [PATCH 12/16] more pins everywhere, I can delete ConsumeAllModule --- src/meld/content/MeldBlocks.java | 70 +++++++++++-------- .../world/blocks/crafting/ModularCrafter.java | 6 ++ .../modules/rework/AttributeModule.java | 13 ++-- .../modules/rework/ConsumeAllModule.java | 31 -------- .../modules/rework/ConsumeDiscreteModule.java | 45 ++++++++++++ .../modules/rework/ConsumeHighestModule.java | 16 ++--- .../modules/rework/ConsumeItemModule.java | 42 +++-------- .../modules/rework/ConsumeModule.java | 33 +++++++++ .../modules/rework/ConsumePayloadModule.java | 52 ++++---------- .../rework/EfficiencySourceModule.java | 13 ++-- .../modules/rework/EfficiencyVoidModule.java | 22 ++++++ .../modules/rework/ProduceDiscreteModule.java | 44 ++++++++++++ .../modules/rework/ProduceItemModule.java | 35 +++------- .../modules/rework/ProducePayloadModule.java | 55 ++++++--------- .../rework/StupidConsumeLiquidModule.java | 20 +++--- .../rework/StupidProduceLiquidModule.java | 28 +++----- 16 files changed, 287 insertions(+), 238 deletions(-) delete mode 100644 src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java create mode 100644 src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java create mode 100644 src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java create mode 100644 src/meld/world/blocks/crafting/modules/rework/EfficiencyVoidModule.java create mode 100644 src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index 25e7ecf..f2a1967 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -669,13 +669,17 @@ public static void load(){ size = 3; modules.addAll( - new ConsumeItemModule(1, -1){{ + new ConsumeItemModule(1){{ items = ItemStack.with(Items.copper, 2); time = 60f; + + progressPin = -1; }}, - new ProduceItemModule(1, -2){{ + new ProduceItemModule(1){{ items = ItemStack.with(Items.titanium, 2); time = 60f; + + progressPin = -2; }}, /* new StupidConsumeLiquidModule(2){{ TODO does not work properly @@ -685,13 +689,17 @@ public static void load(){ liquids = LiquidStack.with(Liquids.cryofluid, 1f); }}, */ - new ConsumePayloadModule(3, -3){{ + new ConsumePayloadModule(3){{ payloads = PayloadStack.with(Blocks.plastaniumWallLarge, 1); time = 180f; + + progressPin = -3; }}, - new ProducePayloadModule(3, -4){{ + new ProducePayloadModule(3){{ payloads = PayloadStack.with(Blocks.plastaniumWall, 2); time = 60f; + + progressPin = -4; }} ); }}; @@ -710,37 +718,37 @@ public void load(){ size = 2; modules.addAll( - new ProduceItemModule( 1, -1){{ + new ProduceItemModule( 1, 2){{ items = ItemStack.with(Items.silicon, 1); time = 60f; + progressPin = 0; }}, - new ConsumeAllModule(1){{ - inputPins = new int[]{2, 3}; + //TODO sand consumption does not scale. + new ConsumeItemModule(1){{ + items = ItemStack.with(Items.sand, 1); + time = 20f; + progressPin = -1; }}, - new ConsumeItemModule(2, -2){{ - items = ItemStack.with(Items.sand, 1); - time = 20f; - }}, - new ConsumeHighestModule(3){{ - inputPins = new int[]{4, 5}; - }}, - new ConsumeItemModule(4, -4){{ - items = ItemStack.with(Items.coal, 1); - time = 40f; - }}, - new AttributeModule(5, -5){{ - attribute = Attribute.heat; - baseEfficiency = 0f; - maxBoost = 2f; - }}, - //This is assigned to the same pin as the attribute, and updates after, which means - //it will only "top off" the efficiency that the attributes don't reach. - new ConsumeItemModule(5, -6){{ - items = ItemStack.with(Items.pyratite, 1); - time = 20f; - - efficiencyIncrease = 2.5f; - }} + new AttributeModule(2){{ + attribute = Attribute.heat; + baseEfficiency = 0f; + maxBoost = 2f; + storagePin = -2; + }}, + //This is assigned to the same pin as the attribute, and updates after, + //which means it will only "top off" the efficiency that the attributes don't reach. + new ConsumeItemModule(2){{ + items = ItemStack.with(Items.pyratite, 1); + efficiencyIncrease = 2.5f; + time = 20f; + progressPin = -3; + }}, + //Same as above, but will also cover for the pyratite consumer. + new ConsumeItemModule(2){{ + items = ItemStack.with(Items.coal, 1); + time = 40f; + progressPin = -4; + }} ); } }; diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index 7bd643a..5aa1e8d 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -116,6 +116,8 @@ public void setup(ModularCrafter block){ public void on_event(ModularCrafterBuild build){ } + + } public static abstract class CraftingModule extends CrafterModule{ @@ -247,6 +249,10 @@ public void setPin(int pin, float value){ data.put(pin, value); } + public void setPins(int[] pins, float value){ + for(int i : pins) setPin(i, value); + } + public float getPin(int pin){ return data.get(pin); } diff --git a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java index 716e1a8..f88d444 100644 --- a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java @@ -5,8 +5,8 @@ import mindustry.world.meta.Attribute; public class AttributeModule extends CrafterModule { - /// Pin to provide efficiency on. - public int outputPin; + /// Pins to provide efficiency on. + public int[] outputPins; /// Pin to store the efficiency that should be output. Don't let other modules touch it. public int storagePin; @@ -17,14 +17,13 @@ public class AttributeModule extends CrafterModule { /// The minimum attribute efficiency needed for it to affect output. public float minEfficiency = -1; - public AttributeModule(int outputPin, int storagePin){ - this.outputPin = outputPin; - this.storagePin = storagePin; + public AttributeModule(int... outputPins){ + this.outputPins = outputPins; } @Override - public void update(ModularCrafter.ModularCrafterBuild build) { - build.setPin(outputPin, build.getPin(storagePin)); + public void update(ModularCrafterBuild build){ + for(int o : outputPins) build.setPin(o, build.getPin(storagePin)); } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java deleted file mode 100644 index 282caed..0000000 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeAllModule.java +++ /dev/null @@ -1,31 +0,0 @@ -package meld.world.blocks.crafting.modules.rework; - -import meld.world.blocks.crafting.ModularCrafter.*; - -public class ConsumeAllModule extends CrafterModule{ - public int[] inputPins; - /// Pin to provide efficiency on. - public int[] outputPins; - - public ConsumeAllModule(int... outputPins){ - this.outputPins = outputPins; - } - - public void update(ModularCrafterBuild build){ - float input = 1f; - for(int i : inputPins) input *= build.getPin(i); - - //Find the least consumed efficiency, it signals inactivity - float output = 0f; - for(int o : outputPins) output = Math.max(output, build.getPin(o)); - - //If consuming would give us more efficiency, do so - if(input > output){ - //Subtract the usable efficiency - for(int i : inputPins) build.setPin(i, build.getPin(i) - input); - for(int o : outputPins) build.setPin(o, input); - } - - } -} - diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java new file mode 100644 index 0000000..f903be3 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java @@ -0,0 +1,45 @@ +package meld.world.blocks.crafting.modules.rework; + +import arc.util.*; +import meld.world.blocks.crafting.ModularCrafter.*; + +public abstract class ConsumeDiscreteModule extends ConsumeModule{ + /// Pin to store consumption progress. + public int progressPin; + public float time = 60f; + + public float baseEfficiency = 0f; + public float efficiencyIncrease = 1f; + + public ConsumeDiscreteModule(int... outputPins){ + super(outputPins); + } + + public abstract boolean canConsume(ModularCrafterBuild build); + + public abstract void consume(ModularCrafterBuild build); + + @Override + public void update(ModularCrafterBuild build){ + float current = getCurrent(build); + //Get the amount of efficiency that was eaten + float consumed = (efficiencyIncrease - current - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float output = Math.max(baseEfficiency, current); + + //if efficiency has been used + if(consumed > 0f && canConsume(build)){ + float progress = build.getPin(progressPin); + progress += consumed * Time.delta; + output = baseEfficiency + efficiencyIncrease; + + //consumption + while(progress > time && canConsume(build)){ + consume(build); + progress -= time; + } + build.setPin(progressPin, progress); + } + + build.setPins(outputPins, output); + } +} diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java index dff687c..06ec172 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java @@ -2,13 +2,12 @@ import meld.world.blocks.crafting.ModularCrafter.*; -public class ConsumeHighestModule extends CrafterModule{ +/// Will only consume from the pin with the highest efficiency. +public class ConsumeHighestModule extends ConsumeModule{ public int[] inputPins; - /// Pin to provide efficiency on. - public int[] outputPins; public ConsumeHighestModule(int... outputPins){ - this.outputPins = outputPins; + super(outputPins); } public void update(ModularCrafterBuild build){ @@ -23,13 +22,12 @@ public void update(ModularCrafterBuild build){ } //Find the least consumed output, it signals inactivity - float output = 0f; - for(int o : outputPins) output = Math.max(output, build.getPin(o)); + float current = getCurrent(build); - if(input > output){ + if(input > current){ //Just swap pin contents - build.setPin(inputPin, output); - for(int o : outputPins) build.setPin(o, input); + build.setPin(inputPin, current); + build.setPins(outputPins, input); } } diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java index 5d9cd40..608fbf3 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java @@ -1,48 +1,24 @@ package meld.world.blocks.crafting.modules.rework; -import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; -public class ConsumeItemModule extends CrafterModule{ +public class ConsumeItemModule extends ConsumeDiscreteModule{ public ItemStack[] items; - /// Pin to provide efficiency on. - public int outputPin; - /// Pin to store consumption progress. - public int progressPin; - public float time = 60f; - public float baseEfficiency = 0f; - public float efficiencyIncrease = 1f; - - public ConsumeItemModule(int outputPin, int progressPin){ - this.outputPin = outputPin; - this.progressPin = progressPin; + public ConsumeItemModule(int... outputPins){ + super(outputPins); } @Override - public void update(ModularCrafterBuild build){ - float output = build.getPin(outputPin); - float progress = build.getPin(progressPin); - //Get the amount of efficiency that was eaten - float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); - - if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); - - //if efficiency has been used - if(consumed > 0f && build.items.has(items)){ - build.setPin(outputPin, baseEfficiency + efficiencyIncrease); - progress += consumed * Time.delta; - - //consumption - while(progress > time && build.items.has(items)){ + public boolean canConsume(ModularCrafterBuild build){ + return build.items.has(items); + } - build.items.remove(items); - progress -= time; - } - build.setPin(progressPin, progress); - } + @Override + public void consume(ModularCrafterBuild build){ + build.items.remove(items); } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java new file mode 100644 index 0000000..7aeeedd --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java @@ -0,0 +1,33 @@ +package meld.world.blocks.crafting.modules.rework; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public abstract class ConsumeModule extends CrafterModule{ + /// Pins to provide efficiency on. + public int[] outputPins; + /// Makes the module ignore other pins that are full until no more can be output. + public boolean dumpExtra = false; + + public ConsumeModule(int... outputPins){ + this.outputPins = outputPins; + } + + public float getCurrent(ModularCrafterBuild build){ + if(!dumpExtra){ + //Find the least consumed output, it signals inactivity + float max = 0f; + for(int i : outputPins){ + max = Math.max(max, build.getPin(i)); + } + return max; + }else{ + //If we don't care about a few full inputs, pick the minimum instead + float min = 0f; + for(int i : outputPins){ + min = Math.min(min, build.getPin(i)); + } + return min; + } + + } +} diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java index 99036d9..eab1869 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java @@ -1,6 +1,5 @@ package meld.world.blocks.crafting.modules.rework; -import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; @@ -8,63 +7,42 @@ import java.util.*; -public class ConsumePayloadModule extends CrafterModule{ +public class ConsumePayloadModule extends ConsumeDiscreteModule{ public PayloadStack[] payloads; - /// Pin to provide efficiency on. - public int outputPin; - /// Pin to store consumption progress. - public int progressPin; - public float time = 60f; - public float baseEfficiency = 0f; - public float efficiencyIncrease = 1f; - - public ConsumePayloadModule(int outputPin, int progressPin){ - this.outputPin = outputPin; - this.progressPin = progressPin; + public ConsumePayloadModule(int... outputPins){ + super(outputPins); } @Override public void update(ModularCrafterBuild build){ - float output = build.getPin(outputPin); - //Get the amount of efficiency that was eaten - float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); - float progress = build.getPin(progressPin); - - if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); + super.update(build); - if(build.payload != null && contains(payloads, build.payload) && build.moveInPayload()){ + if(build.payload != null && wants(build.payload) && build.moveInPayload()){ build.payloads.add(build.payload.content()); build.payload = null; } + } - //if efficiency has been used - if(consumed > 0f && has(build, payloads)){ - build.setPin(outputPin, baseEfficiency + efficiencyIncrease); - progress += consumed * Time.delta; + @Override + public boolean canConsume(ModularCrafterBuild build){ + return Arrays.stream(payloads).allMatch(stack -> build.payloads.contains(stack)); + } - //consumption - while(progress > time && has(build, payloads)){ - for(PayloadStack stack : payloads){ - build.payloads.remove(stack.item, stack.amount); - } - progress -= time; - } - build.setPin(progressPin, progress); + @Override + public void consume(ModularCrafterBuild build){ + for(PayloadStack stack : payloads){ + build.payloads.remove(stack.item, stack.amount); } } - public static boolean contains(PayloadStack[] payloads, Payload pay){ + public boolean wants(Payload pay){ for(PayloadStack stack : payloads){ if(stack.item == pay.content()) return true; } return false; } - public static boolean has(ModularCrafterBuild build, PayloadStack[] payloadStacks){ - return Arrays.stream(payloadStacks).allMatch(stack -> build.payloads.contains(stack)); - } - @Override public void setup(ModularCrafter block){ block.acceptsPayload = true; diff --git a/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java b/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java index d631ecf..b73b9f2 100644 --- a/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/EfficiencySourceModule.java @@ -2,17 +2,20 @@ import meld.world.blocks.crafting.ModularCrafter.*; +/// When you have multiple modules draw from the same pin, the first module in +/// the update order to craft something will block the rest from working. +/// This module is made for when you need this behavior, but without a shared input. public class EfficiencySourceModule extends CrafterModule{ - /// Pin to provide efficiency on. - public int outputPin; + /// Pins to provide efficiency on. + public int[] outputPins; public float baseEfficiency = 1f; - public EfficiencySourceModule(int outputPin){ - this.outputPin = outputPin; + public EfficiencySourceModule(int... outputPins){ + this.outputPins = outputPins; } @Override public void update(ModularCrafterBuild build){ - build.setPin(outputPin, baseEfficiency); + for(int o : outputPins) build.setPin(o, baseEfficiency); } } diff --git a/src/meld/world/blocks/crafting/modules/rework/EfficiencyVoidModule.java b/src/meld/world/blocks/crafting/modules/rework/EfficiencyVoidModule.java new file mode 100644 index 0000000..1ca1e57 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/EfficiencyVoidModule.java @@ -0,0 +1,22 @@ +package meld.world.blocks.crafting.modules.rework; + +import arc.util.*; +import meld.world.blocks.crafting.ModularCrafter.*; + +/// Can be used to make blocks consume, regardless of whether they're doing something. +/// To do this, you can place it after a producer module, and make it consume from its input pin. +public class EfficiencyVoidModule extends CrafterModule{ + /// Pins to consume efficiency of. + public int[] inputPins; + /// The amount of efficiency consumed. + public float amount = Float.POSITIVE_INFINITY; + + public EfficiencyVoidModule(int... inputPins){ + this.inputPins = inputPins; + } + + @Override + public void update(ModularCrafterBuild build){ + for(int i : inputPins) build.setPin(i, Math.max(0f, build.getPin(i) - amount * build.timeScale() * Time.delta)); + } +} diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java new file mode 100644 index 0000000..09c4a80 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java @@ -0,0 +1,44 @@ +package meld.world.blocks.crafting.modules.rework; + +import arc.util.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import mindustry.type.*; + +import java.util.*; + +public abstract class ProduceDiscreteModule extends CrafterModule{ + /// Pins to consume efficiency from. + public int[] inputPins; + /// Pin used to store crafting progress. + public int progressPin; + public float time = 60f; + + public ProduceDiscreteModule(int... inputPins){ + this.inputPins = inputPins; + } + + @Override + public void update(ModularCrafterBuild build){ + if(!canOutput(build)) return; + + float input = 1f; + for(int i : inputPins) input *= build.getPin(i); + + //After summing, subtract the final efficiency + for(int i : inputPins) build.setPin(i, build.getPin(i) - input); + + float progress = build.getPin(progressPin); + progress += input * build.timeScale() * Time.delta; + + while(progress > time && canOutput(build)){ + output(build); + progress -= time; + } + build.setPin(progressPin, progress); + + } + + public abstract boolean canOutput(ModularCrafterBuild build); + + public abstract void output(ModularCrafterBuild build); +} diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java index c48bac2..478b7df 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java @@ -6,38 +6,23 @@ import mindustry.type.*; import java.util.*; -public class ProduceItemModule extends CrafterModule{ +public class ProduceItemModule extends ProduceDiscreteModule{ public ItemStack[] items; - /// Pin to consume efficiency from. - public int inputPin; - /// Pin used to store crafting progress. - public int progressPin; - public float time = 60f; - public ProduceItemModule(int inputPin, int progressPin){ - this.inputPin = inputPin; - this.progressPin = progressPin; + public ProduceItemModule(int... inputPins){ + super(inputPins); } @Override - public void update(ModularCrafterBuild build){ - if(!fits(build, items)) return; - - float progress = build.getPin(progressPin); - progress += build.getPin(inputPin) * build.timeScale() * Time.delta; - build.setPin(inputPin, 0f); - - while(progress > time && fits(build, items)){ - for(ItemStack stack : items){ - build.items.add(stack.item, stack.amount); - } - progress -= time; - } - build.setPin(progressPin, progress); + public boolean canOutput(ModularCrafterBuild build){ + return Arrays.stream(items).allMatch(stack -> build.items.get(stack.item) + stack.amount <= build.block.itemCapacity); } - public static boolean fits(ModularCrafterBuild build, ItemStack[] itemStacks){ - return Arrays.stream(itemStacks).allMatch(stack -> build.items.get(stack.item) + stack.amount <= build.block.itemCapacity); + @Override + public void output(ModularCrafterBuild build){ + for(ItemStack stack : items){ + build.items.add(stack.item, stack.amount); + } } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java index 565bdd8..036f9bc 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java @@ -1,7 +1,6 @@ package meld.world.blocks.crafting.modules.rework; import arc.*; -import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.game.EventType.*; @@ -12,36 +11,18 @@ import java.util.*; -public class ProducePayloadModule extends CrafterModule{ +public class ProducePayloadModule extends ProduceDiscreteModule{ public PayloadStack[] payloads; - /// Pin to consume efficiency from. - public int inputPin; - /// Pin used to store crafting progress. - public int progressPin; - public float time = 60f; - public ProducePayloadModule(int inputPin, int progressPin){ - this.inputPin = inputPin; - this.progressPin = progressPin; + public ProducePayloadModule(int... inputPins){ + super(inputPins); } @Override public void update(ModularCrafterBuild build){ - if(outputFits(build)){ - float progress = build.getPin(progressPin); - progress += build.getPin(inputPin) * build.timeScale() * Time.delta; - build.setPin(inputPin, 0f); + super.update(build); - while(progress > time && outputFits(build)){ - for(PayloadStack stack : payloads){ - build.payloads.add(stack.item, stack.amount); - } - progress -= time; - } - build.setPin(progressPin, progress); - } - - //output + //dump payloads if(build.payload == null && build.payloads.any()){ for(PayloadStack stack : payloads){ if(build.payloads.contains(stack.item)){ @@ -50,9 +31,9 @@ public void update(ModularCrafterBuild build){ if(stack.item instanceof UnitType type){ build.payload = new UnitPayload(type.create(build.team)); Unit p = ((UnitPayload)build.payload).unit; - /*if(commandPos != null && p.isCommandable()){ - p.command().commandPosition(commandPos); - }*/ + /*if(commandPos != null && p.isCommandable()){ + p.command().commandPosition(commandPos); + }*/ Events.fire(new UnitCreateEvent(p, build)); }else if(stack.item instanceof Block block){ build.payload = new BuildPayload(block, build.team); @@ -64,22 +45,30 @@ public void update(ModularCrafterBuild build){ } } - if(build.payload != null && outputs(build.payload)){ + if(build.payload != null && shouldDump(build.payload)){ build.moveOutPayload(); } } - public boolean outputs(Payload pay){ + @Override + public boolean canOutput(ModularCrafterBuild build){ + return Arrays.stream(payloads).allMatch(stack -> build.payloads.get(stack.item) + stack.amount <= build.modular.payloadCapacity); + } + + @Override + public void output(ModularCrafterBuild build){ + for(PayloadStack stack : payloads){ + build.payloads.add(stack.item, stack.amount); + } + } + + public boolean shouldDump(Payload pay){ for(PayloadStack stack : payloads){ if(stack.item == pay.content()) return true; } return false; } - public boolean outputFits(ModularCrafterBuild build){ - return Arrays.stream(payloads).allMatch(stack -> build.payloads.get(stack.item) + stack.amount <= build.modular.payloadCapacity); - } - @Override public void setup(ModularCrafter block){ block.rotate = true; diff --git a/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java index 4fcb145..a310506 100644 --- a/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java @@ -5,25 +5,23 @@ import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; -public class StupidConsumeLiquidModule extends CrafterModule{ +public class StupidConsumeLiquidModule extends ConsumeModule{ public LiquidStack[] liquids; - /// Pin to provide efficiency on. - public int outputPin; public float baseEfficiency = 0; public float efficiencyIncrease = 1; - public StupidConsumeLiquidModule(int outputPin){ - this.outputPin = outputPin; + public StupidConsumeLiquidModule(int... outputPins){ + super(outputPins); } @Override public void update(ModularCrafterBuild build){ - float output = build.getPin(outputPin); + //Find the least consumed output, it signals inactivity + float current = getCurrent(build); //Get the amount of efficiency that was eaten - float consumed = (efficiencyIncrease - output - baseEfficiency) / (efficiencyIncrease - baseEfficiency); - - if(output < baseEfficiency) build.setPin(outputPin, baseEfficiency); + float consumed = (efficiencyIncrease - current - baseEfficiency) / (efficiencyIncrease - baseEfficiency); + float output = Math.max(baseEfficiency, current); //if efficiency has been used if(consumed > 0f){ @@ -36,9 +34,11 @@ public void update(ModularCrafterBuild build){ for(LiquidStack stack : liquids){ build.liquids.remove(stack.liquid, stack.amount * min); } - build.setPin(outputPin, baseEfficiency + efficiencyIncrease * min); + output = baseEfficiency + efficiencyIncrease * min; } } + + build.setPins(outputPins, output); } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java index 7e8dab9..f439342 100644 --- a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java @@ -8,42 +8,36 @@ public class StupidProduceLiquidModule extends CrafterModule{ public LiquidStack[] liquids; /// Pin to consume efficiency from. - public int inputPin; + public int[] inputPins; - public boolean dumpExtraLiquid = false; - - public StupidProduceLiquidModule(int inputPin){ - this.inputPin = inputPin; + public StupidProduceLiquidModule(int... inputPins){ + this.inputPins = inputPins; } - //Entirely GenericCrafter copy-paste, probably Sucks Ass. @Override public void update(ModularCrafterBuild build){ + float input = 1f; + for(int i : inputPins) input *= build.getPin(i); + + //After summing, subtract the final efficiency + for(int i : inputPins) build.setPin(i, build.getPin(i) - input); + //check full - boolean allFull = true; for(LiquidStack stack : liquids){ if(build.liquids.get(stack.liquid) >= build.block.liquidCapacity - 0.001f){ - if(!dumpExtraLiquid) return; - }else{ - //if there's still space left, it's not full for all liquids - allFull = false; + return; } } - //if there is no space left for any liquid, it can't produce - if(allFull) return; - //continuously output based on efficiency for(LiquidStack stack : liquids){ build.handleLiquid(build, stack.liquid, Math.min( - stack.amount * build.getPin(inputPin) * build.timeScale() * Time.delta, + stack.amount * input * build.timeScale() * Time.delta, build.block.liquidCapacity - build.liquids.get(stack.liquid) ) ); } - - build.setPin(inputPin, 0f); } @Override From 281d80028dff3435a4f993ddd61e15de9396b770 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Fri, 3 Apr 2026 15:43:00 +0200 Subject: [PATCH 13/16] consumption fixes --- src/meld/content/MeldBlocks.java | 36 +++++-------------- .../modules/rework/AttributeModule.java | 2 +- .../modules/rework/ConsumeDiscreteModule.java | 2 ++ .../modules/rework/ConsumeModule.java | 4 +-- .../modules/rework/ProduceDiscreteModule.java | 16 ++++----- .../modules/rework/ProduceModule.java | 23 ++++++++++++ .../rework/StupidProduceLiquidModule.java | 15 +++----- 7 files changed, 48 insertions(+), 50 deletions(-) create mode 100644 src/meld/world/blocks/crafting/modules/rework/ProduceModule.java diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index f2a1967..a781400 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -669,37 +669,20 @@ public static void load(){ size = 3; modules.addAll( - new ConsumeItemModule(1){{ - items = ItemStack.with(Items.copper, 2); - time = 60f; - - progressPin = -1; - }}, - new ProduceItemModule(1){{ + new ProduceItemModule(1, 2){{ items = ItemStack.with(Items.titanium, 2); - time = 60f; + time = 30f; - progressPin = -2; - }}, - /* - new StupidConsumeLiquidModule(2){{ TODO does not work properly - liquids = LiquidStack.with(Liquids.water, 1f); + progressPin = 0; }}, - new StupidProduceLiquidModule(5){{ - liquids = LiquidStack.with(Liquids.cryofluid, 1f); - }}, - */ - new ConsumePayloadModule(3){{ - payloads = PayloadStack.with(Blocks.plastaniumWallLarge, 1); - time = 180f; + new ConsumeItemModule(1){{ + items = ItemStack.with(Items.copper, 2); + time = 30f; - progressPin = -3; + progressPin = -1; }}, - new ProducePayloadModule(3){{ - payloads = PayloadStack.with(Blocks.plastaniumWall, 2); - time = 60f; - - progressPin = -4; + new EfficiencySourceModule(2){{ + baseEfficiency = 3f; }} ); }}; @@ -723,7 +706,6 @@ public void load(){ time = 60f; progressPin = 0; }}, - //TODO sand consumption does not scale. new ConsumeItemModule(1){{ items = ItemStack.with(Items.sand, 1); time = 20f; diff --git a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java index f88d444..cb4a4b2 100644 --- a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java @@ -23,7 +23,7 @@ public AttributeModule(int... outputPins){ @Override public void update(ModularCrafterBuild build){ - for(int o : outputPins) build.setPin(o, build.getPin(storagePin)); + for(int i : outputPins) build.setPin(i, Math.max(build.getPin(storagePin), build.getPin(i))); } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java index f903be3..5267596 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java @@ -26,6 +26,8 @@ public void update(ModularCrafterBuild build){ float consumed = (efficiencyIncrease - current - baseEfficiency) / (efficiencyIncrease - baseEfficiency); float output = Math.max(baseEfficiency, current); + build.setPin(outputPins[0] + 20, current); + //if efficiency has been used if(consumed > 0f && canConsume(build)){ float progress = build.getPin(progressPin); diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java index 7aeeedd..404ebf3 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java @@ -15,14 +15,14 @@ public ConsumeModule(int... outputPins){ public float getCurrent(ModularCrafterBuild build){ if(!dumpExtra){ //Find the least consumed output, it signals inactivity - float max = 0f; + float max = Float.NEGATIVE_INFINITY; for(int i : outputPins){ max = Math.max(max, build.getPin(i)); } return max; }else{ //If we don't care about a few full inputs, pick the minimum instead - float min = 0f; + float min = Float.POSITIVE_INFINITY; for(int i : outputPins){ min = Math.min(min, build.getPin(i)); } diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java index 09c4a80..6234de6 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java @@ -6,29 +6,25 @@ import java.util.*; -public abstract class ProduceDiscreteModule extends CrafterModule{ - /// Pins to consume efficiency from. - public int[] inputPins; +public abstract class ProduceDiscreteModule extends ProduceModule{ + /// Pin used to store crafting progress. public int progressPin; public float time = 60f; public ProduceDiscreteModule(int... inputPins){ - this.inputPins = inputPins; + super(inputPins); } @Override public void update(ModularCrafterBuild build){ if(!canOutput(build)) return; - float input = 1f; - for(int i : inputPins) input *= build.getPin(i); - - //After summing, subtract the final efficiency - for(int i : inputPins) build.setPin(i, build.getPin(i) - input); + //Sum efficiencies and timescale up + float input = takeEfficiency(build); float progress = build.getPin(progressPin); - progress += input * build.timeScale() * Time.delta; + progress += input * Time.delta; while(progress > time && canOutput(build)){ output(build); diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceModule.java new file mode 100644 index 0000000..4de9e23 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceModule.java @@ -0,0 +1,23 @@ +package meld.world.blocks.crafting.modules.rework; + +import meld.world.blocks.crafting.ModularCrafter.*; + +public abstract class ProduceModule extends CrafterModule{ + /// Pins to consume efficiency from. + public int[] inputPins; + + public ProduceModule(int... inputPins){ + this.inputPins = inputPins; + } + + public float takeEfficiency(ModularCrafterBuild build){ + //Sum efficiencies and timescale up + float input = build.timeScale(); + for(int i : inputPins) input *= build.getPin(i); + + //After summing, subtract the final efficiency + for(int i : inputPins) build.setPin(i, build.getPin(i) - input); + + return input; + } +} diff --git a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java index f439342..a2e04ee 100644 --- a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java @@ -5,23 +5,15 @@ import meld.world.blocks.crafting.ModularCrafter.*; import mindustry.type.*; -public class StupidProduceLiquidModule extends CrafterModule{ +public class StupidProduceLiquidModule extends ProduceModule{ public LiquidStack[] liquids; - /// Pin to consume efficiency from. - public int[] inputPins; public StupidProduceLiquidModule(int... inputPins){ - this.inputPins = inputPins; + super(inputPins); } @Override public void update(ModularCrafterBuild build){ - float input = 1f; - for(int i : inputPins) input *= build.getPin(i); - - //After summing, subtract the final efficiency - for(int i : inputPins) build.setPin(i, build.getPin(i) - input); - //check full for(LiquidStack stack : liquids){ if(build.liquids.get(stack.liquid) >= build.block.liquidCapacity - 0.001f){ @@ -29,6 +21,9 @@ public void update(ModularCrafterBuild build){ } } + //Sum efficiencies and timescale up + float input = takeEfficiency(build); + //continuously output based on efficiency for(LiquidStack stack : liquids){ build.handleLiquid(build, stack.liquid, From cafe8fc36d1f4588c6f1e4850875df92c04e2f91 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Fri, 3 Apr 2026 22:51:23 +0200 Subject: [PATCH 14/16] kill everything else in the project, also heat production --- src/meld/content/MeldBlocks.java | 44 +++++++++------- .../world/blocks/crafting/ModularCrafter.java | 50 ++++++++++++++----- .../crafting/modules/ConsumeLiquidModule.java | 41 --------------- .../crafting/modules/ProduceLiquidModule.java | 22 -------- .../modules/rework/ConsumeHighestModule.java | 1 + .../modules/rework/ConsumeItemModule.java | 1 + ...idModule.java => ConsumeLiquidModule.java} | 5 +- .../modules/rework/ConsumePayloadModule.java | 1 + .../modules/rework/ProduceHeatModule.java | 28 +++++++++++ .../modules/rework/ProduceItemModule.java | 11 +++- ...idModule.java => ProduceLiquidModule.java} | 13 +++-- .../modules/rework/ProducePayloadModule.java | 1 + .../{ => base}/ConsumeDiscreteModule.java | 4 +- .../rework/{ => base}/ConsumeModule.java | 2 +- .../{ => base}/ProduceDiscreteModule.java | 5 +- .../rework/{ => base}/ProduceModule.java | 2 +- 16 files changed, 122 insertions(+), 109 deletions(-) delete mode 100644 src/meld/world/blocks/crafting/modules/ConsumeLiquidModule.java delete mode 100644 src/meld/world/blocks/crafting/modules/ProduceLiquidModule.java rename src/meld/world/blocks/crafting/modules/rework/{StupidConsumeLiquidModule.java => ConsumeLiquidModule.java} (90%) create mode 100644 src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java rename src/meld/world/blocks/crafting/modules/rework/{StupidProduceLiquidModule.java => ProduceLiquidModule.java} (78%) rename src/meld/world/blocks/crafting/modules/rework/{ => base}/ConsumeDiscreteModule.java (93%) rename src/meld/world/blocks/crafting/modules/rework/{ => base}/ConsumeModule.java (94%) rename src/meld/world/blocks/crafting/modules/rework/{ => base}/ProduceDiscreteModule.java (90%) rename src/meld/world/blocks/crafting/modules/rework/{ => base}/ProduceModule.java (91%) diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index a781400..d4ff185 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -613,10 +613,10 @@ public static void load(){ }} );*/ - modules.addAll( + /*modules.addAll( new ProduceLiquidModule(new LiquidStack(MeldLiquids.pollutantMixture, 1), 0), new ProduceLiquidModule(new LiquidStack(MeldLiquids.fumes, 1), 1) - ); + );*/ }}; elementalBlaster = new BeamDrill("elemental-blaster"){{ @@ -669,20 +669,28 @@ public static void load(){ size = 3; modules.addAll( - new ProduceItemModule(1, 2){{ - items = ItemStack.with(Items.titanium, 2); - time = 30f; - - progressPin = 0; + new ProduceHeatModule(0){{ + heatOutput = 10; }}, - new ConsumeItemModule(1){{ - items = ItemStack.with(Items.copper, 2); - time = 30f; - - progressPin = -1; + new AttributeModule(0){{ + attribute = Attribute.heat; + baseEfficiency = 0f; + maxBoost = 2f; + storagePin = 1; + }}, + //This is assigned to the same pin as the attribute, and updates after, + //which means it will only "top off" the efficiency that the attributes don't reach. + new ConsumeItemModule(0){{ + items = ItemStack.with(Items.pyratite, 1); + efficiencyIncrease = 4f; + time = 20f; + progressPin = 2; }}, - new EfficiencySourceModule(2){{ - baseEfficiency = 3f; + //Same as above, but will also cover for the pyratite consumer. + new ConsumeItemModule(0){{ + items = ItemStack.with(Items.coal, 1); + time = 40f; + progressPin = 3; }} ); }}; @@ -765,7 +773,7 @@ public void load(){ ItemRecipe carbolith = new ItemRecipe(with(MeldItems.debris, 1), with(MeldItems.carbolith, 1)); - modules.addAll( + /*modules.addAll( new ProduceLiquidModule(new LiquidStack(MeldLiquids.fumes, 2f), 0), new GateModule(1, new GateModule.RecipeCondition(carbolith)), new ConsumeLiquidModule(LiquidStack.with(MeldLiquids.fumes, 1, MeldLiquids.aspect, outletRate * 2), 1, 2), @@ -775,7 +783,7 @@ public void load(){ craftTime = 12; recipe = carbolith; }} - ); + );*/ /* @@ -993,7 +1001,7 @@ public void load(){ float produceTime = 30; - modules.addAll( + /*modules.addAll( new GateModule( ModOUT.ZERO, new GateModule.RecipeCondition(aspectPipe1) ), @@ -1024,7 +1032,7 @@ public void load(){ progressPin = ModOUT.FIVE; craftTime = produceTime; }} - ); + );*/ }}; sharkFactory = new UnitFactory("shark-factory"){{ diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index 5aa1e8d..25ec54e 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -13,6 +13,7 @@ import mindustry.gen.Building; import mindustry.type.*; import mindustry.world.Block; +import mindustry.world.blocks.heat.*; import mindustry.world.blocks.payloads.*; import mindustry.world.blocks.production.GenericCrafter; import mindustry.world.blocks.units.UnitAssemblerModule.*; @@ -35,6 +36,9 @@ public class ModularCrafter extends PayloadBlock{ public Seq acceptedItems = new Seq<>(); public Seq acceptedPayloads = new Seq<>(); + public boolean consumesHeat = false; + public boolean producesHeat = false; + //Lists of stuff which gets dumped public Seq dumpedLiquids = new Seq<>(); public Seq dumpedItems = new Seq<>(); @@ -193,11 +197,13 @@ public static class ModIN{ public static final float ON = 1, OFF = 0; - public class ModularCrafterBuild extends PayloadBlockBuild{ + public class ModularCrafterBuild extends PayloadBlockBuild implements HeatConsumer, HeatBlock{ public ModularCrafter modular; public IntFloatMap data = new IntFloatMap(); public PayloadSeq payloads = new PayloadSeq(); + public float heat = 0f; + @Override public void draw(){ super.draw(); @@ -234,17 +240,6 @@ public void created() { data.putAll(defaultData); } - @Override - public void updateTile() { - super.updateTile(); - this.dumpOutputs(); - } - - public void dumpOutputs(){ - dumpedLiquids.each(this::dumpLiquid); - dumpedItems.each(this::dump); - } - public void setPin(int pin, float value){ data.put(pin, value); } @@ -290,9 +285,30 @@ public void update() { modules.each(c -> c.update(this)); } + @Override + public float heat(){ //the useful one + return heat; + } + + @Override + public float heatFrac(){ //only used by DrawHeatOutput + return 0; + } + + @Override + public float[] sideHeat(){ //only used by DrawHeatInput + return new float[0]; + } + + @Override + public float heatRequirement(){ //only used by DrawHeatInput and DrawHeatRegion + return 0; + } + @Override public void write(Writes write) { super.write(write); + write.i(data.size); int[] keys = data.keys().toArray().toArray(); @@ -300,16 +316,26 @@ public void write(Writes write) { write.i(i); write.f(data.get(i)); } + + write.f(heat); } @Override public void read(Reads read, byte revision) { super.read(read, revision); + data = new IntFloatMap(); int len = read.i(); for (int i = 0; i < len; i++){ data.put(read.i(), read.f()); } + + if(revision >= 1) heat = read.f(); + } + + @Override + public byte version(){ + return 1; } } } diff --git a/src/meld/world/blocks/crafting/modules/ConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/ConsumeLiquidModule.java deleted file mode 100644 index cc4df34..0000000 --- a/src/meld/world/blocks/crafting/modules/ConsumeLiquidModule.java +++ /dev/null @@ -1,41 +0,0 @@ -package meld.world.blocks.crafting.modules; - -import meld.world.blocks.crafting.ModularCrafter; -import mindustry.type.LiquidStack; - -public class ConsumeLiquidModule extends ModularCrafter.CrafterModule { - - public ConsumeLiquidModule(LiquidStack[] consumed, int efficiencyPin, int outputEfficiencyPin){ - this.consumed = consumed; - this.efficiencyPin = efficiencyPin; - this.outputEfficiencyPin = outputEfficiencyPin; - } - - public int efficiencyPin; - public int outputEfficiencyPin; - public LiquidStack[] consumed; - - @Override - public void update(ModularCrafter.ModularCrafterBuild build) { - float efficiency = build.getPin(efficiencyPin); - if(efficiency == 0) return; - - float maxEfficiency = 1; - - for(LiquidStack stack: consumed){ - float target = build.liquids.get(stack.liquid); - float consumeAmount = stack.amount * efficiency; - - maxEfficiency = Math.min(maxEfficiency, target/consumeAmount); - } - - efficiency *= maxEfficiency; - - for (LiquidStack stack: consumed){ - float removed = efficiency * stack.amount; - build.liquids.remove(stack.liquid, removed); - } - - build.setPin(outputEfficiencyPin, efficiency); - } -} diff --git a/src/meld/world/blocks/crafting/modules/ProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/ProduceLiquidModule.java deleted file mode 100644 index 590998e..0000000 --- a/src/meld/world/blocks/crafting/modules/ProduceLiquidModule.java +++ /dev/null @@ -1,22 +0,0 @@ -package meld.world.blocks.crafting.modules; - -import arc.math.Mathf; -import meld.world.blocks.crafting.ModularCrafter; -import mindustry.type.LiquidStack; - -public class ProduceLiquidModule extends ModularCrafter.CrafterModule { - public LiquidStack liquid; - public int efficiencyPin; - - public ProduceLiquidModule(LiquidStack liquid, int efficiencyPin){ - this.liquid = liquid; - this.efficiencyPin = efficiencyPin; - } - - @Override - public void update(ModularCrafter.ModularCrafterBuild build) { - float efficiency = build.getPin(efficiencyPin); - float addedAmount = Math.min(liquid.amount * efficiency, Mathf.maxZero(build.block.liquidCapacity - build.liquids.get(liquid.liquid))); - build.liquids.add(liquid.liquid, addedAmount); - } -} diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java index 06ec172..3690bd8 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeHighestModule.java @@ -1,6 +1,7 @@ package meld.world.blocks.crafting.modules.rework; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; /// Will only consume from the pin with the highest efficiency. public class ConsumeHighestModule extends ConsumeModule{ diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java index 608fbf3..bd8713a 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeItemModule.java @@ -2,6 +2,7 @@ import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.type.*; public class ConsumeItemModule extends ConsumeDiscreteModule{ diff --git a/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeLiquidModule.java similarity index 90% rename from src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java rename to src/meld/world/blocks/crafting/modules/rework/ConsumeLiquidModule.java index a310506..c799091 100644 --- a/src/meld/world/blocks/crafting/modules/rework/StupidConsumeLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeLiquidModule.java @@ -3,15 +3,16 @@ import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.type.*; -public class StupidConsumeLiquidModule extends ConsumeModule{ +public class ConsumeLiquidModule extends ConsumeModule{ public LiquidStack[] liquids; public float baseEfficiency = 0; public float efficiencyIncrease = 1; - public StupidConsumeLiquidModule(int... outputPins){ + public ConsumeLiquidModule(int... outputPins){ super(outputPins); } diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java index eab1869..37ecab7 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumePayloadModule.java @@ -2,6 +2,7 @@ import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.type.*; import mindustry.world.blocks.payloads.*; diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java new file mode 100644 index 0000000..8bee6f2 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java @@ -0,0 +1,28 @@ +package meld.world.blocks.crafting.modules.rework; + +import arc.math.*; +import arc.util.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; + +public class ProduceHeatModule extends ProduceModule{ + public float heatOutput = 10f; + public float warmupRate = 0.15f; + + public ProduceHeatModule(int... inputPins){ + super(inputPins); + } + + @Override + public void update(ModularCrafterBuild build){ + float input = takeEfficiency(build); + + build.heat = Mathf.approachDelta(build.heat, heatOutput * input, warmupRate * Time.delta); + } + + @Override + public void setup(ModularCrafter block){ + block.rotate = true; + } +} diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java index 478b7df..c0d6b2e 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceItemModule.java @@ -1,8 +1,8 @@ package meld.world.blocks.crafting.modules.rework; -import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.type.*; import java.util.*; @@ -13,6 +13,15 @@ public ProduceItemModule(int... inputPins){ super(inputPins); } + @Override + public void update(ModularCrafterBuild build){ + super.update(build); + + for(ItemStack stack : items){ + build.dump(stack.item); + } + } + @Override public boolean canOutput(ModularCrafterBuild build){ return Arrays.stream(items).allMatch(stack -> build.items.get(stack.item) + stack.amount <= build.block.itemCapacity); diff --git a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java similarity index 78% rename from src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java rename to src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java index a2e04ee..970f438 100644 --- a/src/meld/world/blocks/crafting/modules/rework/StupidProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java @@ -3,23 +3,28 @@ import arc.util.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.type.*; -public class StupidProduceLiquidModule extends ProduceModule{ +public class ProduceLiquidModule extends ProduceModule{ public LiquidStack[] liquids; - public StupidProduceLiquidModule(int... inputPins){ + public ProduceLiquidModule(int... inputPins){ super(inputPins); } @Override public void update(ModularCrafterBuild build){ - //check full + //dump/check full + boolean full = false; for(LiquidStack stack : liquids){ + build.dumpLiquid(stack.liquid); + if(build.liquids.get(stack.liquid) >= build.block.liquidCapacity - 0.001f){ - return; + full = true; } } + if(full) return; //Sum efficiencies and timescale up float input = takeEfficiency(build); diff --git a/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java index 036f9bc..6ce1c90 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProducePayloadModule.java @@ -3,6 +3,7 @@ import arc.*; import meld.world.blocks.crafting.*; import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; import mindustry.game.EventType.*; import mindustry.gen.*; import mindustry.type.*; diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/base/ConsumeDiscreteModule.java similarity index 93% rename from src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java rename to src/meld/world/blocks/crafting/modules/rework/base/ConsumeDiscreteModule.java index 5267596..f78f10e 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeDiscreteModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/base/ConsumeDiscreteModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules.rework; +package meld.world.blocks.crafting.modules.rework.base; import arc.util.*; import meld.world.blocks.crafting.ModularCrafter.*; @@ -26,8 +26,6 @@ public void update(ModularCrafterBuild build){ float consumed = (efficiencyIncrease - current - baseEfficiency) / (efficiencyIncrease - baseEfficiency); float output = Math.max(baseEfficiency, current); - build.setPin(outputPins[0] + 20, current); - //if efficiency has been used if(consumed > 0f && canConsume(build)){ float progress = build.getPin(progressPin); diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java b/src/meld/world/blocks/crafting/modules/rework/base/ConsumeModule.java similarity index 94% rename from src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java rename to src/meld/world/blocks/crafting/modules/rework/base/ConsumeModule.java index 404ebf3..07f00b8 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ConsumeModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/base/ConsumeModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules.rework; +package meld.world.blocks.crafting.modules.rework.base; import meld.world.blocks.crafting.ModularCrafter.*; diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java similarity index 90% rename from src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java rename to src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java index 6234de6..d0fc288 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceDiscreteModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java @@ -1,10 +1,7 @@ -package meld.world.blocks.crafting.modules.rework; +package meld.world.blocks.crafting.modules.rework.base; import arc.util.*; import meld.world.blocks.crafting.ModularCrafter.*; -import mindustry.type.*; - -import java.util.*; public abstract class ProduceDiscreteModule extends ProduceModule{ diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceModule.java b/src/meld/world/blocks/crafting/modules/rework/base/ProduceModule.java similarity index 91% rename from src/meld/world/blocks/crafting/modules/rework/ProduceModule.java rename to src/meld/world/blocks/crafting/modules/rework/base/ProduceModule.java index 4de9e23..428a3d7 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/base/ProduceModule.java @@ -1,4 +1,4 @@ -package meld.world.blocks.crafting.modules.rework; +package meld.world.blocks.crafting.modules.rework.base; import meld.world.blocks.crafting.ModularCrafter.*; From e99414e778fa909c628845a7e675c3ca4fc43052 Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Sat, 4 Apr 2026 09:58:18 +0200 Subject: [PATCH 15/16] heat consumption --- src/meld/content/MeldBlocks.java | 1 + .../world/blocks/crafting/ModularCrafter.java | 15 ++++++---- .../modules/rework/AttributeModule.java | 10 +++---- .../modules/rework/ConsumeHeatModule.java | 30 +++++++++++++++++++ 4 files changed, 46 insertions(+), 10 deletions(-) create mode 100644 src/meld/world/blocks/crafting/modules/rework/ConsumeHeatModule.java diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index d4ff185..4747fe1 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -719,6 +719,7 @@ public void load(){ time = 20f; progressPin = -1; }}, + new ConsumeHeatModule(2), new AttributeModule(2){{ attribute = Attribute.heat; baseEfficiency = 0f; diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index 25ec54e..bc1d741 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -202,6 +202,7 @@ public class ModularCrafterBuild extends PayloadBlockBuild implements H public IntFloatMap data = new IntFloatMap(); public PayloadSeq payloads = new PayloadSeq(); + public float[] sideHeat = new float[4]; public float heat = 0f; @Override @@ -285,23 +286,27 @@ public void update() { modules.each(c -> c.update(this)); } + //the useful one @Override - public float heat(){ //the useful one + public float heat(){ return heat; } + //only used by DrawHeatOutput @Override - public float heatFrac(){ //only used by DrawHeatOutput + public float heatFrac(){ return 0; } + //only used by DrawHeatInput @Override - public float[] sideHeat(){ //only used by DrawHeatInput - return new float[0]; + public float[] sideHeat(){ + return sideHeat; } + //only used by DrawHeatInput and DrawHeatRegion @Override - public float heatRequirement(){ //only used by DrawHeatInput and DrawHeatRegion + public float heatRequirement(){ return 0; } diff --git a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java index cb4a4b2..dd8bc08 100644 --- a/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/AttributeModule.java @@ -26,11 +26,6 @@ public void update(ModularCrafterBuild build){ for(int i : outputPins) build.setPin(i, Math.max(build.getPin(storagePin), build.getPin(i))); } - @Override - public void setup(ModularCrafter block){ - block.hook(BlockEvent.Defaults.proximityUpdate, this); - } - @Override public void on_event(ModularCrafterBuild build){ float efficiency = baseEfficiency + Math.min(maxBoost, boostScale * build.block.sumAttribute(attribute, build.tileX(), build.tileY()) + attribute.env()); @@ -42,4 +37,9 @@ public void on_event(ModularCrafterBuild build){ build.setPin(storagePin, efficiency); } + + @Override + public void setup(ModularCrafter block){ + block.hook(BlockEvent.Defaults.proximityUpdate, this); + } } \ No newline at end of file diff --git a/src/meld/world/blocks/crafting/modules/rework/ConsumeHeatModule.java b/src/meld/world/blocks/crafting/modules/rework/ConsumeHeatModule.java new file mode 100644 index 0000000..6ecdde7 --- /dev/null +++ b/src/meld/world/blocks/crafting/modules/rework/ConsumeHeatModule.java @@ -0,0 +1,30 @@ +package meld.world.blocks.crafting.modules.rework; + +import arc.math.*; +import meld.world.blocks.crafting.*; +import meld.world.blocks.crafting.ModularCrafter.*; +import meld.world.blocks.crafting.modules.rework.base.*; + +public class ConsumeHeatModule extends ConsumeModule{ + public float baseEfficiency = 0f; + /// Base heat requirement for 100% efficiency. + public float heatRequirement = 10f; + /// After heat meets this requirement, excess heat will be scaled by this number. + public float overheatScale = 1f; + /// Maximum possible efficiency after overheat. + public float maxEfficiency = 4f; + + public ConsumeHeatModule(int... outputPins){ + super(outputPins); + } + + @Override + public void update(ModularCrafterBuild build){ + build.heat = build.calculateHeat(build.sideHeat); + + float over = Math.max(build.heat - heatRequirement, 0f); + float scaled = Math.min(Mathf.clamp(build.heat / heatRequirement) + over / heatRequirement * overheatScale, maxEfficiency); + + for(int i : outputPins) build.setPin(i, Math.max(baseEfficiency + scaled, build.getPin(i))); + } +} From 166a3f41c589e3dbad3a37b8fff82601b4db108c Mon Sep 17 00:00:00 2001 From: stacktrace-error Date: Sat, 4 Apr 2026 12:44:41 +0200 Subject: [PATCH 16/16] support vanilla drawers --- src/meld/content/MeldBlocks.java | 11 ++++ .../world/blocks/crafting/ModularCrafter.java | 50 ++++++++++++------- .../modules/rework/ProduceHeatModule.java | 5 +- .../modules/rework/ProduceLiquidModule.java | 4 +- .../rework/base/ProduceDiscreteModule.java | 1 + 5 files changed, 49 insertions(+), 22 deletions(-) diff --git a/src/meld/content/MeldBlocks.java b/src/meld/content/MeldBlocks.java index 4747fe1..eb437ff 100644 --- a/src/meld/content/MeldBlocks.java +++ b/src/meld/content/MeldBlocks.java @@ -696,18 +696,29 @@ public static void load(){ }}; new ModularCrafter("stupid-silicon-smelter"){ + //I refuse to add sprites to the files. @Override public void load(){ super.load(); region = Core.atlas.find("silicon-smelter"); fullIcon = Core.atlas.find("silicon-smelter"); uiIcon = Core.atlas.find("silicon-smelter"); + if(drawer instanceof DrawMulti m && m.drawers[1] instanceof DrawHeatInput f) f.heat = Core.atlas.find("phase-heater-heat"); + if(drawer instanceof DrawMulti m && m.drawers[2] instanceof DrawRegion r) r.region = Core.atlas.find("pneumatic-drill-rotator"); + if(drawer instanceof DrawMulti m && m.drawers[3] instanceof DrawFlame f) f.top = Core.atlas.find("silicon-smelter-top"); } { requirements(Category.crafting, with(MeldItems.debris, 40)); size = 2; + drawer = new DrawMulti( + new DrawDefault(), + new DrawHeatInput(), + new DrawRegion("", 3f, true), + new DrawFlame(Color.valueOf("ffef99")) + ); + modules.addAll( new ProduceItemModule( 1, 2){{ items = ItemStack.with(Items.silicon, 1); diff --git a/src/meld/world/blocks/crafting/ModularCrafter.java b/src/meld/world/blocks/crafting/ModularCrafter.java index bc1d741..cb7e48b 100644 --- a/src/meld/world/blocks/crafting/ModularCrafter.java +++ b/src/meld/world/blocks/crafting/ModularCrafter.java @@ -1,10 +1,7 @@ package meld.world.blocks.crafting; -import arc.math.*; -import arc.math.geom.*; import arc.scene.ui.layout.*; import arc.struct.*; -import arc.struct.IntFloatMap.*; import arc.util.*; import arc.util.io.Reads; import arc.util.io.Writes; @@ -15,17 +12,10 @@ import mindustry.world.Block; import mindustry.world.blocks.heat.*; import mindustry.world.blocks.payloads.*; -import mindustry.world.blocks.production.GenericCrafter; -import mindustry.world.blocks.units.UnitAssemblerModule.*; +import mindustry.world.draw.*; import mindustry.world.meta.*; -import java.util.*; - -import static mindustry.Vars.*; -import static mindustry.Vars.tilesize; - public class ModularCrafter extends PayloadBlock{ - //Modules updates every update, listeners are for modules with specific events public Seq modules = new Seq<>(); public ObjectMap> listeners = new ObjectMap<>(); @@ -36,9 +26,6 @@ public class ModularCrafter extends PayloadBlock{ public Seq acceptedItems = new Seq<>(); public Seq acceptedPayloads = new Seq<>(); - public boolean consumesHeat = false; - public boolean producesHeat = false; - //Lists of stuff which gets dumped public Seq dumpedLiquids = new Seq<>(); public Seq dumpedItems = new Seq<>(); @@ -47,11 +34,16 @@ public class ModularCrafter extends PayloadBlock{ public boolean replaceBars = true; public int payloadCapacity = 3; + /// Used to show heat as a percentage. Does not affect function. + public float fullHeat = 10f; + /// Default float data array public IntFloatMap defaultData = new IntFloatMap(); /// When true, shows a table with the data map in the block's display. public boolean debugTable = true; + public DrawBlock drawer = new DrawDefault(); + public ModularCrafter(String name) { super(name); @@ -82,6 +74,12 @@ public void init(){ modules.each(m -> m.setup(this)); } + @Override + public void load(){ + super.load(); + drawer.load(this); + } + public static void trigger(ModularCrafter block, ModularCrafterBuild build, Object event){ Seq events = block.listeners.get(event); if(events != null) events.each(c -> c.on_event(build)); @@ -205,9 +203,13 @@ public class ModularCrafterBuild extends PayloadBlockBuild implements H public float[] sideHeat = new float[4]; public float heat = 0f; + public float totalProgress = 0f; + public float visualEfficiency = 0f; + + @Override public void draw(){ - super.draw(); + drawer.draw(this); drawPayload(); } @@ -283,7 +285,11 @@ public void onProximityUpdate() { @Override public void update() { super.update(); + visualEfficiency = 0f; + modules.each(c -> c.update(this)); + + totalProgress += visualEfficiency * Time.delta; } //the useful one @@ -295,7 +301,7 @@ public float heat(){ //only used by DrawHeatOutput @Override public float heatFrac(){ - return 0; + return heat / fullHeat; } //only used by DrawHeatInput @@ -307,7 +313,17 @@ public float[] sideHeat(){ //only used by DrawHeatInput and DrawHeatRegion @Override public float heatRequirement(){ - return 0; + return fullHeat; + } + + @Override + public float warmup(){ + return visualEfficiency; + } + + @Override + public float totalProgress(){ + return totalProgress; } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java index 8bee6f2..936b884 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceHeatModule.java @@ -19,10 +19,7 @@ public void update(ModularCrafterBuild build){ float input = takeEfficiency(build); build.heat = Mathf.approachDelta(build.heat, heatOutput * input, warmupRate * Time.delta); - } - @Override - public void setup(ModularCrafter block){ - block.rotate = true; + build.visualEfficiency = Math.max(input, build.visualEfficiency); } } diff --git a/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java b/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java index 970f438..bd82e2e 100644 --- a/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/ProduceLiquidModule.java @@ -33,11 +33,13 @@ public void update(ModularCrafterBuild build){ for(LiquidStack stack : liquids){ build.handleLiquid(build, stack.liquid, Math.min( - stack.amount * input * build.timeScale() * Time.delta, + stack.amount * input * Time.delta, build.block.liquidCapacity - build.liquids.get(stack.liquid) ) ); } + + build.visualEfficiency = Math.max(input, build.visualEfficiency); } @Override diff --git a/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java b/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java index d0fc288..d0b2213 100644 --- a/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java +++ b/src/meld/world/blocks/crafting/modules/rework/base/ProduceDiscreteModule.java @@ -29,6 +29,7 @@ public void update(ModularCrafterBuild build){ } build.setPin(progressPin, progress); + build.visualEfficiency = Math.max(input, build.visualEfficiency); } public abstract boolean canOutput(ModularCrafterBuild build);