refactor: Pass event class explicitly for event handler lookup during dispatch.

src/main/kotlin/net/hareworks/hcu/items/App.kt

@@ -33,7 +33,6 @@ public class App : JavaPlugin() {
         // Initialize Config
         saveDefaultConfig()
         net.hareworks.hcu.items.config.Config.load(this)
-		server.pluginManager.registerEvents(net.hareworks.hcu.items.listeners.EventListener(this), this)
 		logger.info("Items plugin enabled!")
 		
 		commands = CommandRegistrar.register(this, permits)
@@ -50,5 +49,6 @@ public class App : JavaPlugin() {
 		ComponentRegistry.register(BlinkComponent(this))
 		ComponentRegistry.register(VeinMinerComponent(this))
 
+		server.pluginManager.registerEvents(net.hareworks.hcu.items.listeners.EventListener(this), this)
 	}
 }

src/main/kotlin/net/hareworks/hcu/items/content/items/GrapplingItem.kt

@@ -59,7 +59,7 @@ class GrapplingItem : AbstractItem("grappling_hook") {
         val player = event.player
         
         val isStuck = hook.persistentDataContainer.has(KEY_HOOK_STUCK, org.bukkit.persistence.PersistentDataType.BYTE)
-
+        
         if (event.state == PlayerFishEvent.State.REEL_IN && isStuck) {
             if (!cooldown.checkAndWarn(player)) {
                 return

src/main/kotlin/net/hareworks/hcu/items/events/EventContextStrategy.kt

@@ -119,8 +119,10 @@ object EventStrategyRegistry {
         // PlayerFishEvent
         register(PlayerFishEvent::class, object : EventContextStrategy<PlayerFishEvent> {
              override fun resolveItems(event: PlayerFishEvent): List<ItemStack> {
-                val item = event.player.inventory.itemInMainHand
+                val items = mutableListOf<ItemStack>()
-                return if (item.type.isAir) emptyList() else listOf(item)
+                items.add(event.player.inventory.itemInMainHand)
+                items.add(event.player.inventory.itemInOffHand)
+                return items.filter { !it.type.isAir }
             }
             override fun resolvePlayer(event: PlayerFishEvent): Player = event.player
         })
@@ -129,8 +131,10 @@ object EventStrategyRegistry {
         register(ProjectileLaunchEvent::class, object : EventContextStrategy<ProjectileLaunchEvent> {
              override fun resolveItems(event: ProjectileLaunchEvent): List<ItemStack> {
                 val shooter = event.entity.shooter as? Player ?: return emptyList()
-                val item = shooter.inventory.itemInMainHand
+                val items = mutableListOf<ItemStack>()
-                return if (item.type.isAir) emptyList() else listOf(item)
+                items.add(shooter.inventory.itemInMainHand)
+                items.add(shooter.inventory.itemInOffHand)
+                return items.filter { !it.type.isAir }
             }
             override fun resolvePlayer(event: ProjectileLaunchEvent): Player? = event.entity.shooter as? Player
         })

src/main/kotlin/net/hareworks/hcu/items/listeners/EventListener.kt

@@ -87,7 +87,7 @@ class EventListener(private val plugin: Plugin) : Listener {
             if (eventClass.isInstance(event)) {
                 @Suppress("UNCHECKED_CAST")
                 val castedEvent = event as T
-                dispatchWithStrategy(castedEvent, strategy)
+                dispatchWithStrategy(castedEvent, strategy, eventClass)
             }
         }
         
@@ -100,35 +100,33 @@ class EventListener(private val plugin: Plugin) : Listener {
         )
     }
 
-    private fun <T : Event> dispatchWithStrategy(event: T, strategy: EventContextStrategy<T>) {
+    private fun <T : Event> dispatchWithStrategy(event: T, strategy: EventContextStrategy<T>, eventClass: KClass<T>) {
         val items = strategy.resolveItems(event)
         
         // Avoid duplicate firing for the same component on the same item context
         for (item in items) {
-             dispatchToItem(event, item)
+             dispatchToItem(event, item, eventClass)
-             dispatchToComponents(event, item)
+             dispatchToComponents(event, item, eventClass)
         }
     }
 
-    private fun <T : Event> dispatchToItem(event: T, item: ItemStack) {
+    private fun <T : Event> dispatchToItem(event: T, item: ItemStack, eventClass: KClass<T>) {
         if (item.type.isAir) return
         val id = AbstractItem.getId(item) ?: return
         val abstractItem = ItemRegistry.get(id) ?: return
 
-        val handler = abstractItem.getEventHandlers()[event::class]
+        val handler = abstractItem.getEventHandlers()[eventClass]
         if (handler != null) {
             @Suppress("UNCHECKED_CAST")
             (handler as (T, ItemStack) -> Unit).invoke(event, item)
         }
     }
 
-    private fun <T : Event> dispatchToComponents(event: T, item: ItemStack) {
+    private fun <T : Event> dispatchToComponents(event: T, item: ItemStack, eventClass: KClass<T>) {
         if (item.type.isAir) return
         val meta = item.itemMeta ?: return
         val pdc = meta.persistentDataContainer
         
-        val eventClass = event::class
-
         for (key in pdc.keys) {
             val component = ComponentRegistry.get(key) ?: continue