Add Scripts Loading/Unloading Events

src/main/java/ch/njol/skript/ScriptLoader.java

@@ -23,6 +23,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnknownNullability;
+import org.jetbrains.annotations.Unmodifiable;
 import org.skriptlang.skript.bukkit.text.TextComponentParser;
 import org.skriptlang.skript.lang.script.Script;
 import org.skriptlang.skript.lang.script.ScriptWarning;
@@ -635,6 +636,11 @@ record LoadingStructure (LoadingScriptInfo loadingScriptInfo, Structure structur
 					parser.setInactive();
 
 					// trigger events
+					List<Script> eventScripts = scripts.stream()
+						.map(LoadingScriptInfo::script)
+						.toList();
+					ScriptLoader.eventRegistry().events(ScriptsLoadEvent.class)
+							.forEach(event -> event.onLoad(parser, eventScripts));
 					scripts.forEach(loadingInfo -> {
 						Script script = loadingInfo.script;
 
@@ -900,6 +906,9 @@ record UnloadingStructure (Script script, Structure structure) {}
 			.collect(Collectors.toCollection(ArrayList::new));
 
 		// trigger unload event before unloading scripts
+		Set<Script> finalScripts = scripts;
+		eventRegistry().events(ScriptsUnloadEvent.class)
+			.forEach(event -> event.onUnload(parser, Collections.unmodifiableSet(finalScripts)));
 		for (Script script : scripts) {
 			eventRegistry().events(ScriptUnloadEvent.class)
 				.forEach(event -> event.onUnload(parser, script));
@@ -1272,6 +1281,24 @@ public interface ScriptInitEvent extends LoaderEvent {
 
 	}
 
+	/**
+	 * Called when a batch of {@link Script}s are loaded in the {@link ScriptLoader}.
+	 * This event will trigger <b>after</b> the scripts are completely loaded ({@link Structure} initialization finished).
+	 * @see #loadScripts(File, OpenCloseable)
+	 * @see #loadScripts(Set, OpenCloseable)
+	 */
+	@FunctionalInterface
+	public interface ScriptsLoadEvent extends LoaderEvent {
+
+		/**
+		 * The method that is called when this event triggers.
+		 * @param parser The ParserInstance handling the loading of <code>script</code>.
+		 * @param scripts The Scripts being loaded.
+		 */
+		void onLoad(ParserInstance parser, @Unmodifiable Collection<Script> scripts);
+
+	}
+
 	/**
 	 * Called when a {@link Script} is loaded in the {@link ScriptLoader}.
 	 * This event will trigger <b>after</b> the script is completely loaded ({@link Structure} initialization finished).
@@ -1290,6 +1317,23 @@ public interface ScriptLoadEvent extends LoaderEvent, Script.Event {
 
 	}
 
+	/**
+	 * Called when a batch of {@link Script}s are unloaded in the {@link ScriptLoader}.
+	 * This event will trigger <b>before</b> the scripts are unloaded.
+	 * @see #unloadScript(Script)
+	 */
+	@FunctionalInterface
+	public interface ScriptsUnloadEvent extends LoaderEvent {
+
+		/**
+		 * The method that is called when this event triggers.
+		 * @param parser The ParserInstance handling the unloading of <code>script</code>.
+		 * @param scripts The Scripts being unloaded.
+		 */
+		void onUnload(ParserInstance parser, @Unmodifiable Collection<Script> scripts);
+
+	}
+
 	/**
 	 * Called when a {@link Script} is unloaded in the {@link ScriptLoader}.
 	 * This event will trigger <b>before</b> the script is unloaded.

src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java

@@ -6,7 +6,6 @@
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.command.CommandEvent;
 import ch.njol.skript.entity.EntityData;
-import ch.njol.skript.events.bukkit.ScriptEvent;
 import ch.njol.skript.events.bukkit.SkriptStartEvent;
 import ch.njol.skript.events.bukkit.SkriptStopEvent;
 import ch.njol.skript.util.*;
@@ -434,8 +433,6 @@ else if (hand == EquipmentSlot.OFF_HAND)
 		registry.register(EventValue.simple(CommandEvent.class, Block.class, event -> event.getSender() instanceof BlockCommandSender sender ? sender.getBlock() : null));
 
 		// === ServerEvents ===
-		// Script load/unload event
-		registry.register(EventValue.simple(ScriptEvent.class, CommandSender.class, event -> Bukkit.getConsoleSender()));
 		// Server load event
 		registry.register(EventValue.simple(SkriptStartEvent.class, CommandSender.class, event -> Bukkit.getConsoleSender()));
 		// Server stop event

src/main/java/ch/njol/skript/events/bukkit/ScriptEvent.java

@@ -4,8 +4,10 @@
 import org.bukkit.event.HandlerList;
 
 /**
- * @author Peter Güttinger
+ * @deprecated This event was never actually called.
+ * It is only used as a context holder for certain events.
  */
+@Deprecated(since = "INSERT VERSION", forRemoval = true)
 public class ScriptEvent extends Event {
 
 	public ScriptEvent() {}

src/main/java/org/skriptlang/skript/common/CommonModule.java

@@ -6,6 +6,7 @@
 import org.skriptlang.skript.addon.SkriptAddon;
 import org.skriptlang.skript.common.elements.expressions.*;
 import org.skriptlang.skript.common.properties.PropertiesModule;
+import org.skriptlang.skript.common.script.ScriptModule;
 import org.skriptlang.skript.common.types.*;
 
 import java.util.List;
@@ -15,7 +16,8 @@ public class CommonModule extends HierarchicalAddonModule {
 	@Override
 	public Iterable<AddonModule> children() {
 		return List.of(
-			new PropertiesModule(this)
+			new PropertiesModule(this),
+			new ScriptModule(this)
 		);
 	}
 

src/main/java/org/skriptlang/skript/common/script/ScriptModule.java

@@ -0,0 +1,32 @@
+package org.skriptlang.skript.common.script;
+
+import org.skriptlang.skript.addon.AddonModule;
+import org.skriptlang.skript.addon.HierarchicalAddonModule;
+import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValueRegistry;
+import org.skriptlang.skript.common.script.elements.events.*;
+import org.skriptlang.skript.common.script.elements.expressions.*;
+
+public class ScriptModule extends HierarchicalAddonModule {
+
+	public ScriptModule(AddonModule parentModule) {
+		super(parentModule);
+	}
+
+	@Override
+	protected void loadSelf(SkriptAddon addon) {
+		EventValueRegistry eventValueRegistry = addon.registry(EventValueRegistry.class);
+		register(addon,
+			syntaxRegistry -> EvtScript.register(syntaxRegistry, eventValueRegistry),
+			EvtScripts::register,
+			ExprLoadingScripts::register,
+			ExprUnloadingScripts::register
+		);
+	}
+
+	@Override
+	public String name() {
+		return "script";
+	}
+
+}

src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScript.java

@@ -0,0 +1,98 @@
+package org.skriptlang.skript.common.script.elements.events;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.Trigger;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValue;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValueRegistry;
+import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+public class EvtScript extends SkriptEvent {
+
+	private static class ScriptEvent extends Event {
+		@Override
+		public @NotNull HandlerList getHandlers() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	public static void register(SyntaxRegistry syntaxRegistry, EventValueRegistry eventValueRegistry) {
+		syntaxRegistry.register(BukkitSyntaxInfos.Event.KEY, BukkitSyntaxInfos.Event.builder(EvtScript.class, "Script Load/Unload")
+			.supplier(EvtScript::new)
+			.addEvent(ScriptEvent.class)
+			.addPatterns("[:async] [script] (load|init|enable)",
+				"[:async] [script] (unload|stop|disable)")
+			.addDescription("""
+				Called directly after the trigger is loaded, or directly before the whole script is unloaded. \
+				The keyword 'async' indicates the trigger can be executed asynchronously.
+				""")
+			.addExample("""
+				on load:
+					set {running::%script%} to true
+				on unload:
+					set {running::%script%} to false
+				""")
+			.addSince("2.0")
+			.build());
+		eventValueRegistry.register(EventValue.simple(ScriptEvent.class, CommandSender.class,
+			ignored -> Bukkit.getConsoleSender()));
+	}
+
+	private boolean async;
+	private boolean load;
+
+	@Override
+	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
+		async = parseResult.hasTag("async");
+		load = matchedPattern == 0;
+		return true;
+	}
+
+	@Override
+	public boolean postLoad() {
+		if (load) {
+			runTrigger(trigger, new ScriptEvent());
+		}
+		return true;
+	}
+
+	@Override
+	public void unload() {
+		if (!load) {
+			runTrigger(trigger, new ScriptEvent());
+		}
+	}
+
+	@Override
+	public boolean check(Event event) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public boolean isEventPrioritySupported() {
+		return false;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return (async ? "async " : "") + "script " + (load ? "" : "un") + "load";
+	}
+
+	private void runTrigger(Trigger trigger, Event event) {
+		if (async || Bukkit.isPrimaryThread()) {
+			trigger.execute(event);
+		} else if (Skript.getInstance().isEnabled()) {
+			Bukkit.getScheduler().scheduleSyncDelayedTask(Skript.getInstance(), () -> trigger.execute(event));
+		}
+	}
+
+}