diff --git a/CHANGELOG.md b/CHANGELOG.md index d3f9b6c..58fe4b8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,8 @@ All notable changes to this project will be documented in this file. ## Unreleased -- / +- requester crafting plans run on AE2's calculator thread without parking the server tick. Pattern provider updates and the end-of-tick craftable-pattern refresh wait until those plans are paused, so they do not read or write the pattern map on the same tick. +- failed crafting plans wait before they are calculated again, and only a few plans are calculated at once. ## [1.5.0] - 2026-09-01 diff --git a/src/main/java/com/almostreliable/merequester/core/Config.java b/src/main/java/com/almostreliable/merequester/core/Config.java index a8bd8ce..4cb975b 100644 --- a/src/main/java/com/almostreliable/merequester/core/Config.java +++ b/src/main/java/com/almostreliable/merequester/core/Config.java @@ -28,6 +28,8 @@ public static final class CommonConfig { public final ModConfigSpec.IntValue requests; public final ModConfigSpec.DoubleValue idleEnergy; public final ModConfigSpec.BooleanValue requireChannel; + public final ModConfigSpec.IntValue craftingRetryTicks; + public final ModConfigSpec.IntValue maxConcurrentPlans; private CommonConfig(ModConfigSpec.Builder builder) { builder.push(MERequester.REQUESTER_ID); @@ -38,6 +40,16 @@ private CommonConfig(ModConfigSpec.Builder builder) { requireChannel = builder .comment("Whether the ME Requester requires an ME network channel to function.") .define("require_channel", true); + craftingRetryTicks = builder + .comment( + "How many ticks a request waits after a crafting plan fails before it is planned again. Applies when ingredients are missing or no crafting CPU can take the job. Lower values restock sooner and start more AE2 crafting calculations." + ) + .defineInRange("crafting_retry_ticks", 100, 1, 12000); + maxConcurrentPlans = builder + .comment( + "How many ME Requester crafting plans may be calculated at the same time on one level. Plans run off the server thread. Higher values restock more requests in parallel and use more CPU." + ) + .defineInRange("max_concurrent_plans", 4, 1, 64); builder.pop(); } } diff --git a/src/main/java/com/almostreliable/merequester/mixin/CraftingCalculationMixin.java b/src/main/java/com/almostreliable/merequester/mixin/CraftingCalculationMixin.java new file mode 100644 index 0000000..16c10ba --- /dev/null +++ b/src/main/java/com/almostreliable/merequester/mixin/CraftingCalculationMixin.java @@ -0,0 +1,111 @@ +package com.almostreliable.merequester.mixin; + +import com.almostreliable.merequester.requester.DeferredCraftingProviderUpdates; +import com.almostreliable.merequester.requester.RequesterBlockEntity; +import com.almostreliable.merequester.requester.RequesterPlanActivity; + +import com.google.common.base.Stopwatch; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import appeng.api.networking.crafting.ICraftingSimulationRequester; +import appeng.crafting.CraftingCalculation; + +/** + * AE2 runs a crafting plan on the calculator thread, then {@code simulateFor} parks the server + * thread until the plan yields. Requester plans skip that wait. The plan still pauses itself + * when its time budget is spent, and the next level tick wakes it. + */ +@Mixin(value = CraftingCalculation.class, remap = false) +public class CraftingCalculationMixin { + + @Shadow + private ICraftingSimulationRequester simRequester; + + @Shadow + private Object monitor; + + @Shadow + private Stopwatch watch; + + @Shadow + private boolean running; + + @Shadow + private boolean done; + + @Shadow + private int time; + + @Unique + private boolean merequester$awake; + + @Inject(method = "simulateFor", at = @At("HEAD"), cancellable = true, remap = false) + private void merequester$simulateOffServerThread(int micros, CallbackInfoReturnable cir) { + if (!merequester$isRequesterPlan()) return; + + // Plans are still paused here. Apply queued pattern updates before this tick wakes them. + DeferredCraftingProviderUpdates.flush(); + + synchronized (this.monitor) { + if (this.done) { + merequester$markAsleep(); + cir.setReturnValue(false); + return; + } + + // A running plan already has a budget. Refreshing it here would keep the worker awake across ticks. + if (!this.running) { + this.time = micros; + if (this.watch.isRunning()) this.watch.stop(); + this.watch.reset(); + this.watch.start(); + this.running = true; + merequester$markAwake(); + this.monitor.notifyAll(); + } + } + + cir.setReturnValue(true); + } + + @Inject( + method = {"handlePausing", "finish"}, + at = @At( + value = "FIELD", + target = "Lappeng/crafting/CraftingCalculation;running:Z", + opcode = org.objectweb.asm.Opcodes.PUTFIELD + ), + remap = false + ) + private void merequester$onPlanPaused(CallbackInfo ci) { + merequester$markAsleep(); + } + + @Unique + private void merequester$markAwake() { + if (this.merequester$awake || !merequester$isRequesterPlan()) return; + this.merequester$awake = true; + RequesterPlanActivity.enter(); + } + + @Unique + private void merequester$markAsleep() { + if (!this.merequester$awake) return; + this.merequester$awake = false; + RequesterPlanActivity.exit(); + } + + @Unique + private boolean merequester$isRequesterPlan() { + if (this.simRequester == null) return false; + var source = this.simRequester.getActionSource(); + return source != null && source.machine().orElse(null) instanceof RequesterBlockEntity; + } +} diff --git a/src/main/java/com/almostreliable/merequester/mixin/CraftingServiceMixin.java b/src/main/java/com/almostreliable/merequester/mixin/CraftingServiceMixin.java new file mode 100644 index 0000000..3962d47 --- /dev/null +++ b/src/main/java/com/almostreliable/merequester/mixin/CraftingServiceMixin.java @@ -0,0 +1,150 @@ +package com.almostreliable.merequester.mixin; + +import com.almostreliable.merequester.requester.DeferredCraftingProviderUpdates; +import com.almostreliable.merequester.requester.RequesterPlanActivity; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.Redirect; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.ICraftingProvider; +import appeng.me.service.CraftingService; +import appeng.me.service.helpers.NetworkCraftingProviders; + +/** + * Requester plans read the pattern maps off the server thread. Provider updates and the end-of-tick + * craftable-key copy wait until every requester plan is paused, then run on the server thread. + */ +@Mixin(value = CraftingService.class, remap = false) +public class CraftingServiceMixin { + + @Shadow + private NetworkCraftingProviders craftingProviders; + + /** + * Set when {@code addNode} must keep its remove-and-add pair together. + * Splitting them across an awake check can unmount a provider that was just mounted. + */ + @Unique + private IGridNode merequester$deferredAddNode; + + @Inject(method = "onServerEndTick", at = @At("HEAD"), remap = false) + private void merequester$flushProviderUpdates(CallbackInfo ci) { + DeferredCraftingProviderUpdates.flush(); + } + + @Inject( + method = "onServerEndTick", + at = @At( + value = "INVOKE", + target = "Lappeng/me/service/helpers/NetworkCraftingProviders;getLastModifiedOnTick()J" + ), + cancellable = true, + remap = false + ) + private void merequester$deferCraftableCopy(CallbackInfo ci) { + if (RequesterPlanActivity.isAwake()) { + ci.cancel(); + } + } + + @Inject(method = "refreshNodeCraftingProvider", at = @At("HEAD"), cancellable = true, remap = false) + private void merequester$deferNodeRefresh(IGridNode node, CallbackInfo ci) { + if (!RequesterPlanActivity.isAwake()) return; + + var providers = this.craftingProviders; + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> { + providers.removeProvider(node); + providers.addProvider(node); + }); + ci.cancel(); + } + + @Inject(method = "refreshGlobalCraftingProvider", at = @At("HEAD"), cancellable = true, remap = false) + private void merequester$deferGlobalRefresh(ICraftingProvider provider, CallbackInfo ci) { + if (!RequesterPlanActivity.isAwake()) return; + + var providers = this.craftingProviders; + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> { + providers.removeProvider(provider); + providers.addProvider(provider); + }); + ci.cancel(); + } + + @Inject(method = "addGlobalCraftingProvider", at = @At("HEAD"), cancellable = true, remap = false) + private void merequester$deferGlobalAdd(ICraftingProvider provider, CallbackInfo ci) { + if (!RequesterPlanActivity.isAwake()) return; + + var providers = this.craftingProviders; + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> providers.addProvider(provider)); + ci.cancel(); + } + + @Inject(method = "removeGlobalCraftingProvider", at = @At("HEAD"), cancellable = true, remap = false) + private void merequester$deferGlobalRemove(ICraftingProvider provider, CallbackInfo ci) { + if (!RequesterPlanActivity.isAwake()) return; + + var providers = this.craftingProviders; + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> providers.removeProvider(provider)); + ci.cancel(); + } + + @Redirect( + method = "addNode", + at = @At( + value = "INVOKE", + target = "Lappeng/me/service/helpers/NetworkCraftingProviders;removeProvider(Lappeng/api/networking/IGridNode;)V" + ), + remap = false + ) + private void merequester$addNodeRemove(NetworkCraftingProviders providers, IGridNode node) { + if (!RequesterPlanActivity.isAwake()) { + providers.removeProvider(node); + return; + } + this.merequester$deferredAddNode = node; + } + + @Redirect( + method = "addNode", + at = @At( + value = "INVOKE", + target = "Lappeng/me/service/helpers/NetworkCraftingProviders;addProvider(Lappeng/api/networking/IGridNode;)V" + ), + remap = false + ) + private void merequester$addNodeAdd(NetworkCraftingProviders providers, IGridNode node) { + if (this.merequester$deferredAddNode != node) { + providers.addProvider(node); + return; + } + + this.merequester$deferredAddNode = null; + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> { + providers.removeProvider(node); + providers.addProvider(node); + }); + } + + @Redirect( + method = "removeNode", + at = @At( + value = "INVOKE", + target = "Lappeng/me/service/helpers/NetworkCraftingProviders;removeProvider(Lappeng/api/networking/IGridNode;)V" + ), + remap = false + ) + private void merequester$removeNodeProvider(NetworkCraftingProviders providers, IGridNode node) { + if (!RequesterPlanActivity.isAwake()) { + providers.removeProvider(node); + return; + } + DeferredCraftingProviderUpdates.defer((CraftingService) (Object) this, () -> providers.removeProvider(node)); + } +} diff --git a/src/main/java/com/almostreliable/merequester/requester/CraftingPlanBudget.java b/src/main/java/com/almostreliable/merequester/requester/CraftingPlanBudget.java new file mode 100644 index 0000000..d372522 --- /dev/null +++ b/src/main/java/com/almostreliable/merequester/requester/CraftingPlanBudget.java @@ -0,0 +1,49 @@ +package com.almostreliable.merequester.requester; + +import com.almostreliable.merequester.core.Config; + +import net.minecraft.world.level.Level; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.WeakHashMap; +import java.util.concurrent.Future; + +/** + * Caps how many requester crafting plans are calculating on one level. + * Finished and cancelled plans are dropped the next time the cap is checked, + * so a plan that outlives its block entity cannot hold a slot forever. + */ +public final class CraftingPlanBudget { + + private static final Object LOCK = new Object(); + private static final Map>> IN_FLIGHT = new WeakHashMap<>(); + + private CraftingPlanBudget() {} + + public static boolean hasRoom(Level level) { + synchronized (LOCK) { + return inFlight(level) < Config.COMMON.maxConcurrentPlans.get(); + } + } + + public static void track(Level level, Future plan) { + synchronized (LOCK) { + var plans = IN_FLIGHT.computeIfAbsent(level, ignored -> new ArrayList<>()); + plans.removeIf(Future::isDone); + plans.add(plan); + } + } + + private static int inFlight(Level level) { + var plans = IN_FLIGHT.get(level); + if (plans == null) return 0; + plans.removeIf(Future::isDone); + if (plans.isEmpty()) { + IN_FLIGHT.remove(level); + return 0; + } + return plans.size(); + } +} diff --git a/src/main/java/com/almostreliable/merequester/requester/DeferredCraftingProviderUpdates.java b/src/main/java/com/almostreliable/merequester/requester/DeferredCraftingProviderUpdates.java new file mode 100644 index 0000000..3014a43 --- /dev/null +++ b/src/main/java/com/almostreliable/merequester/requester/DeferredCraftingProviderUpdates.java @@ -0,0 +1,42 @@ +package com.almostreliable.merequester.requester; + +import java.util.ArrayList; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Map; + +import appeng.me.service.CraftingService; + +/** + * Pattern-provider updates mutate the same maps a requester plan reads on the calculator thread. + * Those updates are queued while a plan is awake and applied on the server thread once every plan is paused. + */ +public final class DeferredCraftingProviderUpdates { + + private static final Map> QUEUES = new IdentityHashMap<>(); + private static boolean flushing; + + private DeferredCraftingProviderUpdates() {} + + public static void defer(CraftingService service, Runnable update) { + QUEUES.computeIfAbsent(service, key -> new ArrayList<>()).add(update); + } + + public static void flush() { + if (flushing || RequesterPlanActivity.isAwake() || QUEUES.isEmpty()) return; + + flushing = true; + try { + while (!QUEUES.isEmpty() && !RequesterPlanActivity.isAwake()) { + var entry = QUEUES.entrySet().iterator().next(); + var updates = entry.getValue(); + QUEUES.remove(entry.getKey()); + for (var update : updates) { + update.run(); + } + } + } finally { + flushing = false; + } + } +} diff --git a/src/main/java/com/almostreliable/merequester/requester/RequesterBlockEntity.java b/src/main/java/com/almostreliable/merequester/requester/RequesterBlockEntity.java index 698a0ae..381fb1f 100644 --- a/src/main/java/com/almostreliable/merequester/requester/RequesterBlockEntity.java +++ b/src/main/java/com/almostreliable/merequester/requester/RequesterBlockEntity.java @@ -139,8 +139,18 @@ public TickRateModulation tickingRequest(IGridNode node, int ticksSinceLastCall) return currentTickRate; } + @Override + public void setRemoved() { + for (var state : requestStatus) { + state.cancel(); + } + super.setRemoved(); + } + @Override public void requestChanged(int index) { + requestStatus[index].cancel(); + updateRequestStatus(index, StatusState.IDLE); storageManager.clear(index); saveChanges(); } @@ -218,12 +228,20 @@ private boolean handleRequests() { private StatusState handleRequest(int slot) { var state = requestStatus[slot]; - updateRequestStatus(slot, state.handle(this, slot)); - if (requestStatus[slot].type() != RequestStatus.IDLE && !Objects.equals(requestStatus[slot], state)) { + var next = state.handle(this, slot); + updateRequestStatus(slot, next); + // Follow cheap transitions in this tick. A plan, or a failed plan, has to + // wait for the next tick so one request cannot chain calculations. + if (next != state && continuesOnSameTick(next)) { return handleRequest(slot); } - return requestStatus[slot]; + return next; + } + + private static boolean continuesOnSameTick(StatusState state) { + var type = state.type(); + return type == RequestStatus.REQUEST || type == RequestStatus.LINK || type == RequestStatus.EXPORT; } private void updateRequestStatus(int slot, StatusState state) { diff --git a/src/main/java/com/almostreliable/merequester/requester/RequesterPlanActivity.java b/src/main/java/com/almostreliable/merequester/requester/RequesterPlanActivity.java new file mode 100644 index 0000000..7cc150c --- /dev/null +++ b/src/main/java/com/almostreliable/merequester/requester/RequesterPlanActivity.java @@ -0,0 +1,26 @@ +package com.almostreliable.merequester.requester; + +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Tracks requester crafting plans that are currently running on AE2's calculator thread. + * The server tick uses this to avoid reading the live pattern map on the same tick. + */ +public final class RequesterPlanActivity { + + private static final AtomicInteger AWAKE = new AtomicInteger(); + + private RequesterPlanActivity() {} + + public static void enter() { + AWAKE.incrementAndGet(); + } + + public static void exit() { + AWAKE.updateAndGet(value -> Math.max(0, value - 1)); + } + + public static boolean isAwake() { + return AWAKE.get() > 0; + } +} diff --git a/src/main/java/com/almostreliable/merequester/requester/StorageManager.java b/src/main/java/com/almostreliable/merequester/requester/StorageManager.java index 58b4414..849175c 100644 --- a/src/main/java/com/almostreliable/merequester/requester/StorageManager.java +++ b/src/main/java/com/almostreliable/merequester/requester/StorageManager.java @@ -58,7 +58,10 @@ public long computeAmountToCraft(int slot) { var requests = host.getRequestManager(); if (requests.getKey(slot) == null) return 0; - var storedAmount = get(slot).knownAmount + get(slot).pendingAmount; + var storage = get(slot); + if (storage.knownAmount < 0) return 0; + + var storedAmount = storage.knownAmount + storage.pendingAmount; if (storedAmount < requests.getAmount(slot)) { return requests.get(slot).getBatch(); } diff --git a/src/main/java/com/almostreliable/merequester/requester/status/BlockingState.java b/src/main/java/com/almostreliable/merequester/requester/status/BlockingState.java index 2a9d05d..a165966 100644 --- a/src/main/java/com/almostreliable/merequester/requester/status/BlockingState.java +++ b/src/main/java/com/almostreliable/merequester/requester/status/BlockingState.java @@ -1,49 +1,73 @@ package com.almostreliable.merequester.requester.status; +import com.almostreliable.merequester.core.Config; +import com.almostreliable.merequester.requester.CraftingPlanBudget; import com.almostreliable.merequester.requester.RequesterBlockEntity; +import net.minecraft.world.level.Level; + import appeng.api.networking.ticking.TickRateModulation; import org.jetbrains.annotations.Nullable; public abstract class BlockingState implements StatusState { + private long retryAtGameTime = Long.MIN_VALUE; @Nullable private PlanState simulatedPlanState; BlockingState() {} + static BlockingState coolDown(RequesterBlockEntity host, BlockingState state) { + var level = host.getLevel(); + if (level != null) state.arm(level); + return state; + } + + void arm(Level level) { + retryAtGameTime = level.getGameTime() + Config.COMMON.craftingRetryTicks.get(); + } + + @Override + public void cancel() { + if (simulatedPlanState != null) { + simulatedPlanState.cancel(); + simulatedPlanState = null; + } + } + @Override public StatusState handle(RequesterBlockEntity host, int slot) { - // re-run the crafting job plan to see if we are still missing a cpu if (simulatedPlanState != null) { var planSim = simulatedPlanState.handle(host, slot); + if (planSim == simulatedPlanState) return this; simulatedPlanState = null; return planSim; } var idleSim = IDLE.handle(host, slot); if (idleSim == IDLE || idleSim == EXPORT) { - // idle simulation returning idle means a request is no - // longer required because we have enough items - // idle state returning export should not be possible, - // but just in case, we will return to idle to handle it + // Enough of the item is stored, or a finished craft is waiting to be exported. return IDLE; } - // idle sim returned that we can request + var level = host.getLevel(); + if (level != null && level.getGameTime() < retryAtGameTime) return this; + if (level == null || !CraftingPlanBudget.hasRoom(level)) return this; + var requestSim = REQUEST.handle(host, slot); - if (requestSim == IDLE) { - return IDLE; + if (requestSim instanceof PlanState plan) { + simulatedPlanState = plan; + return this; } - - // request sim returned that we can start planning - simulatedPlanState = (PlanState) requestSim; - return this; + // The request state stays put when every calculation slot is taken. + if (requestSim == REQUEST) return this; + return requestSim; } @Override public TickRateModulation getTickRateModulation() { + if (simulatedPlanState != null) return simulatedPlanState.getTickRateModulation(); return TickRateModulation.IDLE; } } diff --git a/src/main/java/com/almostreliable/merequester/requester/status/IdleState.java b/src/main/java/com/almostreliable/merequester/requester/status/IdleState.java index 65234df..925f39e 100644 --- a/src/main/java/com/almostreliable/merequester/requester/status/IdleState.java +++ b/src/main/java/com/almostreliable/merequester/requester/status/IdleState.java @@ -10,12 +10,14 @@ public class IdleState implements StatusState { @Override public StatusState handle(RequesterBlockEntity host, int index) { - if (host.getStorageManager().get(index).getBufferAmount() > 0) { + var storage = host.getStorageManager().get(index); + if (storage.getBufferAmount() > 0) { return EXPORT; } var request = host.getRequestManager().get(index); - if (request.isRequesting() && request.getAmount() > host.getStorageManager().get(index).getKnownAmount()) { + // knownAmount stays -1 until the storage watcher reports a real count. + if (request.isRequesting() && storage.getKnownAmount() >= 0 && request.getAmount() > storage.getKnownAmount()) { return REQUEST; } diff --git a/src/main/java/com/almostreliable/merequester/requester/status/PlanState.java b/src/main/java/com/almostreliable/merequester/requester/status/PlanState.java index 1d4aca0..1f28079 100644 --- a/src/main/java/com/almostreliable/merequester/requester/status/PlanState.java +++ b/src/main/java/com/almostreliable/merequester/requester/status/PlanState.java @@ -7,6 +7,7 @@ import appeng.api.networking.ticking.TickRateModulation; import java.util.Set; +import java.util.concurrent.CancellationException; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; @@ -25,15 +26,24 @@ public final class PlanState implements StatusState { this.future = future; } + @Override + public void cancel() { + future.cancel(true); + } + @Override public StatusState handle(RequesterBlockEntity host, int index) { if (!future.isDone()) return this; if (future.isCancelled()) return IDLE; + if (!host.getRequestManager().get(index).isRequesting() || host.getStorageManager().computeAmountToCraft(index) <= 0) { + return IDLE; + } + try { var plan = future.get(); if (!plan.missingItems().isEmpty()) { - return new MissingState(); + return BlockingState.coolDown(host, new MissingState()); } var submitResult = host.getMainNodeGrid().getCraftingService().submitJob(plan, host, null, false, host.getActionSource()); @@ -41,7 +51,7 @@ public StatusState handle(RequesterBlockEntity host, int index) { if (!submitResult.successful() || craftingLink == null) { if (submitResult.errorCode() != null && CPU_ERROR_CODES.contains(submitResult.errorCode())) { - return new CpuState(); + return BlockingState.coolDown(host, new CpuState()); } return IDLE; @@ -49,7 +59,7 @@ public StatusState handle(RequesterBlockEntity host, int index) { host.getStorageManager().get(index).setTotalAmount(plan.finalOutput().amount()); return new LinkState(craftingLink); - } catch (InterruptedException | ExecutionException e) { + } catch (CancellationException | InterruptedException | ExecutionException e) { return IDLE; } } diff --git a/src/main/java/com/almostreliable/merequester/requester/status/RequestState.java b/src/main/java/com/almostreliable/merequester/requester/status/RequestState.java index d1d6b45..624b4d9 100644 --- a/src/main/java/com/almostreliable/merequester/requester/status/RequestState.java +++ b/src/main/java/com/almostreliable/merequester/requester/status/RequestState.java @@ -1,5 +1,6 @@ package com.almostreliable.merequester.requester.status; +import com.almostreliable.merequester.requester.CraftingPlanBudget; import com.almostreliable.merequester.requester.RequesterBlockEntity; import appeng.api.networking.crafting.CalculationStrategy; @@ -11,25 +12,36 @@ public class RequestState implements StatusState { @Override public StatusState handle(RequesterBlockEntity owner, int index) { - if (!owner.getRequestManager().get(index).getState()) { - return IDLE; - } + var request = owner.getRequestManager().get(index); + if (!request.getState()) return IDLE; + + var storage = owner.getStorageManager().get(index); + // The storage watcher has not reported a count yet. -1 would look like a deficit. + if (storage.getKnownAmount() < 0) return IDLE; var amountToCraft = owner.getStorageManager().computeAmountToCraft(index); if (amountToCraft <= 0) return IDLE; - var key = owner.getRequestManager().getKey(index); - - var future = owner - .getMainNodeGrid() - .getCraftingService() - .beginCraftingCalculation( - owner.getLevel(), - owner::getActionSource, - key, - amountToCraft, - CalculationStrategy.REPORT_MISSING_ITEMS - ); + var key = request.getKey(); + var level = owner.getLevel(); + if (key == null || level == null) return IDLE; + + var crafting = owner.getMainNodeGrid().getCraftingService(); + if (!crafting.isCraftable(key)) { + return BlockingState.coolDown(owner, new MissingState()); + } + + // Stay in this state so the next tick can try again without queueing a plan. + if (!CraftingPlanBudget.hasRoom(level)) return REQUEST; + + var future = crafting.beginCraftingCalculation( + level, + owner::getActionSource, + key, + amountToCraft, + CalculationStrategy.REPORT_MISSING_ITEMS + ); + CraftingPlanBudget.track(level, future); return new PlanState(future); } diff --git a/src/main/java/com/almostreliable/merequester/requester/status/StatusState.java b/src/main/java/com/almostreliable/merequester/requester/status/StatusState.java index 2fc5559..ecbd2c3 100644 --- a/src/main/java/com/almostreliable/merequester/requester/status/StatusState.java +++ b/src/main/java/com/almostreliable/merequester/requester/status/StatusState.java @@ -20,4 +20,9 @@ public interface StatusState { RequestStatus type(); TickRateModulation getTickRateModulation(); + + /** + * Drops an in-flight crafting plan. Called when the request changes or the block is removed. + */ + default void cancel() {} } diff --git a/src/main/resources/merequester.mixins.json b/src/main/resources/merequester.mixins.json index e3773d9..6a0442b 100644 --- a/src/main/resources/merequester.mixins.json +++ b/src/main/resources/merequester.mixins.json @@ -3,6 +3,10 @@ "minVersion": "0.8.5", "package": "com.almostreliable.merequester.mixin", "compatibilityLevel": "JAVA_21", + "mixins": [ + "CraftingCalculationMixin", + "CraftingServiceMixin" + ], "client": [ "accessors.EditBoxMixin", "accessors.SlotMixin",