Update 4 ready

AzureDoom · AzureDoom · commit 6365c9ad5103 · 2026-03-21T20:21:34.000-04:00
diff --git a/build.gradle b/build.gradle
@@ -21,6 +21,11 @@ configurations {
         canBeConsumed = false
         extendsFrom(vineImplementation, vineCompileOnly)
     }
+    vineServerJar {
+        canBeResolved = true
+        canBeConsumed = false
+        transitive = false
+    }
     implementation.extendsFrom(vineImplementation)
     compileOnly.extendsFrom(vineCompileOnly)
 }
@@ -35,6 +40,10 @@ java {
     toolchain.languageVersion = JavaLanguageVersion.of(java_version)
 }
 
+hytale {
+    updateChannel = "pre-release"
+}
+
 repositories {
     mavenCentral()
     maven {
@@ -78,9 +87,13 @@ repositories {
     }
 }
 
+def hytaleServerDep = 'com.hypixel.hytale:Server:2026.03.20-db226053c'
+
 dependencies {
+    vineServerJar hytaleServerDep
+    vineCompileOnly hytaleServerDep
     vineflowerTool 'org.vineflower:vineflower:1.11.2'
-    implementation 'com.azuredoom.levelingcore:LevelingCore:0.+'
+    implementation 'com.azuredoom.levelingcore:LevelingCore:1.0.0-alpha2'
     vineImplementation 'curse.maven:hyui-1431415:7693755'
     vineImplementation 'curse.maven:dynamictooltipslib-1459711:7702598'
     vineCompileOnly 'at.helpch:placeholderapi-hytale:1.0.7'
@@ -188,76 +201,77 @@ publishing {
 
 tasks.register("decompileLibsWithVineflower") {
     group = "decompilation"
-    description = "Decompile /libs jars + implementation/compileOnly deps (compileClasspath) into build/vineflower/<jarName>/"
+    description = "Decompile only com/hytale from the Hytale Server jar into build/vineflower/hytale-server/"
 
-    def libsDir = file("$rootDir/libs")
-    def outDir = file("$buildDir/vineflower")
+    def outDir = file("$buildDir/vineflower/hytale-server")
+    def tempDir = file("$buildDir/tmp/vineflower")
+    def serverConfig = configurations.vineServerJar
+    def classpathConfig = configurations.vineDecompileClasspath
 
-    def depConfig = configurations.vineDecompileClasspath
-
-    inputs.files(depConfig)
-    inputs.dir(libsDir)
+    inputs.files(serverConfig, classpathConfig)
     outputs.dir(outDir)
 
     doLast {
         outDir.mkdirs()
+        tempDir.mkdirs()
 
         def vineflowerJar = configurations.vineflowerTool.singleFile
 
         def javaExe = javaToolchains.launcherFor {
             languageVersion = JavaLanguageVersion.of(java_version)
         }.get().executablePath.asFile.absolutePath
 
-
-        def localJars = libsDir.exists()
-                ? fileTree(dir: libsDir, include: ["*.jar"]).files
-                : [] as Set<File>
-
-        def depJars = depConfig.incoming.artifactView { it.lenient(true) }
-                .files.files
-                .findAll { it.name.endsWith(".jar") } as Set<File>
-
-        def jars = (localJars + depJars).toList().unique()
-
-        if (jars.isEmpty()) {
-            logger.lifecycle("No .jar files found in /libs or on compileClasspath.")
-            return
+        def serverJar = serverConfig.singleFile
+        if (!serverJar.exists()) {
+            throw new GradleException("Could not resolve Hytale Server jar from vineServerJar")
         }
 
-        jars.each { jarFile ->
-            def jarBase = jarFile.name.replaceAll(/\.jar$/, "")
-            def jarOut = new File(outDir, jarBase)
-            jarOut.mkdirs()
-
-            def externals = jars.findAll { it != jarFile }
-                    .collectMany { ["-e", it.absolutePath] }
-
-            def cmd = [
-                    javaExe,
-                    "-jar", vineflowerJar.absolutePath,
-                    *externals,
-                    jarFile.absolutePath,
-                    jarOut.absolutePath
-            ]
+        def filteredJar = new File(tempDir, "Server-com-hytale-only.jar")
+        if (filteredJar.exists()) {
+            filteredJar.delete()
+        }
 
-            logger.lifecycle("Running: ${cmd.join(' ')}")
+        // Build a temp jar containing only com/hytale classes/resources
+        ant.jar(destfile: filteredJar.absolutePath) {
+            zipfileset(src: serverJar.absolutePath) {
+                include(name: "com/hytale/**")
+            }
+        }
 
-            def pb = new ProcessBuilder(cmd)
-            pb.directory(project.projectDir)
-            pb.redirectErrorStream(true)
+        if (!filteredJar.exists() || filteredJar.length() == 0) {
+            throw new GradleException("Filtered jar is empty. Nothing matched com/hytale/** inside ${serverJar.name}")
+        }
 
-            def proc = pb.start()
-            proc.inputStream.withReader { r ->
-                r.eachLine { line -> logger.lifecycle(line) }
-            }
+        def externals = classpathConfig.incoming.artifactView { it.lenient(true) }
+                .files.files
+                .findAll { it.name.endsWith(".jar") && it != serverJar }
+                .collectMany { ["-e", it.absolutePath] }
+
+        def cmd = [
+                javaExe,
+                "-jar", vineflowerJar.absolutePath,
+                *externals,
+                filteredJar.absolutePath,
+                outDir.absolutePath
+        ]
+
+        logger.lifecycle("Running: ${cmd.join(' ')}")
+
+        def pb = new ProcessBuilder(cmd)
+        pb.directory(project.projectDir)
+        pb.redirectErrorStream(true)
+
+        def proc = pb.start()
+        proc.inputStream.withReader { r ->
+            r.eachLine { line -> logger.lifecycle(line) }
+        }
 
-            def exit = proc.waitFor()
-            if (exit != 0) {
-                logger.lifecycle("Vineflower failed for ${jarFile.name} (exit ${exit})")
-            } else {
-                logger.lifecycle("Decompiled ${jarFile.name} -> ${jarOut}")
-            }
+        def exit = proc.waitFor()
+        if (exit != 0) {
+            throw new GradleException("Vineflower failed (exit ${exit})")
         }
+
+        logger.lifecycle("Decompiled com/hytale from ${serverJar.name} -> ${outDir}")
     }
 }
 
diff --git a/gradle.properties b/gradle.properties
@@ -6,7 +6,7 @@ org.gradle.caching                   = true
 
 # Common
 java_version                         = 25
-hytale_version                       = 2026.02.19-1a311a592
+hytale_version                       = 2026.03.20-db226053c
 release_type                         = RELEASE
 maven_url                            = https://maven.azuredoom.com/mods
 
@@ -28,7 +28,7 @@ includes_pack                        = true
 disabled_by_default                  = false
 patchline                            = release
 load_user_mods                       = false
-server_version                       = 2026.02.19-1a311a592
+server_version                       = 2026.03.20-db226053c
 manifest_dependencies                = Hytale:EntityModule=*,Hytale:InteractionModule=*,Hytale:DamageModule=*,Hytale:AssetModule=*,com.azuredoom:levelingcore=*
 manifest_opt_dependencies            = Ellie:HyUI=*,org.herolias:DynamicTooltipsLib=*
 curseforgeID                         = 1486422
diff --git a/src/main/java/com/azuredoom/classescore/ClassesCore.java b/src/main/java/com/azuredoom/classescore/ClassesCore.java
@@ -22,7 +22,7 @@
 import com.azuredoom.classescore.data.ClassDefinition;
 import com.azuredoom.classescore.data.ClassRegistry;
 import com.azuredoom.classescore.exceptions.ClassesCoreException;
-import com.azuredoom.classescore.gameplay.services.armor.EquipBlockManager;
+import com.azuredoom.classescore.gameplay.services.armor.ArmorBlockClassSystem;
 import com.azuredoom.classescore.gameplay.services.damage.ClassDamageSystem;
 import com.azuredoom.classescore.gameplay.services.items.HandGateTickingSystem;
 import com.azuredoom.classescore.gameplay.services.items.ItemBlockPacketManager;
@@ -49,7 +49,7 @@ public class ClassesCore extends JavaPlugin {
         playerRestrictionCache
     );
 
-    public static final EquipBlockManager equipBlockManager = new EquipBlockManager(playerRestrictionCache);
+    public static final ArmorBlockClassSystem equipBlockManager = new ArmorBlockClassSystem(playerRestrictionCache);
 
     public ClassesCore(@NotNull JavaPluginInit init) {
         super(init);
@@ -98,7 +98,6 @@ protected void setup() {
                     playerRestrictionCache.clear(playerId);
                     ClassesCoreAPI.getClassServiceIfPresent().ifPresent(service -> service.evictPlayer(playerId));
                 });
-            ClassesCore.equipBlockManager.start();
         }
         if (PluginManager.get().getPlugin(new PluginIdentifier("org.herolias", "DynamicTooltipsLib")) != null) {
             DynamicTooltipsLibCompat.register();
@@ -125,7 +124,6 @@ protected void start() {
     protected void shutdown() {
         if (config.get().isEnableClassItemRestrictions()) {
             itemBlockPacketManager.shutdown();
-            equipBlockManager.shutdown();
         }
         var bootstrap = new ClassesBootstrap(this, config.get()).bootstrap();
         try {
@@ -139,6 +137,7 @@ public void registerAllSystems() {
         getEntityStoreRegistry().registerSystem(
             new HandGateTickingSystem(itemBlockPacketManager.getHandCheckState(), playerRestrictionCache)
         );
+        getEntityStoreRegistry().registerSystem(equipBlockManager);
         getEntityStoreRegistry().registerSystem(new ClassDamageSystem());
         getEntityStoreRegistry().registerSystem(new StatsTickingSystem());
     }
diff --git a/src/main/java/com/azuredoom/classescore/gameplay/services/armor/ArmorBlockClassSystem.java b/src/main/java/com/azuredoom/classescore/gameplay/services/armor/ArmorBlockClassSystem.java
@@ -0,0 +1,153 @@
+package com.azuredoom.classescore.gameplay.services.armor;
+
+import com.azuredoom.levelingcore.systems.equipment.ArmorBlockLevelSystem;
+import com.hypixel.hytale.server.core.HytaleServer;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.inventory.ItemStack;
+import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
+import com.hypixel.hytale.server.core.inventory.transaction.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
+
+import com.azuredoom.classescore.gameplay.services.items.PlayerRestrictionCache;
+import com.azuredoom.classescore.util.NotificationsUtil;
+
+public class ArmorBlockClassSystem extends ArmorBlockLevelSystem {
+
+    private final PlayerRestrictionCache restrictionCache;
+
+    public ArmorBlockClassSystem(PlayerRestrictionCache restrictionCache) {
+        super();
+        this.restrictionCache = restrictionCache;
+    }
+
+    @Override
+    protected void rollbackArmorTransaction(
+        @NotNull Player player,
+        @NotNull ItemContainer armorContainer,
+        @Nullable Transaction transaction,
+        @NotNull Set<String> refundedKeys
+    ) {
+        if (transaction == null || !transaction.succeeded()) {
+            return;
+        }
+
+        switch (transaction) {
+            case MoveTransaction<?> moveTransaction -> {
+                if (moveTransaction.getMoveType() == MoveType.MOVE_TO_SELF) {
+                    rollbackArmorTransaction(player, armorContainer, moveTransaction.getAddTransaction(), refundedKeys);
+                }
+            }
+            case ListTransaction<?> listTransaction -> {
+                for (var nested : listTransaction.getList()) {
+                    rollbackArmorTransaction(player, armorContainer, nested, refundedKeys);
+                }
+            }
+            case ItemStackTransaction itemStackTransaction -> {
+                for (var slotTransaction : itemStackTransaction.getSlotTransactions()) {
+                    rollbackArmorTransaction(player, armorContainer, slotTransaction, refundedKeys);
+                }
+            }
+            case SlotTransaction slotTransaction -> {
+                var before = slotTransaction.getSlotBefore();
+                var after = slotTransaction.getSlotAfter();
+
+                if (after == null || ItemStack.isEmpty(after)) {
+                    return;
+                }
+
+                if (sameStack(before, after)) {
+                    return;
+                }
+
+                var itemId = after.getItemId();
+                if (itemId.isEmpty()) {
+                    return;
+                }
+
+                var playerId = player.getUuid();
+                if (restrictionCache.canUseArmor(playerId, itemId)) {
+                    return;
+                }
+
+                var classId = restrictionCache.getClassId(playerId).orElse("Unknown");
+
+                NotificationsUtil.sendItemClassRestrictionNotification(
+                    player.getPlayerRef(),
+                    after,
+                    classId
+                );
+
+                var swapping = (before != null && !ItemStack.isEmpty(before));
+
+                armorContainer.setItemStackForSlot(slotTransaction.getSlot(), before, true);
+
+                var key = "armorSlot:" + slotTransaction.getSlot();
+                if (refundedKeys.add(key)) {
+                    giveOrDrop(player, after);
+
+                    if (swapping) {
+                        var removeOne = oneOf(before);
+                        player.getInventory().getCombinedHotbarFirst().removeItemStack(removeOne, false, true);
+                    }
+                }
+            }
+            default -> {}
+        }
+    }
+
+    @Override
+    public void validateArmorOnReady(@Nonnull Player player) {
+        ignoreArmorEvents.add(player.getUuid());
+        HytaleServer.SCHEDULED_EXECUTOR.schedule(
+            () -> ignoreArmorEvents.remove(player.getUuid()),
+            500L,
+            TimeUnit.MILLISECONDS
+        );
+
+        var inventory = player.getInventory();
+        var armor = inventory.getArmor();
+        if (armor == null) {
+            return;
+        }
+
+        var playerId = player.getUuid();
+
+        restoringArmor = true;
+        try {
+            var capacity = armor.getCapacity();
+            for (short slot = 0; slot < capacity; slot++) {
+                var stack = armor.getItemStack(slot);
+                if (stack == null || ItemStack.isEmpty(stack)) {
+                    continue;
+                }
+
+                var itemId = stack.getItemId();
+                if (itemId.isEmpty()) {
+                    continue;
+                }
+
+                if (restrictionCache.canUseArmor(playerId, itemId)) {
+                    continue;
+                }
+
+                var classId = restrictionCache.getClassId(playerId).orElse("Unknown");
+
+                NotificationsUtil.sendItemClassRestrictionNotification(
+                    player.getPlayerRef(),
+                    stack,
+                    classId
+                );
+
+                armor.setItemStackForSlot(slot, null, true);
+                giveOrDrop(player, stack);
+            }
+        } finally {
+            restoringArmor = false;
+        }
+    }
+}
diff --git a/src/main/java/com/azuredoom/classescore/gameplay/services/armor/EquipBlockManager.java b/src/main/java/com/azuredoom/classescore/gameplay/services/armor/EquipBlockManager.java
diff --git a/src/main/resources/manifest.json b/src/main/resources/manifest.json
