Solved NullPointerException, can't figure out the problem!

Hi, I have a problem...
Each time somebody die, I get this nice Stacktrace...

Show Spoiler Hide Spoiler

Code:

org.bukkit.event.EventException
    at org.bukkit.plugin.java.JavaPluginLoader$1.execute(JavaPluginLoader.java:310) ~[spigot1649.jar:git-Spigot-76236cb-62a2169]
    at org.bukkit.plugin.RegisteredListener.callEvent(RegisteredListener.java:62) ~[spigot1649.jar:git-Spigot-76236cb-62a2169]
    at org.bukkit.plugin.SimplePluginManager.fireEvent(SimplePluginManager.java:502) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at org.bukkit.plugin.SimplePluginManager.callEvent(SimplePluginManager.java:487) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at org.bukkit.craftbukkit.v1_8_R3.event.CraftEventFactory.callPlayerDeathEvent(CraftEventFactory.java:395) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityPlayer.die(EntityPlayer.java:417) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityLiving.damageEntity(EntityLiving.java:812) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityHuman.damageEntity(EntityHuman.java:800) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityPlayer.damageEntity(EntityPlayer.java:496) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityLiving.e(EntityLiving.java:939) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityHuman.e(EntityHuman.java:1440) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.Block.fallOn(Block.java:640) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.Entity.a(Entity.java:811) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityLiving.a(EntityLiving.java:160) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.EntityPlayer.a(EntityPlayer.java:621) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.PlayerConnection.a(PlayerConnection.java:456) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.PacketPlayInFlying.a(SourceFile:126) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.PacketPlayInFlying$PacketPlayInPosition.a(SourceFile:57) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.PlayerConnectionUtils$1.run(SourceFile:13) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) [?:1.7.0_67]
    at java.util.concurrent.FutureTask.run(Unknown Source) [?:1.7.0_67]
    at net.minecraft.server.v1_8_R3.SystemUtils.a(SourceFile:44) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.MinecraftServer.B(MinecraftServer.java:715) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.DedicatedServer.B(DedicatedServer.java:374) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.MinecraftServer.A(MinecraftServer.java:654) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at net.minecraft.server.v1_8_R3.MinecraftServer.run(MinecraftServer.java:557) [spigot1649.jar:git-Spigot-76236cb-62a2169]
    at java.lang.Thread.run(Unknown Source) [?:1.7.0_67]
Caused by: java.lang.NullPointerException
    at qc.maxx.duelpl.utils.DuelManager.endDuel(DuelManager.java:305) ~[?:?]
    at qc.maxx.duelpl.events.PlayerDeath.onPlayerDeath(PlayerDeath.java:52) ~[?:?]
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[?:1.7.0_67]
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source) ~[?:1.7.0_67]
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source) ~[?:1.7.0_67]
    at java.lang.reflect.Method.invoke(Unknown Source) ~[?:1.7.0_67]
    at org.bukkit.plugin.java.JavaPluginLoader$1.execute(JavaPluginLoader.java:306) ~[spigot1649.jar:git-Spigot-76236cb-62a2169]

DuelManager.java:305

Show Spoiler Hide Spoiler

Code:

public void endDuel(Player player)
    {
        UUID playerUUID = player.getUniqueId();
        ArenaManager arena = getPlayersArenaByUUID(playerUUID);
      
        >>>arena.removePlayer(playerUUID);
        if(!player.isDead())
        {
            restorePlayerData(player);
        }
        if(arena.getPlayers().size() == 1)
        {
            startWinnerTimer(arena);
        }
    }

PlayerDeath.java:52

Show Spoiler Hide Spoiler

Code:

    public void onPlayerDeath(PlayerDeathEvent e)
    {
        Player loser = e.getEntity();
        String loserName = loser.getName();
        UUID loserUUID = loser.getUniqueId();
        DuelManager dm = this.plugin.getDuelManager();
        MessageManager mm = this.plugin.getMessageManager();
      
        if(dm.isInDuel(loserUUID))
        {
            dm.addDeadPlayer(loserUUID);
            if(e.getEntity().getKiller() instanceof Player)
            {
                Player killer = e.getEntity().getKiller();
                String killerName = killer.getName();
              
                String deathMessageByPlayer = mm.getKillMessageByPlayer();
                deathMessageByPlayer = deathMessageByPlayer.replaceAll("%p", loserName);
                deathMessageByPlayer = deathMessageByPlayer.replaceAll("%k", killerName);
                e.setDeathMessage(mm.getPrefix() + " " + deathMessageByPlayer);
            } else {
                String deathMessageByOther = mm.getKillMessageByOther();
                deathMessageByOther = deathMessageByOther.replaceAll("%p", loserName);
                e.setDeathMessage(mm.getPrefix() + " " + deathMessageByOther);
            }
        }
        >>>dm.endDuel(loser);
        loser.spigot().respawn();
    }

I tried if(arena == null) { sendConsoleMessage } but it did noting so the arena is not the problem.
Thank you!

 

@Maxx_Qc
Show us both classes entirely, not just snippets of it

 

PlayerDeath.java

Show Spoiler Hide Spoiler

Code:

package qc.maxx.duelpl.events;

import java.util.UUID;

import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;

import qc.maxx.duelpl.main.DuelPlayers;
import qc.maxx.duelpl.utils.DuelManager;
import qc.maxx.duelpl.utils.MessageManager;

public class PlayerDeath implements Listener
{
    private DuelPlayers plugin;

    public PlayerDeath(DuelPlayers plugin)
    {
        this.plugin = plugin;
        plugin.getServer().getPluginManager().registerEvents(this, plugin);
    }
   
    @EventHandler(priority=EventPriority.NORMAL)
    public void onPlayerDeath(PlayerDeathEvent e)
    {
        Player loser = e.getEntity();
        String loserName = loser.getName();
        UUID loserUUID = loser.getUniqueId();
        DuelManager dm = this.plugin.getDuelManager();
        MessageManager mm = this.plugin.getMessageManager();
       
        if(dm.isInDuel(loserUUID))
        {
            dm.addDeadPlayer(loserUUID);
            if(e.getEntity().getKiller() instanceof Player)
            {
                Player killer = e.getEntity().getKiller();
                String killerName = killer.getName();
               
                String deathMessageByPlayer = mm.getKillMessageByPlayer();
                deathMessageByPlayer = deathMessageByPlayer.replaceAll("%p", loserName);
                deathMessageByPlayer = deathMessageByPlayer.replaceAll("%k", killerName);
                e.setDeathMessage(mm.getPrefix() + " " + deathMessageByPlayer);
            } else {
                String deathMessageByOther = mm.getKillMessageByOther();
                deathMessageByOther = deathMessageByOther.replaceAll("%p", loserName);
                e.setDeathMessage(mm.getPrefix() + " " + deathMessageByOther);
            }
        }
        dm.endDuel(loser);
        loser.spigot().respawn();
    }
}

DuelManager.java

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 org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.entity.Player;
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<ArenaManager> duelArenas;
    private HashMap<UUID, PlayerData> playerData;
    private MessageManager mm;
   
    @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);
    }
   
    public List<UUID> getFrozenPlayerUUIDs()
    {
        return this.frozenPlayerUUIDs;
    }
   
    public List<UUID> getDeadPlayers()
    {
        return this.deadPlayers;
    }
   
    public List<ArenaManager> getDuelArenas()
    {
        return this.duelArenas;
    }
   
    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 reçu aucune requête de &b" + senderName + "&a.");
    }
   
    public void addFrozenPlayer(UUID playerUUID)
    {
        this.frozenPlayerUUIDs.add(playerUUID);
    }
   
    public ArenaManager getFreeArena()
    {
        for(ArenaManager duelArena : getDuelArenas())
        {
            if((duelArena.getArenaStatus().equals(Status.WAITING)) && (duelArena.getPlayers().size() == 0))
            {
                return duelArena;
            }
        }
        return null;
    }
   
    public void removePotionEffects(Player player)
    {
        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();

        if (player.getGameMode() != GameMode.SURVIVAL)
        {
            player.setGameMode(GameMode.SURVIVAL);
        }
        addPlayerData(playerUUID, new PlayerData(loc, gamemode));
    }
   
    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<ArenaManager> arenas = getDuelArenas();
        ArenaManager freeArena = getFreeArena();
        String duelStartBroadcast = this.mm.getDuelStartMessage();
        duelStartBroadcast = duelStartBroadcast.replaceAll("%s", senderName);
        duelStartBroadcast = duelStartBroadcast.replaceAll("%a", acceptorName);
       
        if(arenas.size() <= 0)
        {
            Util.sendMsg(sender, this.mm.getNoDuelArenasMessage());
            Util.sendMsg(acceptor, this.mm.getNoDuelArenasMessage());
            return;
        }
        if(freeArena == null)
        {
            Util.sendMsg(acceptor, "&eIl n'y a pas d'arène disponible pour le moment, réessayez plus tard!");
            Util.sendMsg(sender, "&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(Status.USED);
            Util.broadcastMessage(duelStartBroadcast);
            freeArena.addPlayerUUID(senderUUID);
            freeArena.addPlayerUUID(acceptorUUID);
            storePlayerData(acceptor);
            storePlayerData(sender);
            removePotionEffects(acceptor);
            removePotionEffects(sender);
            acceptorTeleportSuccess = acceptor.teleport(freeArena.getSpawn1());
            senderTeleportSuccess = sender.teleport(freeArena.getSpawn2());
        } else {
            Util.sendMsg(acceptor, "&eLes points d'apparition n'ont pas été configurés, contactez un admin!");
            Util.sendMsg(sender, "&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());
        } else {
            endDuel(freeArena);
        }
        new StartDuelThread(this.plugin, sender, acceptor, freeArena).runTaskTimer(this.plugin, 20L, 20L);
    }
   
    public void removeDuelArena(ArenaManager amIn)
    {
        for(ArenaManager am : getDuelArenas())
        {
            if(am == amIn)
            {
                this.duelArenas.remove(amIn);
                return;
            }
        }
    }
   
    public boolean isInDuel(UUID playerUUID)
    {
        for(ArenaManager 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(ArenaManager am)
    {
        this.duelArenas.add(am);
    }
   
    public ArenaManager getPlayersArenaByUUID(UUID playerUUID)
    {
        for(ArenaManager 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();
            if(!isDeadPlayer(playerUUID))
            {
                player.setGameMode(gamemode);
                player.teleport(loc);
            }
            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();
        ArenaManager arena = getPlayersArenaByUUID(playerUUID);
       
        arena.removePlayer(playerUUID);
        if(!player.isDead())
        {
            restorePlayerData(player);
        }
        if(arena.getPlayers().size() == 1)
        {
            startWinnerTimer(arena);
        }
    }
   
    public void endDuel(ArenaManager arena)
    {
        if(arena.getPlayers().size() == 1)
        {
            startWinnerTimer(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(ArenaManager arena)
    {
        arena.getPlayers().clear();
        arena.setArenaStatus(Status.WAITING);
    }
   
    public void startWinnerTimer(ArenaManager arena)
    {
        if(arena.getPlayers().size() == 1)
        {
            for(UUID playerIn : arena.getPlayers())
            {
                final Player winnerPlayer = Bukkit.getPlayer(playerIn);
               
                if(winnerPlayer != null)
                {
                    Util.sendMsg(winnerPlayer, "&fVous avez 10 secondes afin de récupérer le stuff!");
                    this.plugin.getServer().getScheduler().runTaskLater(this.plugin, new Runnable()
                    {
                          public void run()
                          {
                              restorePlayerData(winnerPlayer);
                          }
                        }, 200L);
                }
            }
            resetArena(arena);
        }
    }

    public void sendNormalDuelRequest(Player duelSender, String duelTargetIn)
    {
        String duelSenderName = duelSender.getName();
        UUID duelSenderUUID = duelSender.getUniqueId();
        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);
            Util.sendMsg(duelTarget, duelRequestReceived);
           
            this.duelRequests.put(duelSenderUUID, duelTargetUUID);
        } else {
            String targetNotOnline = this.mm.getTargetNotOnlineMessage();
            targetNotOnline = targetNotOnline.replaceAll("%t", duelTargetIn);
            Util.sendMsg(duelSender, targetNotOnline);
        }
    }

    public ArenaManager getDuelArenaByName(String duelArenaName)
    {
        for(ArenaManager 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
Well as far as I can see, the only other problem would be that the getPlayers() is returning null

 

@Maxx_Qc
Can you double-check which line the error is coming from? The stack trace you posted doesn't match up with the code. Run it with your current code and see what line it says. I doubt it will still be 305 since line 305 in what you posted is just a close-brace.

 

@Maxx_Qc
You call "endDuel" even if the player is not are not in a "duel".

 

@rbrick
Good spot
What this guy said ^

 

I'm so dumb, thank you!