Merge pull request #13 from SkriptDev/dev/patch

Dev/patch - Future Patch Release

Author: ShaneBeee

build.gradle.kts

@@ -26,7 +26,7 @@ repositories {
 dependencies {
     compileOnly("com.hypixel.hytale:Server:${hytaleVersion}")
     compileOnly("org.jetbrains:annotations:26.0.2")
-    implementation("com.github.SkriptDev:skript-parser:1.0.6") {
+    implementation("com.github.SkriptDev:skript-parser:1.0.7") {
         isTransitive = false
     }
     implementation("com.github.Zoltus:TinyMessage:2.0.1") {

src/main/java/com/github/skriptdev/skript/api/skript/ErrorHandler.java

@@ -21,7 +21,7 @@ public static void init() {
         for (SyntaxInfo<? extends Effect> effect : SyntaxManager.getEffects()) {
             EFFECT_MAP.put(effect.getSyntaxClass().getSimpleName(), effect);
         }
-        for (SkriptEventInfo<?> event : SyntaxManager.getEvents()) {
+        for (SkriptEventInfo<?> event : SyntaxManager.getTriggers()) {
             EVENT_MAP.put(event.getSyntaxClass().getSimpleName(), event);
         }
         setup();

src/main/java/com/github/skriptdev/skript/api/skript/command/ScriptCommandBuilder.java

@@ -9,6 +9,7 @@
 import com.hypixel.hytale.component.Store;
 import com.hypixel.hytale.server.core.command.system.AbstractCommand;
 import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.CommandRegistration;
 import com.hypixel.hytale.server.core.command.system.CommandSender;
 import com.hypixel.hytale.server.core.command.system.arguments.system.Argument;
 import com.hypixel.hytale.server.core.command.system.arguments.system.OptionalArg;
@@ -39,6 +40,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Builder for Script Commands.
@@ -57,6 +59,7 @@ public static ScriptCommandBuilder create(int commandType, SkriptLogger logger)
     private final Map<String, CommandArg> args = new LinkedHashMap<>();
     private final Map<String, Argument<?, ?>> argsFromCommand = new LinkedHashMap<>();
     private AbstractCommand hyCommand;
+    private CommandRegistration commandRegistration;
 
     private final SectionConfiguration sec = new SectionConfiguration.Builder()
         .addOptionalLiteral("can-generate-permission", Boolean.class)
@@ -171,14 +174,29 @@ protected boolean canGeneratePermission() {
                     protected @Nullable CompletableFuture<Void> execute(@NotNull CommandContext commandContext) {
                         CompletableFuture.runAsync(() -> {
                             CommandSender sender = commandContext.sender();
-                            Player player = null;
-                            if (sender instanceof Player p) player = p;
-                            ScriptCommandContext context = new ScriptCommandContext(ScriptCommandBuilder.this.commandName,
-                                sender);
-
-                            createLocalVariables(commandContext, context);
-                            Statement.runAll(trigger, context);
-                            Variables.clearLocalVariables(context);
+
+                            AtomicReference<ScriptCommandContext> context = new AtomicReference<>();
+
+                            Runnable code = () -> {
+                                createLocalVariables(commandContext, context.get());
+                                Statement.runAll(trigger, context.get());
+                                Variables.clearLocalVariables(context.get());
+                            };
+
+                            if (sender instanceof Player player && player.getWorld() != null) {
+                                // If a player runs the command, run it in their world
+                                context.set(new PlayerScriptCommandContext(commandName, player));
+                                World world = player.getWorld();
+                                if (world.isInThread()) {
+                                    code.run();
+                                } else {
+                                    world.execute(code);
+                                }
+                            } else {
+                                // Otherwise run as normal
+                                context.set(new ScriptCommandContext(commandName, sender));
+                                code.run();
+                            }
                         });
                         return null;
                     }
@@ -263,6 +281,12 @@ private void createLocalVariables(CommandContext ctx, TriggerContext triggerCont
         });
     }
 
+    public void unregister() {
+        if (this.commandRegistration != null) {
+            this.commandRegistration.unregister();
+        }
+    }
+
     public String getCommandName() {
         return this.commandName;
     }
@@ -275,7 +299,7 @@ public void build(ScriptCommandBuilder parent) {
         if (this.hyCommand == null) return;
 
         if (parent == null) {
-            HySk.getInstance().getCommandRegistry().registerCommand(this.hyCommand);
+            this.commandRegistration = HySk.getInstance().getCommandRegistry().registerCommand(this.hyCommand);
         } else {
             parent.hyCommand.addSubCommand(this.hyCommand);
         }

src/main/java/com/github/skriptdev/skript/api/skript/config/SkriptConfig.java

@@ -10,14 +10,25 @@
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * Config for Skript
  */
 public class SkriptConfig {
 
-    private final Config config;
+    private Config config;
     private final boolean debug;
     private final int maxTargetBlockDistance;
     private final ConfigSection effectCommands;
@@ -40,8 +51,15 @@ public SkriptConfig(Skript skript) {
             logger.debug("Checking for update from: " + configVersion);
             Semver hySkriptVersion = skript.getPlugin().getManifest().getVersion();
             if (configVersion.compareTo(hySkriptVersion) < 0) {
-                logger.debug("Updating config to version: " + hySkriptVersion);
-                updateConfig();
+                logger.info("Updating config to version: " + hySkriptVersion);
+                try {
+                    // Update the config from the default config
+                    updateConfig(skriptConfigPath, hySkriptVersion.toString());
+                    // Reload the config so we have updated values
+                    this.config = new Config(skriptConfigPath, "/config.sk", logger);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
             } else {
                 logger.debug("Config is up to date");
             }
@@ -51,25 +69,20 @@ public SkriptConfig(Skript skript) {
 
         // Set up max-target-block-distance
         this.maxTargetBlockDistance = this.config.getInt("max-target-block-distance");
-        if (this.maxTargetBlockDistance == -1) {
-            // This would happen if the config is missing this value
-            // TODO update config
-        } else if (this.maxTargetBlockDistance < 0) {
+        if (this.maxTargetBlockDistance < 0) {
             logger.error("max-target-block-distance must be greater than or equal to 0", ErrorType.STRUCTURE_ERROR);
         }
 
         // Set up effect commands
         this.effectCommands = this.config.getConfigSection("effect-commands");
         if (this.effectCommands == null) {
             logger.error("Effect commands section not found in config.sk", ErrorType.STRUCTURE_ERROR);
-            // TODO update config
         }
 
         // Set up databases
         this.databases = this.config.getConfigSection("databases");
         if (this.databases == null) {
             logger.error("Databases section not found in config.sk", ErrorType.STRUCTURE_ERROR);
-            // TODO update config
         }
 
         // Set up commands generate permissions
@@ -131,8 +144,71 @@ public boolean getCommandsGeneratePermissions() {
         return this.commandsGeneratePermissions;
     }
 
-    private void updateConfig() {
-        // TODO update config
+    @SuppressWarnings("resource")
+    private void updateConfig(Path userPath, String version) throws IOException {
+        Set<String> userKeys = Files.lines(userPath)
+            .map(String::trim)
+            .filter(l -> !l.startsWith("#") && l.contains(":"))
+            .map(l -> l.split(":")[0].trim())
+            .collect(Collectors.toSet());
+
+        InputStream stream = SkriptConfig.class.getResourceAsStream("/config.sk");
+        assert stream != null;
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
+             BufferedWriter writer = Files.newBufferedWriter(userPath, StandardOpenOption.APPEND)) {
+
+            List<String> commentBuffer = new ArrayList<>();
+            String line;
+
+            while ((line = reader.readLine()) != null) {
+                String trimmed = line.trim();
+
+                if (trimmed.startsWith("#")) {
+                    // It's a comment, save it for the next key we find
+                    commentBuffer.add(line);
+                } else if (trimmed.contains(":")) {
+                    String key = trimmed.split(":")[0].trim();
+
+                    if (!userKeys.contains(key)) {
+                        // User is missing this key!
+                        writer.newLine(); // Add spacing for readability
+
+                        // Write the buffered comments first
+                        for (String comment : commentBuffer) {
+                            writer.write(comment);
+                            writer.newLine();
+                        }
+                        // Write the actual key-value pair
+                        writer.write(line);
+                        writer.newLine();
+                    }
+                    // Clear buffer regardless of whether we wrote it or not
+                    commentBuffer.clear();
+                } else if (trimmed.isEmpty()) {
+                    commentBuffer.clear();
+                }
+            }
+        }
+
+        updateConfigVersion(userPath, version);
+    }
+
+    private void updateConfigVersion(Path userPath, String newVersion) throws IOException {
+        List<String> lines = Files.readAllLines(userPath);
+        boolean updated = false;
+
+        for (int i = 0; i < lines.size(); i++) {
+            String line = lines.get(i).trim();
+            if (line.startsWith("hyskript-version:")) {
+                lines.set(i, "hyskript-version: " + newVersion);
+                updated = true;
+                break;
+            }
+        }
+
+        if (updated) {
+            Files.write(userPath, lines);
+        }
     }
 
 }