2018-07-31 18:03:32 +02:00
|
|
|
package world.bentobox.bentobox.managers;
|
2017-05-20 23:09:53 +02:00
|
|
|
|
2020-12-25 06:56:02 +01:00
|
|
|
import java.util.Collection;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.HashSet;
|
|
|
|
import java.util.Set;
|
|
|
|
import java.util.UUID;
|
2019-07-05 01:54:05 +02:00
|
|
|
|
2018-05-18 06:25:12 +02:00
|
|
|
import org.bukkit.World;
|
2020-07-25 23:37:45 +02:00
|
|
|
import org.bukkit.entity.Player;
|
2020-12-25 00:30:52 +01:00
|
|
|
import org.bukkit.entity.Tameable;
|
2019-01-20 09:01:38 +01:00
|
|
|
import org.eclipse.jdt.annotation.NonNull;
|
2019-04-08 10:49:22 +02:00
|
|
|
import org.eclipse.jdt.annotation.Nullable;
|
2019-07-05 01:54:05 +02:00
|
|
|
|
2018-07-31 18:03:32 +02:00
|
|
|
import world.bentobox.bentobox.BentoBox;
|
2019-08-12 23:54:05 +02:00
|
|
|
import world.bentobox.bentobox.api.flags.Flag;
|
2018-07-31 18:03:32 +02:00
|
|
|
import world.bentobox.bentobox.api.user.User;
|
2018-08-06 15:19:06 +02:00
|
|
|
import world.bentobox.bentobox.database.Database;
|
2023-01-31 16:13:01 +01:00
|
|
|
import world.bentobox.bentobox.database.objects.Island;
|
2018-07-31 18:03:32 +02:00
|
|
|
import world.bentobox.bentobox.database.objects.Names;
|
|
|
|
import world.bentobox.bentobox.database.objects.Players;
|
2020-12-24 23:24:42 +01:00
|
|
|
import world.bentobox.bentobox.util.Util;
|
2017-05-20 23:09:53 +02:00
|
|
|
|
2018-05-14 02:02:24 +02:00
|
|
|
public class PlayersManager {
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2021-08-30 03:17:21 +02:00
|
|
|
private final BentoBox plugin;
|
2018-08-06 15:19:06 +02:00
|
|
|
private Database<Players> handler;
|
2021-08-30 03:17:21 +02:00
|
|
|
private final Database<Names> names;
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2024-04-08 02:05:21 +02:00
|
|
|
private final Set<UUID> inTeleport; // this needs databasing
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2020-11-27 19:21:39 +01:00
|
|
|
private boolean isSaveTaskRunning;
|
|
|
|
|
2017-05-21 08:53:03 +02:00
|
|
|
/**
|
|
|
|
* Provides a memory cache of online player information
|
|
|
|
* This is the one-stop-shop of player info
|
|
|
|
* If the player is not cached, then a request is made to Players to obtain it
|
2017-08-18 16:05:35 +02:00
|
|
|
*
|
2018-07-30 02:09:48 +02:00
|
|
|
* @param plugin - plugin object
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-07-29 22:21:46 +02:00
|
|
|
public PlayersManager(BentoBox plugin){
|
2017-05-20 23:09:53 +02:00
|
|
|
this.plugin = plugin;
|
2017-06-12 17:04:26 +02:00
|
|
|
// Set up the database handler to store and retrieve Players classes
|
2018-08-06 15:19:06 +02:00
|
|
|
handler = new Database<>(plugin, Players.class);
|
2018-05-14 02:02:24 +02:00
|
|
|
// Set up the names database
|
2018-08-06 15:19:06 +02:00
|
|
|
names = new Database<>(plugin, Names.class);
|
2017-08-18 16:05:35 +02:00
|
|
|
inTeleport = new HashSet<>();
|
2017-05-20 23:09:53 +02:00
|
|
|
}
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2018-08-04 19:13:08 +02:00
|
|
|
/**
|
|
|
|
* Used only for testing. Sets the database to a mock database.
|
|
|
|
* @param handler - handler
|
|
|
|
*/
|
2018-08-06 15:19:06 +02:00
|
|
|
public void setHandler(Database<Players> handler) {
|
2018-08-04 19:13:08 +02:00
|
|
|
this.handler = handler;
|
|
|
|
}
|
2018-01-21 21:58:35 +01:00
|
|
|
|
2017-06-12 17:04:26 +02:00
|
|
|
/**
|
2017-07-06 19:21:38 +02:00
|
|
|
* Load all players - not normally used as to load all players into memory will be wasteful
|
2017-06-12 17:04:26 +02:00
|
|
|
*/
|
2017-05-20 23:09:53 +02:00
|
|
|
public void load(){
|
2017-06-12 17:04:26 +02:00
|
|
|
inTeleport.clear();
|
2017-05-20 23:09:53 +02:00
|
|
|
}
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2020-11-27 19:21:39 +01:00
|
|
|
public boolean isSaveTaskRunning() {
|
|
|
|
return isSaveTaskRunning;
|
|
|
|
}
|
|
|
|
|
2017-05-20 23:09:53 +02:00
|
|
|
public void shutdown(){
|
2018-03-19 05:54:24 +01:00
|
|
|
handler.close();
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2018-05-14 02:02:24 +02:00
|
|
|
/**
|
|
|
|
* Get player by UUID. Adds player to cache if not in there already
|
|
|
|
* @param uuid of player
|
2020-05-02 05:48:04 +02:00
|
|
|
* @return player object or null if it does not exist, for example the UUID is null
|
2018-05-14 02:02:24 +02:00
|
|
|
*/
|
2020-05-02 05:48:04 +02:00
|
|
|
@Nullable
|
2017-05-21 08:53:03 +02:00
|
|
|
public Players getPlayer(UUID uuid){
|
2024-04-08 02:05:21 +02:00
|
|
|
return addPlayer(uuid);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2019-01-20 09:01:38 +01:00
|
|
|
/**
|
|
|
|
* Returns an <strong>unmodifiable collection</strong> of all the players that are <strong>currently in the cache</strong>.
|
|
|
|
* @return unmodifiable collection containing every player in the cache.
|
|
|
|
* @since 1.1
|
|
|
|
*/
|
|
|
|
@NonNull
|
|
|
|
public Collection<Players> getPlayers() {
|
2024-04-08 02:05:21 +02:00
|
|
|
return Collections.unmodifiableCollection(handler.loadObjects());
|
2019-01-20 09:01:38 +01:00
|
|
|
}
|
|
|
|
|
2017-05-21 08:53:03 +02:00
|
|
|
/*
|
|
|
|
* Cache control methods
|
|
|
|
*/
|
|
|
|
|
2017-07-07 01:51:40 +02:00
|
|
|
/**
|
2024-04-08 02:05:21 +02:00
|
|
|
* Adds a player to the database. If the UUID does not exist, a new player is made
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2017-07-07 01:51:40 +02:00
|
|
|
*/
|
2024-04-08 02:05:21 +02:00
|
|
|
public Players addPlayer(UUID playerUUID) {
|
2017-07-06 19:21:38 +02:00
|
|
|
// If the player is in the database, load it, otherwise create a new player
|
2018-02-10 02:06:32 +01:00
|
|
|
if (handler.objectExists(playerUUID.toString())) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players player = handler.loadObject(playerUUID.toString());
|
|
|
|
if (player != null) {
|
|
|
|
return player;
|
2019-02-11 00:36:37 +01:00
|
|
|
}
|
2017-07-06 19:21:38 +02:00
|
|
|
}
|
2024-04-08 02:05:21 +02:00
|
|
|
Players player = new Players(plugin, playerUUID);
|
|
|
|
handler.saveObject(player);
|
|
|
|
return player;
|
2017-05-20 23:09:53 +02:00
|
|
|
}
|
2017-05-31 16:32:36 +02:00
|
|
|
|
2017-05-21 08:53:03 +02:00
|
|
|
/**
|
2019-11-09 11:41:48 +01:00
|
|
|
* Checks if the player is known or not.
|
|
|
|
* Will check not just the cache but if the object but in the database too.
|
2017-08-18 16:05:35 +02:00
|
|
|
*
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param uniqueID - unique ID
|
2018-09-02 08:50:40 +02:00
|
|
|
* @return true if player is known, otherwise false
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-05-14 02:02:24 +02:00
|
|
|
public boolean isKnown(UUID uniqueID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
return handler.objectExists(uniqueID.toString());
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-01-21 21:58:35 +01:00
|
|
|
* Attempts to return a UUID for a given player's name.
|
2018-06-10 01:40:38 +02:00
|
|
|
* @param name - name of player
|
2017-05-21 08:53:03 +02:00
|
|
|
* @return UUID of player or null if unknown
|
|
|
|
*/
|
2019-04-08 10:49:22 +02:00
|
|
|
@Nullable
|
|
|
|
public UUID getUUID(@NonNull String name) {
|
2018-01-21 21:58:35 +01:00
|
|
|
// See if this is a UUID
|
2018-05-14 02:02:24 +02:00
|
|
|
// example: 5988eecd-1dcd-4080-a843-785b62419abb
|
2018-06-10 01:40:38 +02:00
|
|
|
if (name.length() == 36 && name.contains("-")) {
|
2018-05-14 02:02:24 +02:00
|
|
|
try {
|
2018-06-10 01:40:38 +02:00
|
|
|
return UUID.fromString(name);
|
2018-10-20 10:59:19 +02:00
|
|
|
} catch (Exception ignored) {
|
|
|
|
// Not used
|
|
|
|
}
|
2018-05-14 02:02:24 +02:00
|
|
|
}
|
2024-04-08 02:05:21 +02:00
|
|
|
return names.loadObjects().stream().filter(n -> n.getUniqueId().equalsIgnoreCase(name)).findFirst()
|
|
|
|
.map(Names::getUuid).orElse(null);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-01-11 01:50:24 +01:00
|
|
|
* Sets the player's name and updates the name to UUID database
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param user - the User
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2019-04-08 10:49:22 +02:00
|
|
|
public void setPlayerName(@NonNull User user) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players player = addPlayer(user.getUniqueId());
|
|
|
|
player.setPlayerName(user.getName());
|
|
|
|
handler.saveObject(player);
|
2018-08-11 21:14:07 +02:00
|
|
|
Names newName = new Names(user.getName(), user.getUniqueId());
|
2018-05-14 02:02:24 +02:00
|
|
|
// Add to names database
|
2020-04-26 01:00:49 +02:00
|
|
|
names.saveObjectAsync(newName);
|
2017-05-20 23:09:53 +02:00
|
|
|
}
|
2017-05-21 08:53:03 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtains the name of the player from their UUID
|
|
|
|
* Player must have logged into the game before
|
2017-08-18 16:05:35 +02:00
|
|
|
*
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2018-06-08 17:20:16 +02:00
|
|
|
* @return String - playerName, empty string if UUID is null
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2019-05-26 21:58:24 +02:00
|
|
|
@NonNull
|
|
|
|
public String getName(@Nullable UUID playerUUID) {
|
2017-05-21 08:53:03 +02:00
|
|
|
if (playerUUID == null) {
|
2018-06-08 17:20:16 +02:00
|
|
|
return "";
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
2024-04-08 02:05:21 +02:00
|
|
|
return names.loadObjects().stream().filter(n -> n.getUuid().equals(playerUUID)).findFirst()
|
|
|
|
.map(Names::getUniqueId).orElse(null);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-04-08 10:49:22 +02:00
|
|
|
* Returns how many island resets the player has done.
|
|
|
|
* @param world world
|
|
|
|
* @param playerUUID the player's UUID
|
2017-05-21 08:53:03 +02:00
|
|
|
* @return number of resets
|
|
|
|
*/
|
2018-07-25 16:04:40 +02:00
|
|
|
public int getResets(World world, UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
return addPlayer(playerUUID).getResets(world);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
2019-04-08 10:49:22 +02:00
|
|
|
/**
|
|
|
|
* Returns how many island resets the player can still do.
|
|
|
|
* @param world world
|
|
|
|
* @param playerUUID the player's UUID
|
|
|
|
* @return number of resets the player can do (always {@code >= 0}), or {@code -1} if unlimited.
|
|
|
|
* @since 1.5.0
|
|
|
|
* @see #getResets(World, UUID)
|
|
|
|
*/
|
|
|
|
public int getResetsLeft(World world, UUID playerUUID) {
|
|
|
|
addPlayer(playerUUID);
|
|
|
|
if (plugin.getIWM().getResetLimit(world) == -1) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return Math.max(plugin.getIWM().getResetLimit(world) - getResets(world, playerUUID), 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-21 08:53:03 +02:00
|
|
|
/**
|
2018-07-25 16:04:40 +02:00
|
|
|
* Sets how many resets the player has performed
|
2017-08-18 16:05:35 +02:00
|
|
|
*
|
2018-12-29 10:47:33 +01:00
|
|
|
* @param world world
|
|
|
|
* @param playerUUID player's UUID
|
|
|
|
* @param resets number of resets to set
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-07-25 16:04:40 +02:00
|
|
|
public void setResets(World world, UUID playerUUID, int resets) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.setResets(world, resets);
|
|
|
|
handler.saveObject(p);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the locale for this player. If missing, will return nothing
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2017-05-21 08:53:03 +02:00
|
|
|
* @return name of the locale this player uses
|
|
|
|
*/
|
|
|
|
public String getLocale(UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
return addPlayer(playerUUID).getLocale();
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the locale this player wants to use
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2018-06-10 01:40:38 +02:00
|
|
|
* @param localeName - locale name, e.g., en-US
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
|
|
|
public void setLocale(UUID playerUUID, String localeName) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.setLocale(localeName);
|
|
|
|
handler.saveObject(p);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add death to player
|
2018-07-29 22:21:46 +02:00
|
|
|
* @param world - world
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-07-29 22:21:46 +02:00
|
|
|
public void addDeath(World world, UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.addDeath(world);
|
|
|
|
handler.saveObject(p);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set death number for player
|
2018-08-05 06:50:10 +02:00
|
|
|
* @param world - world
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
2018-06-10 01:40:38 +02:00
|
|
|
* @param deaths - number of deaths
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-07-29 22:21:46 +02:00
|
|
|
public void setDeaths(World world, UUID playerUUID, int deaths) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.setDeaths(world, deaths);
|
|
|
|
handler.saveObject(p);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-07-29 22:21:46 +02:00
|
|
|
* Get number of times player has died since counting began
|
|
|
|
* @param world - world
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param playerUUID - the player's UUID
|
|
|
|
* @return number of deaths
|
2017-05-21 08:53:03 +02:00
|
|
|
*/
|
2018-07-29 22:21:46 +02:00
|
|
|
public int getDeaths(World world, UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
return addPlayer(playerUUID).getDeaths(world);
|
2017-05-21 08:53:03 +02:00
|
|
|
}
|
|
|
|
|
2017-06-11 01:08:21 +02:00
|
|
|
/**
|
|
|
|
* Sets if a player is mid-teleport or not
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param uniqueId - unique ID
|
2017-06-11 01:08:21 +02:00
|
|
|
*/
|
|
|
|
public void setInTeleport(UUID uniqueId) {
|
2017-08-18 16:05:35 +02:00
|
|
|
inTeleport.add(uniqueId);
|
2017-06-11 01:08:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes player from in-teleport
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param uniqueId - unique ID
|
2017-06-11 01:08:21 +02:00
|
|
|
*/
|
|
|
|
public void removeInTeleport(UUID uniqueId) {
|
2017-08-18 16:05:35 +02:00
|
|
|
inTeleport.remove(uniqueId);
|
2017-06-11 01:08:21 +02:00
|
|
|
}
|
2017-07-06 19:21:38 +02:00
|
|
|
|
2017-06-11 01:08:21 +02:00
|
|
|
/**
|
2018-02-18 02:01:25 +01:00
|
|
|
* @param uniqueId - unique ID
|
2017-06-11 01:08:21 +02:00
|
|
|
* @return true if a player is mid-teleport
|
|
|
|
*/
|
|
|
|
public boolean isInTeleport(UUID uniqueId) {
|
2017-08-18 16:05:35 +02:00
|
|
|
return inTeleport.contains(uniqueId);
|
2017-06-11 01:08:21 +02:00
|
|
|
}
|
|
|
|
|
2018-02-12 05:26:09 +01:00
|
|
|
/**
|
2018-07-19 12:21:31 +02:00
|
|
|
* Tries to get the user from his name
|
2018-06-10 01:40:38 +02:00
|
|
|
* @param name - name
|
2019-11-17 03:17:55 +01:00
|
|
|
* @return user - user or null if unknown
|
2018-02-12 05:26:09 +01:00
|
|
|
*/
|
2018-06-10 01:40:38 +02:00
|
|
|
public User getUser(String name) {
|
2023-07-22 21:00:10 +02:00
|
|
|
UUID uuid = getUUID(name);
|
|
|
|
return uuid == null ? null : getUser(uuid);
|
2018-07-19 12:21:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Tries to get the user from his UUID
|
|
|
|
* @param uuid - UUID
|
|
|
|
* @return user - user
|
|
|
|
*/
|
|
|
|
public User getUser(UUID uuid) {
|
|
|
|
return User.getInstance(uuid);
|
2018-02-12 05:26:09 +01:00
|
|
|
}
|
|
|
|
|
2019-06-08 06:33:29 +02:00
|
|
|
/**
|
|
|
|
* Adds a reset to this player's number of resets
|
2019-07-11 22:55:17 +02:00
|
|
|
* @param world world where island is
|
|
|
|
* @param playerUUID player's UUID
|
2019-06-08 06:33:29 +02:00
|
|
|
*/
|
2018-07-25 16:04:40 +02:00
|
|
|
public void addReset(World world, UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.addReset(world);
|
|
|
|
handler.saveObject(p);
|
2019-08-12 23:54:05 +02:00
|
|
|
}
|
2018-07-25 16:04:40 +02:00
|
|
|
|
2019-08-12 23:54:05 +02:00
|
|
|
/**
|
|
|
|
* Sets the Flags display mode for the Settings Panel for this player.
|
|
|
|
* @param playerUUID player's UUID
|
|
|
|
* @param displayMode the {@link Flag.Mode} to set
|
|
|
|
* @since 1.6.0
|
|
|
|
*/
|
|
|
|
public void setFlagsDisplayMode(UUID playerUUID, Flag.Mode displayMode) {
|
2024-04-08 02:05:21 +02:00
|
|
|
Players p = addPlayer(playerUUID);
|
|
|
|
p.setFlagsDisplayMode(displayMode);
|
|
|
|
handler.saveObject(p);
|
2018-07-25 16:04:40 +02:00
|
|
|
}
|
|
|
|
|
2019-08-12 23:54:05 +02:00
|
|
|
/**
|
|
|
|
* Returns the Flags display mode for the Settings Panel for this player.
|
|
|
|
* @param playerUUID player's UUID
|
|
|
|
* @return the {@link Flag.Mode display mode} for the Flags in the Settings Panel.
|
|
|
|
* @since 1.6.0
|
|
|
|
*/
|
|
|
|
public Flag.Mode getFlagsDisplayMode(UUID playerUUID) {
|
2024-04-08 02:05:21 +02:00
|
|
|
return addPlayer(playerUUID).getFlagsDisplayMode();
|
2019-08-12 23:54:05 +02:00
|
|
|
}
|
2020-07-25 23:37:45 +02:00
|
|
|
|
|
|
|
/**
|
2024-04-08 02:05:21 +02:00
|
|
|
* Remove player from database
|
2020-07-25 23:37:45 +02:00
|
|
|
* @param player player to remove
|
|
|
|
*/
|
|
|
|
public void removePlayer(Player player) {
|
2024-04-08 02:05:21 +02:00
|
|
|
handler.deleteID(player.getUniqueId().toString());
|
2020-07-25 23:37:45 +02:00
|
|
|
}
|
|
|
|
|
2020-12-24 23:24:42 +01:00
|
|
|
/**
|
|
|
|
* Cleans the player when leaving an island
|
|
|
|
* @param world - island world
|
|
|
|
* @param target - target user
|
2020-12-25 00:30:52 +01:00
|
|
|
* @param kicked - true if player is being kicked
|
2023-01-31 16:13:01 +01:00
|
|
|
* @param island - island being left
|
2020-12-24 23:24:42 +01:00
|
|
|
* @since 1.15.4
|
|
|
|
*/
|
2023-01-31 16:13:01 +01:00
|
|
|
public void cleanLeavingPlayer(World world, User target, boolean kicked, Island island) {
|
2020-12-24 23:24:42 +01:00
|
|
|
// Execute commands when leaving
|
2023-01-31 16:13:01 +01:00
|
|
|
String ownerName = this.getName(island.getOwner());
|
|
|
|
Util.runCommands(target, ownerName, plugin.getIWM().getOnLeaveCommands(world), "leave");
|
2020-12-25 00:30:52 +01:00
|
|
|
|
|
|
|
// Remove any tamed animals
|
|
|
|
world.getEntitiesByClass(Tameable.class).stream()
|
|
|
|
.filter(Tameable::isTamed)
|
2022-01-02 02:39:25 +01:00
|
|
|
.filter(t -> t.getOwner() != null && t.getOwner().getUniqueId().equals(target.getUniqueId()))
|
2020-12-25 00:30:52 +01:00
|
|
|
.forEach(t -> t.setOwner(null));
|
|
|
|
|
2020-12-24 23:24:42 +01:00
|
|
|
// Remove money inventory etc.
|
|
|
|
if (plugin.getIWM().isOnLeaveResetEnderChest(world)) {
|
|
|
|
if (target.isOnline()) {
|
|
|
|
target.getPlayer().getEnderChest().clear();
|
|
|
|
} else {
|
2021-11-12 22:19:19 +01:00
|
|
|
Players p = getPlayer(target.getUniqueId());
|
|
|
|
if (p != null) {
|
|
|
|
p.addToPendingKick(world);
|
|
|
|
}
|
2020-12-24 23:24:42 +01:00
|
|
|
}
|
|
|
|
}
|
2020-12-25 06:56:02 +01:00
|
|
|
if ((kicked && plugin.getIWM().isOnLeaveResetInventory(world) && !plugin.getIWM().isKickedKeepInventory(world))
|
|
|
|
|| (!kicked && plugin.getIWM().isOnLeaveResetInventory(world))) {
|
2020-12-24 23:24:42 +01:00
|
|
|
if (target.isOnline()) {
|
|
|
|
target.getPlayer().getInventory().clear();
|
|
|
|
} else {
|
2021-11-12 22:19:19 +01:00
|
|
|
Players p = getPlayer(target.getUniqueId());
|
|
|
|
if (p != null) {
|
|
|
|
p.addToPendingKick(world);
|
|
|
|
}
|
2021-01-09 05:05:23 +01:00
|
|
|
}
|
2020-12-24 23:24:42 +01:00
|
|
|
}
|
2020-12-25 06:56:02 +01:00
|
|
|
|
2020-12-24 23:24:42 +01:00
|
|
|
if (plugin.getSettings().isUseEconomy() && plugin.getIWM().isOnLeaveResetMoney(world)) {
|
2020-12-25 00:30:52 +01:00
|
|
|
plugin.getVault().ifPresent(vault -> vault.withdraw(target, vault.getBalance(target), world));
|
2020-12-24 23:24:42 +01:00
|
|
|
}
|
|
|
|
// Reset the health
|
2022-03-18 14:59:41 +01:00
|
|
|
if (plugin.getIWM().isOnLeaveResetHealth(world) && target.isPlayer()) {
|
2020-12-24 23:24:42 +01:00
|
|
|
Util.resetHealth(target.getPlayer());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reset the hunger
|
2022-03-18 14:59:41 +01:00
|
|
|
if (plugin.getIWM().isOnLeaveResetHunger(world) && target.isPlayer()) {
|
2020-12-24 23:24:42 +01:00
|
|
|
target.getPlayer().setFoodLevel(20);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reset the XP
|
2022-03-18 14:59:41 +01:00
|
|
|
if (plugin.getIWM().isOnLeaveResetXP(world) && target.isPlayer()) {
|
2024-01-31 04:32:13 +01:00
|
|
|
// Player collected XP (displayed)
|
|
|
|
target.getPlayer().setLevel(0);
|
|
|
|
target.getPlayer().setExp(0);
|
|
|
|
// Player total XP (not displayed)
|
2020-12-24 23:24:42 +01:00
|
|
|
target.getPlayer().setTotalExperience(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-20 23:09:53 +02:00
|
|
|
}
|