From 25e6f39afd27b7c882e7ec5222c8ade419a52f4e Mon Sep 17 00:00:00 2001 From: bigguy345 Date: Wed, 2 Jul 2025 20:56:54 +0300 Subject: [PATCH] Rewrote ActionManager with the new IActionQueue framework --- .../data/action/ActionManager.java | 356 ++++++------------ .../controllers/data/action/ActionQueue.java | 26 +- 2 files changed, 144 insertions(+), 238 deletions(-) diff --git a/src/main/java/noppes/npcs/controllers/data/action/ActionManager.java b/src/main/java/noppes/npcs/controllers/data/action/ActionManager.java index 1f7db6f5c..7305551fc 100644 --- a/src/main/java/noppes/npcs/controllers/data/action/ActionManager.java +++ b/src/main/java/noppes/npcs/controllers/data/action/ActionManager.java @@ -3,13 +3,12 @@ package noppes.npcs.controllers.data.action; import noppes.npcs.api.handler.IActionManager; import noppes.npcs.api.handler.data.IAction; import noppes.npcs.api.handler.data.IActionChain; +import noppes.npcs.api.handler.data.IActionQueue; import noppes.npcs.api.handler.data.actions.IConditionalAction; import noppes.npcs.controllers.data.action.action.ConditionalAction; import noppes.npcs.controllers.data.action.chain.ActionChain; import noppes.npcs.controllers.data.action.chain.ParallelActionChain; -import java.util.*; -import java.util.concurrent.ConcurrentLinkedDeque; import java.util.function.Consumer; import java.util.function.Function; @@ -22,11 +21,27 @@ import java.util.function.Function; * - cancellation & clearing */ public class ActionManager implements IActionManager { - private boolean isWorking = false; + protected boolean isWorking = false; - private final Deque actionQueue = new ConcurrentLinkedDeque<>(); - private final Deque parallelActions = new ConcurrentLinkedDeque<>(); - private final Deque conditionalActions = new ConcurrentLinkedDeque<>(); + protected final IActionQueue sequentialQueue = new ActionQueue(this, "mainSequential"); + protected final IActionQueue parallelQueue = new ActionQueue(this, "mainParallel").setParallel(true); + protected final IActionQueue conditionalQueue = new ActionQueue(this, "mainConditional").setParallel(true); + + @Override + public IActionManager start() { + isWorking = true; + return this; + } + + @Override + public IActionManager stop() { + isWorking = false; + return this; + } + + /////////////////////////////////////////////////// + /////////////////////////////////////////////////// + // Creators @Override public IAction create(String name) { @@ -92,157 +107,139 @@ public class ActionManager implements IActionManager { return new ConditionalAction(this, name, condition, task, terminateWhen, onTermination); } - @Override - public IActionManager start() { - isWorking = true; - return this; - } + /////////////////////////////////////////////////// + /////////////////////////////////////////////////// + // Sequential @Override - public IActionManager stop() { - isWorking = false; - return this; + public IActionQueue getSequentialQueue() { + return sequentialQueue; } @Override public IAction schedule(IAction action) { if (action instanceof IConditionalAction) - return schedule((IConditionalAction) action); + return conditionalQueue.schedule(action); - Action act = (Action) action; - if (act.unscheduledBefore != null) - act.scheduleAllBefore(actionQueue); - - actionQueue.addLast(action); - - if (act.unscheduledAfter != null) - act.scheduleAllAfter(actionQueue); - - act.isScheduled = true; - return action; + return sequentialQueue.schedule(action); } @Override public void schedule(IAction... actions) { - for (IAction act : actions) - schedule(act); + sequentialQueue.schedule(actions); } @Override public void schedule(Consumer... tasks) { - for (Consumer task : tasks) - schedule(task); + sequentialQueue.schedule(tasks); } @Override public IAction schedule(Consumer task) { - return schedule(create(task)); + return sequentialQueue.schedule(task); } @Override public IAction schedule(int delay, Consumer task) { - return schedule(create(delay, task)); + return sequentialQueue.schedule(delay, task); } @Override public IAction schedule(int maxDuration, int delay, Consumer task) { - return schedule(create(maxDuration, delay, task)); + return sequentialQueue.schedule(maxDuration, delay, task); } @Override public IAction schedule(String name, Consumer task) { - return schedule(create(name, task)); + return sequentialQueue.schedule(name, task); } @Override public IAction schedule(String name, int delay, Consumer task) { - return schedule(create(name, delay, task)); + return sequentialQueue.schedule(name, delay, task); } @Override public IAction schedule(String name, int maxDuration, int delay, Consumer task) { - return schedule(create(name, maxDuration, delay, task)); + return sequentialQueue.schedule(name, maxDuration, delay, task); } @Override public IAction scheduleActionAt(int index, IAction action) { - int size = actionQueue.size(); - if (index <= 0) { - actionQueue.addFirst(action); - } else if (index >= size) { - actionQueue.addLast(action); - } else { - List tmp = new ArrayList<>(actionQueue); - tmp.add(index, action); - actionQueue.clear(); - actionQueue.addAll(tmp); - } - ((Action) action).isScheduled = true; - return action; + return sequentialQueue.scheduleActionAt(index, action); + } + + /////////////////////////////////////////////////// + /////////////////////////////////////////////////// + // Parallels + + @Override + public IActionQueue getParallelQueue() { + return parallelQueue; } @Override - public int getIndex(IAction action) { - int i = 0; - for (IAction a : actionQueue) { - if (a.equals(action)) return i; - i++; - } - return -1; + public IAction scheduleParallel(IAction action) { + return parallelQueue.schedule(action); } @Override - public IAction getCurrentAction() { - return actionQueue.peekFirst(); + public void scheduleParallel(IAction... actions) { + parallelQueue.schedule(actions); } @Override - public IAction getAction(String name) { - for (IAction action : actionQueue) { - if (action.getName().equals(name)) - return action; - } - - for (IAction action : parallelActions) { - if (action.getName().equals(name)) - return action; - } - - for (IAction action : conditionalActions) { - if (action.getName().equals(name)) - return action; - } - - return null; + public void scheduleParallel(Consumer... tasks) { + parallelQueue.schedule(tasks); } @Override - public Queue getActionQueue() { - return actionQueue; + public IAction scheduleParallel(Consumer task) { + return parallelQueue.schedule(task); } @Override - public boolean hasAction(String name) { - for (IAction act : actionQueue) - if (act.getName().equals(name)) - return true; + public IAction scheduleParallel(int delay, Consumer task) { + return parallelQueue.schedule(delay, task); + } - return false; + @Override + public IAction scheduleParallel(int maxDuration, int delay, Consumer task) { + return parallelQueue.schedule(maxDuration, delay, task); + } + + @Override + public IAction scheduleParallel(String name, Consumer task) { + return parallelQueue.schedule(name, task); } @Override - public boolean hasAny(String name) { - if (hasAction(name)) - return true; - else if (hasParallel(name)) - return true; - else if (hasConditional(name)) - return true; + public IAction scheduleParallel(String name, int delay, Consumer task) { + return parallelQueue.schedule(delay, task); + } - return false; + @Override + public IAction scheduleParallel(String name, int maxDuration, int delay, Consumer task) { + return parallelQueue.schedule(name, maxDuration, delay, task); } /////////////////////////////////////////////////// /////////////////////////////////////////////////// // Conditionals + + @Override + public IActionQueue getConditionalQueue() { + return conditionalQueue; + } + + @Override + public IConditionalAction schedule(IConditionalAction action) { + return (IConditionalAction) conditionalQueue.schedule(action); + } + + @Override + public void schedule(IConditionalAction... actions) { + conditionalQueue.schedule(actions); + } + @Override public IConditionalAction schedule(Function condition, Consumer task) { return schedule(new ConditionalAction(this, condition, task)); @@ -274,81 +271,49 @@ public class ActionManager implements IActionManager { return schedule(new ConditionalAction(this, name, condition, task, terminateWhen, onTermination)); } + /////////////////////////////////////////////////// + /////////////////////////////////////////////////// + // Handling + @Override - public IConditionalAction schedule(IConditionalAction action) { - conditionalActions.add(action); - ((Action) action).isScheduled = true; - return action; + public boolean hasAny(String name) { + return getAny(name) != null; } @Override - public void schedule(IConditionalAction... actions) { - for (IConditionalAction act : actions) - schedule(act); + public IAction getAny(String name) { + IAction act = sequentialQueue.get(name); + if (act != null) + return act; + + act = parallelQueue.get(name); + if (act != null) + return act; + + act = conditionalQueue.get(name); + if (act != null) + return act; + + return null; } @Override - public List getConditionalActions() { - return new ArrayList<>(conditionalActions); - } + public boolean cancelAny(String name) { + boolean canceled = sequentialQueue.cancel(name); + if (canceled) + return true; - @Override - public boolean hasConditional(String name) { - for (IAction act : conditionalActions) - if (act.getName().equals(name)) - return true; + canceled = parallelQueue.cancel(name); + if (canceled) + return true; + + canceled = conditionalQueue.cancel(name); + if (canceled) + return true; return false; } - @Override - public IAction scheduleParallel(IAction action) { - parallelActions.add(action); - ((Action) action).isScheduled = true; - return action; - } - - @Override - public void scheduleParallel(IAction... actions) { - for (IAction act : actions) - scheduleParallel(act); - } - - @Override - public void scheduleParallel(Consumer... tasks) { - for (Consumer task : tasks) - scheduleParallel(task); - } - - @Override - public IAction scheduleParallel(Consumer task) { - return scheduleParallel(create(task)); - } - - @Override - public IAction scheduleParallel(int delay, Consumer task) { - return scheduleParallel(create(delay, task)); - } - @Override - public IAction scheduleParallel(int maxDuration, int delay, Consumer task) { - return scheduleParallel(create(maxDuration, delay, task)); - } - - @Override - public IAction scheduleParallel(String name, Consumer task) { - return scheduleParallel(create(name, task)); - } - @Override - public IAction scheduleParallel(String name, int delay, Consumer task) { - return scheduleParallel(create(name, delay, task)); - } - - @Override - public IAction scheduleParallel(String name, int maxDuration, int delay, Consumer task) { - return scheduleParallel(create(name, maxDuration, delay, task)); - } - - /** * Call once per tick from your main loop. * @@ -358,79 +323,20 @@ public class ActionManager implements IActionManager { if (!isWorking) return; // ─── Sequential (head only) ───────────────────────────────── - IAction current = getCurrentAction(); - if (current instanceof Action) { - Action cab = (Action) current; - cab.tick(ticksExisted); - if (cab.isDone()) { - cab.kill(); - actionQueue.pollFirst(); - } - } + ((ActionQueue) sequentialQueue).tick(ticksExisted); // ─── Parallel (all) ─────────────────────────────────────── - Iterator pit = parallelActions.iterator(); - while (pit.hasNext()) { - Action a = (Action) pit.next(); - a.tick(ticksExisted); - if (a.isDone()) { - a.kill(); - pit.remove(); - } - } + ((ActionQueue) parallelQueue).tick(ticksExisted); // ─── Conditionals ───────────────────────────────────────── - Iterator cit = conditionalActions.iterator(); - while (cit.hasNext()) { - ConditionalAction con = (ConditionalAction) cit.next(); - con.tick(ticksExisted); - if (con.isDone()) { - con.kill(); - cit.remove(); - } - } + ((ActionQueue) conditionalQueue).tick(ticksExisted); } @Override public void clear() { - actionQueue.forEach((act) -> act.kill()); - actionQueue.clear(); - - parallelActions.forEach((act) -> act.kill()); - parallelActions.clear(); - - conditionalActions.forEach((act) -> act.kill()); - conditionalActions.clear(); - } - - @Override - public boolean cancelAction(String name) { - Iterator acts = actionQueue.iterator(); - while (acts.hasNext()) { - IAction act = acts.next(); - if (act.getName().equals(name)) { - acts.remove(); - return true; - } - } - - Iterator pit = parallelActions.iterator(); - while (pit.hasNext()) { - if (pit.next().getName().equals(name)) { - pit.remove(); - return true; - } - } - - Iterator cons = conditionalActions.iterator(); - while (cons.hasNext()) { - IConditionalAction con = cons.next(); - if (con.getName().equals(name)) { - cons.remove(); - return true; - } - } - return false; + sequentialQueue.clear(); + parallelQueue.clear(); + conditionalQueue.clear(); } @Override @@ -442,18 +348,4 @@ public class ActionManager implements IActionManager { public IActionChain parallelChain() { return new ParallelActionChain(this); } - - @Override - public Queue getParallelActions() { - return parallelActions; - } - - @Override - public boolean hasParallel(String name) { - for (IAction act : parallelActions) - if (act.getName().equals(name)) - return true; - - return false; - } } diff --git a/src/main/java/noppes/npcs/controllers/data/action/ActionQueue.java b/src/main/java/noppes/npcs/controllers/data/action/ActionQueue.java index 46e42ccf6..a231f6e3a 100644 --- a/src/main/java/noppes/npcs/controllers/data/action/ActionQueue.java +++ b/src/main/java/noppes/npcs/controllers/data/action/ActionQueue.java @@ -20,6 +20,11 @@ public class ActionQueue implements IActionQueue { this.name = name; } + public ActionQueue(ActionManager manager, String name, boolean isParallel) { + this(manager, name); + this.isParallel = isParallel; + } + @Override public IActionQueue start() { isWorking = true; @@ -45,6 +50,11 @@ public class ActionQueue implements IActionQueue { return isParallel; } + public IActionQueue setParallel(boolean parallel) { + isParallel = parallel; + return this; + } + @Override public Queue getQueue() { return queue; @@ -53,12 +63,15 @@ public class ActionQueue implements IActionQueue { @Override public IAction schedule(IAction action) { Action act = (Action) action; - if (act.unscheduledBefore != null) + + if (!isParallel && act.unscheduledBefore != null) act.scheduleAllBefore(queue); + queue.addLast(action); - if (act.unscheduledAfter != null) + + if (!isParallel && act.unscheduledAfter != null) act.scheduleAllAfter(queue); act.isScheduled = true; @@ -71,16 +84,17 @@ public class ActionQueue implements IActionQueue { schedule(act); } + @Override + public IAction schedule(Consumer task) { + return schedule(manager.create(task)); + } + @Override public void schedule(Consumer... tasks) { for (Consumer task : tasks) schedule(task); } - @Override - public IAction schedule(Consumer task) { - return schedule(manager.create(task)); - } @Override public IAction schedule(int delay, Consumer task) {