package com.relicroalm.abilities; import com.cryptomorin.xseries.XSound; import com.relicroalm.RelicRealm; import com.relicroalm.data.PlayerData; import com.relicroalm.data.RelicDefinition; import com.relicroalm.data.RelicInstance; import com.relicroalm.data.RelicType; import net.md_5.bungee.api.ChatMessageType; import net.md_5.bungee.api.chat.TextComponent; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.EntityEffect; import org.bukkit.FluidCollisionMode; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.World; import org.bukkit.entity.Arrow; import org.bukkit.entity.Entity; import org.bukkit.entity.Fireball; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.entity.SmallFireball; import org.bukkit.entity.SplashPotion; import org.bukkit.entity.TNTPrimed; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.persistence.PersistentDataContainer; import org.bukkit.persistence.PersistentDataType; import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import org.bukkit.potion.PotionType; import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.util.RayTraceResult; import org.bukkit.util.Vector; import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.inventory.ItemStack; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Random; import java.util.Set; import java.util.UUID; public class RelicAbilityHandler { private final RelicRealm plugin; private final Random random = new Random(); // Cooldown tracking: UUID -> (RelicType.name -> expiry time ms) private final Map> cooldowns = new HashMap<>(); // Passive internal cooldowns (for chance-based passives) private final Map> passiveCooldowns = new HashMap<>(); // Players launched by Breeze Relic (fall damage immunity) private final Set breezeLaunched = new HashSet<>(); // Players immune to their own projectile damage private final Set selfDamageImmune = new HashSet<>(); // Projectile -> owner UUID mapping private final Map relicProjectiles = new HashMap<>(); // Track last position for pig relic movement detection private final Map lastLocations = new HashMap<>(); public final NamespacedKey relicProjectileKey; public final NamespacedKey ownerKey; public RelicAbilityHandler(RelicRealm plugin) { this.plugin = plugin; this.relicProjectileKey = new NamespacedKey(plugin, "relic_projectile"); this.ownerKey = new NamespacedKey(plugin, "relic_owner"); } public void startSchedulers() { int passiveTick = plugin.getConfigManager().getPassiveTickInterval(); int actionBarTick = plugin.getConfigManager().getActionBarTick(); int pigTick = plugin.getConfigManager().getPigTickInterval(); int villagerInterval = plugin.getConfigManager().getVillagerInterval(); // Passive effects (dolphin, rabbit, zombie, bat knockback resistance) new BukkitRunnable() { @Override public void run() { for (Player p : Bukkit.getOnlinePlayers()) { applyPassiveEffects(p); } } }.runTaskTimer(plugin, 0L, passiveTick); // Action bar cooldown display new BukkitRunnable() { @Override public void run() { for (Player p : Bukkit.getOnlinePlayers()) { updateActionBar(p); } } }.runTaskTimer(plugin, 0L, actionBarTick); // Pig relic - movement based healing new BukkitRunnable() { @Override public void run() { for (Player p : Bukkit.getOnlinePlayers()) { tickPigRelic(p); } } }.runTaskTimer(plugin, 0L, pigTick); // Villager relic - money every interval new BukkitRunnable() { @Override public void run() { for (Player p : Bukkit.getOnlinePlayers()) { tickVillagerRelic(p); } } }.runTaskTimer(plugin, 0L, (long) villagerInterval * 20L); } // ======================== // ACTIVE RELIC ACTIVATION // ======================== public void activateActiveRelic(Player player) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; RelicType activeRelic = data.getEquippedRelic(1); if (activeRelic == null) { player.sendMessage(plugin.getConfigManager().getMessage("no-active-relic")); return; } RelicDefinition def = plugin.getRelicManager().getDefinition(activeRelic); if (def == null || def.isPassive()) return; // Check cooldown long remaining = getRemainingCooldown(player.getUniqueId(), activeRelic.name()); if (remaining > 0) { player.sendMessage(plugin.getConfigManager().getMessage("active-on-cooldown") .replace("{relic}", def.getDisplayName()) .replace("{seconds}", String.valueOf((remaining / 1000) + 1))); return; } RelicInstance instance = data.getRelic(activeRelic); if (instance == null) return; int level = instance.getLevel(); boolean executed = executeActiveAbility(player, activeRelic, def, level); if (executed) { int cooldownSec = def.getCooldown(level); setCooldown(player.getUniqueId(), activeRelic.name(), cooldownSec * 1000L); // Give RXP to all equipped relics giveRxpToAllEquipped(player, plugin.getConfigManager().getActiveAbilityRxp()); } } private boolean executeActiveAbility(Player player, RelicType type, RelicDefinition def, int level) { switch (type) { case CREEPER: return activateCreeper(player, def, level); case ENDERMAN: return activateEnderman(player, def, level); case BLAZE: return activateBlaze(player, def, level); case WITCH: return activateWitch(player, def, level); case WITHER_SKELETON: return activateWitherSkeleton(player, def, level); case BREEZE: return activateBreeze(player, def, level); case SILVERFISH: return activateSilverfish(player, def, level); case GHAST: return activateGhast(player, def, level); default: return false; } } private boolean activateCreeper(Player player, RelicDefinition def, int level) { selfDamageImmune.add(player.getUniqueId()); Location loc = player.getEyeLocation(); Vector dir = loc.getDirection().normalize(); Location spawnLoc = loc.add(dir.clone().multiply(2)); TNTPrimed tnt = player.getWorld().spawn(spawnLoc, TNTPrimed.class); tnt.setFuseTicks(40); tnt.setVelocity(dir.multiply(1.2)); tnt.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "CREEPER"); tnt.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, player.getUniqueId().toString()); relicProjectiles.put(tnt.getUniqueId(), player.getUniqueId()); Bukkit.getScheduler().runTaskLater(plugin, () -> selfDamageImmune.remove(player.getUniqueId()), 100L); return true; } private boolean activateEnderman(Player player, RelicDefinition def, int level) { UUID playerId = player.getUniqueId(); relicProjectiles.put(playerId, playerId); // mark as relic ender pearl org.bukkit.entity.EnderPearl pearl = player.launchProjectile(org.bukkit.entity.EnderPearl.class); pearl.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "ENDERMAN"); pearl.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, playerId.toString()); relicProjectiles.put(pearl.getUniqueId(), playerId); return true; } private boolean activateBlaze(Player player, RelicDefinition def, int level) { selfDamageImmune.add(player.getUniqueId()); int count = def.getFireballCount(level); Location loc = player.getEyeLocation(); Vector dir = loc.getDirection().normalize(); for (int i = 0; i < count; i++) { final int idx = i; Bukkit.getScheduler().runTaskLater(plugin, () -> { Vector spread = dir.clone() .add(new Vector((random.nextDouble() - 0.5) * 0.2, (random.nextDouble() - 0.5) * 0.2, (random.nextDouble() - 0.5) * 0.2)); SmallFireball fireball = player.getWorld().spawn(loc.clone().add(dir.clone().multiply(2)), SmallFireball.class); fireball.setDirection(spread); fireball.setShooter(player); fireball.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "BLAZE"); fireball.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, player.getUniqueId().toString()); relicProjectiles.put(fireball.getUniqueId(), player.getUniqueId()); }, idx * 3L); } Bukkit.getScheduler().runTaskLater(plugin, () -> selfDamageImmune.remove(player.getUniqueId()), 100L); return true; } private boolean activateWitch(Player player, RelicDefinition def, int level) { selfDamageImmune.add(player.getUniqueId()); Location loc = player.getEyeLocation(); Vector dir = loc.getDirection().normalize(); ItemStack potionItem = new ItemStack(Material.SPLASH_POTION); PotionMeta pm = (PotionMeta) potionItem.getItemMeta(); if (pm != null) { pm.addCustomEffect(new PotionEffect(PotionEffectType.INSTANT_DAMAGE, 1, 1), true); potionItem.setItemMeta(pm); } SplashPotion potion = player.getWorld().spawn(loc.add(dir.multiply(1)), SplashPotion.class); potion.setItem(potionItem); potion.setVelocity(dir.multiply(1.5)); potion.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "WITCH"); potion.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, player.getUniqueId().toString()); relicProjectiles.put(potion.getUniqueId(), player.getUniqueId()); Bukkit.getScheduler().runTaskLater(plugin, () -> selfDamageImmune.remove(player.getUniqueId()), 60L); return true; } private boolean activateWitherSkeleton(Player player, RelicDefinition def, int level) { int radius = def.getRadius(level); int witherDuration = def.getWitherDuration(level); for (Entity entity : player.getWorld().getNearbyEntities(player.getLocation(), radius, radius, radius)) { if (entity instanceof LivingEntity target && target != player) { target.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, witherDuration * 20, 1, false, true)); } } return true; } private boolean activateBreeze(Player player, RelicDefinition def, int level) { int height = def.getLaunchHeight(level); int speedDuration = def.getSpeedDuration(level); breezeLaunched.add(player.getUniqueId()); player.setVelocity(new Vector(0, height * 0.2, 0)); player.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, speedDuration * 20, 1, false, true)); // Remove immunity after 30 seconds timeout Bukkit.getScheduler().runTaskLater(plugin, () -> breezeLaunched.remove(player.getUniqueId()), 600L); return true; } private boolean activateSilverfish(Player player, RelicDefinition def, int level) { int radius = def.getRadius(level); int poisonDuration = def.getPoisonDuration(level); for (Entity entity : player.getWorld().getNearbyEntities(player.getLocation(), radius, radius, radius)) { if (entity instanceof LivingEntity target && target != player) { target.addPotionEffect(new PotionEffect(PotionEffectType.POISON, poisonDuration * 20, 0, false, true)); } } return true; } private boolean activateGhast(Player player, RelicDefinition def, int level) { selfDamageImmune.add(player.getUniqueId()); Location loc = player.getEyeLocation(); Vector dir = loc.getDirection().normalize(); Fireball fireball = player.getWorld().spawn(loc.add(dir.multiply(2)), Fireball.class); fireball.setDirection(dir.multiply(2)); fireball.setShooter(player); fireball.setIsIncendiary(true); fireball.setYield(3.0f); fireball.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "GHAST"); fireball.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, player.getUniqueId().toString()); relicProjectiles.put(fireball.getUniqueId(), player.getUniqueId()); Bukkit.getScheduler().runTaskLater(plugin, () -> selfDamageImmune.remove(player.getUniqueId()), 200L); return true; } // ======================== // PASSIVE RELIC TRIGGERS (combat events) // ======================== // Called when combat event happens // playerIsVictim = true means the relic player is being hit, false means player is hitting public void onCombatEvent(Player relicPlayer, LivingEntity target, boolean playerIsVictim) { PlayerData data = plugin.getPlayerDataManager().get(relicPlayer); if (data == null) return; // Check all equipped passive slots (slots 2-7) and slot 1 if passive relic there for (Map.Entry entry : data.getEquippedSlots().entrySet()) { RelicType type = entry.getValue(); RelicDefinition def = plugin.getRelicManager().getDefinition(type); if (def == null || def.isActive()) continue; RelicInstance instance = data.getRelic(type); if (instance == null) continue; triggerPassiveCombat(relicPlayer, target, type, def, instance.getLevel(), playerIsVictim); } } private void triggerPassiveCombat(Player player, LivingEntity target, RelicType type, RelicDefinition def, int level, boolean playerIsVictim) { switch (type) { case SKELETON -> triggerSkeleton(player, target, def, level); case SPIDER -> { if (!playerIsVictim) triggerSpider(player, target, def, level); } case SLIME -> { if (playerIsVictim) triggerSlime(player, target, def, level); } case AXOLOTL -> { if (playerIsVictim) triggerAxolotl(player, def, level); } case MAGMA_CUBE -> { if (playerIsVictim) triggerMagmaCube(player, target, def, level); } } } private void triggerSkeleton(Player player, LivingEntity target, RelicDefinition def, int level) { if (!checkPassiveCooldown(player.getUniqueId(), "SKELETON", def.getCooldown(level) * 1000L)) return; double chance = def.getChance(level); if (random.nextDouble() * 100 > chance) return; int arrowCount = 3; double dmgMin = def.getArrowDamageMin(level); double dmgMax = def.getArrowDamageMax(level); Location from = player.getEyeLocation(); Vector dir = target.getEyeLocation().subtract(from).toVector().normalize(); for (int i = 0; i < arrowCount; i++) { final int idx = i; Bukkit.getScheduler().runTaskLater(plugin, () -> { Arrow arrow = player.getWorld().spawnArrow(from, dir.clone().add(new Vector( (random.nextDouble() - 0.5) * 0.1, (random.nextDouble() - 0.5) * 0.1, (random.nextDouble() - 0.5) * 0.1)), 1.5f, 0f); arrow.setShooter(player); double dmg = dmgMin + random.nextDouble() * (dmgMax - dmgMin); arrow.getPersistentDataContainer().set(relicProjectileKey, PersistentDataType.STRING, "SKELETON"); arrow.getPersistentDataContainer().set(ownerKey, PersistentDataType.STRING, player.getUniqueId().toString()); arrow.setDamage(dmg * 2); // hearts to half-hearts }, idx * 4L); } } private void triggerSpider(Player player, LivingEntity target, RelicDefinition def, int level) { if (!checkPassiveCooldown(player.getUniqueId(), "SPIDER", def.getCooldown(level) * 1000L)) return; double chance = def.getChance(level); if (random.nextDouble() * 100 > chance) return; int duration = def.getSlowDuration(level); target.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, duration * 20, 1, false, true)); target.addPotionEffect(new PotionEffect(PotionEffectType.WEAKNESS, duration * 20, 1, false, true)); } private void triggerSlime(Player player, LivingEntity attacker, RelicDefinition def, int level) { if (!checkPassiveCooldown(player.getUniqueId(), "SLIME", def.getCooldown(level) * 1000L)) return; double chance = def.getChance(level); if (random.nextDouble() * 100 > chance) return; int slowDuration = def.getSlowDuration(level); // Knockback attacker away Vector kb = attacker.getLocation().toVector().subtract(player.getLocation().toVector()).normalize().multiply(3); kb.setY(0.5); attacker.setVelocity(kb); attacker.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, slowDuration * 20, 0, false, true)); } private void triggerAxolotl(Player player, RelicDefinition def, int level) { int regenLevel = def.getRegenLevel(level) - 1; player.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, 100, regenLevel, false, true)); if (def.hasStrengthBonus(level)) { player.addPotionEffect(new PotionEffect(PotionEffectType.STRENGTH, 100, 1, false, true)); } } private void triggerMagmaCube(Player player, LivingEntity attacker, RelicDefinition def, int level) { if (!checkPassiveCooldown(player.getUniqueId(), "MAGMA_CUBE", def.getCooldown(level) * 1000L)) return; int fireDuration = def.getFireDuration(level); attacker.setFireTicks(fireDuration * 20); } // ======================== // PASSIVE EFFECT TICKING // ======================== public void applyPassiveEffects(Player player) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; for (Map.Entry entry : data.getEquippedSlots().entrySet()) { RelicType type = entry.getValue(); RelicDefinition def = plugin.getRelicManager().getDefinition(type); if (def == null) continue; RelicInstance instance = data.getRelic(type); if (instance == null) continue; int level = instance.getLevel(); switch (type) { case DOLPHIN -> applyDolphinEffect(player, def, level); case RABBIT -> applyRabbitEffect(player, def, level); case ZOMBIE -> applyZombieEffect(player, def, level); } } } public void applyPassiveEffectsIfNeeded(Player player) { applyPassiveEffects(player); } private void applyDolphinEffect(Player player, RelicDefinition def, int level) { if (player.isInWater() || player.isInBubbleColumn()) { player.addPotionEffect(new PotionEffect(PotionEffectType.WATER_BREATHING, 120, 0, false, false)); int hasteLevel = def.getHasteLevel(level); if (hasteLevel > 0) { player.addPotionEffect(new PotionEffect(PotionEffectType.HASTE, 120, hasteLevel - 1, false, false)); } } } private void applyRabbitEffect(Player player, RelicDefinition def, int level) { int jumpLevel = def.getJumpBoostLevel(level) - 1; player.addPotionEffect(new PotionEffect(PotionEffectType.JUMP_BOOST, 120, jumpLevel, false, false)); } private void applyZombieEffect(Player player, RelicDefinition def, int level) { player.addPotionEffect(new PotionEffect(PotionEffectType.NIGHT_VISION, 600, 0, false, false)); int speedLevel = def.getSpeedLevel(level); if (speedLevel > 0) { boolean isNight = player.getWorld().getTime() > 12300 && player.getWorld().getTime() < 23850; boolean isCave = player.getLocation().getY() < 60 && !player.getWorld().getHighestBlockAt(player.getLocation()).equals(player.getLocation().getBlock()); if (isNight || isCave) { player.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, 120, speedLevel - 1, false, false)); } } } private void tickPigRelic(Player player) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; for (Map.Entry entry : data.getEquippedSlots().entrySet()) { if (entry.getValue() != RelicType.PIG) continue; RelicInstance instance = data.getRelic(RelicType.PIG); if (instance == null) continue; RelicDefinition def = plugin.getRelicManager().getDefinition(RelicType.PIG); if (def == null) continue; Location lastLoc = lastLocations.get(player.getUniqueId()); Location currentLoc = player.getLocation(); boolean moved = lastLoc == null || currentLoc.distanceSquared(lastLoc) > 0.01; lastLocations.put(player.getUniqueId(), currentLoc.clone()); if (moved) { double chance = def.getChance(instance.getLevel()); if (random.nextDouble() * 100 <= chance) { double healMin = def.getHealMin(instance.getLevel()); double healMax = def.getHealMax(instance.getLevel()); double heal = healMin + random.nextDouble() * (healMax - healMin); double newHealth = Math.min(player.getHealth() + heal, player.getMaxHealth()); player.setHealth(newHealth); } } break; } } private void tickVillagerRelic(Player player) { if (plugin.getAfkManager().isAfk(player)) return; PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; for (Map.Entry entry : data.getEquippedSlots().entrySet()) { if (entry.getValue() != RelicType.VILLAGER) continue; RelicInstance instance = data.getRelic(RelicType.VILLAGER); if (instance == null) continue; RelicDefinition def = plugin.getRelicManager().getDefinition(RelicType.VILLAGER); if (def == null) continue; String currency = plugin.getConfigManager().getCurrencySymbol(); double amount = def.getMoneyPerInterval(instance.getLevel()); plugin.getEconomyManager().deposit(player, amount); player.sendMessage(plugin.getConfigManager().getMessage("villager-money-earned") .replace("{amount}", String.format("%.0f", amount)) .replace("{currency}", currency)); break; } } // ======================== // DAMAGE MODIFIERS // ======================== public double applyDamageModifiers(Player player, EntityDamageEvent.DamageCause cause, double baseDamage) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return baseDamage; double damage = baseDamage; for (Map.Entry entry : data.getEquippedSlots().entrySet()) { RelicType type = entry.getValue(); RelicDefinition def = plugin.getRelicManager().getDefinition(type); if (def == null) continue; RelicInstance instance = data.getRelic(type); if (instance == null) continue; int level = instance.getLevel(); switch (type) { case IRON_GOLEM -> { if (cause == EntityDamageEvent.DamageCause.ENTITY_ATTACK || cause == EntityDamageEvent.DamageCause.ENTITY_SWEEP_ATTACK) { damage *= (1.0 - def.getMeleeReduction(level) / 100.0); } } case BAT -> { if (cause == EntityDamageEvent.DamageCause.FALL) { damage *= (1.0 - def.getFallReduction(level) / 100.0); } } case MAGMA_CUBE -> { if (cause == EntityDamageEvent.DamageCause.FIRE || cause == EntityDamageEvent.DamageCause.FIRE_TICK || cause == EntityDamageEvent.DamageCause.LAVA) { damage *= (1.0 - def.getFireReduction(level) / 100.0); } } case RABBIT -> { if (cause == EntityDamageEvent.DamageCause.PROJECTILE) { double reduction = def.getProjectileReduction(level); if (reduction > 0) damage *= (1.0 - reduction / 100.0); } } } } return damage; } public boolean shouldCancelFallDamage(Player player) { return breezeLaunched.contains(player.getUniqueId()); } public void clearBreezeLaunch(Player player) { breezeLaunched.remove(player.getUniqueId()); } // ======================== // ACTION BAR // ======================== private void updateActionBar(Player player) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; RelicType activeRelic = data.getEquippedRelic(1); if (activeRelic == null) return; RelicDefinition def = plugin.getRelicManager().getDefinition(activeRelic); if (def == null || def.isPassive()) return; long remaining = getRemainingCooldown(player.getUniqueId(), activeRelic.name()); if (remaining <= 0) return; long secs = (remaining / 1000) + 1; String msg = ChatColor.translateAlternateColorCodes('&', "&e⚡ " + def.getDisplayName() + " &7cooldown: &c" + secs + "s"); player.spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(msg)); } // ======================== // COOLDOWN MANAGEMENT // ======================== public void setCooldown(UUID uuid, String relicName, long durationMs) { cooldowns.computeIfAbsent(uuid, k -> new HashMap<>()) .put(relicName, System.currentTimeMillis() + durationMs); } public long getRemainingCooldown(UUID uuid, String relicName) { Map playerCooldowns = cooldowns.get(uuid); if (playerCooldowns == null) return 0; Long expiry = playerCooldowns.get(relicName); if (expiry == null) return 0; long remaining = expiry - System.currentTimeMillis(); return Math.max(0, remaining); } public void clearCooldown(UUID uuid, String relicName) { Map playerCooldowns = cooldowns.get(uuid); if (playerCooldowns != null) playerCooldowns.remove(relicName); } public void clearAllCooldowns(UUID uuid) { cooldowns.remove(uuid); } private boolean checkPassiveCooldown(UUID uuid, String key, long durationMs) { Map pcd = passiveCooldowns.computeIfAbsent(uuid, k -> new HashMap<>()); Long expiry = pcd.get(key); long now = System.currentTimeMillis(); if (expiry != null && now < expiry) return false; pcd.put(key, now + durationMs); return true; } // ======================== // RXP DISTRIBUTION // ======================== public void giveRxpToAllEquipped(Player player, long amount) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null || amount <= 0) return; for (Map.Entry entry : data.getEquippedSlots().entrySet()) { RelicInstance instance = data.getRelic(entry.getValue()); if (instance != null) { instance.addRxp(amount); } } XSound.matchXSound("ENTITY_EXPERIENCE_ORB_PICKUP").ifPresent(s -> s.play(player)); } public void giveRxpToRelic(Player player, RelicType type, long amount) { PlayerData data = plugin.getPlayerDataManager().get(player); if (data == null) return; RelicInstance instance = data.getRelic(type); if (instance != null) { instance.addRxp(amount); XSound.matchXSound("ENTITY_EXPERIENCE_ORB_PICKUP").ifPresent(s -> s.play(player)); } } // ======================== // SELF DAMAGE CHECK // ======================== public boolean isSelfDamageImmune(UUID uuid) { return selfDamageImmune.contains(uuid); } public boolean isRelicProjectile(UUID entityId) { return relicProjectiles.containsKey(entityId); } public UUID getProjectileOwner(UUID entityId) { return relicProjectiles.get(entityId); } public void removeProjectile(UUID entityId) { relicProjectiles.remove(entityId); } public void removePlayerData(UUID uuid) { cooldowns.remove(uuid); passiveCooldowns.remove(uuid); breezeLaunched.remove(uuid); selfDamageImmune.remove(uuid); lastLocations.remove(uuid); } }