From ce4502d3d807613841e7d35a160a7ea68d1e1864 Mon Sep 17 00:00:00 2001 From: Moritz Ruth Date: Sun, 21 Jun 2020 17:16:27 +0200 Subject: [PATCH] Allow multiple listeners for a single TTTItem --- .../de/moritzruth/spigot_ttt/Resourcepack.kt | 1 + .../spigot_ttt/game/GeneralGameListener.kt | 12 +- .../spigot_ttt/game/items/ItemListener.kt | 176 ++++++++++++++++++ .../spigot_ttt/game/items/ItemManager.kt | 176 +----------------- .../spigot_ttt/game/items/TTTItem.kt | 12 +- .../spigot_ttt/game/items/impl/BoomBody.kt | 92 ++++----- .../game/items/impl/CloakingDevice.kt | 12 +- .../game/items/impl/Defibrillator.kt | 54 +++--- .../spigot_ttt/game/items/impl/FakeCorpse.kt | 94 +++++----- .../game/items/impl/HealingPotion.kt | 16 +- .../game/items/impl/MartyrdomGrenade.kt | 36 ++-- .../spigot_ttt/game/items/impl/Radar.kt | 38 ++-- .../game/items/impl/SecondChance.kt | 60 +++--- .../game/items/impl/weapons/BaseballBat.kt | 42 +++-- .../game/items/impl/weapons/Fireball.kt | 18 +- .../game/items/impl/weapons/Knife.kt | 60 +++--- .../spigot_ttt/game/players/DeathReason.kt | 1 + 17 files changed, 468 insertions(+), 432 deletions(-) create mode 100644 src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemListener.kt diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/Resourcepack.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/Resourcepack.kt index 86922ba..fab3fd9 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/Resourcepack.kt +++ b/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 diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/GeneralGameListener.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/GeneralGameListener.kt index b7ec9a7..ed8edde 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/GeneralGameListener.kt +++ b/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 - if (player is Player) { - if (player.inventory.itemInMainHand.type == Material.AIR) { + val damager = event.damager + if (damager is Player) { + 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 - if (player is Player) { - nextTick { player.noDamageTicks = 0 } + val entity = event.entity + if (entity is Player) { + nextTick { entity.noDamageTicks = 0 } } } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemListener.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemListener.kt new file mode 100644 index 0000000..32acd0d --- /dev/null +++ b/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()) + } + } + } +} diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemManager.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemManager.kt index c85bd66..ae22875 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemManager.kt +++ b/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 packetListeners get () = ITEMS.mapNotNull { it.packetListener } + val listeners get () = ITEMS.flatMap { it.listeners }.plus(ItemListener) + 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()) - } - } - } - } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/TTTItem.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/TTTItem.kt index 8801966..a3b5cc4 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/TTTItem.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/TTTItem.kt @@ -24,8 +24,16 @@ open class TTTItem( val disableDamage: Boolean = true, val removeInstanceOnDeath: Boolean = true ) { - open val listener: Listener? = null - open val packetListener: PacketListener? = null + var listeners: Set = emptySet(); private set + var packetListeners: Set = emptySet(); private set + + protected fun addListener(listener: Listener) { + listeners = listeners + listener + } + + protected fun addListener(packetListener: PacketListener) { + packetListeners = packetListeners + packetListener + } val material = templateItemStack.type diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/BoomBody.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/BoomBody.kt index 0faadca..1474bd0 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/BoomBody.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/BoomBody.kt @@ -55,52 +55,54 @@ object BoomBody: TTTItem( val boomBodies: MutableSet = Collections.newSetFromMap(WeakHashMap()) - override val listener = object : TTTItemListener(this) { - @EventHandler - fun onCorpseClick(event: CorpseClickEvent) { - if (boomBodies.contains(event.tttCorpse)) { - boomBodies.remove(event.tttCorpse) - event.tttCorpse.destroy() - event.isCancelled = true - createKillExplosion(event.tttCorpse.spawnedBy!!, event.tttCorpse.location, 5.0) - } - } - - @EventHandler - fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer -> - val instance = getInstance(tttPlayer) ?: return@handle - if (event.clickedInventory !== instance.choosePlayerInventory) return@handle - - event.isCancelled = true - - val item = event.currentItem - if (item != null && event.click == ClickType.LEFT) { - tttPlayer.player.closeInventory() - - val corpsePlayer = plugin.server.getPlayer((item.itemMeta as SkullMeta).owningPlayer!!.uniqueId)!! - val corpseTTTPlayer = TTTPlayer.of(corpsePlayer) - - if (corpseTTTPlayer == null) { - tttPlayer.player.sendActionBarMessage("${ChatColor.RED}Das hat nicht funktioniert") - } else { - GameManager.world.playSound( - tttPlayer.player.location, - Resourcepack.Sounds.playerDeath, - SoundCategory.PLAYERS, - 1F, - 1F - ) - - boomBodies.add(TTTCorpse.spawnFake( - Role.INNOCENT, - corpseTTTPlayer, - tttPlayer, - tttPlayer.player.location - )) - - tttPlayer.removeItem(BoomBody) + init { + addListener(object : TTTItemListener(this) { + @EventHandler + fun onCorpseClick(event: CorpseClickEvent) { + if (boomBodies.contains(event.tttCorpse)) { + boomBodies.remove(event.tttCorpse) + event.tttCorpse.destroy() + event.isCancelled = true + createKillExplosion(event.tttCorpse.spawnedBy!!, event.tttCorpse.location, 5.0) } } - } + + @EventHandler + fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer -> + val instance = getInstance(tttPlayer) ?: return@handle + if (event.clickedInventory !== instance.choosePlayerInventory) return@handle + + event.isCancelled = true + + val item = event.currentItem + if (item != null && event.click == ClickType.LEFT) { + tttPlayer.player.closeInventory() + + val corpsePlayer = plugin.server.getPlayer((item.itemMeta as SkullMeta).owningPlayer!!.uniqueId)!! + val corpseTTTPlayer = TTTPlayer.of(corpsePlayer) + + if (corpseTTTPlayer == null) { + tttPlayer.player.sendActionBarMessage("${ChatColor.RED}Das hat nicht funktioniert") + } else { + GameManager.world.playSound( + tttPlayer.player.location, + Resourcepack.Sounds.playerDeath, + SoundCategory.PLAYERS, + 1F, + 1F + ) + + boomBodies.add(TTTCorpse.spawnFake( + Role.INNOCENT, + corpseTTTPlayer, + tttPlayer, + tttPlayer.player.location + )) + + tttPlayer.removeItem(BoomBody) + } + } + } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/CloakingDevice.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/CloakingDevice.kt index bc8f960..1405f22 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/CloakingDevice.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/CloakingDevice.kt @@ -81,10 +81,12 @@ object CloakingDevice: TTTItem( } } - override val listener = object : TTTItemListener(CloakingDevice) { - @EventHandler - fun onPlayerToggleSprint(event: PlayerToggleSprintEvent) = handleWithInstance(event) { instance -> - if (event.isSprinting && instance.enabled) event.isCancelled = true - } + init { + addListener(object : TTTItemListener(CloakingDevice) { + @EventHandler + fun onPlayerToggleSprint(event: PlayerToggleSprintEvent) = handleWithInstance(event) { instance -> + if (event.isSprinting && instance.enabled) event.isCancelled = true + } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Defibrillator.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Defibrillator.kt index 8774498..0db0bfe 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Defibrillator.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Defibrillator.kt @@ -65,37 +65,39 @@ object Defibrillator: TTTItem( it.stopSound(Resourcepack.Sounds.Item.Defibrillator.use, SoundCategory.PLAYERS) } - override val listener = object : TTTItemListener(this) { - @EventHandler(ignoreCancelled = true) - fun onCorpseClick(event: CorpseClickEvent) { - val instance = getInstance(event.tttPlayer.player.inventory.itemInMainHand) ?: return - event.isCancelled = true + init { + addListener(object : TTTItemListener(this) { + @EventHandler(ignoreCancelled = true) + fun onCorpseClick(event: CorpseClickEvent) { + val instance = getInstance(event.tttPlayer.player.inventory.itemInMainHand) ?: return + event.isCancelled = true - when(val action = instance.action) { - null -> instance.action = Action.Reviving(event.tttPlayer, instance) - is Action.Reviving -> { - action.cancelTask.cancel() - action.cancelTask = action.createCancelTask() + when(val action = instance.action) { + null -> instance.action = Action.Reviving(event.tttPlayer, instance) + is Action.Reviving -> { + action.cancelTask.cancel() + action.cancelTask = action.createCancelTask() - val progress = action.duration / REVIVE_DURATION - if (progress >= 1) { - try { - event.tttCorpse.revive() - event.tttPlayer.player.sendActionBarMessage( - "${ChatColor.BOLD}${event.tttCorpse.tttPlayer.player.displayName} " + - "${ChatColor.GREEN}wurde wiederbelebt" - ) + val progress = action.duration / REVIVE_DURATION + if (progress >= 1) { + try { + event.tttCorpse.revive() + event.tttPlayer.player.sendActionBarMessage( + "${ChatColor.BOLD}${event.tttCorpse.tttPlayer.player.displayName} " + + "${ChatColor.GREEN}wurde wiederbelebt" + ) - action.cancelTask.cancel() - event.tttPlayer.removeItem(Defibrillator) - } catch(e: TTTPlayer.AlreadyLivingException) { - action.cancel() - } - } else instance.bossBar.progress = progress + action.cancelTask.cancel() + event.tttPlayer.removeItem(Defibrillator) + } catch(e: TTTPlayer.AlreadyLivingException) { + action.cancel() + } + } else instance.bossBar.progress = progress + } + is Action.Canceled -> noop() } - is Action.Canceled -> noop() } - } + }) } sealed class Action(val tttPlayer: TTTPlayer) { diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/FakeCorpse.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/FakeCorpse.kt index 5348d9e..05913d4 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/FakeCorpse.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/FakeCorpse.kt @@ -69,61 +69,63 @@ object FakeCorpse: TTTItem( .toTypedArray()) } - override val listener = object : TTTItemListener(this) { - @EventHandler - fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer -> - val instance = getInstance(tttPlayer) ?: return@handle + init { + addListener(object : TTTItemListener(this) { + @EventHandler + fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer -> + val instance = getInstance(tttPlayer) ?: return@handle - if ( - !setOf( - instance.choosePlayerInventory, - chooseRoleInventory - ).contains(event.clickedInventory) - ) return@handle - event.isCancelled = true + if ( + !setOf( + instance.choosePlayerInventory, + chooseRoleInventory + ).contains(event.clickedInventory) + ) return@handle + event.isCancelled = true - val item = event.currentItem + val item = event.currentItem - if (item != null && event.click == ClickType.LEFT) { - when (event.clickedInventory) { - chooseRoleInventory -> { - instance.chosenRole = Role.values()[event.slot] - val choosePlayerInventory = createPlayerHeadInventory( - "${INVENTORY_TITLE}${ChatColor.RESET} - Spieler", - PlayerManager.tttPlayers.map { it.player } - ) - instance.choosePlayerInventory = choosePlayerInventory - tttPlayer.player.openInventory(choosePlayerInventory) - } - instance.choosePlayerInventory -> { - tttPlayer.player.closeInventory() - - val corpsePlayer = plugin.server.getPlayer((item.itemMeta as SkullMeta).owningPlayer!!.uniqueId)!! - val corpseTTTPlayer = TTTPlayer.of(corpsePlayer) - - if (corpseTTTPlayer == null) { - tttPlayer.player.sendActionBarMessage("${ChatColor.RED}Das hat nicht funktioniert") - } else { - GameManager.world.playSound( - tttPlayer.player.location, - Resourcepack.Sounds.playerDeath, - SoundCategory.PLAYERS, - 1F, - 1F + if (item != null && event.click == ClickType.LEFT) { + when (event.clickedInventory) { + chooseRoleInventory -> { + instance.chosenRole = Role.values()[event.slot] + val choosePlayerInventory = createPlayerHeadInventory( + "${INVENTORY_TITLE}${ChatColor.RESET} - Spieler", + PlayerManager.tttPlayers.map { it.player } ) + instance.choosePlayerInventory = choosePlayerInventory + tttPlayer.player.openInventory(choosePlayerInventory) + } + instance.choosePlayerInventory -> { + tttPlayer.player.closeInventory() - TTTCorpse.spawnFake( - instance.chosenRole!!, - corpseTTTPlayer, - tttPlayer, - tttPlayer.player.location - ) + val corpsePlayer = plugin.server.getPlayer((item.itemMeta as SkullMeta).owningPlayer!!.uniqueId)!! + val corpseTTTPlayer = TTTPlayer.of(corpsePlayer) - tttPlayer.removeItem(FakeCorpse) + if (corpseTTTPlayer == null) { + tttPlayer.player.sendActionBarMessage("${ChatColor.RED}Das hat nicht funktioniert") + } else { + GameManager.world.playSound( + tttPlayer.player.location, + Resourcepack.Sounds.playerDeath, + SoundCategory.PLAYERS, + 1F, + 1F + ) + + TTTCorpse.spawnFake( + instance.chosenRole!!, + corpseTTTPlayer, + tttPlayer, + tttPlayer.player.location + ) + + tttPlayer.removeItem(FakeCorpse) + } } } } } - } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/HealingPotion.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/HealingPotion.kt index 823eeab..3f7f37d 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/HealingPotion.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/HealingPotion.kt @@ -39,13 +39,15 @@ object HealingPotion: TTTItem( buyLimit = 2 ) ) { - override val listener = object : TTTItemListener(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 - } + init { + addListener(object : TTTItemListener(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) diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/MartyrdomGrenade.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/MartyrdomGrenade.kt index caf6c13..e3127f9 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/MartyrdomGrenade.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/MartyrdomGrenade.kt @@ -47,24 +47,26 @@ object MartyrdomGrenade: TTTItem( } } - override val listener = object : TTTItemListener(this) { - @EventHandler - fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) { - val instance = getInstance(event.tttPlayer) ?: return - instance.tttPlayer = event.tttPlayer + init { + addListener(object : TTTItemListener(this) { + @EventHandler + fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) { + val instance = getInstance(event.tttPlayer) ?: return + instance.tttPlayer = event.tttPlayer - instance.explodeTask = plugin.server.scheduler.runTaskLater(plugin, fun() { - GameManager.world.playSound( - event.location, - Resourcepack.Sounds.grenadeExplode, - SoundCategory.PLAYERS, - 1F, - 1F - ) + instance.explodeTask = plugin.server.scheduler.runTaskLater(plugin, fun() { + GameManager.world.playSound( + event.location, + Resourcepack.Sounds.grenadeExplode, + SoundCategory.PLAYERS, + 1F, + 1F + ) - createKillExplosion(event.tttPlayer, event.location, 5.0) - instance.remove() - }, secondsToTicks(3).toLong()) - } + createKillExplosion(event.tttPlayer, event.location, 5.0) + instance.remove() + }, secondsToTicks(3).toLong()) + } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Radar.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Radar.kt index 9ef3f90..635a855 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Radar.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/Radar.kt @@ -106,27 +106,29 @@ object Radar: TTTItem( } } - override val packetListener = object : PacketAdapter(plugin, PacketType.Play.Server.ENTITY_METADATA) { - override fun onPacketSending(event: PacketEvent) { - val receivingTTTPlayer = TTTPlayer.of(event.player) ?: return + init { + addListener(object : PacketAdapter(plugin, PacketType.Play.Server.ENTITY_METADATA) { + override fun onPacketSending(event: PacketEvent) { + val receivingTTTPlayer = TTTPlayer.of(event.player) ?: return - val packet = WrapperPlayServerEntityMetadata(event.packet) - val tttPlayerOfPacket = plugin.server.onlinePlayers - .find { it.entityId == packet.entityID } - ?.let { TTTPlayer.of(it) } ?: return - val instance = getInstance(receivingTTTPlayer) ?: return + val packet = WrapperPlayServerEntityMetadata(event.packet) + val tttPlayerOfPacket = plugin.server.onlinePlayers + .find { it.entityId == packet.entityID } + ?.let { TTTPlayer.of(it) } ?: return + val instance = getInstance(receivingTTTPlayer) ?: return - if (tttPlayerOfPacket.alive) { - // https://wiki.vg/Entity_metadata#Entity_Metadata_Format - try { - val modifiers = packet.metadata[0].value as Byte - packet.metadata[0].value = - if (instance.active) modifiers or 0x40.toByte() - else modifiers and 0b10111111.toByte() - } catch (ignored: Exception) { - // Idk why this throws exceptions, but it works anyways + if (tttPlayerOfPacket.alive) { + // https://wiki.vg/Entity_metadata#Entity_Metadata_Format + try { + val modifiers = packet.metadata[0].value as Byte + packet.metadata[0].value = + if (instance.active) modifiers or 0x40.toByte() + else modifiers and 0b10111111.toByte() + } catch (ignored: Exception) { + // Idk why this throws exceptions, but it works anyways + } } } - } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/SecondChance.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/SecondChance.kt index a46cfc6..256db4e 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/SecondChance.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/SecondChance.kt @@ -155,44 +155,46 @@ object SecondChance: TTTItem( }) } - override val listener = object : TTTItemListener(this) { - @EventHandler - fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) { - val instance = getInstance(event.tttPlayer) ?: return - instance.possiblyTrigger(event.tttCorpse) - event.winnerRoleGroup = PlayerManager.getOnlyRemainingRoleGroup() - } + init { + addListener(object : TTTItemListener(this) { + @EventHandler + fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) { + val instance = getInstance(event.tttPlayer) ?: return + instance.possiblyTrigger(event.tttCorpse) + event.winnerRoleGroup = PlayerManager.getOnlyRemainingRoleGroup() + } - @EventHandler - fun onInventoryClose(event: InventoryCloseEvent) { - if (event.inventory === chooseSpawnInventory || event.inventory === chooseSpawnWithoutCorpseInventory) { - nextTick { - handleWithInstance(event) { instance -> - instance.timeoutAction?.openInventory() + @EventHandler + fun onInventoryClose(event: InventoryCloseEvent) { + if (event.inventory === chooseSpawnInventory || event.inventory === chooseSpawnWithoutCorpseInventory) { + nextTick { + handleWithInstance(event) { instance -> + instance.timeoutAction?.openInventory() + } } } } - } - @EventHandler - fun onInventoryClick(event: InventoryClickEvent) { - if (event.inventory !== chooseSpawnInventory && event.inventory !== chooseSpawnWithoutCorpseInventory) return + @EventHandler + fun onInventoryClick(event: InventoryClickEvent) { + if (event.inventory !== chooseSpawnInventory && event.inventory !== chooseSpawnWithoutCorpseInventory) return - handleWithInstance(event) { instance -> - val timeoutAction = instance.timeoutAction!! + handleWithInstance(event) { instance -> + val timeoutAction = instance.timeoutAction!! - val location = when (event.currentItem?.type) { - ON_SPAWN -> GameManager.world.spawnLocation - ON_CORPSE -> timeoutAction.tttCorpse?.location ?: return@handleWithInstance - else -> return@handleWithInstance + val location = when (event.currentItem?.type) { + ON_SPAWN -> GameManager.world.spawnLocation + ON_CORPSE -> timeoutAction.tttCorpse?.location ?: return@handleWithInstance + else -> return@handleWithInstance + } + + timeoutAction.stop() + instance.tttPlayer.revive(location) } - - timeoutAction.stop() - instance.tttPlayer.revive(location) } - } - @EventHandler - fun onTTTPlayerRevive(event: TTTPlayerReviveEvent) = handle(event) { it.timeoutAction?.stop() } + @EventHandler + fun onTTTPlayerRevive(event: TTTPlayerReviveEvent) = handle(event) { it.timeoutAction?.stop() } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/BaseballBat.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/BaseballBat.kt index 132bcae..a446257 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/BaseballBat.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/BaseballBat.kt @@ -57,31 +57,33 @@ object BaseballBat: TTTItem( } } - override val listener = object : TTTItemListener(this) { - @EventHandler(ignoreCancelled = true) - fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { tttPlayer, _ -> - event.isCancelled = true - if (event.damage != 1.0) return@handle // Cooldown on weapon + init { + addListener(object : TTTItemListener(this) { + @EventHandler(ignoreCancelled = true) + fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { tttPlayer, _ -> + event.isCancelled = true + if (event.damage != 1.0) return@handle // Cooldown on weapon - val damagedPlayer = event.entity as Player - val distance = tttPlayer.player.location.distance(damagedPlayer.location) + val damagedPlayer = event.entity as Player + val distance = tttPlayer.player.location.distance(damagedPlayer.location) - if (distance < 2.5) { - tttPlayer.removeItem(BaseballBat) + if (distance < 2.5) { + tttPlayer.removeItem(BaseballBat) - GameManager.world.playSound( - damagedPlayer.location, - Resourcepack.Sounds.Item.Weapon.BaseballBat.hit, - SoundCategory.PLAYERS, - 1F, - 1F - ) + GameManager.world.playSound( + damagedPlayer.location, + Resourcepack.Sounds.Item.Weapon.BaseballBat.hit, + SoundCategory.PLAYERS, + 1F, + 1F + ) - event.damage = 0.0 + event.damage = 0.0 - val direction = tttPlayer.player.location.direction - damagedPlayer.velocity = Vector(direction.x * 5, 8.0, direction.z * 5) + val direction = tttPlayer.player.location.direction + damagedPlayer.velocity = Vector(direction.x * 5, 8.0, direction.z * 5) + } } - } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Fireball.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Fireball.kt index fc5ad49..5693712 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Fireball.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Fireball.kt @@ -53,16 +53,18 @@ object Fireball: TTTItem( val sendersByEntity = WeakHashMap() - override val listener = object : TTTItemListener(this) { - @EventHandler - fun onExplosionPrime(event: ExplosionPrimeEvent) { - val sender = sendersByEntity[event.entity] + init { + addListener(object : TTTItemListener(this) { + @EventHandler + fun onExplosionPrime(event: ExplosionPrimeEvent) { + val sender = sendersByEntity[event.entity] - if (sender != null) { - event.isCancelled = true + if (sender != null) { + event.isCancelled = true - createKillExplosion(sender, event.entity.location, 2.5) + createKillExplosion(sender, event.entity.location, 2.5) + } } - } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Knife.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Knife.kt index f79f1cf..1670089 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Knife.kt +++ b/src/main/kotlin/de/moritzruth/spigot_ttt/game/items/impl/weapons/Knife.kt @@ -48,42 +48,44 @@ object Knife: TTTItem( ) { class Instance: TTTItem.Instance(Knife) - override val listener = object : TTTItemListener(this) { - @EventHandler(ignoreCancelled = true) - fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { damagerTTTPlayer, damagedTTTPlayer -> - event.isCancelled = true + init { + addListener(object : TTTItemListener(this) { + @EventHandler(ignoreCancelled = true) + fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { damagerTTTPlayer, damagedTTTPlayer -> + event.isCancelled = true - if (event.damage == 1.0) { - val distance = damagerTTTPlayer.player.location.distance(damagedTTTPlayer.player.location) + if (event.damage == 1.0) { + val distance = damagerTTTPlayer.player.location.distance(damagedTTTPlayer.player.location) - if (distance <= 1.5) { - damagedTTTPlayer.damage( - 1000.0, - DeathReason.Item(Knife), - damagerTTTPlayer, - false - ) + if (distance <= 1.5) { + damagedTTTPlayer.damage( + 1000.0, + DeathReason.Item(Knife), + damagerTTTPlayer, + false + ) - GameManager.world.playSound( - damagedTTTPlayer.player.location, - Resourcepack.Sounds.Item.Weapon.Knife.hit, - SoundCategory.PLAYERS, - 1F, - 1F - ) + GameManager.world.playSound( + damagedTTTPlayer.player.location, + Resourcepack.Sounds.Item.Weapon.Knife.hit, + SoundCategory.PLAYERS, + 1F, + 1F + ) - damagerTTTPlayer.player.playSound( - damagerTTTPlayer.player.location, - Sound.ENTITY_ITEM_BREAK, - SoundCategory.PLAYERS, - 1F, - 1F - ) + damagerTTTPlayer.player.playSound( + damagerTTTPlayer.player.location, + Sound.ENTITY_ITEM_BREAK, + SoundCategory.PLAYERS, + 1F, + 1F + ) - damagerTTTPlayer.removeItem(Knife) + damagerTTTPlayer.removeItem(Knife) + } } } - } + }) } } diff --git a/src/main/kotlin/de/moritzruth/spigot_ttt/game/players/DeathReason.kt b/src/main/kotlin/de/moritzruth/spigot_ttt/game/players/DeathReason.kt index 62fe56c..d2b6394 100644 --- a/src/main/kotlin/de/moritzruth/spigot_ttt/game/players/DeathReason.kt +++ b/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}") }