Custom events and reloading now fully work

common/src/main/java/me/caseload/knockbacksync/Base.java

@@ -43,7 +43,7 @@ public abstract class Base {
     @Getter protected SchedulerAdapter scheduler;
     @Getter protected ConfigManager configManager;
     protected CommandManager<Sender> commandManager;
-    private final EventBus simpleEventBus = new OptimizedEventBus();
+    @Getter protected final EventBus simpleEventBus = new OptimizedEventBus();
 
     @Getter
     protected AbstractPlayerSelectorParser<Sender> playerSelectorParser;

common/src/main/java/me/caseload/knockbacksync/command/subcommand/ReloadCommand.java

@@ -40,6 +40,7 @@ public class ReloadCommand implements BuilderCommand {
                             context.sender().sendMessage(reloadMessage);
                         })
         );
+        Base.INSTANCE.getSimpleEventBus().registerListeners(this);
     }
 
     @KBSyncEventHandler

common/src/main/java/me/caseload/knockbacksync/command/subcommand/StatusCommand.java

@@ -72,6 +72,7 @@ public class StatusCommand implements BuilderCommand {
                             }
                         })
         );
+        Base.INSTANCE.getSimpleEventBus().registerListeners(this);
     }
 
     private void showPlayerStatus(Sender sender, PlatformPlayer target) {

common/src/main/java/me/caseload/knockbacksync/event/EventBus.java

@@ -2,6 +2,12 @@ package me.caseload.knockbacksync.event;
 
 public interface EventBus {
     void registerListeners(Object listener);
+
+    void registerStaticListeners(Class<?> clazz);
+
     void unregisterListeners(Object listener);
+
+    void unregisterStaticListeners(Class<?> clazz);
+
     void post(Event event);
 }

common/src/main/java/me/caseload/knockbacksync/event/OptimizedEventBus.java

@@ -3,6 +3,7 @@ package me.caseload.knockbacksync.event;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -14,14 +15,28 @@ public class OptimizedEventBus implements EventBus {
 
     @Override
     public void registerListeners(Object listener) {
-        for (Method method : listener.getClass().getDeclaredMethods()) {
+        registerMethods(listener, listener.getClass());
+    }
+
+    @Override
+    public void registerStaticListeners(Class<?> clazz) {
+        registerMethods(null, clazz);
+    }
+
+    private void registerMethods(Object instance, Class<?> clazz) {
+        for (Method method : clazz.getDeclaredMethods()) {
             KBSyncEventHandler annotation = method.getAnnotation(KBSyncEventHandler.class);
             if (annotation != null && method.getParameterCount() == 1) {
                 Class<?> eventType = method.getParameterTypes()[0];
                 if (Event.class.isAssignableFrom(eventType)) {
                     try {
+                        // Skip instance methods when registering static listeners
+                        if (instance == null && !Modifier.isStatic(method.getModifiers())) {
+                            continue;
+                        }
+
                         MethodHandle handle = lookup.unreflect(method);
-                        OptimizedListener optimizedListener = new OptimizedListener(listener, handle, annotation.priority());
+                        OptimizedListener optimizedListener = new OptimizedListener(instance, handle, annotation.priority(), method.getDeclaringClass());
                         listenerMap.computeIfAbsent((Class<? extends Event>) eventType, k -> new ArrayList<>()).add(optimizedListener);
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
@@ -35,7 +50,12 @@ public class OptimizedEventBus implements EventBus {
 
     @Override
     public void unregisterListeners(Object listener) {
-        listenerMap.values().forEach(list -> list.removeIf(l -> l.listener == listener));
+        listenerMap.values().forEach(list -> list.removeIf(l -> l.instance == listener));
+    }
+
+    @Override
+    public void unregisterStaticListeners(Class<?> clazz) {
+        listenerMap.values().forEach(list -> list.removeIf(l -> l.instance == null && l.declaringClass == clazz));
     }
 
     @Override
@@ -44,7 +64,13 @@ public class OptimizedEventBus implements EventBus {
         if (listeners != null) {
             for (OptimizedListener listener : listeners) {
                 try {
-                    listener.handle.invoke(listener.listener, event);
+                    if (listener.instance != null) {
+                        // Instance method
+                        listener.handle.invoke(listener.instance, event);
+                    } else {
+                        // Static method
+                        listener.handle.invoke(event);
+                    }
                     if (event.isCancelled()) {
                         break;
                     }
@@ -56,14 +82,16 @@ public class OptimizedEventBus implements EventBus {
     }
 
     private static class OptimizedListener {
-        final Object listener;
+        final Object instance; // null for static methods
         final MethodHandle handle;
         final int priority;
+        final Class<?> declaringClass;
 
-        OptimizedListener(Object listener, MethodHandle handle, int priority) {
-            this.listener = listener;
+        OptimizedListener(Object instance, MethodHandle handle, int priority, Class<?> declaringClass) {
+            this.instance = instance;
             this.handle = handle;
             this.priority = priority;
+            this.declaringClass = declaringClass;
         }
     }
 }

fabric/build.gradle.kts

@@ -45,10 +45,15 @@ dependencies {
     include(modImplementation("com.github.retrooper:packetevents-fabric:2.5.8-SNAPSHOT")!!)
     include(modImplementation("org.incendo:cloud-fabric:2.0.0-beta.9")!!)
 
-    shadeThisThing(implementation("org.yaml:snakeyaml:2.0")!!)
-//    shadeThisThing(implementation("com.fasterxml.jackson.core:jackson-databind:2.17.2")!!)
-//    shadeThisThing(implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.17.2")!!)
-    shadeThisThing(implementation("org.kohsuke:github-api:1.326")!!)
+    include(implementation("org.yaml:snakeyaml:2.0")!!)
+    include(implementation("org.kohsuke:github-api:1.326")!!)
+    // Required for org.kohsuke.github
+    include(implementation("com.fasterxml.jackson.core:jackson-databind:2.17.2")!!)
+    include(implementation("com.fasterxml.jackson.core:jackson-annotations:2.17.2")!!)
+    include(implementation("com.fasterxml.jackson.core:jackson-core:2.17.2")!!)
+    //    Not requires in modern Minecraft. May be needed if fabric version is backported to older versions
+    //    include(implementation("org.apache.commons:commons-lang3:3.17.0")!!)
+    //    include(implementation("commons-io:commons-io:2.16.1")!!)
 
     compileOnly("org.geysermc.floodgate:api:2.0-SNAPSHOT")
     compileOnly("org.projectlombok:lombok:1.18.34")

fabric/src/main/java/me/caseload/knockbacksync/FabricBase.java

@@ -3,11 +3,13 @@ package me.caseload.knockbacksync;
 import com.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.factory.fabric.FabricPacketEventsBuilder;
 import lombok.Getter;
+import me.caseload.knockbacksync.entity.EntityTickManager;
 import me.caseload.knockbacksync.listener.fabric.FabricPlayerDamageListener;
 import me.caseload.knockbacksync.listener.fabric.FabricPlayerJoinQuitListener;
 import me.caseload.knockbacksync.listener.fabric.FabricPlayerKnockbackListener;
 import me.caseload.knockbacksync.listener.fabric.FabricTickRateChangeListener;
 import me.caseload.knockbacksync.manager.ConfigManager;
+import me.caseload.knockbacksync.mixin.ServerEntityMixin;
 import me.caseload.knockbacksync.permission.FabricPermissionChecker;
 import me.caseload.knockbacksync.permission.PermissionChecker;
 import me.caseload.knockbacksync.scheduler.FabricSchedulerAdapter;
@@ -81,6 +83,7 @@ public class FabricBase extends Base {
         new FabricPlayerDamageListener().register();
         new FabricPlayerKnockbackListener().register();
         new FabricTickRateChangeListener().register();
+        super.simpleEventBus.registerStaticListeners(EntityTickManager.class);
     }
 
     @Override

fabric/src/main/java/me/caseload/knockbacksync/entity/EntityTickManager.java

@@ -2,8 +2,11 @@ package me.caseload.knockbacksync.entity;
 
 import me.caseload.knockbacksync.Base;
 import me.caseload.knockbacksync.ConfigWrapper;
+import me.caseload.knockbacksync.FabricLoaderMod;
 import me.caseload.knockbacksync.event.ConfigReloadEvent;
 import me.caseload.knockbacksync.event.KBSyncEventHandler;
+import me.caseload.knockbacksync.util.CustomUpdateIntervals;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.EntityType;
 
 import java.util.HashMap;
@@ -21,6 +24,11 @@ public class EntityTickManager {
     public static void updateTickIntervals(ConfigReloadEvent event) {
         ConfigWrapper configWrapper = event.getConfigManager().getConfigWrapper();
         updateTickIntervals(configWrapper);
+
+//        Map<String, Integer> entityIntervals = CustomUpdateIntervals.loadEntityIntervalsFromConfig();
+//        for (ServerLevel level : FabricLoaderMod.getServer().getAllLevels()) {
+//            CustomUpdateIntervals.updateIntervals(level, entityIntervals);
+//        }
     }
 
     private static void updateTickIntervals(ConfigWrapper configWrapper) {

fabric/src/main/java/me/caseload/knockbacksync/mixin/ServerEntityMixin.java

@@ -24,7 +24,6 @@ import java.util.Map;
 @Mixin(ServerEntity.class)
 public class ServerEntityMixin {
 
-
     @Shadow
     @Final
     private Entity entity;
@@ -65,13 +64,4 @@ public class ServerEntityMixin {
 //    public void setUpdateInterval(int interval) {
 //        this.updateInterval = interval;
 //    }
-
-
-    @KBSyncEventHandler
-    public void onConfigReload(ConfigReloadEvent event) {
-        Map<String, Integer> entityIntervals = CustomUpdateIntervals.loadEntityIntervalsFromConfig();
-        for (ServerLevel level : FabricLoaderMod.getServer().getAllLevels()) {
-            CustomUpdateIntervals.updateIntervals(level, entityIntervals);
-        }
-    }
 }