Done

.live-plugins/event/plugin.kts

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.types.typeUtil.supertypes
 
 val skyhanniEvent = "at.hannibal2.skyhanni.api.event.SkyHanniEvent"
 val handleEvent = "HandleEvent"
+val eventType = "eventType"
 
 registerInspection(HandleEventInspectionKotlin())
 
@@ -30,14 +31,20 @@ class HandleEventInspectionKotlin : AbstractKotlinInspection() {
                 val hasEventAnnotation = function.annotationEntries.any { it.shortName!!.asString() == handleEvent }
                 val isEvent = function.valueParameters.firstOrNull()?.type()?.supertypes()
                     ?.any { it.fqName?.asString() == skyhanniEvent } ?: false
+                val hasEventType = function.annotationEntries
+                    .find { it.shortName!!.asString() == handleEvent }
+                    ?.valueArguments
+                    ?.find { it.getArgumentName()?.asName?.asString() == eventType }
+                    ?.getArgumentExpression()
+                    ?.text != null
 
                 if (isEvent && !hasEventAnnotation && function.valueParameters.size == 1 && function.isPublic) {
                     holder.registerProblem(
                         function,
                         "Event handler function should be annotated with @HandleEvent",
                         HandleEventQuickFix()
                     )
-                } else if (!isEvent && hasEventAnnotation) {
+                } else if (!isEvent && !hasEventType && hasEventAnnotation) {
                     holder.registerProblem(
                         function,
                         "Function should not be annotated with @HandleEvent if it does not take a SkyHanniEvent",

annotation-processors/src/main/kotlin/at/hannibal2/skyhanni/skyhannimodule/ModuleProcessor.kt

@@ -68,8 +68,13 @@ class ModuleProcessor(private val codeGenerator: CodeGenerator, private val logg
             }
 
             if (function.annotations.any { it.shortName.asString() == "HandleEvent" }) {
-                val firstParameter = function.parameters.firstOrNull()?.type?.resolve()!!
-                if (!skyHanniEvent!!.isAssignableFrom(firstParameter)) {
+                val firstParameter = function.parameters.firstOrNull()?.type?.resolve()
+                val handleEventAnnotation = function.annotations.find { it.shortName.asString() == "HandleEvent" }
+                val eventType = handleEventAnnotation?.arguments?.find { it.name?.asString() == "eventType" }?.value
+                val isFirstParameterProblem = firstParameter == null && eventType == null
+                val notAssignable = firstParameter != null && !skyHanniEvent!!.isAssignableFrom(firstParameter)
+
+                if (isFirstParameterProblem || notAssignable) {
                     warnings.add("Function in $className must have an event assignable from $skyHanniEvent because it is annotated with @HandleEvent")
                 }
             }

src/main/java/at/hannibal2/skyhanni/api/event/EventListeners.kt

@@ -18,18 +18,6 @@ class EventListeners private constructor(val name: String, private val isGeneric
     )
 
     fun addListener(method: Method, instance: Any, options: HandleEvent) {
-        require(method.parameterCount == 1)
-        val generic: Class<*>? = if (isGeneric) {
-            ReflectionUtils.resolveUpperBoundSuperClassGenericParameter(
-                method.genericParameterTypes[0],
-                GenericSkyHanniEvent::class.java.typeParameters[0],
-            ) ?: error(
-                "Generic event handler type parameter is not present in " +
-                    "event class hierarchy for type ${method.genericParameterTypes[0]}",
-            )
-        } else {
-            null
-        }
         val name = "${method.declaringClass.name}.${method.name}${
             method.parameterTypes.joinTo(
                 StringBuilder(),
@@ -39,7 +27,44 @@ class EventListeners private constructor(val name: String, private val isGeneric
                 transform = Class<*>::getTypeName,
             )
         }"
-        listeners.add(Listener(name, createEventConsumer(name, instance, method), options, generic))
+
+        val eventConsumer: (Any) -> Unit = when (method.parameterCount) {
+            0 -> {
+                // Handle methods with no parameters
+                if (options.eventType == SkyHanniEvent::class) {
+                    throw IllegalArgumentException("Method ${method.name} has no parameters but no eventType was provided in the annotation.")
+                }
+                // Verify the provided eventType
+                val eventType = options.eventType.java
+                if (!SkyHanniEvent::class.java.isAssignableFrom(eventType)) {
+                    throw IllegalArgumentException("eventType in @HandleEvent must extend SkyHanniEvent. Provided: $eventType")
+                }
+                { method.invoke(instance) }
+            }
+            1 -> {
+                // Handle methods with a single parameter (original behavior)
+                if (!SkyHanniEvent::class.java.isAssignableFrom(method.parameterTypes[0])) {
+                    throw IllegalArgumentException("Method ${method.name} parameter must be a subclass of SkyHanniEvent.")
+                }
+                { event -> method.invoke(instance, event) }
+            }
+            else -> {
+                throw IllegalArgumentException("Method ${method.name} must have either 0 or 1 parameters.")
+            }
+        }
+
+        val generic: Class<*>? = if (isGeneric) {
+            val genericType = method.genericParameterTypes.getOrNull(0)
+                ?: error("Method ${method.name} does not have a generic parameter type.")
+            ReflectionUtils.resolveUpperBoundSuperClassGenericParameter(
+                genericType,
+                GenericSkyHanniEvent::class.java.typeParameters[0],
+            ) ?: error(
+                "Generic event handler type parameter is not present in " +
+                    "event class hierarchy for type $genericType",
+            )
+        } else null
+        listeners.add(Listener(name, eventConsumer, options, generic))
     }
 
     /**

src/main/java/at/hannibal2/skyhanni/api/event/HandleEvent.kt

@@ -1,6 +1,7 @@
 package at.hannibal2.skyhanni.api.event
 
 import at.hannibal2.skyhanni.data.IslandType
+import kotlin.reflect.KClass
 
 @Retention(AnnotationRetention.RUNTIME)
 @Target(AnnotationTarget.FUNCTION)
@@ -31,6 +32,11 @@ annotation class HandleEvent(
      * If the event is cancelled & receiveCancelled is true, then the method will still invoke.
      */
     val receiveCancelled: Boolean = false,
+
+    /**
+     * For cases where the event properties are themselves not needed, and solely a listener for an event fire suffices.
+     */
+    val eventType: KClass<out SkyHanniEvent> = SkyHanniEvent::class
 ) {
 
     companion object {

src/main/java/at/hannibal2/skyhanni/api/event/SkyHanniEvents.kt

@@ -38,12 +38,25 @@ object SkyHanniEvents {
 
     @Suppress("UNCHECKED_CAST")
     private fun registerMethod(method: Method, instance: Any) {
-        if (method.parameterCount != 1) return
         val options = method.getAnnotation(HandleEvent::class.java) ?: return
-        val event = method.parameterTypes[0]
-        if (!SkyHanniEvent::class.java.isAssignableFrom(event)) return
-        listeners.getOrPut(event as Class<SkyHanniEvent>) { EventListeners(event) }
-            .addListener(method, instance, options)
+        val parameterTypes = method.parameterTypes
+
+        // Check if the method has no parameters and an eventType is provided
+        if (parameterTypes.isEmpty()) {
+            val eventType = options.eventType.java
+            if (!SkyHanniEvent::class.java.isAssignableFrom(eventType)) return
+            listeners.getOrPut(eventType as Class<SkyHanniEvent>) { EventListeners(eventType) }
+                .addListener(method, instance, options)
+            return
+        }
+
+        // Handle methods with parameters (original behavior)
+        if (parameterTypes.size == 1) {
+            val eventType = parameterTypes[0]
+            if (!SkyHanniEvent::class.java.isAssignableFrom(eventType)) return
+            listeners.getOrPut(eventType as Class<SkyHanniEvent>) { EventListeners(eventType) }
+                .addListener(method, instance, options)
+        }
     }
 
     @SubscribeEvent