moritzruth/spigot-ttt
Archived
1
0
Fork 0
Code Activity

Allow multiple listeners for a single TTTItem

Browse source
This commit is contained in:
Moritz Ruth 2020-06-21 17:16:27 +02:00
parent 1d638db078
commit ce4502d3d8
No known key found for this signature in database
GPG key ID: AFD57E23E753841B
17 changed files with 468 additions and 432 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/main/kotlin/de/moritzruth/spigot_ttt/Resourcepack.kt
View file

@ -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

12
src/main/kotlin/de/moritzruth/spigot_ttt/game/GeneralGameListener.kt
View file

@ -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 }
}
}
}

176
src/main/kotlin/de/moritzruth/spigot_ttt/game/items/ItemListener.kt Normal file
View file

@ -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())
}
}
}
}

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

@ -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())
}
}
}
}
}

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

@ -24,8 +24,16 @@ open class TTTItem<InstanceT: TTTItem.Instance>(
val disableDamage: Boolean = true,
val removeInstanceOnDeath: Boolean = true
) {
open val listener: Listener? = null
open val packetListener: PacketListener? = null
var listeners: Set<Listener> = emptySet(); private set
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

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

@ -55,52 +55,54 @@ object BoomBody: TTTItem<BoomBody.Instance>(
val boomBodies: MutableSet<TTTCorpse> = Collections.newSetFromMap(WeakHashMap<TTTCorpse, Boolean>())
override val listener = object : TTTItemListener<Instance>(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<Instance>(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)
}
}
}
})
}
}

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

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

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

@ -65,37 +65,39 @@ object Defibrillator: TTTItem<Defibrillator.Instance>(
it.stopSound(Resourcepack.Sounds.Item.Defibrillator.use, SoundCategory.PLAYERS)
}
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler(ignoreCancelled = true)
fun onCorpseClick(event: CorpseClickEvent) {
val instance = getInstance(event.tttPlayer.player.inventory.itemInMainHand) ?: return
event.isCancelled = true
init {
addListener(object : TTTItemListener<Instance>(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) {

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

@ -69,61 +69,63 @@ object FakeCorpse: TTTItem<FakeCorpse.Instance>(
.toTypedArray())
}
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler
fun onInventoryClick(event: InventoryClickEvent) = handle(event) { tttPlayer ->
val instance = getInstance(tttPlayer) ?: return@handle
init {
addListener(object : TTTItemListener<Instance>(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)
}
}
}
}
}
}
})
}
}

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

@ -39,13 +39,15 @@ object HealingPotion: TTTItem<HealingPotion.Instance>(
buyLimit = 2
)
) {
override val listener = 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
}
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)

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

@ -47,24 +47,26 @@ object MartyrdomGrenade: TTTItem<MartyrdomGrenade.Instance>(
}
}
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler
fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
val instance = getInstance(event.tttPlayer) ?: return
instance.tttPlayer = event.tttPlayer
init {
addListener(object : TTTItemListener<Instance>(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())
}
})
}
}

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

@ -106,27 +106,29 @@ object Radar: TTTItem<Radar.Instance>(
}
}
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
}
}
}
}
})
}
}

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

@ -155,44 +155,46 @@ object SecondChance: TTTItem<SecondChance.Instance>(
})
}
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler
fun onTTTPlayerTrueDeath(event: TTTPlayerTrueDeathEvent) {
val instance = getInstance(event.tttPlayer) ?: return
instance.possiblyTrigger(event.tttCorpse)
event.winnerRoleGroup = PlayerManager.getOnlyRemainingRoleGroup()
}
init {
addListener(object : TTTItemListener<Instance>(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() }
})
}
}

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

@ -57,31 +57,33 @@ object BaseballBat: TTTItem<BaseballBat.Instance>(
}
}
override val listener = object : TTTItemListener<Instance>(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<Instance>(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)
}
}
}
})
}
}

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

@ -53,16 +53,18 @@ object Fireball: TTTItem<Fireball.Instance>(
val sendersByEntity = WeakHashMap<FireballEntity, TTTPlayer>()
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler
fun onExplosionPrime(event: ExplosionPrimeEvent) {
val sender = sendersByEntity[event.entity]
init {
addListener(object : TTTItemListener<Instance>(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)
}
}
}
})
}
}

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

@ -48,42 +48,44 @@ object Knife: TTTItem<Knife.Instance>(
) {
class Instance: TTTItem.Instance(Knife)
override val listener = object : TTTItemListener<Instance>(this) {
@EventHandler(ignoreCancelled = true)
fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) = handle(event) { damagerTTTPlayer, damagedTTTPlayer ->
event.isCancelled = true
init {
addListener(object : TTTItemListener<Instance>(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)
}
}
}
}
})
}
}

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

@ -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}")
}