Feat: 添加重启进度恢复机制

src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AsyncMachineOperationStartEvent.java

@@ -0,0 +1,96 @@
+package io.github.thebusybiscuit.slimefun4.api.events;
+
+import io.github.bakedlibs.dough.blocks.BlockPosition;
+import io.github.thebusybiscuit.slimefun4.core.machines.MachineOperation;
+import io.github.thebusybiscuit.slimefun4.core.machines.MachineProcessor;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * This {@link Event} is fired whenever an {@link MachineProcessor} wants to start a {@link MachineOperation} when invoking any of the {@link MachineProcessor#startOperation} method
+ * The event is cancellable, if the event is cancelled, the operation will not be added to the operation map and {@link MachineProcessor#startOperation} will return false
+ *
+ * @author m1919810
+ *
+ */
+public class AsyncMachineOperationStartEvent extends Event implements Cancellable {
+    private static final HandlerList handlers = new HandlerList();
+
+    private final BlockPosition position;
+    private final MachineProcessor<?> machineProcessor;
+    private final MachineOperation machineOperation;
+    private boolean cancel;
+
+    public <T extends MachineOperation> AsyncMachineOperationStartEvent(
+            BlockPosition pos, MachineProcessor<T> processor, T operation) {
+        super(!Bukkit.isPrimaryThread());
+
+        this.position = pos;
+        this.machineProcessor = processor;
+        this.machineOperation = operation;
+    }
+
+    /**
+     * This returns the {@link BlockPosition} of the machine.
+     *
+     * @return The {@link BlockPosition} of the machine
+     */
+    @Nonnull
+    public BlockPosition getPosition() {
+        return position;
+    }
+
+    /**
+     * The {@link MachineProcessor} instance of the machine.
+     *
+     * @return The {@link MachineProcessor} instance of the machine
+     */
+    @Nullable public MachineProcessor<?> getProcessor() {
+        return machineProcessor;
+    }
+
+    /**
+     * This returns the used {@link MachineOperation} in the process.
+     *
+     * @return The {@link MachineOperation} of the process
+     */
+    @Nullable public MachineOperation getOperation() {
+        return machineOperation;
+    }
+
+    @Nonnull
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Nonnull
+    @Override
+    public HandlerList getHandlers() {
+        return getHandlerList();
+    }
+
+    /**
+     * This returns whether the event is cancelled
+     *
+     * @return cancel flag
+     */
+    @Override
+    public boolean isCancelled() {
+        return this.cancel;
+    }
+
+    /**
+     * This sets the cancel flag of the event
+     * If the event is cancelled, the operation will not be added to the operation map and {@link MachineProcessor#startOperation} will return false
+     *
+     * @param b new flag
+     */
+    @Override
+    public void setCancelled(boolean b) {
+        this.cancel = b;
+    }
+}

src/main/java/io/github/thebusybiscuit/slimefun4/core/attributes/MachineProcessSerializable.java

@@ -0,0 +1,26 @@
+package io.github.thebusybiscuit.slimefun4.core.attributes;
+
+import io.github.bakedlibs.dough.blocks.BlockPosition;
+import io.github.thebusybiscuit.slimefun4.core.machines.MachineOperation;
+
+public interface MachineProcessSerializable<T extends MachineOperation> extends MachineProcessHolder<T> {
+    String KEY_PROGRESS_LEFT = "p-tick-left";
+    String KEY_OPERATION_INFO = "p-op-info";
+
+    /**
+     * this called when a MachineProcessor trys to load a MachineOperation from a blockData by using the value under the key {@link MachineProcessSerializable#KEY_OPERATION_INFO} as the operation information and {@link MachineProcessSerializable#KEY_PROGRESS_LEFT} as the progress left
+     * @param position
+     * @param output
+     * @return
+     */
+    T deserialize(BlockPosition position, String output);
+
+    /**
+     * this called when a MachineProcessor trys to save a MachineOperation when startOperation called, it will store the return value under key {@link  MachineProcessSerializable#KEY_OPERATION_INFO}
+     *
+     * @param position
+     * @param operation
+     * @return
+     */
+    String serialize(BlockPosition position, T operation);
+}

src/main/java/io/github/thebusybiscuit/slimefun4/core/machines/MachineOperation.java

@@ -2,6 +2,8 @@
 
 import io.github.bakedlibs.dough.blocks.BlockPosition;
 import io.github.thebusybiscuit.slimefun4.core.attributes.MachineProcessHolder;
+import io.github.thebusybiscuit.slimefun4.implementation.operations.CraftingOperation;
+import org.bukkit.configuration.ConfigurationSection;
 
 /**
  * This represents a {@link MachineOperation} which is handled
@@ -63,4 +65,10 @@ default boolean isFinished() {
      * Implement to specify behaviour that should happen in this case.
      */
     default void onCancel(BlockPosition position) {}
+
+    public static String TOTAL_TICKS = "total-ticks";
+
+    default void serializeOperation(ConfigurationSection yaml, CraftingOperation operation) {
+        yaml.set(TOTAL_TICKS, operation.getTotalTicks());
+    }
 }

src/main/java/io/github/thebusybiscuit/slimefun4/core/machines/MachineProcessor.java

@@ -1,10 +1,15 @@
 package io.github.thebusybiscuit.slimefun4.core.machines;
 
+import com.xzavier0722.mc.plugin.slimefun4.storage.controller.SlimefunBlockData;
+import com.xzavier0722.mc.plugin.slimefun4.storage.util.StorageCacheUtils;
 import io.github.bakedlibs.dough.blocks.BlockPosition;
 import io.github.thebusybiscuit.slimefun4.api.events.AsyncMachineOperationFinishEvent;
+import io.github.thebusybiscuit.slimefun4.api.events.AsyncMachineOperationStartEvent;
 import io.github.thebusybiscuit.slimefun4.core.attributes.MachineProcessHolder;
+import io.github.thebusybiscuit.slimefun4.core.attributes.MachineProcessSerializable;
 import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -32,6 +37,7 @@ public class MachineProcessor<T extends MachineOperation> {
 
     private final Map<BlockPosition, T> machines = new ConcurrentHashMap<>();
     private final MachineProcessHolder<T> owner;
+    private final MachineProcessSerializable<T> optionalSerializer;
 
     private ItemStack progressBar;
 
@@ -45,6 +51,8 @@ public MachineProcessor(@Nonnull MachineProcessHolder<T> owner) {
         Validate.notNull(owner, "The MachineProcessHolder cannot be null.");
 
         this.owner = owner;
+        this.optionalSerializer =
+                this.owner instanceof MachineProcessSerializable<T> serializable ? serializable : null;
     }
 
     /**
@@ -123,13 +131,47 @@ public boolean startOperation(@Nonnull Block b, @Nonnull T operation) {
      *            The {@link MachineOperation} to start
      *
      * @return Whether the {@link MachineOperation} was successfully started. This will return false if another
-     *         {@link MachineOperation} has already been started at that {@link BlockPosition}.
+     *         {@link MachineOperation} has already been started at that {@link BlockPosition} or the StartEvent is cancelled.
      */
     public boolean startOperation(@Nonnull BlockPosition pos, @Nonnull T operation) {
         Validate.notNull(pos, "The BlockPosition must not be null");
         Validate.notNull(operation, "The machine operation cannot be null");
+        // async Machine Operation Start Event
+
+        var currentOperation = machines.computeIfAbsent(pos, (ps) -> {
+            // only if the current operation if absent and Event is not cancelled  can we put the new operation in the
+            // map
+            // other wise it will keep null
+            var event = new AsyncMachineOperationStartEvent(ps, this, operation);
+            if (event.callEvent()) {
+                return operation;
+            } else {
+                return null;
+            }
+        });
+        // if the current Operation is successfully put into the map, returns true
+        if (currentOperation == operation) {
+            // serialize and save to blockData
+            if (optionalSerializer != null) {
+                SlimefunBlockData blockData = StorageCacheUtils.getBlock(pos.toLocation());
+                if (blockData != null) {
+                    StorageCacheUtils.executeAfterLoad(
+                            blockData,
+                            () -> {
+                                blockData.setData(
+                                        MachineProcessSerializable.KEY_OPERATION_INFO,
+                                        optionalSerializer.serialize(pos, operation));
+                                blockData.setData(
+                                        MachineProcessSerializable.KEY_PROGRESS_LEFT,
+                                        String.valueOf(operation.getRemainingTicks()));
+                            },
+                            false);
+                }
+            }
+            return true;
+        }
 
-        return machines.putIfAbsent(pos, operation) == null;
+        return false;
     }
 
     /**
@@ -171,7 +213,55 @@ public boolean startOperation(@Nonnull BlockPosition pos, @Nonnull T operation)
     @Nullable public T getOperation(@Nonnull BlockPosition pos) {
         Validate.notNull(pos, "The BlockPosition must not be null");
 
-        return machines.get(pos);
+        T value = machines.get(pos);
+        if (value != null) {
+            if (optionalSerializer != null) {
+                // try update the progressLeft field
+                SlimefunBlockData sfdata = StorageCacheUtils.getBlock(pos.toLocation());
+                if (sfdata != null) {
+                    StorageCacheUtils.executeAfterLoad(
+                            sfdata,
+                            () -> sfdata.setData(
+                                    MachineProcessSerializable.KEY_PROGRESS_LEFT,
+                                    String.valueOf(value.getRemainingTicks())),
+                            false);
+                }
+            }
+        } else {
+            if (optionalSerializer != null) {
+                // try load if operation is absent
+                SlimefunBlockData sfdata = StorageCacheUtils.getBlock(pos.toLocation());
+                if (sfdata != null && sfdata.isDataLoaded()) {
+                    // this may not be multithread-safe, but who cares?
+                    String infoYaml = sfdata.getData(MachineProcessSerializable.KEY_OPERATION_INFO);
+                    if (infoYaml != null) {
+                        T operationLoaded;
+                        try {
+                            operationLoaded = Objects.requireNonNull(optionalSerializer.deserialize(pos, infoYaml));
+                        } finally {
+                            sfdata.removeData(MachineProcessSerializable.KEY_OPERATION_INFO);
+                        }
+                        String progress = sfdata.getData(MachineProcessSerializable.KEY_PROGRESS_LEFT);
+                        int progressTickLeft;
+                        try {
+                            progressTickLeft =
+                                    progress == null ? operationLoaded.getTotalTicks() : Integer.parseInt(progress);
+                        } catch (Throwable e) {
+                            progressTickLeft = operationLoaded.getTotalTicks();
+                        }
+                        operationLoaded.addProgress(operationLoaded.getTotalTicks() - progressTickLeft);
+                        sfdata.setData(
+                                MachineProcessSerializable.KEY_OPERATION_INFO,
+                                optionalSerializer.serialize(pos, operationLoaded));
+                        sfdata.setData(
+                                MachineProcessSerializable.KEY_PROGRESS_LEFT,
+                                String.valueOf(operationLoaded.getRemainingTicks()));
+                        machines.put(pos, operationLoaded);
+                    }
+                }
+            }
+        }
+        return value;
     }
 
     /**
@@ -215,6 +305,19 @@ public boolean endOperation(@Nonnull Block b) {
      */
     public boolean endOperation(@Nonnull BlockPosition pos) {
         Validate.notNull(pos, "The BlockPosition cannot be null");
+        // remove the serialized data from the blockData
+        if (optionalSerializer != null) {
+            SlimefunBlockData sfdata = StorageCacheUtils.getBlock(pos.toLocation());
+            if (sfdata != null) {
+                StorageCacheUtils.executeAfterLoad(
+                        sfdata,
+                        () -> {
+                            sfdata.removeData(MachineProcessSerializable.KEY_PROGRESS_LEFT);
+                            sfdata.removeData(MachineProcessSerializable.KEY_OPERATION_INFO);
+                        },
+                        false);
+            }
+        }
 
         T operation = machines.remove(pos);
 

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/AutoAnvil.java

@@ -4,6 +4,7 @@
 import io.github.thebusybiscuit.slimefun4.api.items.SlimefunItemStack;
 import io.github.thebusybiscuit.slimefun4.api.recipes.RecipeType;
 import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
+import io.github.thebusybiscuit.slimefun4.implementation.operations.CraftingOperationSerializable;
 import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AContainer;
 import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineRecipe;
@@ -20,7 +21,7 @@
  * @author TheBusyBiscuit
  *
  */
-public class AutoAnvil extends AContainer {
+public class AutoAnvil extends AContainer implements CraftingOperationSerializable {
 
     private final int repairFactor;
 

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/enchanting/AbstractEnchantmentMachine.java

@@ -8,6 +8,7 @@
 import io.github.thebusybiscuit.slimefun4.api.items.settings.IntRangeSetting;
 import io.github.thebusybiscuit.slimefun4.api.recipes.RecipeType;
 import io.github.thebusybiscuit.slimefun4.implementation.Slimefun;
+import io.github.thebusybiscuit.slimefun4.implementation.operations.CraftingOperationSerializable;
 import java.util.Collections;
 import java.util.List;
 import javax.annotation.Nonnull;
@@ -29,7 +30,7 @@
  * @see AutoDisenchanter
  *
  */
-abstract class AbstractEnchantmentMachine extends AContainer {
+abstract class AbstractEnchantmentMachine extends AContainer implements CraftingOperationSerializable {
 
     private final ItemSetting<Boolean> useLevelLimit = new ItemSetting<>(this, "use-enchant-level-limit", false);
     private final IntRangeSetting levelLimit = new IntRangeSetting(this, "enchant-level-limit", 0, 10, Short.MAX_VALUE);

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/enchanting/BookBinder.java

@@ -6,6 +6,7 @@
 import io.github.thebusybiscuit.slimefun4.api.items.SlimefunItemStack;
 import io.github.thebusybiscuit.slimefun4.api.items.settings.IntRangeSetting;
 import io.github.thebusybiscuit.slimefun4.api.recipes.RecipeType;
+import io.github.thebusybiscuit.slimefun4.implementation.operations.CraftingOperationSerializable;
 import java.util.HashMap;
 import java.util.Map;
 import javax.annotation.Nonnull;
@@ -24,7 +25,7 @@
  *
  * @author ProfElements
  */
-public class BookBinder extends AContainer {
+public class BookBinder extends AContainer implements CraftingOperationSerializable {
 
     private final ItemSetting<Boolean> bypassVanillaMaxLevel =
             new ItemSetting<>(this, "bypass-vanilla-max-level", false);