diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java index 6a084bc14..b2087dbfc 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java @@ -122,32 +122,6 @@ public Duration teleportationTimeToSpawn() { @Comment("# Settings for player home management") HomesConfig homes = new HomesConfig(); - @Comment("") - @Comment("# Sound Configuration") - @Comment("# Settings for various sound effects") - @Bean - public Sounds sound = new Sounds(); - - public static class Sounds extends OkaeriConfig { - @Comment("# Enable sound when player joins the server") - public boolean enabledAfterJoin = true; - public Sound afterJoin = Sound.BLOCK_NOTE_BLOCK_PLING; - public float afterJoinVolume = 1.8F; - public float afterJoinPitch = 1F; - - @Comment("# Enable sound when player leaves the server") - public boolean enableAfterQuit = true; - public Sound afterQuit = Sound.BLOCK_NOTE_BLOCK_BASEDRUM; - public float afterQuitVolume = 1.8F; - public float afterQuitPitch = 1F; - - @Comment("# Enable sound when player sends a chat message") - public boolean enableAfterChatMessage = true; - public Sound afterChatMessage = Sound.ENTITY_ITEM_PICKUP; - public float afterChatMessageVolume = 1.8F; - public float afterChatMessagePitch = 1F; - } - @Bean(proxied = ChatSettings.class) @Comment("") @Comment("# Chat Configuration") diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0004_Move_death_to_dedicated_section.java b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0004_Move_death_to_dedicated_section.java new file mode 100644 index 000000000..1d512bf10 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0004_Move_death_to_dedicated_section.java @@ -0,0 +1,17 @@ +package com.eternalcode.core.configuration.migrations; + +import eu.okaeri.configs.migrate.builtin.NamedMigration; + +import static eu.okaeri.configs.migrate.ConfigMigrationDsl.move; + +public class Migration_0004_Move_death_to_dedicated_section extends NamedMigration { + + Migration_0004_Move_death_to_dedicated_section() { + super("Move death to dedicated section", + move("event.deathMessage", "death.deathMessage"), + move("event.unknownDeathCause", "death.unknownDeathCause"), + move("event.deathMessageByDamageCause", "death.deathMessageByDamageCause") + ); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0005_Move_join_quit_message_to_dedicated_section.java b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0005_Move_join_quit_message_to_dedicated_section.java new file mode 100644 index 000000000..993446592 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migration_0005_Move_join_quit_message_to_dedicated_section.java @@ -0,0 +1,17 @@ +package com.eternalcode.core.configuration.migrations; + +import eu.okaeri.configs.migrate.builtin.NamedMigration; + +import static eu.okaeri.configs.migrate.ConfigMigrationDsl.move; + +public class Migration_0005_Move_join_quit_message_to_dedicated_section extends NamedMigration { + + Migration_0005_Move_join_quit_message_to_dedicated_section() { + super("Move joinquit messages from event to joinQuit section", + move("event.joinMessage", "joinQuit.joinMessage"), + move("event.firstJoinMessage", "joinQuit.firstJoinMessage"), + move("event.quitMessage", "joinQuit.quitMessage") + ); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migrations.java b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migrations.java index 4945d3975..6f86eddbb 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migrations.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/configuration/migrations/Migrations.java @@ -6,6 +6,8 @@ public class Migrations { public static final ConfigMigration[] ALL = new ConfigMigration[] { new Migration_0001_Rename_privateChat_to_msg(), + new Migration_0004_Move_death_to_dedicated_section(), + new Migration_0005_Move_join_quit_message_to_dedicated_section() }; } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatConfig.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatConfig.java index 2574819fc..625e8914a 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatConfig.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatConfig.java @@ -1,11 +1,14 @@ package com.eternalcode.core.feature.chat; +import com.eternalcode.multification.bukkit.notice.BukkitNotice; +import com.eternalcode.multification.notice.Notice; import eu.okaeri.configs.OkaeriConfig; import eu.okaeri.configs.annotation.Comment; import java.time.Duration; import lombok.Getter; import lombok.Setter; import lombok.experimental.Accessors; +import org.bukkit.Sound; @Getter @Setter @@ -23,4 +26,10 @@ public class ChatConfig extends OkaeriConfig implements ChatSettings { @Comment("# Chat should be enabled?") public boolean chatEnabled = true; + + @Comment({ + "# Sound played when a player sends a chat message.", + "# To disable, set this to: chatNotice: []" + }) + public Notice chatNotice = BukkitNotice.sound(Sound.ENTITY_ITEM_PICKUP, 1.8F, 1F); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSettings.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSettings.java index f72f5808a..0d8781fb0 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSettings.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSettings.java @@ -1,5 +1,7 @@ package com.eternalcode.core.feature.chat; +import com.eternalcode.multification.notice.Notice; + import java.time.Duration; public interface ChatSettings { @@ -17,4 +19,6 @@ public interface ChatSettings { ChatSettings chatDelay(Duration delay); ChatSettings linesToClear(int lines); + + Notice chatNotice(); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSoundController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSoundController.java new file mode 100644 index 000000000..6c8ddaa46 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/chat/ChatSoundController.java @@ -0,0 +1,28 @@ +package com.eternalcode.core.feature.chat; + +import com.eternalcode.core.injector.annotations.component.Controller; +import com.eternalcode.core.notice.NoticeService; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +@Controller +class ChatSoundController implements Listener { + + private final NoticeService noticeService; + private final ChatSettings settings; + + ChatSoundController(NoticeService noticeService, ChatSettings settings) { + this.noticeService = noticeService; + this.settings = settings; + } + + @EventHandler + void onChat(AsyncPlayerChatEvent event) { + this.noticeService.create() + .notice(this.settings.chatNotice()) + .onlinePlayers() + .send(); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/DeathMessageController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/DeathMessageController.java index d23a3f683..ac5175e2d 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/DeathMessageController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/DeathMessageController.java @@ -1,6 +1,5 @@ package com.eternalcode.core.feature.deathmessage; - import com.eternalcode.commons.RandomElementUtil; import com.eternalcode.core.feature.vanish.VanishService; import com.eternalcode.core.injector.annotations.Inject; @@ -8,13 +7,19 @@ import com.eternalcode.core.notice.NoticeService; import com.eternalcode.multification.notice.Notice; import java.util.List; +import java.util.Optional; + +import org.bukkit.block.Block; import org.bukkit.entity.Entity; import org.bukkit.entity.Player; +import org.bukkit.entity.Projectile; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.inventory.ItemStack; +import org.bukkit.projectiles.ProjectileSource; @Controller class DeathMessageController implements Listener { @@ -30,48 +35,190 @@ class DeathMessageController implements Listener { @EventHandler void onPlayerDeath(PlayerDeathEvent event) { - Player player = event.getEntity(); + Player victim = event.getEntity(); event.setDeathMessage(null); - - if (this.vanishService.isVanished(player)) { + + if (this.vanishService.isVanished(victim)) { return; } - EntityDamageEvent damageCause = player.getLastDamageCause(); + EntityDamageEvent damageCause = victim.getLastDamageCause(); + if (!(damageCause instanceof EntityDamageByEntityEvent causeByEntity)) { + this.handleEnvironmentalDeath(victim, damageCause); + return; + } + + Entity directDamager = causeByEntity.getDamager(); + if (directDamager instanceof Projectile projectile) { + this.handleProjectileDeath(victim, projectile); + return; + } + + if (directDamager instanceof Player killer) { + this.handlePvPDeath(victim, killer); + return; + } + this.handleEntityDeath(victim, directDamager); + } + + private void handleProjectileDeath(Player victim, Projectile projectile) { + ProjectileSource shooter = projectile.getShooter(); - if (damageCause instanceof EntityDamageByEntityEvent causeByEntity && causeByEntity.getDamager() instanceof Player killer) { + if (shooter instanceof Player killerPlayer) { + String weaponType = this.getProjectileWeaponType(projectile); this.noticeService.create() - .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().deathMessage())) - .placeholder("{PLAYER}", player.getName()) - .placeholder("{KILLER}", killer.getName()) + .noticeOptional(translation -> { + List weaponMessages = translation.death().deathMessageByWeapon().get(weaponType); + return weaponMessages != null + ? RandomElementUtil.randomElement(weaponMessages) + : RandomElementUtil.randomElement(translation.death().deathMessage()); + }) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{KILLER}", killerPlayer.getName()) + .placeholder("{WEAPON}", weaponType.toLowerCase().replace("_", " ")) .onlinePlayers() .send(); return; } - if (damageCause != null) { - EntityDamageEvent.DamageCause cause = damageCause.getCause(); + if (shooter instanceof Entity shooterEntity) { + String entityType = shooterEntity.getType().name(); + String projectileType = projectile.getType().name(); this.noticeService.create() .noticeOptional(translation -> { - List notifications = translation.event().deathMessageByDamageCause().get(cause); - - if (notifications == null) { - return RandomElementUtil.randomElement(translation.event().unknownDeathCause()); + List entityMessages = translation.death().deathMessageByEntity().get(entityType); + if (entityMessages != null) { + return RandomElementUtil.randomElement(entityMessages); } - - return RandomElementUtil.randomElement(notifications); + List projectileMessages = translation.death().deathMessageByEntity().get(projectileType); + if (projectileMessages != null) { + return RandomElementUtil.randomElement(projectileMessages); + } + return RandomElementUtil.randomElement(translation.death().deathMessage()); }) - .placeholder("{PLAYER}", player.getName()) - .placeholder("{CAUSE}", cause.name()) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{KILLER}", shooterEntity.getName()) + .placeholder("{PROJECTILE}", projectileType.toLowerCase().replace("_", " ")) .onlinePlayers() .send(); return; } + String projectileType = projectile.getType().name(); this.noticeService.create() - .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().unknownDeathCause())) - .placeholder("{PLAYER}", player.getName()) + .noticeOptional(translation -> { + List projectileMessages = translation.death().deathMessageByEntity().get(projectileType); + return projectileMessages != null + ? RandomElementUtil.randomElement(projectileMessages) + : RandomElementUtil.randomElement(translation.death().unknownDeathCause()); + }) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{KILLER}", projectileType.toLowerCase().replace("_", " ")) .onlinePlayers() .send(); } + + private void handlePvPDeath(Player victim, Player killer) { + String weaponType = this.getWeaponType(killer.getInventory().getItemInMainHand()); + this.noticeService.create() + .noticeOptional(translation -> Optional.ofNullable(translation.death().deathMessageByWeapon().get(weaponType)) + .filter(list -> !list.isEmpty()) + .map(RandomElementUtil::randomElement) + .orElseGet(() -> RandomElementUtil.randomElement(translation.death().deathMessage()))) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{KILLER}", killer.getName()) + .placeholder("{WEAPON}", weaponType.toLowerCase().replace("_", " ")) + .onlinePlayers() + .send(); + } + + private void handleEntityDeath(Player victim, Entity damager) { + String entityType = damager.getType().name(); + this.noticeService.create() + .noticeOptional(translation -> { + List entityMessages = translation.death().deathMessageByEntity().get(entityType); + return entityMessages != null + ? RandomElementUtil.randomElement(entityMessages) + : RandomElementUtil.randomElement(translation.death().deathMessage()); + }) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{KILLER}", damager.getName()) + .onlinePlayers() + .send(); + } + + private void handleEnvironmentalDeath(Player victim, EntityDamageEvent damageCause) { + if (damageCause == null) { + this.handleUnknownDeath(victim); + return; + } + + EntityDamageEvent.DamageCause cause = damageCause.getCause(); + if (cause == EntityDamageEvent.DamageCause.CONTACT) { + String blockType = this.getContactBlockType(victim); + if (blockType != null) { + this.noticeService.create() + .noticeOptional(translation -> { + List blockMessages = translation.death().deathMessageByEntity().get(blockType); + return blockMessages != null + ? RandomElementUtil.randomElement(blockMessages) + : RandomElementUtil.randomElement(translation.death().unknownDeathCause()); + }) + .placeholder("{PLAYER}", victim.getName()) + .onlinePlayers() + .send(); + return; + } + } + + this.noticeService.create() + .noticeOptional(translation -> { + List notifications = translation.death().deathMessageByDamageCause().get(cause); + return notifications != null + ? RandomElementUtil.randomElement(notifications) + : RandomElementUtil.randomElement(translation.death().unknownDeathCause()); + }) + .placeholder("{PLAYER}", victim.getName()) + .placeholder("{CAUSE}", cause.name()) + .onlinePlayers() + .send(); + } + + private void handleUnknownDeath(Player victim) { + this.noticeService.create() + .noticeOptional(translation -> RandomElementUtil.randomElement(translation.death().unknownDeathCause())) + .placeholder("{PLAYER}", victim.getName()) + .onlinePlayers() + .send(); + } + + private String getProjectileWeaponType(Projectile projectile) { + return switch (projectile.getType()) { + case ARROW, SPECTRAL_ARROW -> "BOW"; + case FIREBALL, SMALL_FIREBALL -> "FIREBALL"; + default -> projectile.getType().name(); + }; + } + + private String getWeaponType(ItemStack item) { + return item == null || item.getType().isAir() + ? "HAND" + : item.getType().name(); + } + + private String getContactBlockType(Player player) { + Block blockAtFeet = player.getLocation().getBlock(); + Block blockAtEyes = player.getEyeLocation().getBlock(); + + for (Block block : new Block[] { blockAtFeet, blockAtEyes }) { + String type = switch (block.getType()) { + case CACTUS, MAGMA_BLOCK, SWEET_BERRY_BUSH, WITHER_ROSE -> block.getType().name(); + default -> null; + }; + if (type != null) { + return type; + } + } + return null; + } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/DeathMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/DeathMessages.java new file mode 100644 index 000000000..7ec553f02 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/DeathMessages.java @@ -0,0 +1,18 @@ +package com.eternalcode.core.feature.deathmessage.messages; + +import com.eternalcode.multification.notice.Notice; +import org.bukkit.event.entity.EntityDamageEvent; + +import java.util.List; +import java.util.Map; + +public interface DeathMessages { + + List deathMessage(); + List unknownDeathCause(); + + Map> deathMessageByDamageCause(); + Map> deathMessageByEntity(); + Map> deathMessageByWeapon(); + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/ENDeathMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/ENDeathMessages.java new file mode 100644 index 000000000..a283e752e --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/ENDeathMessages.java @@ -0,0 +1,245 @@ +package com.eternalcode.core.feature.deathmessage.messages; + +import com.eternalcode.multification.bukkit.notice.BukkitNotice; +import com.eternalcode.multification.notice.Notice; +import eu.okaeri.configs.OkaeriConfig; +import eu.okaeri.configs.annotation.Comment; +import lombok.Getter; +import lombok.experimental.Accessors; +import org.bukkit.Sound; +import org.bukkit.event.entity.EntityDamageEvent; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@Getter +@Accessors(fluent = true) +public class ENDeathMessages extends OkaeriConfig implements DeathMessages { + + @Comment({ + "# {PLAYER} - Killed player", + "# {KILLER} - Killer (only for PvP deaths)" + }) + public List deathMessage = List.of( + Notice.chat("☠ {PLAYER} died!"), + Notice.chat("☠ {PLAYER} was killed by {KILLER}!") + ); + + @Comment("# {PLAYER} - Player who died from an unknown cause") + public List unknownDeathCause = List.of( + Notice.chat("☠ {PLAYER} died under mysterious circumstances!") + ); + + @Comment({ + "# Messages shown when a player dies from specific damage causes", + "# {PLAYER} - Killed player", + "# {CAUSE} - Death cause (e.g., FALL, VOID)", + "# List of DamageCauses: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html" + }) + public Map> deathMessageByDamageCause = Map.of( + EntityDamageEvent.DamageCause.VOID, Collections.singletonList( + BukkitNotice.builder() + .actionBar("☠ {PLAYER} fell into the void!") + .sound(Sound.BLOCK_PORTAL_TRAVEL) + .build() + ), + EntityDamageEvent.DamageCause.FALL, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_ANVIL_LAND) + .chat("☠ {PLAYER} fell from a high place!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_ANVIL_LAND) + .chat("☠ {PLAYER} fell off a deadly cliff!") + .build() + ), + + EntityDamageEvent.DamageCause.FIRE, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} burned to death!") + .build(), + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} was consumed by flames!") + .build() + ), + + EntityDamageEvent.DamageCause.FIRE_TICK, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} burned out in flames...") + .build() + ), + + EntityDamageEvent.DamageCause.LAVA, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_POP) + .chat("☠ {PLAYER} fell into lava!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_EXTINGUISH) + .chat("☠ {PLAYER} disappeared in a sea of lava!") + .build() + ), + + EntityDamageEvent.DamageCause.DROWNING, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_DROWNED_DEATH) + .chat("☠ {PLAYER} drowned!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_DROWNED_DEATH) + .chat("☠ {PLAYER} died under the waves!") + .build() + ), + + EntityDamageEvent.DamageCause.POISON, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} died from poison!") + .build() + ), + + EntityDamageEvent.DamageCause.MAGIC, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_WITCH_DEATH) + .chat("☠ {PLAYER} died from dark magic!") + .build() + ) + ); + + @Comment({ + "# Enhanced death messages by entity type", + "# {PLAYER} - Killed player", + "# {KILLER} - Entity that killed the player" + }) + public Map> deathMessageByEntity = Map.of( + "ZOMBIE", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ZOMBIE_DEATH) + .chat("☠ {PLAYER} was devoured by a zombie!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_ZOMBIE_DEATH) + .chat("☠ {PLAYER} couldn't survive the zombie attack!") + .build() + ), + "SKELETON", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SKELETON_DEATH) + .chat("☠ {PLAYER} was pierced by a skeleton's arrow!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_SKELETON_DEATH) + .chat("☠ {PLAYER} fell victim to a skeleton archer!") + .build() + ), + "SPIDER", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} was bitten by a spider!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} got caught in a spider's web!") + .build() + ), + "CREEPER", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} was blown up by a creeper!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} couldn't escape the explosion!") + .build() + ), + "ENDERMAN", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ENDERMAN_DEATH) + .chat("☠ {PLAYER} was teleported into nothingness by an Enderman!") + .build() + ), + + "CACTUS", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_GRASS_BREAK) + .chat("☠ {PLAYER} pricked themselves on a cactus!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_GRASS_BREAK) + .chat("☠ {PLAYER} was pierced by cactus spines!") + .build() + ), + "MAGMA_BLOCK", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_POP) + .chat("☠ {PLAYER} was burned by a magma block!") + .build() + ), + "SWEET_BERRY_BUSH", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.BLOCK_SWEET_BERRY_BUSH_BREAK) + .chat("☠ {PLAYER} was scratched to death by a berry bush!") + .build() + ), + "PRIMED_TNT", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} was blown up by {KILLER} using TNT!") + .build() + ) + ); + + @Comment({ + "# PvP death messages by weapon type", + "# {PLAYER} - Killed player", + "# {KILLER} - Killer player", + "# {WEAPON} - Weapon used" + }) + public Map> deathMessageByWeapon = Map.of( + "BOW", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ARROW_HIT_PLAYER) + .chat("☠ {PLAYER} was shot by {KILLER} with a bow!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_ARROW_HIT_PLAYER) + .chat("☠ {PLAYER} fell to {KILLER}'s arrow!") + .build() + ), + "CROSSBOW", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_CROSSBOW_HIT) + .chat("☠ {PLAYER} was pierced by {KILLER}'s crossbow bolt!") + .build() + ), + "TRIDENT", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_TRIDENT_HIT) + .chat("☠ {PLAYER} was impaled by {KILLER}'s trident!") + .build() + ), + "DIAMOND_SWORD", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_CRIT) + .chat("☠ {PLAYER} was sliced by {KILLER}'s diamond sword!") + .build() + ), + "NETHERITE_SWORD", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_CRIT) + .chat("☠ {PLAYER} was annihilated by {KILLER}'s netherite sword!") + .build() + ), + "HAND", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_WEAK) + .chat("☠ {PLAYER} was beaten to death by {KILLER}'s bare hands!") + .build() + ) + ); +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/PLDeathMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/PLDeathMessages.java new file mode 100644 index 000000000..5b79f358f --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/messages/PLDeathMessages.java @@ -0,0 +1,249 @@ +package com.eternalcode.core.feature.deathmessage.messages; + +import com.eternalcode.multification.bukkit.notice.BukkitNotice; +import com.eternalcode.multification.notice.Notice; +import eu.okaeri.configs.OkaeriConfig; +import eu.okaeri.configs.annotation.Comment; +import lombok.Getter; +import lombok.experimental.Accessors; +import org.bukkit.Sound; +import org.bukkit.event.entity.EntityDamageEvent; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@Getter +@Accessors(fluent = true) +public class PLDeathMessages extends OkaeriConfig implements DeathMessages { + + @Comment({ + "# {PLAYER} - Gracz, który zginął", + "# {KILLER} - Gracz, który zabił (tylko w przypadku PvP)" + }) + public List deathMessage = List.of( + Notice.actionbar("☠ {PLAYER} zginął przez {KILLER}!"), + Notice.actionbar("☠ {PLAYER} zginął tragicznie podczas ciężkiej walki!") + ); + + @Comment("# {PLAYER} - Gracz, który zginął z nieznanej przyczyny") + public List unknownDeathCause = List.of( + Notice.chat("☠ {PLAYER} został zabity przez niezidentyfikowany obiekt!") + ); + + @Comment({ + "# Wiadomości wyświetlane gdy gracz ginie od konkretnego typu obrażeń", + "# {PLAYER} - Gracz, który zginął", + "# {CAUSE} - Przyczyna śmierci (np. UPADEK, VOID)", + "# List of DamageCauses: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html" + }) + public Map> deathMessageByDamageCause = Map.of( + EntityDamageEvent.DamageCause.VOID, Collections.singletonList( + BukkitNotice.builder() + .actionBar("☠ {PLAYER} wypadł w otchłań!") + .sound(Sound.BLOCK_PORTAL_TRAVEL) + .build() + ), + EntityDamageEvent.DamageCause.FALL, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_ANVIL_LAND) + .chat("☠ {PLAYER} spadł z wysokości!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_ANVIL_LAND) + .chat("☠ {PLAYER} spadł z zabójczego klifu!") + .build() + ), + + EntityDamageEvent.DamageCause.FIRE, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} spłonął żywcem!") + .build(), + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} został pochłonięty przez płomienie!") + .build() + ), + + EntityDamageEvent.DamageCause.FIRE_TICK, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_FIRECHARGE_USE) + .chat("☠ {PLAYER} dogasał w płomieniach...") + .build() + ), + + EntityDamageEvent.DamageCause.LAVA, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_POP) + .chat("☠ {PLAYER} wpadł do lawy!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_EXTINGUISH) + .chat("☠ {PLAYER} zniknął w morzu lawy!") + .build() + ), + + EntityDamageEvent.DamageCause.DROWNING, Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_DROWNED_DEATH) + .chat("☠ {PLAYER} utonął!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_DROWNED_DEATH) + .chat("☠ {PLAYER} zginął pod falami!") + .build() + ), + + EntityDamageEvent.DamageCause.POISON, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} zmarł od trucizny!") + .build() + ), + + EntityDamageEvent.DamageCause.MAGIC, Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_WITCH_DEATH) + .chat("☠ {PLAYER} zginął od czarnej magii!") + .build() + ) + ); + + @Comment({ + "# Rozszerzone wiadomości śmierci według typu entity", + "# {PLAYER} - Zabity gracz", + "# {KILLER} - Entity które zabiło gracza" + }) + public Map> deathMessageByEntity = Map.of( + "ZOMBIE", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ZOMBIE_DEATH) + .chat("☠ {PLAYER} został pożarty przez zombie!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_ZOMBIE_DEATH) + .chat("☠ {PLAYER} nie przetrwał ataku zombie!") + .build() + ), + "SKELETON", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SKELETON_DEATH) + .chat("☠ {PLAYER} został przeszyty strzałą szkieleta!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_SKELETON_DEATH) + .chat("☠ {PLAYER} padł ofiarą szkieleta łucznika!") + .build() + ), + "SPIDER", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} został ugryziony przez pająka!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_SPIDER_DEATH) + .chat("☠ {PLAYER} wpadł w pajęczą sieć!") + .build() + ), + "CREEPER", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} został wysadzony przez creepera!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} nie zdążył uciec przed eksplozją!") + .build() + ), + "ENDERMAN", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ENDERMAN_DEATH) + .chat("☠ {PLAYER} został teleportowany w nicość przez Endermana!") + .build() + ), + + "CACTUS", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.BLOCK_GRASS_BREAK) + .chat("☠ {PLAYER} ukłuł się na kaktusie!") + .build(), + BukkitNotice.builder() + .sound(Sound.BLOCK_GRASS_BREAK) + .chat("☠ {PLAYER} został przebity przez kolce kaktusa!") + .build() + ), + "MAGMA_BLOCK", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.BLOCK_LAVA_POP) + .chat("☠ {PLAYER} został spalony przez magma block!") + .build() + ), + "SWEET_BERRY_BUSH", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.BLOCK_SWEET_BERRY_BUSH_BREAK) + .chat("☠ {PLAYER} został zadrapany na śmierć przez krzak jagód!") + .build() + ), + "PRIMED_TNT", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ {PLAYER} wysadził sie w powietrze!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_GENERIC_EXPLODE) + .chat("☠ Piroman {PLAYER} nie przeżył!") + .build() + ) + ); + + @Comment({ + "# Wiadomości śmierci PvP według typu broni", + "# {PLAYER} - Zabity gracz", + "# {KILLER} - Zabójca", + "# {WEAPON} - Używana broń" + }) + public Map> deathMessageByWeapon = Map.of( + "BOW", Arrays.asList( + BukkitNotice.builder() + .sound(Sound.ENTITY_ARROW_HIT_PLAYER) + .chat("☠ {PLAYER} został zastrzelony przez {KILLER} z łuku!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_ARROW_HIT_PLAYER) + .chat("☠ {PLAYER} padł od strzały gracza {KILLER}!") + .build() + ), + "CROSSBOW", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_CROSSBOW_HIT) + .chat("☠ {PLAYER} został przebity bełtem {KILLER}!") + .build() + ), + "TRIDENT", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ITEM_TRIDENT_HIT) + .chat("☠ {PLAYER} został przebity trójzębem przez {KILLER}!") + .build() + ), + "DIAMOND_SWORD", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_CRIT) + .chat("☠ {PLAYER} został pokrojony diamentowym mieczem przez {KILLER}!") + .build() + ), + "NETHERITE_SWORD", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_CRIT) + .chat("☠ {PLAYER} został unicestwiony netheritowym mieczem gracza {KILLER}!") + .build() + ), + "HAND", Collections.singletonList( + BukkitNotice.builder() + .sound(Sound.ENTITY_PLAYER_ATTACK_WEAK) + .chat("☠ {PLAYER} został zmasakrowany gołymi rękami przez {KILLER}!") + .build() + ) + ); +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinmessage/PlayerJoinMessageController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/JoinMessageController.java similarity index 85% rename from eternalcore-core/src/main/java/com/eternalcode/core/feature/joinmessage/PlayerJoinMessageController.java rename to eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/JoinMessageController.java index 9928cdb4b..6b55ec1ed 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinmessage/PlayerJoinMessageController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/JoinMessageController.java @@ -1,4 +1,4 @@ -package com.eternalcode.core.feature.joinmessage; +package com.eternalcode.core.feature.joinquitmessage; import com.eternalcode.commons.RandomElementUtil; @@ -13,13 +13,13 @@ import panda.utilities.StringUtils; @Controller -class PlayerJoinMessageController implements Listener { +class JoinMessageController implements Listener { private final NoticeService noticeService; private final VanishService vanishService; @Inject - PlayerJoinMessageController(NoticeService noticeService, VanishService vanishService) { + JoinMessageController(NoticeService noticeService, VanishService vanishService) { this.noticeService = noticeService; this.vanishService = vanishService; } @@ -35,7 +35,7 @@ void onPlayerJoin(PlayerJoinEvent event) { if (!player.hasPlayedBefore()) { this.noticeService.create() - .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().firstJoinMessage())) + .noticeOptional(translation -> RandomElementUtil.randomElement(translation.joinQuit().firstJoinMessage())) .placeholder("{PLAYER}", player.getName()) .onlinePlayers() .send(); @@ -50,7 +50,7 @@ void onPlayerJoin(PlayerJoinEvent event) { event.setJoinMessage(StringUtils.EMPTY); this.noticeService.create() - .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().joinMessage())) + .noticeOptional(translation -> RandomElementUtil.randomElement(translation.joinQuit().joinMessage())) .placeholder("{PLAYER}", player.getName()) .onlinePlayers() .sendAsync(); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/QuitMessageController.java similarity index 67% rename from eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java rename to eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/QuitMessageController.java index d614ec8eb..93438c43a 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/QuitMessageController.java @@ -1,4 +1,4 @@ -package com.eternalcode.core.feature.quitmessage; +package com.eternalcode.core.feature.joinquitmessage; import com.eternalcode.commons.RandomElementUtil; @@ -13,30 +13,23 @@ import panda.utilities.StringUtils; @Controller -class PlayerQuitMessageController implements Listener { +class QuitMessageController implements Listener { private final NoticeService noticeService; - private final VanishService vanishService; @Inject - PlayerQuitMessageController(NoticeService noticeService, VanishService vanishService) { + QuitMessageController(NoticeService noticeService) { this.noticeService = noticeService; - this.vanishService = vanishService; } @EventHandler void onPlayerQuit(PlayerQuitEvent event) { Player player = event.getPlayer(); - if (this.vanishService.isVanished(player)) { - event.setQuitMessage(StringUtils.EMPTY); - return; - } - event.setQuitMessage(StringUtils.EMPTY); this.noticeService.create() - .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().quitMessage())) + .noticeOptional(translation -> RandomElementUtil.randomElement(translation.joinQuit().quitMessage())) .placeholder("{PLAYER}", player.getName()) .onlinePlayers() .send(); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/ENJoinQuitMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/ENJoinQuitMessages.java new file mode 100644 index 000000000..9003e4976 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/ENJoinQuitMessages.java @@ -0,0 +1,52 @@ +package com.eternalcode.core.feature.joinquitmessage.messages; + +import com.eternalcode.multification.bukkit.notice.BukkitNotice; +import com.eternalcode.multification.notice.Notice; +import eu.okaeri.configs.OkaeriConfig; +import eu.okaeri.configs.annotation.Comment; +import lombok.Getter; +import lombok.experimental.Accessors; +import org.bukkit.Sound; + +import java.util.List; + +@Getter +@Accessors(fluent = true) +public class ENJoinQuitMessages extends OkaeriConfig implements JoinQuitMessages { + + @Comment("# {PLAYER} - Player who joined") + public List joinMessage = List.of( + BukkitNotice.builder() + .actionBar("► {PLAYER} joined the server!") + .sound(Sound.BLOCK_BEACON_ACTIVATE, 1.8F, 1F) + .build(), + BukkitNotice.builder() + .actionBar("► Welcome to the server {PLAYER}!") + .sound(Sound.BLOCK_BEACON_ACTIVATE, 1.8F, 1F) + .build() + ); + + @Comment("# {PLAYER} - Player who joined.") + public List firstJoinMessage = List.of( + BukkitNotice.builder() + .sound(Sound.ENTITY_VILLAGER_CELEBRATE) + .actionBar("► {PLAYER} joined the server for the first time!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_VILLAGER_CELEBRATE) + .actionBar("► {PLAYER} welcome to the server for the first time!") + .build() + ); + + @Comment("# {PLAYER} - Player who left") + public List quitMessage = List.of( + BukkitNotice.builder() + .actionBar("► {PLAYER} logged off the server!") + .sound(Sound.BLOCK_NOTE_BLOCK_BASEDRUM, 1.8F, 1F) + .build(), + BukkitNotice.builder() + .actionBar("► {PLAYER} left the server!") + .sound(Sound.BLOCK_NOTE_BLOCK_BASEDRUM, 1.8F, 1F) + .build() + ); +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/JoinQuitMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/JoinQuitMessages.java new file mode 100644 index 000000000..2b2d22543 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/JoinQuitMessages.java @@ -0,0 +1,13 @@ +package com.eternalcode.core.feature.joinquitmessage.messages; + +import com.eternalcode.multification.notice.Notice; + +import java.util.List; + +public interface JoinQuitMessages { + + List joinMessage(); + List quitMessage(); + List firstJoinMessage(); + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/PLJoinQuitMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/PLJoinQuitMessages.java new file mode 100644 index 000000000..494ef5533 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/joinquitmessage/messages/PLJoinQuitMessages.java @@ -0,0 +1,64 @@ +package com.eternalcode.core.feature.joinquitmessage.messages; + +import com.eternalcode.multification.bukkit.notice.BukkitNotice; +import com.eternalcode.multification.notice.Notice; +import eu.okaeri.configs.OkaeriConfig; +import eu.okaeri.configs.annotation.Comment; +import lombok.Getter; +import lombok.experimental.Accessors; +import org.bukkit.Sound; + +import java.util.List; + +@Getter +@Accessors(fluent = true) +public class PLJoinQuitMessages extends OkaeriConfig implements JoinQuitMessages { + + @Comment({ + "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", + "# za każdym razem gdy gracz dołączy do serwera", + "# {PLAYER} - Gracz który dołączył do serwera", + }) + public List joinMessage = List.of( + BukkitNotice.builder() + .actionBar("► {PLAYER} dołączył do serwera!") + .sound(Sound.BLOCK_BEACON_ACTIVATE, 1.8F, 1F) + .build(), + BukkitNotice.builder() + .actionBar("► Witaj na serwerze {PLAYER}!") + .sound(Sound.BLOCK_BEACON_ACTIVATE, 1.8F, 1F) + .build() + ); + + @Comment({ + "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", + "# za każdym razem gdy gracz dołączy do serwera po raz pierwszy", + "# {PLAYER} - Gracz który dołączył do serwera po raz pierwszy" + }) + public List firstJoinMessage = List.of( + BukkitNotice.builder() + .sound(Sound.ENTITY_VILLAGER_CELEBRATE) + .actionBar("► {PLAYER} dołączył do serwera po raz pierwszy!") + .build(), + BukkitNotice.builder() + .sound(Sound.ENTITY_VILLAGER_CELEBRATE) + .actionBar("► {PLAYER} zawitał u nas po raz pierwszy!") + .build() + ); + + @Comment({ + "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", + "# za każdym razem gdy gracz opuści serwer", + "# {PLAYER} - Gracz który opuścił serwer" + }) + public List quitMessage = List.of( + BukkitNotice.builder() + .actionBar("► {PLAYER} opuścił serwer!") + .sound(Sound.BLOCK_NOTE_BLOCK_BASEDRUM, 1.8F, 1F) + .build(), + BukkitNotice.builder() + .actionBar("► {PLAYER} wylogował się z serwera!") + .sound(Sound.BLOCK_NOTE_BLOCK_BASEDRUM, 1.8F, 1F) + .build() + ); +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerChatSoundListener.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerChatSoundListener.java deleted file mode 100644 index 88af118bd..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerChatSoundListener.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.eternalcode.core.feature.sound; - - -import com.eternalcode.core.configuration.implementation.PluginConfiguration; -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Controller; -import org.bukkit.Server; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.EventPriority; -import org.bukkit.event.Listener; -import org.bukkit.event.player.AsyncPlayerChatEvent; - -@Controller -class PlayerChatSoundListener implements Listener { - - private final PluginConfiguration config; - private final Server server; - - @Inject - PlayerChatSoundListener(PluginConfiguration config, Server server) { - this.config = config; - this.server = server; - } - - @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR) - void playSound(AsyncPlayerChatEvent event) { - PluginConfiguration.Sounds sound = this.config.sound; - - if (!sound.enableAfterChatMessage) { - return; - } - - for (Player online : this.server.getOnlinePlayers()) { - online.playSound(online.getLocation(), sound.afterChatMessage, sound.afterChatMessageVolume, sound.afterChatMessagePitch); - } - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerJoinSoundListener.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerJoinSoundListener.java deleted file mode 100644 index be13d1769..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerJoinSoundListener.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.eternalcode.core.feature.sound; - - -import com.eternalcode.core.configuration.implementation.PluginConfiguration; -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Controller; -import org.bukkit.Server; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.player.PlayerJoinEvent; - -@Controller -class PlayerJoinSoundListener implements Listener { - - private final PluginConfiguration config; - private final Server server; - - @Inject - PlayerJoinSoundListener(PluginConfiguration config, Server server) { - this.config = config; - this.server = server; - } - - @EventHandler - void onPlayerJoinSound(PlayerJoinEvent event) { - if (this.config.sound.enabledAfterJoin) { - for (Player online : this.server.getOnlinePlayers()) { - online.playSound(online.getLocation(), this.config.sound.afterJoin, this.config.sound.afterJoinVolume, this.config.sound.afterJoinPitch); - } - } - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerQuitSoundListener.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerQuitSoundListener.java deleted file mode 100644 index 752c0bcb0..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/sound/PlayerQuitSoundListener.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.eternalcode.core.feature.sound; - - -import com.eternalcode.core.configuration.implementation.PluginConfiguration; -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Controller; -import org.bukkit.Server; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.player.PlayerQuitEvent; - -@Controller -class PlayerQuitSoundListener { - - private final PluginConfiguration config; - private final Server server; - - @Inject - PlayerQuitSoundListener(PluginConfiguration config, Server server) { - this.config = config; - this.server = server; - } - - @EventHandler - void onPlayerQuitSound(PlayerQuitEvent event) { - if (this.config.sound.enableAfterQuit) { - for (Player online : this.server.getOnlinePlayers()) { - online.playSound(online.getLocation(), this.config.sound.afterQuit, this.config.sound.afterQuitVolume, this.config.sound.afterQuitPitch); - } - } - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java b/eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java index 9144f3e30..f6dcb6604 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java @@ -6,12 +6,14 @@ import com.eternalcode.core.feature.afk.messages.AfkMessages; import com.eternalcode.core.feature.automessage.messages.AutoMessageMessages; import com.eternalcode.core.feature.burn.messages.BurnMessages; +import com.eternalcode.core.feature.deathmessage.messages.DeathMessages; import com.eternalcode.core.feature.fun.demoscreen.messages.DemoScreenMessages; import com.eternalcode.core.feature.fun.elderguardian.messages.ElderGuardianMessages; import com.eternalcode.core.feature.helpop.messages.HelpOpSection; import com.eternalcode.core.feature.home.messages.HomeMessages; import com.eternalcode.core.feature.itemedit.messages.ItemEditMessages; import com.eternalcode.core.feature.jail.messages.JailMessages; +import com.eternalcode.core.feature.joinquitmessage.messages.JoinQuitMessages; import com.eternalcode.core.feature.language.Language; import com.eternalcode.core.feature.msg.messages.MsgMessages; import com.eternalcode.core.feature.randomteleport.messages.RandomTeleportMessages; @@ -91,16 +93,13 @@ interface ChatSection { Notice alertQueueSent(); } - interface EventSection { - List deathMessage(); - List unknownDeathCause(); - List joinMessage(); - List quitMessage(); - List firstJoinMessage(); + // join quit messages + JoinQuitMessages joinQuit(); - Map> deathMessageByDamageCause(); + interface EventSection { Notice welcome(); + } interface InventorySection { @@ -258,4 +257,6 @@ interface ContainerSection { BurnMessages burn(); // vanish section VanishMessages vanish(); + // death section + DeathMessages death(); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java b/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java index e212638a7..799d0cbeb 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java @@ -6,12 +6,14 @@ import com.eternalcode.core.feature.afk.messages.ENAfkMessages; import com.eternalcode.core.feature.automessage.messages.ENAutoMessageMessages; import com.eternalcode.core.feature.burn.messages.ENBurnMessages; +import com.eternalcode.core.feature.deathmessage.messages.ENDeathMessages; import com.eternalcode.core.feature.fun.demoscreen.messages.ENDemoScreenMessages; import com.eternalcode.core.feature.fun.elderguardian.messages.ENElderGuardianMessages; import com.eternalcode.core.feature.helpop.messages.ENHelpOpMessages; import com.eternalcode.core.feature.home.messages.ENHomeMessages; import com.eternalcode.core.feature.itemedit.messages.ENItemEditMessages; import com.eternalcode.core.feature.jail.messages.ENJailMessages; +import com.eternalcode.core.feature.joinquitmessage.messages.ENJoinQuitMessages; import com.eternalcode.core.feature.language.Language; import com.eternalcode.core.feature.msg.messages.ENMsgMessages; import com.eternalcode.core.feature.randomteleport.messages.ENRandomTeleportMessages; @@ -25,12 +27,14 @@ import com.eternalcode.core.feature.vanish.messages.ENVanishMessages; import com.eternalcode.core.feature.warp.messages.ENWarpMessages; import com.eternalcode.core.translation.AbstractTranslation; +import com.eternalcode.multification.bukkit.notice.BukkitNotice; import com.eternalcode.multification.notice.Notice; import eu.okaeri.configs.OkaeriConfig; import eu.okaeri.configs.annotation.Comment; import lombok.Getter; import lombok.experimental.Accessors; import org.bukkit.Material; +import org.bukkit.Sound; import org.bukkit.event.entity.EntityDamageEvent; import java.io.File; @@ -301,6 +305,9 @@ public static class ENChatSection extends OkaeriConfig implements ChatSection { }) public ENAfkMessages afk = new ENAfkMessages(); + @Comment("# This section is responsible for the messages of join/quit events.") + public ENJoinQuitMessages joinQuit = new ENJoinQuitMessages(); + @Comment({ " ", "# Section responsible for various server events." @@ -309,53 +316,6 @@ public static class ENChatSection extends OkaeriConfig implements ChatSection { @Getter public static class ENEventSection extends OkaeriConfig implements EventSection { - @Comment({ - "# {PLAYER} - Killed player", - "# {KILLER} - Killer (only for PvP deaths)" - }) - public List deathMessage = List.of( - Notice.chat("☠ {PLAYER} died!"), - Notice.chat("☠ {PLAYER} was killed by {KILLER}!") - ); - - @Comment({ - "# Messages shown when a player dies from specific damage causes", - "# {PLAYER} - Killed player", - "# {CAUSE} - Death cause (e.g., FALL, VOID)", - "# List of DamageCauses: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html" - }) - public Map> deathMessageByDamageCause = Map.of( - EntityDamageEvent.DamageCause.VOID, Collections.singletonList( - Notice.chat("☠ {PLAYER} fell into the void!") - ), - EntityDamageEvent.DamageCause.FALL, Arrays.asList( - Notice.chat("☠ {PLAYER} fell from a high place!"), - Notice.chat("☠ {PLAYER} fell off a deadly cliff!") - ) - ); - - @Comment("# {PLAYER} - Player who died from an unknown cause") - public List unknownDeathCause = List.of( - Notice.chat("☠ {PLAYER} died under mysterious circumstances!") - ); - - @Comment({"", "# {PLAYER} - Player who joined"}) - public List joinMessage = List.of( - Notice.actionbar("► {PLAYER} joined the server!"), - Notice.actionbar("► Welcome to the server {PLAYER}!") - ); - - @Comment("# {PLAYER} - Player who joined.") - public List firstJoinMessage = List.of( - Notice.chat("► {PLAYER} joined the server for the first time!"), - Notice.chat("► {PLAYER} welcome to the server for the first time!") - ); - - @Comment("# {PLAYER} - Player who left") - public List quitMessage = List.of( - Notice.actionbar("► {PLAYER} logged off the server!"), - Notice.actionbar("► {PLAYER} left the server!") - ); @Comment({" ", "# {PLAYER} - Player who joined"}) public Notice welcome = Notice.title("EternalCode.pl", "Welcome back to the server!"); @@ -578,4 +538,7 @@ public static class ENLanguageSection extends OkaeriConfig implements LanguageSe @Comment({" ", "# This section is responsible for vanish-related stuff."}) public ENVanishMessages vanish = new ENVanishMessages(); + + @Comment({" ", "# This section is responsible for death messages."}) + public ENDeathMessages death = new ENDeathMessages(); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/PLTranslation.java b/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/PLTranslation.java index e280d773c..e8fa63890 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/PLTranslation.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/PLTranslation.java @@ -6,12 +6,14 @@ import com.eternalcode.core.feature.afk.messages.PLAfkMessages; import com.eternalcode.core.feature.automessage.messages.PLAutoMessageMessages; import com.eternalcode.core.feature.burn.messages.PLBurnMessages; +import com.eternalcode.core.feature.deathmessage.messages.PLDeathMessages; import com.eternalcode.core.feature.fun.demoscreen.messages.PLDemoScreenMessages; import com.eternalcode.core.feature.fun.elderguardian.messages.PLElderGuardianMessages; import com.eternalcode.core.feature.helpop.messages.PLHelpOpMessages; import com.eternalcode.core.feature.home.messages.PLHomeMessages; import com.eternalcode.core.feature.itemedit.messages.PLItemEditMessages; import com.eternalcode.core.feature.jail.messages.PLJailMessages; +import com.eternalcode.core.feature.joinquitmessage.messages.PLJoinQuitMessages; import com.eternalcode.core.feature.language.Language; import com.eternalcode.core.feature.msg.messages.PLMsgMessages; import com.eternalcode.core.feature.randomteleport.messages.PLRandomTeleportMessages; @@ -25,19 +27,18 @@ import com.eternalcode.core.feature.vanish.messages.PLVanishMessages; import com.eternalcode.core.feature.warp.messages.PLWarpMessages; import com.eternalcode.core.translation.AbstractTranslation; +import com.eternalcode.multification.bukkit.notice.BukkitNotice; import com.eternalcode.multification.notice.Notice; import eu.okaeri.configs.OkaeriConfig; import eu.okaeri.configs.annotation.Comment; import lombok.Getter; import lombok.experimental.Accessors; import org.bukkit.Material; -import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.Sound; import java.io.File; -import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.Map; @Getter @Accessors(fluent = true) @@ -306,6 +307,12 @@ public static class PLChatSection extends OkaeriConfig implements ChatSection { }) public PLAfkMessages afk = new PLAfkMessages(); + @Comment({ + " ", + "# Ta sekcja odpowiada za ustawianie i edycję wiadomości o dołączeniu i wyjściu gracza", + }) + public PLJoinQuitMessages joinQuit = new PLJoinQuitMessages(); + @Comment({ " ", "# Ta sekcja odpowiada za ustawianie i edycję wiadomości o zdarzeniach gracza", @@ -314,68 +321,6 @@ public static class PLChatSection extends OkaeriConfig implements ChatSection { @Getter public static class PLEventSection extends OkaeriConfig implements EventSection { - @Comment({ - "# {PLAYER} - Gracz, który zginął", - "# {KILLER} - Gracz, który zabił (tylko w przypadku PvP)" - }) - public List deathMessage = List.of( - Notice.actionbar("☠ {PLAYER} zginął przez {KILLER}!"), - Notice.actionbar("☠ {PLAYER} zginął tragicznie podczas ciężkiej walki!") - ); - - @Comment({ - "# Wiadomości wyświetlane gdy gracz ginie od konkretnego typu obrażeń", - "# {PLAYER} - Gracz, który zginął", - "# {CAUSE} - Przyczyna śmierci (np. UPADEK, VOID)", - "# List of DamageCauses: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html" - }) - public Map> deathMessageByDamageCause = Map.of( - EntityDamageEvent.DamageCause.VOID, Collections.singletonList( - Notice.chat("☠ {PLAYER} wypadł w otchłań!") - ), - EntityDamageEvent.DamageCause.FALL, Arrays.asList( - Notice.chat("☠ {PLAYER} spadł z wysokości!"), - Notice.chat("☠ {PLAYER} spadł z zabójczego klifu!") - ) - ); - - @Comment("# {PLAYER} - Gracz, który zginął z nieznanej przyczyny") - public List unknownDeathCause = List.of( - Notice.chat("☠ {PLAYER} został zabity przez niezidentyfikowany obiekt!") - ); - - @Comment({ - " ", - "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", - "# za każdym razem gdy gracz dołączy do serwera", - "# {PLAYER} - Gracz który dołączył do serwera", - }) - public List joinMessage = List.of( - Notice.actionbar("► {PLAYER} dołączył do serwera!"), - Notice.actionbar("► Witaj na serwerze {PLAYER}!") - ); - - @Comment({ - " ", - "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", - "# za każdym razem gdy gracz dołączy do serwera po raz pierwszy", - "# {PLAYER} - Gracz który dołączył do serwera po raz pierwszy" - }) - public List firstJoinMessage = List.of( - Notice.actionbar("► {PLAYER} dołączył do serwera po raz pierwszy!"), - Notice.actionbar("► {PLAYER} zawitał u nas po raz pierwszy!") - ); - - @Comment({ - " ", - "# Podobnie jak w wiadomości o śmierci, EternalCore będzie losował losową wiadomość z poniższej listy", - "# za każdym razem gdy gracz opuści serwer", - "# {PLAYER} - Gracz który opuścił serwer" - }) - public List quitMessage = List.of( - Notice.actionbar("► {PLAYER} wylogował się z serwera!"), - Notice.actionbar("► {PLAYER} opuścił serwer!") - ); @Comment({" ", "# {PLAYER} - Gracz który dołączył do serwera"}) public Notice welcome = Notice.title("{PLAYER}", "Witaj ponownie na serwerze!"); @@ -602,4 +547,7 @@ public static class PLLanguageSection extends OkaeriConfig implements LanguageSe @Comment({" ", "# Ta sekcja odpowiada za wiadomości dotyczące trybu niewidoczności graczy"}) public PLVanishMessages vanish = new PLVanishMessages(); + + @Comment({" ", "# Ta sekcja odpowiada za wiadomości dotyczące śmierci graczy"}) + public PLDeathMessages death = new PLDeathMessages(); }