Solved Get the drops on PlayerDeathEvent and add it to an inventory

Hi guys, I have another problem...
I want to get the drops when a Player die and add it to an inventory that is linked with the killer's name.

Show Spoiler Hide Spoiler

Solved

The inventory doesn't event open for the killer and the killer doesn't get the Experience...
I don't know what is wrong, please help!
Thank you

 

@Maxx_Qc
Ok for future reference, if you are going to give us code, give us the whole class -- not just cutouts. That saves us asking every time we need it

Now, where's the rest of the Duel Manager Class?

 

Show Spoiler Hide Spoiler

Code:

package qc.maxx.duelpl.utils;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import net.minecraft.server.v1_8_R3.IChatBaseComponent.ChatSerializer;
import net.minecraft.server.v1_8_R3.PacketPlayOutChat;

import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;

import qc.maxx.duelpl.arena.*;
import qc.maxx.duelpl.main.DuelPlayers;

public class DuelManager
{
    private DuelPlayers plugin;
    private Map<UUID, UUID> duelRequests;
    private List<UUID> frozenPlayerUUIDs;
    private List<UUID> deadPlayers;
    private List<Arena> duelArenas;
    private HashMap<UUID, PlayerData> playerData;
    private HashMap<String, ItemStack[]> invMap;
    private MessageManager mm;
    private Inventory lootInventory;
    private HashMap<String, Integer> expDrop;
   
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public DuelManager(DuelPlayers plugin)
    {
        this.plugin = plugin;
        this.duelRequests = new HashMap();
        this.frozenPlayerUUIDs = new ArrayList();
        this.duelArenas = new ArrayList();
        this.deadPlayers = new ArrayList();
        this.playerData = new HashMap();
        this.mm = new MessageManager(this.plugin);
        this.invMap = new HashMap<String, ItemStack[]>();
        this.lootInventory = Bukkit.createInventory(null, 36, Colorize.c("&bStuff de %a"));
        this.expDrop = new HashMap<String, Integer>();
    }
   
    public List<UUID> getFrozenPlayerUUIDs()
    {
        return this.frozenPlayerUUIDs;
    }
   
    public HashMap<String, Integer> getExpDrop()
    {
        return this.expDrop;
    }
   
    public HashMap<String, ItemStack[]> getInvMap()
    {
        return this.invMap;
    }
   
    public List<UUID> getDeadPlayers()
    {
        return this.deadPlayers;
    }
   
    public List<Arena> getDuelArenas()
    {
        return this.duelArenas;
    }
   
    public Map<UUID, UUID> getDuelRequests()
    {
        return this.duelRequests;
    }
   
    public void endRunningDuel(Arena arena)
    {
        for(UUID playerUUID : arena.getPlayers())
        {
            if(isFrozen(playerUUID))
            {
                removeFrozenPlayer(playerUUID);
            }
           
            Player playerOut = Bukkit.getPlayer(playerUUID);
            if(playerOut != null)
            {
                restorePlayerData(playerOut);
                Util.sendMsg(playerOut, this.mm.getDuelForcefullyCancelledMessage());
            }
        }
        resetArena(arena);
    }
   
    public void denyRequest(Player refuser, Player requestSender)
    {
        UUID senderUUID = requestSender.getUniqueId();
        Util.sendMsg(requestSender, "&b" + refuser.getName()+ "&a a refusé votre demande!");
        Util.sendMsg(refuser, "&aLa demande de &b" + requestSender.getName() + "&a a été refusée!");
        this.duelRequests.remove(senderUUID);
    }
   
    public void acceptRequest(Player acceptor, String senderName)
    {
        Player sender = Bukkit.getPlayer(senderName);
       
        if(sender == null)
        {
            String targetNotOnline = this.mm.getTargetNotOnlineMessage();
            targetNotOnline = targetNotOnline.replaceAll("%t", senderName);
            Util.sendMsg(acceptor, targetNotOnline);
            return;
        }
        UUID acceptorUUID = acceptor.getUniqueId();
        UUID senderUUID = sender.getUniqueId();
        if((this.duelRequests.containsKey(senderUUID)) && (this.duelRequests.containsValue(acceptorUUID)))
        {
            this.duelRequests.remove(senderUUID);
            startDuel(acceptor, sender);
            return;
        }
         Util.sendMsg(acceptor, "&aVous n'avez aucune requête en attente de &b" + senderName + "&a.");
    }
   
    public void addFrozenPlayer(UUID playerUUID)
    {
        this.frozenPlayerUUIDs.add(playerUUID);
    }
   
    public Arena getFreeArena()
    {
        for(Arena duelArena : getDuelArenas())
        {
            if((duelArena.getArenaStatus().equals(ArenaStatus.WAITING)) && (duelArena.getPlayers().size() == 0))
            {
                return duelArena;
            }
        }
        return null;
    }
   
    public void storePotionEffects(Player player)
    {
        PlayerData playerData = getPlayerDataByUUID(player.getUniqueId());
        playerData.getPotionEffects().put(player, player.getActivePotionEffects());
        for(PotionEffect p : player.getActivePotionEffects())
        {   
            player.removePotionEffect(p.getType());
        }
    }
   
    public void addPlayerData(UUID uuidIn, PlayerData playerData)
    {
        getPlayerData().put(uuidIn, playerData);
    }
   
    public void storePlayerData(Player player)
    {
        UUID playerUUID = player.getUniqueId();
        Location loc = player.getLocation();
        GameMode gamemode = player.getGameMode();
        double health = player.getHealth();
        int foodLevel = player.getFoodLevel();

        if (player.getGameMode() != GameMode.SURVIVAL)
        {
            player.setGameMode(GameMode.SURVIVAL);
        }
        addPlayerData(playerUUID, new PlayerData(loc, gamemode, health, foodLevel));
    }
   
    public void startDuel(Player acceptor, Player sender)
    {
        String acceptorName = acceptor.getName();
        String senderName = sender.getName();
        boolean acceptorTeleportSuccess = false;
        boolean senderTeleportSuccess = false;
        UUID acceptorUUID = acceptor.getUniqueId();
        UUID senderUUID = sender.getUniqueId();
        List<Arena> arenas = getDuelArenas();
        Arena freeArena = getFreeArena();
        String duelStartBroadcast = this.mm.getDuelStartMessage();
        duelStartBroadcast = duelStartBroadcast.replaceAll("%s", senderName);
        duelStartBroadcast = duelStartBroadcast.replaceAll("%a", acceptorName);
       
        if(arenas.size() <= 0)
        {
            Util.sendMsg(acceptor, sender, this.mm.getNoDuelArenasMessage());
            return;
        }
        if(freeArena == null)
        {
            Util.sendMsg(sender, acceptor, "&eIl n'y a pas d'arène disponible pour le moment, réessayez plus tard!");
            return;
        }
        if((freeArena.getSpawn1() != null) && (freeArena.getSpawn2() != null))
        {
            freeArena.setArenaStatus(ArenaStatus.USED);
            Util.broadcastMessage(duelStartBroadcast);
            freeArena.addPlayerUUID(senderUUID);
            freeArena.addPlayerUUID(acceptorUUID);
            storePlayerData(acceptor);
            storePlayerData(sender);
            storePotionEffects(acceptor);
            storePotionEffects(sender);
            acceptorTeleportSuccess = acceptor.teleport(freeArena.getSpawn1());
            senderTeleportSuccess = sender.teleport(freeArena.getSpawn2());
        } else {
            Util.sendMsg(sender, acceptor, "&eLes points d'apparition n'ont pas été configurés, contactez un admin!");
            return;
        }
        if ((senderTeleportSuccess) && (acceptorTeleportSuccess))
        {
            addFrozenPlayer(senderUUID);
            addFrozenPlayer(acceptorUUID);
            sender.setHealth(sender.getMaxHealth());
            acceptor.setHealth(acceptor.getMaxHealth());
            sender.setFoodLevel(20);
            acceptor.setFoodLevel(20);
        } else {
            endDuel(freeArena);
        }
        new StartDuelThread(this.plugin, sender, acceptor, freeArena).runTaskTimer(this.plugin, 20L, 20L);
    }
   
    public void removeDuelArena(Arena amIn)
    {
        for(Arena am : getDuelArenas())
        {
            if(am == amIn)
            {
                this.duelArenas.remove(amIn);
                return;
            }
        }
    }
   
    public boolean isInDuel(UUID playerUUID)
    {
        for(Arena arenas : getDuelArenas())
        {
            if(arenas.getPlayers().contains(playerUUID))
            {
                return true;
            }
        }
        return false;
    }
   
    public boolean isFrozen(UUID playerUUID)
    {
        if(getFrozenPlayerUUIDs().contains(playerUUID))
        {
            return true;
        }
        return false;
    }
   
    public void removeFrozenPlayer(UUID playerUUID)
    {
        this.frozenPlayerUUIDs.remove(playerUUID);
    }
   
    public void addDuelArena(Arena am)
    {
        this.duelArenas.add(am);
    }
   
    public Arena getPlayersArenaByUUID(UUID playerUUID)
    {
        for(Arena arena : getDuelArenas())
        {
            List<UUID> players = arena.getPlayers();
            if(players.contains(playerUUID))
            {
                return arena;
            }
        }
        return null;
    }
   
    public PlayerData getPlayerDataByUUID(UUID playerUUID)
    {
        return (PlayerData)this.playerData.get(playerUUID);
    }
   
    public void addDeadPlayer(UUID uuid)
    {
        if(!this.deadPlayers.contains(uuid))
        {
            this.deadPlayers.add(uuid);
        }
    }
   
    public boolean isDeadPlayer(UUID uuid)
    {
        if(getDeadPlayers().contains(uuid))
        {
            return true;
        }
        return false;
    }
   
    public void removeDeadPlayer(UUID uuid)
    {
        this.deadPlayers.remove(uuid);
    }
   
    public HashMap<UUID, PlayerData> getPlayerData()
    {
        return this.playerData;
    }
   
    public void removePlayerDataByUUID(UUID playerUUID)
    {
        getPlayerData().remove(playerUUID);
    }
   
    public boolean restorePlayerData(Player player)
    {
        UUID playerUUID = player.getUniqueId();
        PlayerData playerData = getPlayerDataByUUID(playerUUID);
       
        try
        {
            Location loc = playerData.getLocation();
            GameMode gamemode = playerData.getGameMode();
            double health = playerData.getHealth();
            int foodLevel = playerData.getFoodLevel();
            if(!isDeadPlayer(playerUUID))
            {
                player.setGameMode(gamemode);
                player.teleport(loc);
                player.setHealth(health);
                player.setFoodLevel(foodLevel);
               
                for(PotionEffect p : playerData.getPotionEffects().get(player))
                {
                    player.addPotionEffect(p);
                }
            }
            removePlayerDataByUUID(playerUUID);
            return true;
        } catch (Exception e) {
            Util.sendMsg(player, "&cUne erreur s'est produite lors de la tentative de restauration de vos données!");
        }
        return false;
    }
   
    public void endDuel(Player player)
    {
        UUID playerUUID = player.getUniqueId();
        Arena arena = getPlayersArenaByUUID(playerUUID);
       
        arena.removePlayer(playerUUID);
        if(!player.isDead())
        {
            restorePlayerData(player);
        }
        if(arena.getPlayers().size() == 1)
        {
            for(UUID playerIn : arena.getPlayers())
            {
                Player winnerPlayer = Bukkit.getPlayer(playerIn);
                   
                if(winnerPlayer != null)
                {
                    Util.sendMsg(winnerPlayer, "&aBravo, vous avez gagné un duel contre &b" + player.getName() + "&a!");
                    openLootInventory(winnerPlayer, player.getName());
                    restorePlayerData(winnerPlayer);
                }
            }
            resetArena(arena);
        }
    }
   
    public void endDuelWithoutTimer(Player player)
    {
        UUID playerUUID = player.getUniqueId();
        Arena arena = getPlayersArenaByUUID(playerUUID);
       
        arena.removePlayer(playerUUID);
        if(!player.isDead())
        {
            restorePlayerData(player);
        }
        if(arena.getPlayers().size() == 1)
        {
            doNotStartWinnerTimer(arena, player);
        }
    }
   
    public void doNotStartWinnerTimer(final Arena arena, Player playerWhoLeft)
    {
        if(arena.getPlayers().size() == 1)
        {
            for(UUID playerIn : arena.getPlayers())
            {
                Player winnerPlayer = Bukkit.getPlayer(playerIn);
               
                if(winnerPlayer != null)
                {
                    Util.sendMsg(winnerPlayer, "&aVotre adversaire &b" + playerWhoLeft.getName() + "&a a quitté le combat!");
                    restorePlayerData(winnerPlayer);
                }
            }
            resetArena(arena);
        }
    }
   
    public void endDuel(Arena arena)
    {
        if(arena.getPlayers().size() == 1)
        {
            for(UUID playerIn : arena.getPlayers())
            {
                Player winnerPlayer = Bukkit.getPlayer(playerIn);
                   
                if(winnerPlayer != null)
                {
                    Util.sendMsg(winnerPlayer, this.mm.getDuelForcefullyCancelledMessage());
                    restorePlayerData(winnerPlayer);
                }
            }
            resetArena(arena);
            return;
        }
        for(UUID playerUUID : arena.getPlayers())
        {
            if(isFrozen(playerUUID))
            {
                removeFrozenPlayer(playerUUID);
            }
           
            Player playerOut = Bukkit.getPlayer(playerUUID);
            if(playerOut != null)
            {
                restorePlayerData(playerOut);
                Util.sendMsg(playerOut, this.mm.getDuelForcefullyCancelledMessage());
            }
        }
    }
   
    public void resetArena(Arena arena)
    {
        arena.getPlayers().clear();
        arena.setArenaStatus(ArenaStatus.WAITING);
    }
   
    public void openLootInventory(Player player, String adversaryName)
    {
        if((this.invMap.containsKey(player.getName())) && (this.expDrop.containsKey(player.getName())))
        {
            this.lootInventory.getName().replaceAll("%a", adversaryName);
            this.lootInventory.addItem(this.invMap.get(player.getName()));
            player.openInventory(lootInventory);
            this.invMap.remove(player.getName());
           
            int exp = this.expDrop.get(player.getName());
            player.setTotalExperience(player.getTotalExperience() + exp);
            this.expDrop.remove(player.getName());
        }
    }

    public void sendNormalDuelRequest(final Player duelSender, String duelTargetIn)
    {
        String duelSenderName = duelSender.getName();
        final UUID duelSenderUUID = duelSender.getUniqueId();
        final Player duelTarget = Bukkit.getPlayer(duelTargetIn);
       
        if(duelTarget != null)
        {
            UUID duelTargetUUID = duelTarget.getUniqueId();
            if(isInDuel(duelTargetUUID))
            {
                String playerAlreadyInDuel = this.mm.getPlayerAlreadyInDuelMessage();
                playerAlreadyInDuel = playerAlreadyInDuel.replaceAll("%t", duelTargetIn);
                Util.sendMsg(duelSender, playerAlreadyInDuel);
                return;
            }
            if((this.duelRequests.containsKey(duelSenderUUID)) && (this.duelRequests.containsValue(duelTargetUUID)))
            {
                String requestAlreadySent = this.mm.getDuelRequestAlreadySentMessage();
                requestAlreadySent = requestAlreadySent.replaceAll("%t", duelTargetIn);
                Util.sendMsg(duelSender, requestAlreadySent);
                return;
            }
            String duelTargetName = duelTarget.getName();
            if(duelSenderName.equals(duelTargetName))
            {
                Util.sendMsg(duelSender, this.mm.getCannotDuelSelfMessage());
                return;
            }
            String duelRequestSentMessage = this.mm.getDuelRequestSentMessage();
            duelRequestSentMessage = duelRequestSentMessage.replaceAll("%t", duelTargetName);
            Util.sendMsg(duelSender, duelRequestSentMessage);
           
            String duelRequestReceived = this.mm.getDuelRequestReceivedMessage();
            duelRequestReceived = duelRequestReceived.replaceAll("%s", duelSenderName);
            ((CraftPlayer) duelTarget).getHandle().playerConnection.sendPacket(new PacketPlayOutChat(ChatSerializer.a(duelRequestReceived)));
            duelTarget.playSound(duelTarget.getLocation(), Sound.NOTE_PLING, 10.0F, 5.0F);
           
            this.duelRequests.put(duelSenderUUID, duelTargetUUID);
            new StartRequestThread(this.plugin, duelSender, duelTarget).runTaskTimer(this.plugin, 20L, 20L);
        } else {
            String targetNotOnline = this.mm.getTargetNotOnlineMessage();
            targetNotOnline = targetNotOnline.replaceAll("%t", duelTargetIn);
            Util.sendMsg(duelSender, targetNotOnline);
        }
    }
   
    public void cancelDuelRequest(Player sender, Player target)
    {
        UUID senderUUID = sender.getUniqueId();
        Util.sendMsg(sender, "&aVotre demande de duel contre &b" + target.getName() + "&a a expirée!");
        Util.sendMsg(target, "&aLa demande de &b" + sender.getName() + "&a a expirée!");
        this.duelRequests.remove(senderUUID);
    }

    public Arena getDuelArenaByName(String duelArenaName)
    {
        for(Arena da : this.duelArenas)
        {
            if (da.getName().equalsIgnoreCase(duelArenaName))
            {
                return da;
            }
        }
        return null;
    }

    public void createDuelArenaFile(String arenaName)
    {
        File arenaFile = new File(this.plugin.getDataFolder().getAbsolutePath() + File.separator + "arenas" + File.separator + arenaName + ".yml");
        try
        {
            arenaFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

@Maxx_Qc
Is this line:
Util.sendMsg(winnerPlayer, "&aBravo, vous avez gagné un duel contre &b"+ player.getName()+"&a!");
Actually occuring ingame?

 

Yop

Bump.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

This is how you would get the items:

Code:

@EventHandler
public void onDeath(EntityDeathEvent e){
if(e.getEntity() instanceof Player && e.getEntity().getKiller() instanceof Player){
Player v = (Player)e.getEntity();
Player k = (Player)e.getEntity();
List<ItemStack> items = e.getDrops();
ItemStack[] contents = items.toArray(new ItemStack[0]);
k.getInventory().setContents(contents);
e.getDrops().clear();
items.clear();
}

read it and understand it

 

@DoggyCode™ Thank you! Helped me a lot! + I needed to put a RunTaskLater to make it works because the inventory was getting open when the player was getting teleport.