GH-986 GH-1096 Moved sounds and enhanced death messages

eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java

@@ -106,32 +106,6 @@ public Duration teleportationTimeToSpawn() {
     @Comment("# Settings for player home management")
     public 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
     @Comment("")
     @Comment("# Chat Configuration")

eternalcore-core/src/main/java/com/eternalcode/core/feature/deathmessage/DeathMessageController.java

@@ -1,20 +1,23 @@
 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;
 import com.eternalcode.core.injector.annotations.component.Controller;
 import com.eternalcode.core.notice.NoticeService;
 import com.eternalcode.multification.notice.Notice;
 import java.util.List;
+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 +33,192 @@ 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 (damageCause instanceof EntityDamageByEntityEvent causeByEntity && causeByEntity.getDamager() instanceof Player killer) {
+        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 (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<Notice> weaponMessages = translation.event().deathMessageByWeapon().get(weaponType);
+                    return weaponMessages != null
+                        ? RandomElementUtil.randomElement(weaponMessages)
+                        : RandomElementUtil.randomElement(translation.event().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<Notice> notifications = translation.event().deathMessageByDamageCause().get(cause);
-
-                    if (notifications == null) {
-                        return RandomElementUtil.randomElement(translation.event().unknownDeathCause());
+                    List<Notice> entityMessages = translation.event().deathMessageByEntity().get(entityType);
+                    if (entityMessages != null) {
+                        return RandomElementUtil.randomElement(entityMessages);
                     }
-
-                    return RandomElementUtil.randomElement(notifications);
+                    List<Notice> projectileMessages = translation.event().deathMessageByEntity().get(projectileType);
+                    if (projectileMessages != null) {
+                        return RandomElementUtil.randomElement(projectileMessages);
+                    }
+                    return RandomElementUtil.randomElement(translation.event().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 -> {
+                List<Notice> projectileMessages = translation.event().deathMessageByEntity().get(projectileType);
+                return projectileMessages != null
+                    ? RandomElementUtil.randomElement(projectileMessages)
+                    : RandomElementUtil.randomElement(translation.event().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 -> {
+                return java.util.Optional.ofNullable(translation.event().deathMessageByWeapon().get(weaponType))
+                    .filter(list -> !list.isEmpty())
+                    .map(RandomElementUtil::randomElement)
+                    .orElseGet(() -> RandomElementUtil.randomElement(translation.event().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<Notice> entityMessages = translation.event().deathMessageByEntity().get(entityType);
+                return entityMessages != null
+                    ? RandomElementUtil.randomElement(entityMessages)
+                    : RandomElementUtil.randomElement(translation.event().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<Notice> blockMessages = translation.event().deathMessageByEntity().get(blockType);
+                        return blockMessages != null
+                            ? RandomElementUtil.randomElement(blockMessages)
+                            : RandomElementUtil.randomElement(translation.event().unknownDeathCause());
+                    })
+                    .placeholder("{PLAYER}", victim.getName())
+                    .onlinePlayers()
+                    .send();
+                return;
+            }
+        }
+
+        this.noticeService.create()
+            .noticeOptional(translation -> {
+                List<Notice> notifications = translation.event().deathMessageByDamageCause().get(cause);
+                return notifications != null
+                    ? RandomElementUtil.randomElement(notifications)
+                    : RandomElementUtil.randomElement(translation.event().unknownDeathCause());
+            })
+            .placeholder("{PLAYER}", victim.getName())
+            .placeholder("{CAUSE}", cause.name())
+            .onlinePlayers()
+            .send();
+    }
+
+    private void handleUnknownDeath(Player victim) {
         this.noticeService.create()
             .noticeOptional(translation -> RandomElementUtil.randomElement(translation.event().unknownDeathCause()))
-            .placeholder("{PLAYER}", player.getName())
+            .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;
+    }
 }

eternalcore-core/src/main/java/com/eternalcode/core/translation/Translation.java

@@ -97,6 +97,8 @@ interface EventSection {
         List<Notice> firstJoinMessage();
 
         Map<EntityDamageEvent.DamageCause, List<Notice>> deathMessageByDamageCause();
+        Map<String, List<Notice>> deathMessageByEntity();
+        Map<String, List<Notice>> deathMessageByWeapon();
 
         Notice welcome();
     }