2015-11-18 08:49:57 +01:00
|
|
|
package com.boydti.fawe.bukkit;
|
|
|
|
|
|
|
|
import com.boydti.fawe.Fawe;
|
2016-03-26 14:29:23 +01:00
|
|
|
import com.boydti.fawe.FaweAPI;
|
2015-11-18 08:49:57 +01:00
|
|
|
import com.boydti.fawe.IFawe;
|
|
|
|
import com.boydti.fawe.bukkit.regions.FactionsFeature;
|
2016-04-21 07:53:37 +02:00
|
|
|
import com.boydti.fawe.bukkit.regions.FactionsOneFeature;
|
2015-11-18 08:49:57 +01:00
|
|
|
import com.boydti.fawe.bukkit.regions.FactionsUUIDFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.GriefPreventionFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.PlotMeFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.PreciousStonesFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.ResidenceFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.TownyFeature;
|
|
|
|
import com.boydti.fawe.bukkit.regions.Worldguard;
|
2016-04-21 17:41:54 +02:00
|
|
|
import com.boydti.fawe.bukkit.v0.BukkitQueue_All;
|
2015-11-18 08:49:57 +01:00
|
|
|
import com.boydti.fawe.bukkit.v1_8.BukkitEditSessionWrapper_1_8;
|
|
|
|
import com.boydti.fawe.bukkit.v1_8.BukkitQueue_1_8;
|
2016-03-02 22:51:41 +01:00
|
|
|
import com.boydti.fawe.bukkit.v1_9.BukkitQueue_1_9;
|
2016-04-19 17:22:36 +02:00
|
|
|
import com.boydti.fawe.bukkit.v1_9.BukkitQueue_1_9_R1;
|
2016-04-19 22:30:34 +02:00
|
|
|
import com.boydti.fawe.config.Settings;
|
2015-11-18 08:49:57 +01:00
|
|
|
import com.boydti.fawe.object.EditSessionWrapper;
|
|
|
|
import com.boydti.fawe.object.FaweCommand;
|
|
|
|
import com.boydti.fawe.object.FawePlayer;
|
|
|
|
import com.boydti.fawe.regions.FaweMaskManager;
|
|
|
|
import com.boydti.fawe.util.FaweQueue;
|
|
|
|
import com.boydti.fawe.util.StringMan;
|
|
|
|
import com.boydti.fawe.util.TaskManager;
|
|
|
|
import com.sk89q.worldedit.EditSession;
|
|
|
|
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
|
2016-04-02 07:58:42 +02:00
|
|
|
import java.io.File;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Collection;
|
2016-04-02 18:50:50 +02:00
|
|
|
import java.util.HashSet;
|
|
|
|
import java.util.Set;
|
2016-04-21 06:07:28 +02:00
|
|
|
import java.util.UUID;
|
2016-04-02 07:58:42 +02:00
|
|
|
import org.bukkit.Bukkit;
|
|
|
|
import org.bukkit.ChatColor;
|
|
|
|
import org.bukkit.entity.Player;
|
2016-04-02 18:50:50 +02:00
|
|
|
import org.bukkit.event.EventHandler;
|
|
|
|
import org.bukkit.event.Listener;
|
2016-04-19 22:30:34 +02:00
|
|
|
import org.bukkit.event.player.PlayerChangedWorldEvent;
|
2016-04-02 18:50:50 +02:00
|
|
|
import org.bukkit.event.player.PlayerQuitEvent;
|
2016-04-02 07:58:42 +02:00
|
|
|
import org.bukkit.plugin.Plugin;
|
|
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
2015-11-18 08:49:57 +01:00
|
|
|
|
2016-04-02 18:50:50 +02:00
|
|
|
public class FaweBukkit extends JavaPlugin implements IFawe, Listener {
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
private VaultUtil vault;
|
|
|
|
private WorldEditPlugin worldedit;
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
public VaultUtil getVault() {
|
2016-03-31 11:23:10 +02:00
|
|
|
return this.vault;
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
public WorldEditPlugin getWorldEditPlugin() {
|
2016-03-31 11:23:10 +02:00
|
|
|
if (this.worldedit == null) {
|
|
|
|
this.worldedit = (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit");
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
return this.worldedit;
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public void onEnable() {
|
|
|
|
try {
|
2016-04-02 18:50:50 +02:00
|
|
|
Bukkit.getPluginManager().registerEvents(this, this);
|
2015-11-18 08:49:57 +01:00
|
|
|
Fawe.set(this);
|
2016-04-02 07:58:42 +02:00
|
|
|
} catch (final Throwable e) {
|
2015-11-18 08:49:57 +01:00
|
|
|
e.printStackTrace();
|
2016-03-31 11:23:10 +02:00
|
|
|
this.getServer().shutdown();
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public void debug(final String s) {
|
2016-03-31 11:23:10 +02:00
|
|
|
this.getLogger().info(ChatColor.translateAlternateColorCodes('&', s));
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public File getDirectory() {
|
2016-03-31 11:23:10 +02:00
|
|
|
return this.getDataFolder();
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public void setupCommand(final String label, final FaweCommand cmd) {
|
2016-03-31 11:23:10 +02:00
|
|
|
this.getCommand(label).setExecutor(new BukkitCommand(cmd));
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public FawePlayer<Player> wrap(final Object obj) {
|
|
|
|
if (obj.getClass() == String.class) {
|
2016-04-02 18:50:50 +02:00
|
|
|
String name = (String) obj;
|
|
|
|
FawePlayer existing = Fawe.get().getCachedPlayer(name);
|
|
|
|
if (existing != null) {
|
|
|
|
return existing;
|
|
|
|
}
|
|
|
|
return new BukkitPlayer(Bukkit.getPlayer(name));
|
2015-11-18 08:49:57 +01:00
|
|
|
} else if (obj instanceof Player) {
|
2016-04-02 18:50:50 +02:00
|
|
|
Player player = (Player) obj;
|
|
|
|
FawePlayer existing = Fawe.get().getCachedPlayer(player.getName());
|
|
|
|
return existing != null ? existing : new BukkitPlayer(player);
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-02 07:58:42 +02:00
|
|
|
@Override
|
|
|
|
public void startMetrics() {
|
|
|
|
Metrics metrics = new Metrics(this);
|
|
|
|
metrics.start();
|
|
|
|
debug("&6Metrics enabled.");
|
|
|
|
}
|
|
|
|
|
2016-04-02 18:50:50 +02:00
|
|
|
@Override
|
|
|
|
public Set<FawePlayer> getPlayers() {
|
|
|
|
HashSet<FawePlayer> players = new HashSet<>();
|
|
|
|
for (Player player : Bukkit.getServer().getOnlinePlayers()) {
|
|
|
|
players.add(wrap(player));
|
|
|
|
}
|
|
|
|
return players;
|
|
|
|
}
|
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* Kinda a really messy class I just copied over from an old project<br>
|
|
|
|
* - Still works, so cbf cleaning it up<br>
|
|
|
|
* - Completely optional to have this class enabled since things get cancelled further down anyway<br>
|
|
|
|
* - Useful since it informs the player why an edit changed no blocks etc.<br>
|
|
|
|
* - Predicts the number of blocks changed and cancels the edit if it's too large<br>
|
|
|
|
* - Predicts where the edit will effect and cancels it if it's outside a region<br>
|
|
|
|
* - Restricts the brush iteration limit<br>
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public void setupWEListener() {
|
2016-03-31 11:23:10 +02:00
|
|
|
this.getServer().getPluginManager().registerEvents(new WEListener(), this);
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* Vault isn't required, but used for setting player permissions (WorldEdit bypass)
|
|
|
|
* @return
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public void setupVault() {
|
|
|
|
try {
|
2016-03-31 11:23:10 +02:00
|
|
|
this.vault = new VaultUtil();
|
2015-11-18 08:49:57 +01:00
|
|
|
} catch (final Throwable e) {
|
2016-03-31 11:23:10 +02:00
|
|
|
this.debug("&cPlease install vault!");
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* The task manager handles sync/async tasks
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public TaskManager getTaskManager() {
|
|
|
|
return new BukkitTaskMan(this);
|
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-13 12:04:01 +02:00
|
|
|
private int[] version;
|
|
|
|
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public int[] getVersion() {
|
2016-04-13 12:04:01 +02:00
|
|
|
if (this.version == null) {
|
|
|
|
try {
|
|
|
|
this.version = new int[3];
|
|
|
|
final String[] split = Bukkit.getBukkitVersion().split("-")[0].split("\\.");
|
|
|
|
this.version[0] = Integer.parseInt(split[0]);
|
|
|
|
this.version[1] = Integer.parseInt(split[1]);
|
|
|
|
if (split.length == 3) {
|
|
|
|
this.version[2] = Integer.parseInt(split[2]);
|
|
|
|
}
|
|
|
|
} catch (final NumberFormatException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
Fawe.debug(StringMan.getString(Bukkit.getBukkitVersion()));
|
|
|
|
Fawe.debug(StringMan.getString(Bukkit.getBukkitVersion().split("-")[0].split("\\.")));
|
|
|
|
return new int[] { Integer.MAX_VALUE, 0, 0 };
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
|
|
|
}
|
2016-04-13 12:04:01 +02:00
|
|
|
return this.version;
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-21 17:41:54 +02:00
|
|
|
private boolean hasNMS = true;
|
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* The FaweQueue is a core part of block placement<br>
|
|
|
|
* - The queue returned here is used in the SetQueue class (SetQueue handles the implementation specific queue)<br>
|
|
|
|
* - Block changes are grouped by chunk (as it's more efficient for lighting/packet sending)<br>
|
|
|
|
* - The FaweQueue returned here will provide the wrapper around the chunk object (FaweChunk)<br>
|
|
|
|
* - When a block change is requested, the SetQueue will first check if the chunk exists in the queue, or it will create and add it<br>
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
2016-04-03 20:03:35 +02:00
|
|
|
public FaweQueue getNewQueue(String world) {
|
2016-04-21 17:41:54 +02:00
|
|
|
try {
|
|
|
|
if (FaweAPI.checkVersion(this.getVersion(), 1, 9, 0)) {
|
|
|
|
try {
|
|
|
|
return new BukkitQueue_1_9_R1(world);
|
|
|
|
} catch (Throwable e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
return new BukkitQueue_1_9(world);
|
|
|
|
} catch (final Throwable e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2016-04-19 17:22:36 +02:00
|
|
|
}
|
2016-04-21 17:41:54 +02:00
|
|
|
return new BukkitQueue_1_8(world);
|
2016-04-21 18:31:20 +02:00
|
|
|
} catch (Throwable ignore) {}
|
|
|
|
if (hasNMS) {
|
|
|
|
debug("====== NO NMS BLOCK PLACER FOUND ======");
|
|
|
|
debug("FAWE couldn't find a fast block placer");
|
|
|
|
debug("Bukkit version: " + Bukkit.getVersion());
|
|
|
|
debug("Supported NMS versions: 1.8, 1.9");
|
|
|
|
debug("Fallback placer: " + BukkitQueue_All.class);
|
|
|
|
debug("=======================================");
|
|
|
|
hasNMS = false;
|
2016-03-02 22:51:41 +01:00
|
|
|
}
|
2016-04-21 18:31:20 +02:00
|
|
|
return new BukkitQueue_All(world);
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* The EditSessionWrapper should have the same functionality as the normal EditSessionWrapper but with some optimizations
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public EditSessionWrapper getEditSessionWrapper(final EditSession session) {
|
|
|
|
return new BukkitEditSessionWrapper_1_8(session);
|
|
|
|
}
|
2016-03-31 11:23:10 +02:00
|
|
|
|
2016-04-01 07:20:35 +02:00
|
|
|
/**
|
|
|
|
* A mask manager handles region restrictions e.g. PlotSquared plots / WorldGuard regions
|
|
|
|
*/
|
2015-11-18 08:49:57 +01:00
|
|
|
@Override
|
|
|
|
public Collection<FaweMaskManager> getMaskManagers() {
|
|
|
|
final Plugin worldguardPlugin = Bukkit.getServer().getPluginManager().getPlugin("WorldGuard");
|
|
|
|
final ArrayList<FaweMaskManager> managers = new ArrayList<>();
|
|
|
|
if ((worldguardPlugin != null) && worldguardPlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new Worldguard(worldguardPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'WorldGuard' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'WorldGuard' not found. Worldguard features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin plotmePlugin = Bukkit.getServer().getPluginManager().getPlugin("PlotMe");
|
|
|
|
if ((plotmePlugin != null) && plotmePlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new PlotMeFeature(plotmePlugin, this));
|
|
|
|
Fawe.debug("Plugin 'PlotMe' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'PlotMe' not found. PlotMe features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin townyPlugin = Bukkit.getServer().getPluginManager().getPlugin("Towny");
|
|
|
|
if ((townyPlugin != null) && townyPlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new TownyFeature(townyPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'Towny' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'Towny' not found. Towny features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin factionsPlugin = Bukkit.getServer().getPluginManager().getPlugin("Factions");
|
|
|
|
if ((factionsPlugin != null) && factionsPlugin.isEnabled()) {
|
|
|
|
try {
|
|
|
|
managers.add(new FactionsFeature(factionsPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'Factions' found. Using it now.");
|
|
|
|
} catch (final Throwable e) {
|
2016-04-21 07:53:37 +02:00
|
|
|
try {
|
|
|
|
managers.add(new FactionsUUIDFeature(factionsPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'FactionsUUID' found. Using it now.");
|
|
|
|
} catch (Throwable e2) {
|
|
|
|
try {
|
|
|
|
managers.add(new FactionsOneFeature(factionsPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'FactionsUUID' found. Using it now.");
|
|
|
|
} catch (Throwable e3) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'Factions' not found. Factions features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin residencePlugin = Bukkit.getServer().getPluginManager().getPlugin("Residence");
|
|
|
|
if ((residencePlugin != null) && residencePlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new ResidenceFeature(residencePlugin, this));
|
|
|
|
Fawe.debug("Plugin 'Residence' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'Residence' not found. Factions features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin griefpreventionPlugin = Bukkit.getServer().getPluginManager().getPlugin("GriefPrevention");
|
|
|
|
if ((griefpreventionPlugin != null) && griefpreventionPlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new GriefPreventionFeature(griefpreventionPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'GriefPrevention' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'GriefPrevention' not found. GriefPrevention features disabled.");
|
|
|
|
}
|
|
|
|
final Plugin preciousstonesPlugin = Bukkit.getServer().getPluginManager().getPlugin("PreciousStones");
|
|
|
|
if ((preciousstonesPlugin != null) && preciousstonesPlugin.isEnabled()) {
|
2016-02-09 11:15:03 +01:00
|
|
|
try {
|
|
|
|
managers.add(new PreciousStonesFeature(preciousstonesPlugin, this));
|
|
|
|
Fawe.debug("Plugin 'PreciousStones' found. Using it now.");
|
2016-03-31 11:23:10 +02:00
|
|
|
} catch (final Throwable e) {
|
2016-02-09 11:15:03 +01:00
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
} else {
|
|
|
|
Fawe.debug("Plugin 'PreciousStones' not found. PreciousStones features disabled.");
|
|
|
|
}
|
|
|
|
return managers;
|
|
|
|
}
|
2016-04-02 18:50:50 +02:00
|
|
|
|
|
|
|
@EventHandler
|
|
|
|
public void onPlayerQuit(PlayerQuitEvent event) {
|
2016-04-19 22:30:34 +02:00
|
|
|
Player player = event.getPlayer();
|
|
|
|
FawePlayer fp = FawePlayer.wrap(player);
|
|
|
|
fp.unregister();
|
2016-04-02 18:50:50 +02:00
|
|
|
Fawe.get().unregister(event.getPlayer().getName());
|
|
|
|
}
|
2016-04-19 22:30:34 +02:00
|
|
|
|
|
|
|
@EventHandler
|
|
|
|
public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
|
|
|
|
Player player = event.getPlayer();
|
|
|
|
FawePlayer fp = FawePlayer.wrap(player);
|
|
|
|
if (Settings.STORE_HISTORY_ON_DISK) {
|
|
|
|
fp.getSession().clearHistory();
|
|
|
|
fp.loadSessionFromDisk(fp.getWorld());
|
|
|
|
}
|
|
|
|
}
|
2016-04-20 20:22:47 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getPlatform() {
|
|
|
|
return "bukkit";
|
|
|
|
}
|
2016-04-21 06:07:28 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public UUID getUUID(String name) {
|
|
|
|
return Bukkit.getOfflinePlayer(name).getUniqueId();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getName(UUID uuid) {
|
|
|
|
return Bukkit.getOfflinePlayer(uuid).getName();
|
|
|
|
}
|
2015-11-18 08:49:57 +01:00
|
|
|
}
|