Allow multiple listeners for a single TTTItem

src/main/kotlin/de/moritzruth/spigot_ttt/Resourcepack.kt

@@ -32,6 +32,7 @@ object Resourcepack {
         val boomBody = Material.BIRCH_WOOD
         val defibrillator = Material.IRON_INGOT
         val secondChance = Material.GOLD_INGOT
+        val beeBomb = Material.BEEHIVE
 
         // Weapons
         val deagle = Material.IRON_HOE

src/main/kotlin/de/moritzruth/spigot_ttt/game/GeneralGameListener.kt

@@ -55,9 +55,9 @@ object GeneralGameListener : Listener {
 
     @EventHandler
     fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) {
-        val player = event.damager
+        val damager = event.damager
-        if (player is Player) {
+        if (damager is Player) {
-            if (player.inventory.itemInMainHand.type == Material.AIR) {
+            if (damager.inventory.itemInMainHand.type == Material.AIR) {
                 event.damage = 0.2
             }
         }
@@ -77,9 +77,9 @@ object GeneralGameListener : Listener {
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     fun onEntityDamageLow(event: EntityDamageEvent) {
         if (ZERO_NO_DAMAGE_TICKS_CAUSES.contains(event.cause)) {
-            val player = event.entity
+            val entity = event.entity
-            if (player is Player) {
+            if (entity is Player) {
-                nextTick { player.noDamageTicks = 0 }
+                nextTick { entity.noDamageTicks = 0 }
             }
         }
     }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemListener.kt

@@ -0,0 +1,176 @@
+package de.moritzruth.spigot_ttt.game.items
+
+import com.codingforcookies.armorequip.ArmorEquipEvent
+import de.moritzruth.spigot_ttt.game.GameListener
+import de.moritzruth.spigot_ttt.game.GameManager
+import de.moritzruth.spigot_ttt.game.players.TTTPlayer
+import de.moritzruth.spigot_ttt.game.players.TTTPlayerDeathInPreparingEvent
+import de.moritzruth.spigot_ttt.game.players.TTTPlayerTrueDeathEvent
+import de.moritzruth.spigot_ttt.utils.isLeftClick
+import de.moritzruth.spigot_ttt.utils.isRightClick
+import de.moritzruth.spigot_ttt.utils.nextTick
+import de.moritzruth.spigot_ttt.utils.sendActionBarMessage
+import org.bukkit.GameMode
+import org.bukkit.Material
+import org.bukkit.entity.Player
+import org.bukkit.event.EventHandler
+import org.bukkit.event.EventPriority
+import org.bukkit.event.entity.EntityDamageByEntityEvent
+import org.bukkit.event.entity.EntityPickupItemEvent
+import org.bukkit.event.entity.ItemDespawnEvent
+import org.bukkit.event.inventory.ClickType
+import org.bukkit.event.inventory.InventoryAction
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.player.PlayerDropItemEvent
+import org.bukkit.event.player.PlayerInteractEvent
+import org.bukkit.event.player.PlayerItemHeldEvent
+import org.bukkit.event.player.PlayerSwapHandItemsEvent
+
+object ItemListener: GameListener() {
+    @EventHandler(priority = EventPriority.LOW)
+    fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer ->
+        if (event.click === ClickType.CREATIVE || event.clickedInventory?.holder != event.whoClicked) return@handle
+
+        if (event.slot in 0..8) {
+            // is in hotbar
+            when(event.action) {
+                InventoryAction.PICKUP_ALL,
+                InventoryAction.PICKUP_HALF,
+                InventoryAction.PICKUP_ONE -> {
+                    event.currentItem?.also { itemStack -> ItemManager.getInstanceByItemStack(itemStack)?.isSelected = false }
+                }
+                InventoryAction.PLACE_ALL,
+                InventoryAction.PLACE_SOME,
+                InventoryAction.PLACE_ONE -> {
+                    nextTick {
+                        if (event.slot == tttPlayer.player.inventory.heldItemSlot) {
+                            tttPlayer.player.inventory.getItem(event.slot)?.also { itemStack ->
+                                ItemManager.getInstanceByItemStack(itemStack)?.isSelected = true
+                            }
+                        }
+                    }
+                }
+                else -> event.isCancelled = true
+            }
+        }
+    }
+
+    @EventHandler
+    fun onArmorEquip(event: ArmorEquipEvent) {
+        if (event.player.gameMode != GameMode.CREATIVE) event.isCancelled = true
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    fun onPlayerInteract(event: PlayerInteractEvent) = handle(event) { tttPlayer ->
+        if (tttPlayer.ignoreNextInteract) {
+            tttPlayer.ignoreNextInteract = false
+            event.isCancelled = true
+            return@handle
+        }
+
+        val instance = event.item?.let { ItemManager.getInstanceByItemStack(it) } ?: return@handle
+
+        val clickEvent = ClickEvent()
+        if (event.action.isLeftClick) instance.onLeftClick(clickEvent)
+        else if (event.action.isRightClick) instance.onRightClick(clickEvent)
+        event.isCancelled = clickEvent.isCancelled
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) {
+        val damager = event.damager
+        if (damager is Player) {
+            TTTPlayer.of(damager) ?: return
+            val item = damager.inventory.itemInMainHand
+            if (item.type != Material.AIR) {
+                val tttItem = ItemManager.getTTTItemByItemStack(item) ?: return
+                event.isCancelled = tttItem.disableDamage
+            }
+        }
+    }
+
+    @EventHandler
+    fun onPlayerSwapHandItems(event: PlayerSwapHandItemsEvent) = handle(event) { _ ->
+        val instance = event.offHandItem?.let { ItemManager.getInstanceByItemStack(it) } ?: return@handle
+        instance.onHandSwap()
+        event.isCancelled = true
+    }
+
+    @EventHandler
+    fun onPlayerItemHeld(event: PlayerItemHeldEvent) = handle(event) { tttPlayer ->
+        tttPlayer.player.inventory.getItem(event.previousSlot)
+            ?.also { itemStack -> ItemManager.getInstanceByItemStack(itemStack)?.isSelected = false }
+
+        tttPlayer.player.inventory.getItem(event.newSlot)
+            ?.also { itemStack -> ItemManager.getInstanceByItemStack(itemStack)?.isSelected = true }
+    }
+
+    @EventHandler
+    fun onPlayerDropItem(event: PlayerDropItemEvent) = handle(event) { tttPlayer ->
+        val instance = ItemManager.getInstanceByItemStack(event.itemDrop.itemStack) ?: return@handle
+
+        val notDroppableReason = instance.notDroppableReason
+        if (notDroppableReason == null) {
+            instance.carrier = null
+        } else {
+            tttPlayer.player.sendActionBarMessage(notDroppableReason)
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler
+    fun onEntityPickupItem(event: EntityPickupItemEvent) {
+        val player = event.entity
+        if (player !is Player) return
+
+        val tttPlayer = TTTPlayer.of(player) ?: return
+        val instance = ItemManager.getInstanceByItemStack(event.item.itemStack)
+
+        if (instance != null) {
+            if (runCatching { tttPlayer.checkAddItemPreconditions(instance.tttItem) }.isSuccess) {
+                instance.carrier = tttPlayer
+                return
+            }
+        }
+
+        event.isCancelled = true
+    }
+
+    @EventHandler
+    fun onItemDespawn(event: ItemDespawnEvent) {
+        if (ItemManager.getTTTItemByItemStack(event.entity.itemStack) != null) {
+            event.entity.ticksLived = 1
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler
+    fun onTTTPlayerDeathInPreparing(event: TTTPlayerDeathInPreparingEvent) {
+        val itemStackInHand = event.tttPlayer.player.inventory.itemInMainHand
+        if (itemStackInHand.type != Material.AIR) {
+            val instance = ItemManager.getInstanceByItemStack(itemStackInHand)
+
+            if (
+                instance != null &&
+                !event.tttPlayer.tttClass.defaultItems.contains(instance.tttItem) &&
+                instance.notDroppableReason == null
+            ) {
+                event.tttPlayer.removeItem(instance.tttItem, removeInstance = false, becauseOfDeath = true)
+                GameManager.world.dropItem(event.location, instance.createItemStack())
+            }
+        }
+    }
+
+    @EventHandler
+    fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
+        val itemStackInHand = event.tttPlayer.player.inventory.itemInMainHand
+        if (itemStackInHand.type != Material.AIR) {
+            val instance = ItemManager.getInstanceByItemStack(itemStackInHand)
+
+            if (instance != null && instance.notDroppableReason == null) {
+                event.tttPlayer.removeItem(instance.tttItem, removeInstance = false, becauseOfDeath = true)
+                GameManager.world.dropItem(event.location, instance.createItemStack())
+            }
+        }
+    }
+}

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemManager.kt

@@ -1,37 +1,14 @@
 package de.moritzruth.spigot_ttt.game.items
 
-import com.codingforcookies.armorequip.ArmorEquipEvent
-import de.moritzruth.spigot_ttt.game.GameListener
 import de.moritzruth.spigot_ttt.game.GameManager
 import de.moritzruth.spigot_ttt.game.items.impl.*
 import de.moritzruth.spigot_ttt.game.items.impl.weapons.BaseballBat
 import de.moritzruth.spigot_ttt.game.items.impl.weapons.Fireball
 import de.moritzruth.spigot_ttt.game.items.impl.weapons.Knife
 import de.moritzruth.spigot_ttt.game.items.impl.weapons.guns.*
-import de.moritzruth.spigot_ttt.game.players.TTTPlayer
-import de.moritzruth.spigot_ttt.game.players.TTTPlayerDeathInPreparingEvent
-import de.moritzruth.spigot_ttt.game.players.TTTPlayerTrueDeathEvent
-import de.moritzruth.spigot_ttt.utils.isLeftClick
-import de.moritzruth.spigot_ttt.utils.isRightClick
-import de.moritzruth.spigot_ttt.utils.nextTick
-import de.moritzruth.spigot_ttt.utils.sendActionBarMessage
-import org.bukkit.GameMode
 import org.bukkit.Location
 import org.bukkit.Material
 import org.bukkit.entity.Item
-import org.bukkit.entity.Player
-import org.bukkit.event.EventHandler
-import org.bukkit.event.EventPriority
-import org.bukkit.event.entity.EntityDamageByEntityEvent
-import org.bukkit.event.entity.EntityPickupItemEvent
-import org.bukkit.event.entity.ItemDespawnEvent
-import org.bukkit.event.inventory.ClickType
-import org.bukkit.event.inventory.InventoryAction
-import org.bukkit.event.inventory.InventoryClickEvent
-import org.bukkit.event.player.PlayerDropItemEvent
-import org.bukkit.event.player.PlayerInteractEvent
-import org.bukkit.event.player.PlayerItemHeldEvent
-import org.bukkit.event.player.PlayerSwapHandItemsEvent
 import org.bukkit.inventory.ItemStack
 
 object ItemManager {
@@ -41,8 +18,8 @@ object ItemManager {
         Shotgun, Radar, SecondChance, BoomBody, TreeGun
     )
 
-    val listeners get () = ITEMS.mapNotNull { it.listener }.plus(listener)
+    val listeners get () = ITEMS.flatMap { it.listeners }.plus(ItemListener)
-    val packetListeners get () = ITEMS.mapNotNull { it.packetListener }
+    val packetListeners get () = ITEMS.flatMap { it.packetListeners }
 
     private fun getTTTItemByMaterial(material: Material) = ITEMS.find { tttItem -> material == tttItem.material }
     fun getTTTItemByItemStack(itemStack: ItemStack) = getTTTItemByMaterial(itemStack.type)
@@ -57,153 +34,4 @@ object ItemManager {
         GameManager.world.getEntitiesByClass(Item::class.java).forEach(Item::remove)
         ITEMS.forEach(TTTItem<*>::reset)
     }
-
-    val listener = object : GameListener() {
-        @EventHandler(priority = EventPriority.LOW)
-        fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer ->
-            if (event.click === ClickType.CREATIVE || event.clickedInventory?.holder != event.whoClicked) return@handle
-
-            if (event.slot in 0..8) {
-                // is in hotbar
-                when(event.action) {
-                    InventoryAction.PICKUP_ALL,
-                    InventoryAction.PICKUP_HALF,
-                    InventoryAction.PICKUP_ONE -> {
-                        event.currentItem?.also { itemStack -> getInstanceByItemStack(itemStack)?.isSelected = false }
-                    }
-                    InventoryAction.PLACE_ALL,
-                    InventoryAction.PLACE_SOME,
-                    InventoryAction.PLACE_ONE -> {
-                        nextTick {
-                            if (event.slot == tttPlayer.player.inventory.heldItemSlot) {
-                                tttPlayer.player.inventory.getItem(event.slot)?.also { itemStack ->
-                                    getInstanceByItemStack(itemStack)?.isSelected = true
-                                }
-                            }
-                        }
-                    }
-                    else -> event.isCancelled = true
-                }
-            }
-        }
-
-        @EventHandler
-        fun onArmorEquip(event: ArmorEquipEvent) {
-            if (event.player.gameMode != GameMode.CREATIVE) event.isCancelled = true
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        fun onPlayerInteract(event: PlayerInteractEvent) = handle(event) { tttPlayer ->
-            if (tttPlayer.ignoreNextInteract) {
-                tttPlayer.ignoreNextInteract = false
-                event.isCancelled = true
-                return@handle
-            }
-
-            val instance = event.item?.let { getInstanceByItemStack(it) } ?: return@handle
-
-            val clickEvent = ClickEvent()
-            if (event.action.isLeftClick) instance.onLeftClick(clickEvent)
-            else if (event.action.isRightClick) instance.onRightClick(clickEvent)
-            event.isCancelled = clickEvent.isCancelled
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) {
-            val damager = event.damager
-            if (damager is Player) {
-                TTTPlayer.of(damager) ?: return
-                val item = damager.inventory.itemInMainHand
-                if (item.type != Material.AIR) {
-                    val tttItem = getTTTItemByItemStack(item) ?: return
-                    event.isCancelled = tttItem.disableDamage
-                }
-            }
-        }
-
-        @EventHandler
-        fun onPlayerSwapHandItems(event: PlayerSwapHandItemsEvent) = handle(event) { _ ->
-            val instance = event.offHandItem?.let { getInstanceByItemStack(it) } ?: return@handle
-            instance.onHandSwap()
-            event.isCancelled = true
-        }
-
-        @EventHandler
-        fun onPlayerItemHeld(event: PlayerItemHeldEvent) = handle(event) { tttPlayer ->
-            tttPlayer.player.inventory.getItem(event.previousSlot)
-                ?.also { itemStack -> getInstanceByItemStack(itemStack)?.isSelected = false }
-
-            tttPlayer.player.inventory.getItem(event.newSlot)
-                ?.also { itemStack -> getInstanceByItemStack(itemStack)?.isSelected = true }
-        }
-
-        @EventHandler
-        fun onPlayerDropItem(event: PlayerDropItemEvent) = handle(event) { tttPlayer ->
-            val instance = getInstanceByItemStack(event.itemDrop.itemStack) ?: return@handle
-
-            val notDroppableReason = instance.notDroppableReason
-            if (notDroppableReason == null) {
-                instance.carrier = null
-            } else {
-                tttPlayer.player.sendActionBarMessage(notDroppableReason)
-                event.isCancelled = true
-            }
-        }
-
-        @EventHandler
-        fun onEntityPickupItem(event: EntityPickupItemEvent) {
-            val player = event.entity
-            if (player !is Player) return
-
-            val tttPlayer = TTTPlayer.of(player) ?: return
-            val instance = getInstanceByItemStack(event.item.itemStack)
-
-            if (instance != null) {
-                if (runCatching { tttPlayer.checkAddItemPreconditions(instance.tttItem) }.isSuccess) {
-                    instance.carrier = tttPlayer
-                    return
-                }
-            }
-
-            event.isCancelled = true
-        }
-
-        @EventHandler
-        fun onItemDespawn(event: ItemDespawnEvent) {
-            if (getTTTItemByItemStack(event.entity.itemStack) != null) {
-                event.entity.ticksLived = 1
-                event.isCancelled = true
-            }
-        }
-
-        @EventHandler
-        fun onTTTPlayerDeathInPreparing(event: TTTPlayerDeathInPreparingEvent) {
-            val itemStackInHand = event.tttPlayer.player.inventory.itemInMainHand
-            if (itemStackInHand.type != Material.AIR) {
-                val instance = getInstanceByItemStack(itemStackInHand)
-
-                if (
-                    instance != null &&
-                    !event.tttPlayer.tttClass.defaultItems.contains(instance.tttItem) &&
-                    instance.notDroppableReason == null
-                ) {
-                    event.tttPlayer.removeItem(instance.tttItem, removeInstance = false, becauseOfDeath = true)
-                    GameManager.world.dropItem(event.location, instance.createItemStack())
-                }
-            }
-        }
-
-        @EventHandler
-        fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
-            val itemStackInHand = event.tttPlayer.player.inventory.itemInMainHand
-            if (itemStackInHand.type != Material.AIR) {
-                val instance = getInstanceByItemStack(itemStackInHand)
-
-                if (instance != null && instance.notDroppableReason == null) {
-                    event.tttPlayer.removeItem(instance.tttItem, removeInstance = false, becauseOfDeath = true)
-                    GameManager.world.dropItem(event.location, instance.createItemStack())
-                }
-            }
-        }
-    }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/TTTItem.kt

@@ -24,8 +24,16 @@ open class TTTItem<InstanceT: TTTItem.Instance>(
     val disableDamage: Boolean = true,
     val removeInstanceOnDeath: Boolean = true
 ) {
-    open val listener: Listener? = null
+    var listeners: Set<Listener> = emptySet(); private set
-    open val packetListener: PacketListener? = null
+    var packetListeners: Set<PacketListener> = emptySet(); private set
+
+    protected fun addListener(listener: Listener) {
+        listeners = listeners + listener
+    }
+
+    protected fun addListener(packetListener: PacketListener) {
+        packetListeners = packetListeners + packetListener
+    }
 
     val material = templateItemStack.type
 

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/BoomBody.kt

@@ -55,7 +55,8 @@ object BoomBody: TTTItem<BoomBody.Instance>(
 
     val boomBodies: MutableSet<TTTCorpse> = Collections.newSetFromMap(WeakHashMap<TTTCorpse, Boolean>())
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onCorpseClick(event: CorpseClickEvent) {
                 if (boomBodies.contains(event.tttCorpse)) {
@@ -102,5 +103,6 @@ object BoomBody: TTTItem<BoomBody.Instance>(
                     }
                 }
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/CloakingDevice.kt

@@ -81,10 +81,12 @@ object CloakingDevice: TTTItem<CloakingDevice.Instance>(
         }
     }
 
-    override val listener = object : TTTItemListener<Instance>(CloakingDevice) {
+    init {
+        addListener(object : TTTItemListener<Instance>(CloakingDevice) {
             @EventHandler
             fun onPlayerToggleSprint(event: PlayerToggleSprintEvent) = handleWithInstance(event) { instance ->
                 if (event.isSprinting && instance.enabled) event.isCancelled = true
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Defibrillator.kt

@@ -65,7 +65,8 @@ object Defibrillator: TTTItem<Defibrillator.Instance>(
         it.stopSound(Resourcepack.Sounds.Item.Defibrillator.use, SoundCategory.PLAYERS)
     }
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler(ignoreCancelled = true)
             fun onCorpseClick(event: CorpseClickEvent) {
                 val instance = getInstance(event.tttPlayer.player.inventory.itemInMainHand) ?: return
@@ -96,6 +97,7 @@ object Defibrillator: TTTItem<Defibrillator.Instance>(
                     is Action.Canceled -> noop()
                 }
             }
+        })
     }
 
     sealed class Action(val tttPlayer: TTTPlayer) {

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/FakeCorpse.kt

@@ -69,7 +69,8 @@ object FakeCorpse: TTTItem<FakeCorpse.Instance>(
             .toTypedArray())
     }
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer ->
                 val instance = getInstance(tttPlayer) ?: return@handle
@@ -125,5 +126,6 @@ object FakeCorpse: TTTItem<FakeCorpse.Instance>(
                     }
                 }
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/HealingPotion.kt

@@ -39,13 +39,15 @@ object HealingPotion: TTTItem<HealingPotion.Instance>(
         buyLimit = 2
     )
 ) {
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onPlayerItemConsume(event: PlayerItemConsumeEvent) = handle(event) {
                 event.isCancelled = true
                 event.player.inventory.clear(event.player.inventory.indexOf(event.item))
                 event.player.health = event.player.getAttribute(Attribute.GENERIC_MAX_HEALTH)?.value ?: 100.0
             }
+        })
     }
 
     class Instance: TTTItem.Instance(HealingPotion)

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/MartyrdomGrenade.kt

@@ -47,7 +47,8 @@ object MartyrdomGrenade: TTTItem<MartyrdomGrenade.Instance>(
         }
     }
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
                 val instance = getInstance(event.tttPlayer) ?: return
@@ -66,5 +67,6 @@ object MartyrdomGrenade: TTTItem<MartyrdomGrenade.Instance>(
                     instance.remove()
                 }, secondsToTicks(3).toLong())
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Radar.kt

@@ -106,7 +106,8 @@ object Radar: TTTItem<Radar.Instance>(
         }
     }
 
-    override val packetListener = object : PacketAdapter(plugin, PacketType.Play.Server.ENTITY_METADATA) {
+    init {
+        addListener(object : PacketAdapter(plugin, PacketType.Play.Server.ENTITY_METADATA) {
             override fun onPacketSending(event: PacketEvent) {
                 val receivingTTTPlayer = TTTPlayer.of(event.player) ?: return
 
@@ -128,5 +129,6 @@ object Radar: TTTItem<Radar.Instance>(
                     }
                 }
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/SecondChance.kt

@@ -155,7 +155,8 @@ object SecondChance: TTTItem<SecondChance.Instance>(
         })
     }
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
                 val instance = getInstance(event.tttPlayer) ?: return
@@ -194,5 +195,6 @@ object SecondChance: TTTItem<SecondChance.Instance>(
 
             @EventHandler
             fun onTTTPlayerRevive(event: TTTPlayerReviveEvent) = handle(event) { it.timeoutAction?.stop() }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/BaseballBat.kt

@@ -57,7 +57,8 @@ object BaseballBat: TTTItem<BaseballBat.Instance>(
         }
     }
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler(ignoreCancelled = true)
             fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { tttPlayer, _ ->
                 event.isCancelled = true
@@ -83,5 +84,6 @@ object BaseballBat: TTTItem<BaseballBat.Instance>(
                     damagedPlayer.velocity = Vector(direction.x * 5, 8.0, direction.z * 5)
                 }
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Fireball.kt

@@ -53,7 +53,8 @@ object Fireball: TTTItem<Fireball.Instance>(
 
     val sendersByEntity = WeakHashMap<FireballEntity, TTTPlayer>()
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler
             fun onExplosionPrime(event: ExplosionPrimeEvent) {
                 val sender = sendersByEntity[event.entity]
@@ -64,5 +65,6 @@ object Fireball: TTTItem<Fireball.Instance>(
                     createKillExplosion(sender, event.entity.location, 2.5)
                 }
             }
+        })
     }
 }

src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Knife.kt

@@ -48,7 +48,8 @@ object Knife: TTTItem<Knife.Instance>(
 ) {
     class Instance: TTTItem.Instance(Knife)
 
-    override val listener = object : TTTItemListener<Instance>(this) {
+    init {
+        addListener(object : TTTItemListener<Instance>(this) {
             @EventHandler(ignoreCancelled = true)
             fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { damagerTTTPlayer, damagedTTTPlayer ->
                 event.isCancelled = true
@@ -84,6 +85,7 @@ object Knife: TTTItem<Knife.Instance>(
                     }
                 }
             }
+        })
     }
 }
 

src/main/kotlin/de/moritzruth/spigot_ttt/game/players/DeathReason.kt

@@ -10,5 +10,6 @@ sealed class DeathReason(val displayText: String) {
     object DROWNED: DeathReason("Ertrunken")
     object FIRE: DeathReason("Verbrannt")
     object POISON: DeathReason("Vergiftet")
+    object BEE: DeathReason("Zu Tode gestochen")
     class Item(val item: TTTItem<*>): DeathReason("Getötet mit: ${item.templateItemStack.itemMeta!!.displayName}")
 }