mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 02:37:27 +00:00
445 lines
13 KiB
Java
445 lines
13 KiB
Java
package noppes.npcs.scripted;
|
||
|
||
import noppes.npcs.api.handler.IActionManager;
|
||
import noppes.npcs.api.handler.data.IAction;
|
||
import noppes.npcs.api.handler.data.IActionChain;
|
||
|
||
import java.util.Deque;
|
||
import java.util.LinkedList;
|
||
import java.util.Queue;
|
||
import java.util.function.Consumer;
|
||
import java.util.function.Supplier;
|
||
|
||
/**
|
||
* Full-featured ActionManager:
|
||
* - delayed start, max-duration, tick-interval
|
||
* - chaining (getNext, getPrevious, scheduleAfter/Before)
|
||
* - per-action data
|
||
* - conditional actions
|
||
* - cancellation & clearing
|
||
*/
|
||
public class ScriptedActionManager implements IActionManager {
|
||
private boolean isWorking = false;
|
||
private final Deque<IAction> actionQueue = new LinkedList<>();
|
||
|
||
@Override
|
||
public IAction create(String name, int maxDuration, int startAfterTicks, Consumer<IAction> task) {
|
||
return new Action(name, maxDuration, startAfterTicks, task);
|
||
}
|
||
|
||
@Override
|
||
public IAction create(String name, int delay, Consumer<IAction> t) {
|
||
return new Action(name, delay, t);
|
||
}
|
||
|
||
@Override
|
||
public IAction create(int delay, Consumer<IAction> t) {
|
||
return new Action(delay, t);
|
||
}
|
||
|
||
@Override
|
||
public IAction create(String name, Consumer<IAction> t) {
|
||
return new Action(name, t);
|
||
}
|
||
|
||
@Override
|
||
public IAction create(Consumer<IAction> t) {
|
||
return new Action(t);
|
||
}
|
||
@Override
|
||
public void start() {
|
||
isWorking = true;
|
||
}
|
||
|
||
@Override
|
||
public void stop() {
|
||
isWorking = false;
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleAction(IAction action) {
|
||
actionQueue.addLast(action);
|
||
return action;
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleAction(String name, int maxDuration, int startAfterTicks, Consumer<IAction> task) {
|
||
return scheduleAction(create(name, maxDuration, startAfterTicks, task));
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleActionAt(int index, IAction action) {
|
||
if (index < 0 || index > actionQueue.size()) {
|
||
actionQueue.addLast(action);
|
||
} else {
|
||
((LinkedList<IAction>) actionQueue).add(index, action);
|
||
}
|
||
|
||
return action;
|
||
}
|
||
|
||
@Override
|
||
public int getIndex(IAction action) {
|
||
if (action == null) return -1;
|
||
return ((LinkedList<IAction>) actionQueue).indexOf(action);
|
||
}
|
||
|
||
@Override
|
||
public IAction getCurrentAction() {
|
||
return actionQueue.peekFirst();
|
||
}
|
||
|
||
@Override
|
||
public Queue<IAction> getActionQueue() {
|
||
return actionQueue;
|
||
}
|
||
|
||
@Override
|
||
public void clear() {
|
||
actionQueue.clear();
|
||
}
|
||
|
||
@Override
|
||
public boolean cancelAction(String name) {
|
||
for (IAction act : actionQueue) {
|
||
if (act.getName().equals(name)) {
|
||
((LinkedList<IAction>) actionQueue).remove(act);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleConditionalAction(String name,
|
||
int checkIntervalTicks,
|
||
Supplier<Boolean> predicate,
|
||
Consumer<IAction> task) {
|
||
return scheduleConditionalAction(name, checkIntervalTicks, predicate, task, -1);
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleConditionalAction(String name,
|
||
int checkIntervalTicks,
|
||
Supplier<Boolean> predicate,
|
||
Consumer<IAction> task,
|
||
int maxChecks) {
|
||
return scheduleAction(new ConditionalAction(name, checkIntervalTicks, predicate, task, maxChecks));
|
||
}
|
||
|
||
@Override
|
||
public IAction scheduleConditionalAction(String name, int checkIntervalTicks, Supplier<Boolean> predicate, Supplier<Boolean> terminateWhen, Consumer<IAction> task, int maxChecks) {
|
||
return scheduleAction(new ConditionalAction(name, checkIntervalTicks, predicate, terminateWhen, task, maxChecks));
|
||
}
|
||
|
||
/**
|
||
* Call once per tick from your main loop.
|
||
*
|
||
* @param ticksExisted the global tick count, used for modulo checks.
|
||
*/
|
||
public void tick(int ticksExisted) {
|
||
if (!isWorking) return;
|
||
IAction current = getCurrentAction();
|
||
if (current instanceof ActionBase) {
|
||
ActionBase cab = (ActionBase) current;
|
||
cab.tick(ticksExisted);
|
||
if (cab.isDone() || cab.getDuration() >= cab.getMaxDuration()) {
|
||
actionQueue.pollFirst();
|
||
}
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public IActionChain chain() {
|
||
return new ActionChain();
|
||
}
|
||
|
||
/** helper to build a back‐to‐back chain of one‐shot actions */
|
||
public class ActionChain implements IActionChain {
|
||
private int offset = 0, index = 0;
|
||
|
||
/** schedule the next task ‘delay’ ticks after the previous one */
|
||
@Override
|
||
public IActionChain after(int delay, Consumer<IAction> task) {
|
||
offset += delay;
|
||
Consumer<IAction> wrapper = act -> {
|
||
task.accept(act);
|
||
act.markDone();
|
||
};
|
||
IAction a = create("chain#" + (index++), Integer.MAX_VALUE, offset, wrapper);
|
||
a.setUpdateEveryXTick(1);
|
||
scheduleAction(a);
|
||
return this;
|
||
}
|
||
}
|
||
|
||
// ──── base class for all custom actions ──────────────────────────────────
|
||
|
||
private abstract class ActionBase implements IAction {
|
||
protected final String name;
|
||
protected int startAfterTicks;
|
||
protected int count = 0;
|
||
protected int duration = 0;
|
||
protected int maxDuration = -1;
|
||
protected int updateEveryXTick = 5;
|
||
protected final Consumer<IAction> task;
|
||
private boolean done = false;
|
||
|
||
protected ActionBase(String name, int maxDuration, int startAfterTicks, Consumer<IAction> task) {
|
||
this.name = name;
|
||
this.maxDuration = maxDuration;
|
||
this.startAfterTicks = startAfterTicks;
|
||
this.task = task;
|
||
}
|
||
|
||
public ActionBase(String name, int startAfterTicks, Consumer<IAction> task) {
|
||
this.name = name;
|
||
this.startAfterTicks = startAfterTicks;
|
||
this.task = task;
|
||
}
|
||
|
||
public ActionBase(String name, Consumer<IAction> task) {
|
||
this.name = name;
|
||
this.task = task;
|
||
}
|
||
|
||
public ActionBase(int startAfterTicks, Consumer<IAction> task) {
|
||
this(task);
|
||
this.startAfterTicks = startAfterTicks;
|
||
}
|
||
|
||
public ActionBase(Consumer<IAction> task) {
|
||
this.name = task.toString();
|
||
this.task = task;
|
||
}
|
||
/**
|
||
* Called once per global tick; respects delay, interval, duration & done‐flag.
|
||
*/
|
||
public void tick(int ticksExisted) {
|
||
if (done) return;
|
||
|
||
if (startAfterTicks > 0) {
|
||
startAfterTicks--;
|
||
return;
|
||
}
|
||
// only run on our update tick
|
||
if (ticksExisted % updateEveryXTick == 0) {
|
||
task.accept(this);
|
||
count++;
|
||
}
|
||
duration++;
|
||
}
|
||
|
||
@Override
|
||
public int getCount() {
|
||
return count;
|
||
}
|
||
|
||
@Override
|
||
public int getDuration() {
|
||
return duration;
|
||
}
|
||
|
||
@Override
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
@Override
|
||
public int getMaxDuration() {
|
||
return maxDuration;
|
||
}
|
||
|
||
@Override
|
||
public void markDone() {
|
||
done = true;
|
||
}
|
||
|
||
@Override
|
||
public boolean isDone() {
|
||
return done;
|
||
}
|
||
|
||
private final java.util.Map<String, Object> dataStore = new java.util.HashMap<>();
|
||
@Override
|
||
public Object getData(String key) {
|
||
return dataStore.get(key);
|
||
}
|
||
|
||
@Override
|
||
public void addData(String key, Object v) {
|
||
dataStore.put(key, v);
|
||
}
|
||
|
||
@Override
|
||
public int getUpdateEveryXTick() {
|
||
return updateEveryXTick;
|
||
}
|
||
|
||
@Override
|
||
public void setUpdateEveryXTick(int x) {
|
||
updateEveryXTick = x;
|
||
}
|
||
|
||
@Override
|
||
public int getStartAfterTicks() {
|
||
return startAfterTicks;
|
||
}
|
||
|
||
@Override
|
||
public IAction getNext() {
|
||
int idx = getIndex(this);
|
||
return (idx >= 0 && idx + 1 < actionQueue.size())
|
||
? ((LinkedList<IAction>) actionQueue).get(idx + 1)
|
||
: null;
|
||
}
|
||
|
||
@Override
|
||
public IAction getPrevious() {
|
||
int idx = getIndex(this);
|
||
return (idx > 0)
|
||
? ((LinkedList<IAction>) actionQueue).get(idx - 1)
|
||
: null;
|
||
}
|
||
|
||
/////////////////////////////////////////////////
|
||
/////////////////////////////////////////////////
|
||
//After chains
|
||
@Override
|
||
public IAction after(IAction after) {
|
||
int idx = getIndex(this);
|
||
if (idx >= 0) scheduleActionAt(idx + 1, after);
|
||
return after;
|
||
}
|
||
|
||
@Override
|
||
public IAction after(String name, int maxDuration, int delay, Consumer<IAction> t) {
|
||
return after(create(name, maxDuration, delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction after(String name, int delay, Consumer<IAction> t) {
|
||
return after(create(name, delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction after(int delay, Consumer<IAction> t) {
|
||
return after(create(delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction after(String name, Consumer<IAction> t) {
|
||
return after(create(name, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction after(Consumer<IAction> t) {
|
||
return after(create(t));
|
||
|
||
}
|
||
|
||
/////////////////////////////////////////////////
|
||
/////////////////////////////////////////////////
|
||
//Before chains
|
||
@Override
|
||
public IAction before(IAction before) {
|
||
int idx = getIndex(this);
|
||
if (idx >= 0) scheduleActionAt(Math.max(0, idx), before);
|
||
return before;
|
||
}
|
||
|
||
@Override
|
||
public IAction before(String name, int maxDuration, int delay, Consumer<IAction> t) {
|
||
return before(create(name, maxDuration, delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction before(String name, int delay, Consumer<IAction> t) {
|
||
return before(create(name, delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction before(int delay, Consumer<IAction> t) {
|
||
return before(create(delay, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction before(String name, Consumer<IAction> t) {
|
||
return before(create(name, t));
|
||
}
|
||
|
||
@Override
|
||
public IAction before(Consumer<IAction> t) {
|
||
return before(create(t));
|
||
|
||
}
|
||
}
|
||
|
||
private class Action extends ActionBase {
|
||
public Action(String name, int maxDuration, int startAfterTicks, Consumer<IAction> task) {
|
||
super(name, maxDuration, startAfterTicks, task);
|
||
}
|
||
|
||
public Action(String name, int startAfterTicks, Consumer<IAction> task) {
|
||
super(name, startAfterTicks, task);
|
||
}
|
||
|
||
public Action(String name, Consumer<IAction> task) {
|
||
super(name, task);
|
||
}
|
||
|
||
public Action(int startAfterTicks, Consumer<IAction> task) {
|
||
super(startAfterTicks, task);
|
||
}
|
||
|
||
public Action(Consumer<IAction> task) {
|
||
super(task);
|
||
}
|
||
|
||
@Override public int getCheckCount() { return 0; }
|
||
|
||
@Override public int getMaxChecks() { return 0; }
|
||
}
|
||
|
||
private class ConditionalAction extends ActionBase {
|
||
private final Supplier<Boolean> predicate;
|
||
private Supplier<Boolean> terminate;
|
||
private final int maxChecks;
|
||
private int checkCount = 0;
|
||
|
||
public ConditionalAction(String name,
|
||
int checkIntervalTicks,
|
||
Supplier<Boolean> predicate,
|
||
Consumer<IAction> task,
|
||
int maxChecks) {
|
||
super(name, Integer.MAX_VALUE, 0, task);
|
||
this.predicate = predicate;
|
||
this.updateEveryXTick = checkIntervalTicks;
|
||
this.maxChecks = maxChecks;
|
||
}
|
||
|
||
public ConditionalAction(String name, int checkIntervalTicks, Supplier<Boolean> predicate, Supplier<Boolean> terminate, Consumer<IAction> task, int maxChecks) {
|
||
this(name, checkIntervalTicks, predicate, task, maxChecks);
|
||
this.terminate = terminate;
|
||
}
|
||
|
||
@Override
|
||
public void tick(int ticksExisted) {
|
||
if (isDone()) return;
|
||
if (ticksExisted % updateEveryXTick == 0) {
|
||
checkCount++;
|
||
if ((maxChecks >= 0 && checkCount > maxChecks) || terminate != null && terminate.get()) {
|
||
markDone();
|
||
return;
|
||
}
|
||
if (predicate.get())
|
||
task.accept(this);
|
||
}
|
||
}
|
||
|
||
@Override public int getCheckCount() { return checkCount; }
|
||
|
||
@Override public int getMaxChecks() { return maxChecks; }
|
||
}
|
||
}
|