From 2824b526ecbc8d601edc822c2aca503967f08a1c Mon Sep 17 00:00:00 2001 From: Lotzyprod Date: Mon, 5 Feb 2024 10:18:20 +0300 Subject: [PATCH] Added sync-only entry in custom events --- .../syntax/event/SyncOnlyEntryData.java | 40 +++++++++++++++++++ .../syntax/event/elements/CustomEvent.java | 16 ++++++-- .../event/elements/StructCustomEvent.java | 28 +++++++++---- 3 files changed, 72 insertions(+), 12 deletions(-) create mode 100644 src/main/java/org/skriptlang/reflect/syntax/event/SyncOnlyEntryData.java diff --git a/src/main/java/org/skriptlang/reflect/syntax/event/SyncOnlyEntryData.java b/src/main/java/org/skriptlang/reflect/syntax/event/SyncOnlyEntryData.java new file mode 100644 index 0000000..cf33ca7 --- /dev/null +++ b/src/main/java/org/skriptlang/reflect/syntax/event/SyncOnlyEntryData.java @@ -0,0 +1,40 @@ +package org.skriptlang.reflect.syntax.event; + +import ch.njol.skript.ScriptLoader; +import ch.njol.skript.Skript; +import ch.njol.skript.config.Node; +import ch.njol.skript.config.SimpleNode; +import org.eclipse.jdt.annotation.Nullable; +import org.skriptlang.skript.lang.entry.KeyValueEntryData; + +public class SyncOnlyEntryData extends KeyValueEntryData { + + public SyncOnlyEntryData(String key, @Nullable Boolean defaultValue, boolean optional) { + super(key, defaultValue, optional); + } + + @Override + @Nullable + protected Boolean getValue(String value) { + if (!(value.equalsIgnoreCase("false") || value.equalsIgnoreCase("true"))) { + Skript.error("Sync only entry can be only true or false."); + return null; + } + return Boolean.valueOf(value); + } + + @Override + public final boolean canCreateWith(Node node) { + if (!(node instanceof SimpleNode)) + return false; + String key = node.getKey(); + if (key == null) + return false; + return canCreateWith(ScriptLoader.replaceOptions(key)); + } + + protected boolean canCreateWith(String node) { + return node.startsWith(getKey() + getSeparator()); + } + +} diff --git a/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java b/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java index dbc515c..19010a0 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java +++ b/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java @@ -31,7 +31,8 @@ public class CustomEvent extends SkriptEvent { private Expression[] exprs; private SkriptParser.ParseResult parseResult; private Object variablesMap; - + private boolean syncOnly; + @Override public boolean init(Literal[] args, int matchedPattern, SkriptParser.ParseResult parseResult) { which = StructCustomEvent.lookup(SkriptUtil.getCurrentScript(), matchedPattern); @@ -39,7 +40,7 @@ public boolean init(Literal[] args, int matchedPattern, SkriptParser.ParseRes if (which == null) { return false; } - + this.exprs = Arrays.stream(args) .map(SkriptUtil::defendExpression) .toArray(Expression[]::new); @@ -48,7 +49,9 @@ public boolean init(Literal[] args, int matchedPattern, SkriptParser.ParseRes if (!SkriptUtil.canInitSafely(this.exprs)) { return false; } - + + syncOnly = StructCustomEvent.syncOnly.get(which); + Boolean bool = StructCustomEvent.parseSectionLoaded.get(which); if (bool != null && !bool) { Skript.error("You can't use custom events with parse sections before they're loaded."); @@ -83,7 +86,12 @@ public boolean load() { CustomEvent.setLastWhich(null); return parsed; } - + + @Override + public boolean canExecuteAsynchronously() { + return !syncOnly; + } + @Override public boolean check(Event e) { BukkitCustomEvent bukkitCustomEvent = (BukkitCustomEvent) e; diff --git a/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java b/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java index d526ff1..00b93cd 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java +++ b/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java @@ -18,6 +18,7 @@ import org.skriptlang.reflect.syntax.event.EventSyntaxInfo; import org.skriptlang.reflect.syntax.event.EventTriggerEvent; import org.skriptlang.reflect.syntax.event.EventValuesEntryData; +import org.skriptlang.reflect.syntax.event.SyncOnlyEntryData; import org.skriptlang.skript.lang.entry.EntryContainer; import org.skriptlang.skript.lang.script.Script; @@ -34,6 +35,11 @@ public class StructCustomEvent extends CustomSyntaxStructure { static { Skript.registerStructure(StructCustomEvent.class, customSyntaxValidator() .addEntry("pattern", null, true) + .addEntryData(new SyncOnlyEntryData("sync only", false, true) { + public boolean canCreateWith(String node) { + return super.canCreateWith(node) || node.startsWith(getKey().replace(' ', '-') + getSeparator()); + } + }) .addEntryData(new EventValuesEntryData("event values", null, true) { @Override public boolean canCreateWith(String node) { @@ -47,13 +53,14 @@ public boolean canCreateWith(String node) { } private static final DataTracker dataTracker = new DataTracker<>(); - + static final Map nameValues = new HashMap<>(); static final Map>> eventValueTypes = new HashMap<>(); static final Map parserHandlers = new HashMap<>(); static final Map eventHandlers = new HashMap<>(); static final Map parseSectionLoaded = new HashMap<>(); - + static final Map syncOnly = new HashMap<>(); + static { Skript.registerEvent("custom event", CustomEvent.class, BukkitCustomEvent.class); Optional> info = Skript.getEvents().stream() @@ -66,6 +73,7 @@ public boolean canCreateWith(String node) { dataTracker.addManaged(parserHandlers); dataTracker.addManaged(eventHandlers); dataTracker.addManaged(parseSectionLoaded); + dataTracker.addManaged(syncOnly); } private SectionNode parseNode; @@ -90,25 +98,29 @@ public boolean init(Literal[] args, int matchedPattern, SkriptParser.ParseRes } else if (patternNode != null) { patterns = Collections.singletonList(patternNode); } - + if (patterns == null || patterns.isEmpty()) { // Always false. Used for the error return checkHasPatterns(); } - + + boolean syncOnlyEntry = entryContainer.getOptional("sync only", Boolean.class, true); + int i = 1; for (String pattern : patterns) { register(EventSyntaxInfo.create(script, pattern, i++)); } - + String name = (String) args[0].getSingle(); if (nameValues.values().stream().anyMatch(name::equalsIgnoreCase)) { Skript.error("There is already a custom event with that name"); return false; } - + + whichInfo.forEach(which -> syncOnly.put(which, syncOnlyEntry)); + whichInfo.forEach(which -> nameValues.put(which, name)); - + // Register the custom events during #init, rather than #preLoad super.preLoad(); return true; @@ -134,7 +146,7 @@ public boolean load() { SkriptReflection.replaceEventValues(classInfoList); whichInfo.forEach(which -> eventValueTypes.put(which, classInfoList)); } - + if (parseNode != null) { SkriptLogger.setNode(parseNode); SyntaxParseEvent.register(parseNode, whichInfo, parserHandlers);