@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void a(PlayerRespawnEvent e) {
	ITabPlayer p = Shared.getPlayer(e.getPlayer().getUniqueId());
	if (p == null) return;
	if (!p.disabledNametag) Shared.featureCpu.runMeasuredTask("processing PlayerRespawnEvent", CPUFeature.NAMETAGX_EVENT_RESPAWN, new Runnable() {
		public void run() {
			for (ArmorStand as : p.getArmorStands()) {
				as.updateLocation(e.getRespawnLocation());
				List<ITabPlayer> nearbyPlayers = as.getNearbyPlayers();
				synchronized (nearbyPlayers){
					for (ITabPlayer nearby : nearbyPlayers) {
						nearby.sendPacket(as.getTeleportPacket(nearby));
					}
				}
			}
		}
	});
}
 

/**
 * Effect if a player respawns
 */
@EventHandler
public void effect(PlayerRespawnEvent event) {
	Player player = event.getPlayer();

	if (!player.hasPermission("minetinker.modifiers.soulbound.use")) {
		return;
	}

	if (!storedItemStacks.containsKey(player.getUniqueId())) {
		return;
	}

	ArrayList<ItemStack> stored = storedItemStacks.get(player.getUniqueId());

	for (ItemStack is : stored) {
		if (player.getInventory().addItem(is).size() != 0) { //adds items to (full) inventory
			player.getWorld().dropItem(player.getLocation(), is);
		} // no else as it gets added in if
		ChatWriter.logModifier(player, event, this, is);
	}

	storedItemStacks.remove(player.getUniqueId());
}
 

/**
 * Returns enhanced item to the player when respawn.
 *
 * @param e
 */
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerRespawn(PlayerRespawnEvent e) {
    Player p = e.getPlayer();

    File playerFile = new File(m.getDataFolder() + "/death/" + p.getName() + ".yml");
    FileConfiguration pFile = YamlConfiguration.loadConfiguration(
            playerFile);
    if (playerFile.exists()) {
        ItemStack[] content = ((List<?>) pFile.get("Items"))
                .toArray(new ItemStack[0]);
        p.getInventory().addItem(content);

        if (playerFile.delete()) {
            // Delete a file.
        }
    }
}
 

@EventHandler
public void onPlayerRespawn(PlayerRespawnEvent event) {
    final Player player = event.getPlayer();
    final Civilian civilian = CivilianManager.getInstance().getCivilian(player.getUniqueId());
    Location respawnLocation = civilian.getRespawnPoint();
    if (respawnLocation == null) {
        return;
    }

    if (ConfigManager.getInstance().getUseStarterBook()) {
        Bukkit.getScheduler().scheduleSyncDelayedTask(Civs.getInstance(), new Runnable() {
            @Override
            public void run() {
                player.getInventory().addItem(Util.createStarterBook(civilian.getLocale()));
            }
        }, 5L);
    }
    event.setRespawnLocation(respawnLocation);
    civilian.setRespawnPoint(null);
    CivilianManager.getInstance().saveCivilian(civilian);
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	if (ScriptLoader.isCurrentEvent(PlayerRespawnEvent.class) && !ScriptLoader.hasDelayBefore.isTrue()) {
		Skript.error("Cannot change a player's level in a respawn event. Add a delay of 1 tick or change the 'new level' in a death event.");
		return null;
	}
	if (ScriptLoader.isCurrentEvent(PlayerDeathEvent.class) && getTime() == 0 && getExpr().isDefault() && !ScriptLoader.hasDelayBefore.isTrue()) {
		Skript.warning("Changing the player's level in a death event will change the player's level before he dies. " +
				"Use either 'past level of player' or 'new level of player' to clearly state whether to change the level before or after he dies.");
	}
	if (getTime() == -1 && !ScriptLoader.isCurrentEvent(PlayerDeathEvent.class))
		return null;
	return new Class[] {Number.class};
}
 

@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled = true)
public void respawnHandler(PlayerRespawnEvent event)
{
	final Player player = event.getPlayer();
	final AnniPlayer p = AnniPlayer.getPlayer(player.getUniqueId());
	if(p != null)
	{
		if(Game.isGameRunning())
		{
			if(p.getTeam() != null && !p.getTeam().isTeamDead())
			{
				event.setRespawnLocation(p.getTeam().getRandomSpawn());
				p.getKit().onPlayerSpawn(player);
				return;
			}
		}
		if(Game.LobbyMap != null && Game.LobbyMap.getSpawn() != null)
			event.setRespawnLocation(Game.LobbyMap.getSpawn());  //Set people to respawn in the lobby
	}
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerRespawn(PlayerRespawnEvent pre) {
  Player p = pre.getPlayer();
  Game game = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(p);

  if (game == null) {
    return;
  }

  if (game.getState() == GameState.RUNNING) {
    game.getCycle().onPlayerRespawn(pre, p);
    return;
  }

  if (game.getState() == GameState.WAITING) {
    pre.setRespawnLocation(game.getLobby());
  }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onRespawn(final PlayerRespawnEvent event) {
    if (Config.getString("config.remove_items_after_respawn").equals("false"))
        return;
    // some plugins block item dropping after death and add those
    // items after respawning, so the player doesn't loose his
    // inventory after death; this aims to force removing quest
    // items, as they have been added to the backpack already
    if (event.getPlayer().getGameMode() == GameMode.CREATIVE)
        return;
    final Inventory inv = event.getPlayer().getInventory();
    for (int i = 0; i < inv.getSize(); i++) {
        if (Utils.isQuestItem(inv.getItem(i))) {
            inv.setItem(i, null);
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onRespawn(PlayerRespawnEvent event) {
    String playerID = PlayerConverter.getID(event.getPlayer());
    if (containsPlayer(playerID) && checkConditions(playerID)) {

        if (location != null) {
            try {
                event.setRespawnLocation(location.getLocation(playerID));
            } catch (QuestRuntimeException e) {
                LogUtils.getLogger().log(Level.WARNING, "Error while handling '" + instruction.getID() + "' objective: \" + e.getMessage()");
                LogUtils.logThrowable(e);
            }
        }
        completeObjective(playerID);
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerRespawn(PlayerRespawnEvent event) {
	Resident resident = CivGlobal.getResident(event.getPlayer());
	
	if (!resident.isInsideArena()) {
		return;
	}
	
	Arena arena = resident.getCurrentArena();
	if (arena == null) {
		return;
	}
	
	Location loc = arena.getRespawnLocation(resident);
	if (loc != null) {
		CivMessage.send(resident, CivColor.LightGray+"Respawned in arena.");
		World world = Bukkit.getWorld(arena.getInstanceName());
		loc.setWorld(world);
		
		resident.setLastKilledTime(new Date());
		event.setRespawnLocation(loc);
	}
}
 

/**
 * Places player back on their island if the setting is true
 * @param e - event
 */
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerRespawn(final PlayerRespawnEvent e) {
    if (DEBUG) {
        plugin.getLogger().info(e.getEventName());
    }
    if (!Settings.respawnOnIsland) {
        return;
    }
    if (respawn.contains(e.getPlayer().getUniqueId())) {
        respawn.remove(e.getPlayer().getUniqueId());
        Location respawnLocation = plugin.getGrid().getSafeHomeLocation(e.getPlayer().getUniqueId(), 1);
        if (respawnLocation != null) {
            //plugin.getLogger().info("DEBUG: Setting respawn location to " + respawnLocation);
            e.setRespawnLocation(respawnLocation);
            // Get island
            Island island = plugin.getGrid().getIslandAt(respawnLocation);
            if (island != null) {
                // Run perms etc.
                processPerms(e.getPlayer(), island);
            }
        }
    }
}
 

@Test
public void shouldIgnorePlayerRespawn() {
    // given
    Player player = mock(Player.class);
    Location respawnLocation = mock(Location.class);
    PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, respawnLocation, false));
    given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
    given(listenerService.shouldCancelEvent(event)).willReturn(false);

    // when
    listener.onPlayerRespawn(event);

    // then
    verifyNoInteractions(spawnLoader);
    verify(event, never()).setRespawnLocation(any());
}
 

@Test
public void shouldHandlePlayerRespawn() {
    // given
    Player player = mock(Player.class);
    Location originalLocation = mock(Location.class);
    Location newLocation = mock(Location.class);
    World world = mock(World.class);
    given(newLocation.getWorld()).willReturn(world);
    PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
    given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
    given(listenerService.shouldCancelEvent(event)).willReturn(true);
    given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);

    // when
    listener.onPlayerRespawn(event);

    // then
    verify(spawnLoader).getSpawnLocation(player);
    verify(event).setRespawnLocation(newLocation);
}
 

@Test
public void shouldIgnorePlayerRespawnUnloadedWorld() {
    // given
    Player player = mock(Player.class);
    Location originalLocation = mock(Location.class);
    Location newLocation = mock(Location.class);
    given(newLocation.getWorld()).willReturn(null);
    PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
    given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
    given(listenerService.shouldCancelEvent(event)).willReturn(true);
    given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);

    // when
    listener.onPlayerRespawn(event);

    // then
    verify(spawnLoader).getSpawnLocation(player);
    verify(event, never()).setRespawnLocation(any());
}
 

@Test
public void shouldHandlePlayerRespawnNoChanges() {
    // given
    Player player = mock(Player.class);
    Location originalLocation = mock(Location.class);
    PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
    given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
    given(listenerService.shouldCancelEvent(event)).willReturn(true);
    given(spawnLoader.getSpawnLocation(player)).willReturn(null);

    // when
    listener.onPlayerRespawn(event);

    // then
    verify(spawnLoader).getSpawnLocation(player);
    verify(event, never()).setRespawnLocation(any());
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerRespawn(PlayerRespawnEvent event) {
    Player player = event.getPlayer();
    if (!GriefDefenderPlugin.getInstance().claimsEnabledForWorld(player.getWorld().getUID())) {
        return;
    }

    final GDPlayerData playerData = GriefDefenderPlugin.getInstance().dataStore.getOrCreatePlayerData(player.getWorld(), player.getUniqueId());
    playerData.lastPvpTimestamp = null;
}
 

@EventHandler
public void a(PlayerRespawnEvent e) {
	try {
		long time = System.nanoTime();
		ITabPlayer p = Shared.getPlayer(e.getPlayer().getUniqueId());
		if (p != null) mainFeature.detectBossBarsAndSend(p);
		Shared.featureCpu.addTime(CPUFeature.BOSSBAR_LEGACY, System.nanoTime()-time);
	} catch (Throwable t) {
		Shared.errorManager.printError("An error occurred when processing PlayerRespawnEvent", t);
	}
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerRespawn(PlayerRespawnEvent event){
	PlayersManager pm = GameManager.getGameManager().getPlayersManager();
	UhcPlayer uhcPlayer = pm.getUhcPlayer(event.getPlayer());

	if(uhcPlayer.getState().equals(PlayerState.DEAD)){
		Bukkit.getScheduler().runTaskLater(UhcCore.getPlugin(), () -> pm.setPlayerSpectateAtLobby(uhcPlayer), 1);
	}
}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	if (!ScriptLoader.isCurrentEvent(PlayerRespawnEvent.class)) {
		Skript.error("The expression 'respawn location' may only be used in the respawn event", ErrorQuality.SEMANTIC_ERROR);
		return false;
	}
	return true;
}
 

@Override
protected void execute(final Event e) {
	Location to = location.getSingle(e);
	if (to == null)
		return;
	if (Math.abs(to.getX() - to.getBlockX() - 0.5) < Skript.EPSILON && Math.abs(to.getZ() - to.getBlockZ() - 0.5) < Skript.EPSILON) {
		final Block on = to.getBlock().getRelative(BlockFace.DOWN);
		if (on.getType() != Material.AIR) {
			to = to.clone();
			// TODO 1.13 block height stuff
			//to.setY(on.getY() + Utils.getBlockHeight(on.getTypeId(), on.getData()));
		}
	}
	for (final Entity entity : entities.getArray(e)) {
		final Location loc;
		if (ignoreDirection(to.getYaw(), to.getPitch())) {
			loc = to.clone();
			loc.setPitch(entity.getLocation().getPitch());
			loc.setYaw(entity.getLocation().getYaw());
		} else {
			loc = to;
		}
		loc.getChunk().load();
		if (e instanceof PlayerRespawnEvent && entity.equals(((PlayerRespawnEvent) e).getPlayer()) && !Delay.isDelayed(e)) {
			((PlayerRespawnEvent) e).setRespawnLocation(loc);
		} else {
			entity.teleport(loc);
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onRespawn(final PlayerRespawnEvent event)
{
    final User user = UserManager.getUser(event.getPlayer().getUniqueId());

    if (user != null) {
        user.getTimestampMap().nullifyTimeStamp(TimestampKey.INVENTORY_OPENED);
        user.getTimestampMap().updateTimeStamps(TimestampKey.LAST_RESPAWN, TimestampKey.LAST_TELEPORT);
    }
}
 

@EventHandler
public void on(PlayerRespawnEvent e) {
    if (e.isBedSpawn() || e.getPlayer().getBedLocation() != null) {
        return;
    }

    if (e.getPlayer().hasPermission("wild.wildtp.respawn.except")) {
        return;
    }

    e.setRespawnLocation(loc.getRandomLoc(loc.getWorldInformation(e.getPlayer().getLocation()), e.getPlayer()));
}
 

@EventHandler(ignoreCancelled = true)
public void onPlayerRespawnEvent(PlayerRespawnEvent event)
{
	Player player = event.getPlayer();
	
	ApplicableRegionSet regions = this.plugin.getWorldGuardCommunicator().getRegionContainer().createQuery().getApplicableRegions(player.getLocation());
	
	Object respawnLocation = WorldGuardUtils.queryValueUnchecked(player, player.getWorld(), regions.getRegions(), Flags.RESPAWN_LOCATION);
	if (respawnLocation != null)
	{
		event.setRespawnLocation(WorldEditUtils.toLocation(respawnLocation));
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerTeleport(final PlayerRespawnEvent event)
{
    if(event.getPlayer() != null && event.getRespawnLocation() != null)
    {
       // final AnniPlayer p = AnniPlayer.getPlayer(event.getPlayer().getUniqueId());
       // if(p != null)
       // {
            //					if(permanentBar)
            //						BarAPI.sendPermDragon(event.getPlayer());
            //					else
            handleTeleport(event.getPlayer(), event.getRespawnLocation().clone());
       // }
    }
}
 

@EventHandler
public void on(final PlayerRespawnEvent event) {
	Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
		@Override
		public void run() {
			for (AnimatedFrame frame : plugin.frameManager.getFramesInWorld(event.getPlayer().getWorld().getName())) {
				frame.addViewer(event.getPlayer());
			}
		}
	}, 20);
}
 

@EventHandler
public void onPlayerRespawn(PlayerRespawnEvent event) {
    final Player p = event.getPlayer();
    new BukkitRunnable() {

        @Override
        public void run() {
            EchoPet.getManager().loadPets(p, true, false, true);
        }

    }.runTaskLater(EchoPet.getPlugin(), 20L);
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerRespawn(PlayerRespawnEvent event) {
    if (Settings.extras_sendToSpawn) {
        return;
    }
    if (plugin.getWorldManager().isSkyWorld(event.getPlayer().getWorld())) {
        event.setRespawnLocation(plugin.getWorldManager().getWorld().getSpawnLocation());
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerRespawn(PlayerRespawnEvent event) {
	
	Player player = event.getPlayer();
	Resident resident = CivGlobal.getResident(player);
	if (resident == null || !resident.hasTown()) {
		return;
	}
	
	if (War.isWarTime() && !resident.isInsideArena()) {
		if (resident.getTown().getCiv().getDiplomacyManager().isAtWar()) {
			//TownHall townhall = resident.getTown().getTownHall();
			Capitol capitol = resident.getCiv().getCapitolStructure();
			if (capitol != null) {
				BlockCoord respawn = capitol.getRandomRespawnPoint();
				if (respawn != null) {
					//PlayerReviveTask reviveTask = new PlayerReviveTask(player, townhall.getRespawnTime(), townhall, event.getRespawnLocation());
					resident.setLastKilledTime(new Date());
					event.setRespawnLocation(respawn.getCenteredLocation());
					CivMessage.send(player, CivColor.LightGray+"You've respawned in the War Room since it's WarTime and you're at war.");
					
					//TaskMaster.asyncTask("", reviveTask, 0);
				}
			}
		}
	}
	
}
 

@ParameterizedTest
@ValueSource(booleans = { true, false })
public void testItemRecover(boolean soulbound) {
    PlayerMock player = server.addPlayer();
    ItemStack item = new CustomItem(Material.DIAMOND_SWORD, "&4Cool Sword");
    SlimefunUtils.setSoulbound(item, soulbound);
    player.getInventory().setItem(6, item);
    player.setHealth(0);
    player.respawn();

    server.getPluginManager().assertEventFired(PlayerRespawnEvent.class, event -> {
        return player.getInventory().getItem(6).isSimilar(item) == soulbound;
    });
}
 

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onVistorSpawn(final PlayerRespawnEvent e) {
    if (DEBUG) {
        plugin.getLogger().info(e.getEventName());
    }
    // This will override any global settings
    if (Settings.allowVisitorKeepInvOnDeath) {
        InventorySave.getInstance().loadPlayerInventory(e.getPlayer());
        InventorySave.getInstance().clearSavedInventory(e.getPlayer());
    }
}