Saber-Factions/src/main/java/com/massivecraft/factions/SavageFactions.java

746 lines
29 KiB
Java
Raw Normal View History

package com.massivecraft.factions;
2018-12-27 02:22:06 +01:00
import ch.njol.skript.Skript;
import ch.njol.skript.SkriptAddon;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
2012-01-08 00:27:03 +01:00
import com.massivecraft.factions.cmd.CmdAutoHelp;
import com.massivecraft.factions.cmd.FCmdRoot;
import com.massivecraft.factions.integration.Econ;
import com.massivecraft.factions.integration.Essentials;
import com.massivecraft.factions.integration.Worldguard;
import com.massivecraft.factions.integration.dynmap.EngineDynmap;
2014-04-04 20:55:21 +02:00
import com.massivecraft.factions.listeners.*;
import com.massivecraft.factions.struct.ChatMode;
import com.massivecraft.factions.util.*;
import com.massivecraft.factions.util.Particles.ReflectionUtils;
import com.massivecraft.factions.zcore.CommandVisibility;
import com.massivecraft.factions.zcore.MCommand;
import com.massivecraft.factions.zcore.MPlugin;
import com.massivecraft.factions.zcore.fperms.Access;
2018-02-06 04:46:43 +01:00
import com.massivecraft.factions.zcore.fperms.Permissable;
2018-02-03 21:49:04 +01:00
import com.massivecraft.factions.zcore.fperms.PermissableAction;
2018-03-26 23:43:15 +02:00
import com.massivecraft.factions.zcore.fupgrades.CropUpgrades;
import com.massivecraft.factions.zcore.fupgrades.EXPUpgrade;
import com.massivecraft.factions.zcore.fupgrades.FUpgradesGUI;
import com.massivecraft.factions.zcore.fupgrades.SpawnerUpgrades;
import com.massivecraft.factions.zcore.util.TextUtil;
2018-03-26 23:43:15 +02:00
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.permission.Permission;
2018-03-26 23:43:15 +02:00
import org.bukkit.*;
2014-04-04 20:55:21 +02:00
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
2018-03-26 23:43:15 +02:00
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EntityType;
2014-04-04 20:55:21 +02:00
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
2014-04-04 20:55:21 +02:00
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.inventory.Inventory;
2018-03-26 23:43:15 +02:00
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.RegisteredServiceProvider;
2014-04-04 20:55:21 +02:00
import java.io.*;
2014-04-04 20:55:21 +02:00
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
2018-03-26 23:43:15 +02:00
import java.util.*;
2014-04-04 20:55:21 +02:00
import java.util.logging.Level;
import java.util.stream.Collectors;
2018-03-26 23:43:15 +02:00
public class SavageFactions extends MPlugin {
// Our single plugin instance.
// Single 4 life.
public static SavageFactions plugin;
2015-02-26 15:58:09 +01:00
public static Permission perms = null;
2014-04-04 20:55:21 +02:00
public boolean PlaceholderApi;
2018-07-12 18:11:07 +02:00
// Commands
public FCmdRoot cmdBase;
public CmdAutoHelp cmdAutoHelp;
public boolean mc17 = false;
public boolean mc18 = false;
public boolean mc113 = false;
2018-07-29 21:34:40 +02:00
public boolean useNonPacketParticles = false;
2018-07-12 18:11:07 +02:00
public boolean factionsFlight = false;
2018-11-07 06:38:43 +01:00
//multiversion material fields
public Material SUGAR_CANE_BLOCK, BANNER, CROPS, REDSTONE_LAMP_ON,
STAINED_GLASS, STATIONARY_WATER, STAINED_CLAY, WOOD_BUTTON,
SOIL, MOB_SPANWER, THIN_GLASS, IRON_FENCE, NETHER_FENCE, FENCE,
WOODEN_DOOR, TRAP_DOOR, FENCE_GATE, BURNING_FURNACE, DIODE_BLOCK_OFF,
DIODE_BLOCK_ON, ENCHANTMENT_TABLE, FIREBALL;
// Persistence related
2014-04-04 20:55:21 +02:00
private boolean locked = false;
2018-07-12 18:11:07 +02:00
private Integer AutoLeaveTask = null;
private boolean hookedPlayervaults;
private ClipPlaceholderAPIManager clipPlaceholderAPIManager;
private boolean mvdwPlaceholderAPIManager = false;
2018-12-27 02:22:06 +01:00
SkriptAddon skriptAddon;
private Listener[] eventsListener;
public SavageFactions() {
plugin = this;
2018-07-12 18:11:07 +02:00
}
2014-04-04 20:55:21 +02:00
public boolean getLocked() {
return this.locked;
}
public void setLocked(boolean val) {
2014-07-01 22:10:18 +02:00
this.locked = val;
this.setAutoSave(val);
2014-04-04 20:55:21 +02:00
}
2018-03-26 23:43:15 +02:00
public void playSoundForAll(String sound) {
for (Player pl : Bukkit.getOnlinePlayers()) {
playSound(pl, sound);
}
}
public void playSoundForAll(List<String> sounds) {
for (Player pl : Bukkit.getOnlinePlayers()) {
playSound(pl, sounds);
}
}
public void playSound(Player p, List<String> sounds) {
for (String sound : sounds) {
playSound(p, sound);
}
}
2014-04-04 20:55:21 +02:00
2018-03-26 23:43:15 +02:00
public void playSound(Player p, String sound) {
float pitch = Float.valueOf(sound.split(":")[1]);
sound = sound.split(":")[0];
p.playSound(p.getLocation(), Sound.valueOf(sound), pitch, 5.0F);
}
2014-04-04 20:55:21 +02:00
@Override
public void onEnable() {
log("==== Setup ====");
// Vault dependency check.
if (getServer().getPluginManager().getPlugin("Vault") == null) {
log("Vault is not present, the plugin will not run properly.");
getServer().getPluginManager().disablePlugin(plugin);
2018-11-07 06:38:43 +01:00
return;
}
int version = Integer.parseInt(ReflectionUtils.PackageType.getServerVersion().split("_")[1]);
if (version == 7) {
SavageFactions.plugin.log("Minecraft Version 1.7 found, disabling banners, itemflags inside GUIs, and Titles.");
mc17 = true;
} else if (version == 8) {
SavageFactions.plugin.log("Minecraft Version 1.8 found, Title Fadeouttime etc will not be configurable.");
mc18 = true;
} else if (version == 13) {
SavageFactions.plugin.log("Minecraft Version 1.13 found, New Items will be used.");
mc113 = true;
changeItemIDSInConfig();
}
setupMultiversionMaterials();
migrateFPlayerLeaders();
log("==== End Setup ====");
if (!preEnable()) {
2014-07-01 22:10:18 +02:00
return;
}
this.loadSuccessful = false;
saveDefaultConfig();
2014-04-04 20:55:21 +02:00
// Load Conf from disk
2014-07-01 22:10:18 +02:00
Conf.load();
2018-03-26 23:43:15 +02:00
Essentials.setup();
hookedPlayervaults = setupPlayervaults();
FPlayers.getInstance().load();
Factions.getInstance().load();
for (FPlayer fPlayer : FPlayers.getInstance().getAllFPlayers()) {
Faction faction = Factions.getInstance().getFactionById(fPlayer.getFactionId());
if (faction == null) {
log("Invalid faction id on " + fPlayer.getName() + ":" + fPlayer.getFactionId());
fPlayer.resetFactionData(false);
continue;
}
faction.addFPlayer(fPlayer);
}
Board.getInstance().load();
2014-12-07 22:15:42 +01:00
Board.getInstance().clean();
2014-04-04 20:55:21 +02:00
// Add Base Commands
2014-07-01 22:10:18 +02:00
this.cmdBase = new FCmdRoot();
this.cmdAutoHelp = new CmdAutoHelp();
this.getBaseCommands().add(cmdBase);
2014-04-04 20:55:21 +02:00
Econ.setup();
2015-02-26 15:58:09 +01:00
setupPermissions();
2014-04-04 20:55:21 +02:00
if (Conf.worldGuardChecking || Conf.worldGuardBuildPriority) {
Worldguard.init(this);
}
EngineDynmap.getInstance().init();
2014-04-04 20:55:21 +02:00
// start up task which runs the autoLeaveAfterDaysOfInactivity routine
startAutoLeaveTask(false);
2018-11-18 18:24:52 +01:00
if (getConfig().getBoolean("MassiveStats")) {
// massive stats
new MassiveStats(this);
}
if (version > 8) {
2018-07-29 21:34:40 +02:00
useNonPacketParticles = true;
log("Minecraft Version 1.9 or higher found, using non packet based particle API");
}
2018-03-26 23:43:15 +02:00
if (getConfig().getBoolean("enable-faction-flight")) {
factionsFlight = true;
}
2018-12-27 02:22:06 +01:00
if (getServer().getPluginManager().getPlugin("Skript") != null) {
log("Skript was found! Registering SavageFactions Addon...");
skriptAddon = Skript.registerAddon(this);
try {
skriptAddon.loadClasses("com.massivecraft.factions.skript", "expressions");
} catch (IOException ex) {
ex.printStackTrace();
}
log("Skript addon registered!");
}
2014-04-04 20:55:21 +02:00
// Register Event Handlers
eventsListener = new Listener[] {
new FactionsPlayerListener(this),
new FactionsChatListener(this),
new FactionsEntityListener(this),
new FactionsExploitListener(),
new FactionsBlockListener(this),
new FUpgradesGUI(),
new EXPUpgrade(),
new CropUpgrades(),
new SpawnerUpgrades(),
};
for (Listener eventListener: eventsListener)
getServer().getPluginManager().registerEvents(eventListener, this);
2014-04-04 20:55:21 +02:00
// since some other plugins execute commands directly through this command interface, provide it
getCommand(this.refCommand).setExecutor(this);
getCommand(this.refCommand).setTabCompleter(this);
2014-04-04 20:55:21 +02:00
if (getDescription().getFullName().contains("BETA")) {
divider();
System.out.println("You are using a BETA version of the plugin!");
System.out.println("This comes with risks of small bugs in newer features!");
System.out.println("For support head to: https://github.com/ProSavage/SavageFactions/issues");
divider();
}
2018-11-07 06:38:43 +01:00
this.setupPlaceholderAPI();
this.postEnable();
2014-07-01 22:10:18 +02:00
this.loadSuccessful = true;
2014-04-04 20:55:21 +02:00
}
2018-12-27 02:22:06 +01:00
public SkriptAddon getSkriptAddon() {
return skriptAddon;
}
private void setupMultiversionMaterials() {
if (mc113) {
2018-08-13 07:41:29 +02:00
BANNER = Material.valueOf("LEGACY_BANNER");
CROPS = Material.valueOf("LEGACY_CROPS");
SUGAR_CANE_BLOCK = Material.valueOf("LEGACY_SUGAR_CANE_BLOCK");
REDSTONE_LAMP_ON = Material.valueOf("LEGACY_REDSTONE_LAMP_ON");
STAINED_GLASS = Material.valueOf("LEGACY_STAINED_GLASS");
STATIONARY_WATER = Material.valueOf("LEGACY_STATIONARY_WATER");
STAINED_CLAY = Material.valueOf("LEGACY_STAINED_CLAY");
WOOD_BUTTON = Material.valueOf("LEGACY_WOOD_BUTTON");
SOIL = Material.valueOf("LEGACY_SOIL");
MOB_SPANWER = Material.valueOf("LEGACY_MOB_SPAWNER");
THIN_GLASS = Material.valueOf("LEGACY_THIN_GLASS");
IRON_FENCE = Material.valueOf("LEGACY_IRON_FENCE");
NETHER_FENCE = Material.valueOf("LEGACY_NETHER_FENCE");
FENCE = Material.valueOf("LEGACY_FENCE");
WOODEN_DOOR = Material.valueOf("LEGACY_WOODEN_DOOR");
TRAP_DOOR = Material.valueOf("LEGACY_TRAP_DOOR");
FENCE_GATE = Material.valueOf("LEGACY_FENCE_GATE");
BURNING_FURNACE = Material.valueOf("LEGACY_BURNING_FURNACE");
DIODE_BLOCK_OFF = Material.valueOf("LEGACY_DIODE_BLOCK_OFF");
DIODE_BLOCK_ON = Material.valueOf("LEGACY_DIODE_BLOCK_ON");
ENCHANTMENT_TABLE = Material.valueOf("LEGACY_ENCHANTMENT_TABLE");
FIREBALL = Material.valueOf("LEGACY_FIREBALL");
} else {
if (!mc17) {
BANNER = Material.valueOf("BANNER");
}
CROPS = Material.valueOf("CROPS");
SUGAR_CANE_BLOCK = Material.valueOf("SUGAR_CANE_BLOCK");
REDSTONE_LAMP_ON = Material.valueOf("REDSTONE_LAMP_ON");
STAINED_GLASS = Material.valueOf("STAINED_GLASS");
STATIONARY_WATER = Material.valueOf("STATIONARY_WATER");
STAINED_CLAY = Material.valueOf("STAINED_CLAY");
WOOD_BUTTON = Material.valueOf("WOOD_BUTTON");
SOIL = Material.valueOf("SOIL");
MOB_SPANWER = Material.valueOf("MOB_SPAWNER");
THIN_GLASS = Material.valueOf("THIN_GLASS");
IRON_FENCE = Material.valueOf("IRON_FENCE");
NETHER_FENCE = Material.valueOf("NETHER_FENCE");
FENCE = Material.valueOf("FENCE");
WOODEN_DOOR = Material.valueOf("WOODEN_DOOR");
TRAP_DOOR = Material.valueOf("TRAP_DOOR");
FENCE_GATE = Material.valueOf("FENCE_GATE");
BURNING_FURNACE = Material.valueOf("BURNING_FURNACE");
DIODE_BLOCK_OFF = Material.valueOf("DIODE_BLOCK_OFF");
DIODE_BLOCK_ON = Material.valueOf("DIODE_BLOCK_ON");
ENCHANTMENT_TABLE = Material.valueOf("ENCHANTMENT_TABLE");
FIREBALL = Material.valueOf("FIREBALL");
}
}
private void setupPlaceholderAPI() {
2018-01-07 01:56:43 +01:00
Plugin clip = getServer().getPluginManager().getPlugin("PlaceholderAPI");
if (clip != null && clip.isEnabled()) {
this.clipPlaceholderAPIManager = new ClipPlaceholderAPIManager();
if (this.clipPlaceholderAPIManager.register()) {
PlaceholderApi = true;
log(Level.INFO, "Successfully registered placeholders with PlaceholderAPI.");
} else {
PlaceholderApi = false;
}
} else {
PlaceholderApi = false;
}
2018-01-07 01:56:43 +01:00
Plugin mvdw = getServer().getPluginManager().getPlugin("MVdWPlaceholderAPI");
if (mvdw != null && mvdw.isEnabled()) {
this.mvdwPlaceholderAPIManager = true;
log(Level.INFO, "Found MVdWPlaceholderAPI. Adding hooks.");
}
}
private void migrateFPlayerLeaders() {
List<String> lines = new ArrayList<>();
File fplayerFile = new File("plugins\\Factions\\players.json");
try {
BufferedReader br = new BufferedReader(new FileReader(fplayerFile));
System.out.println("Migrating old players.json file.");
String line;
while ((line = br.readLine()) != null) {
if (line.contains("\"role\": \"ADMIN\"")) {
line = line.replace("\"role\": \"ADMIN\"", "\"role\": " + "\"LEADER\"");
}
lines.add(line);
}
br.close();
BufferedWriter bw = new BufferedWriter(new FileWriter(fplayerFile));
for (String newLine : lines) {
bw.write(newLine + "\n");
}
bw.flush();
bw.close();
} catch (IOException ex) {
System.out.println("File was not found for players.json, assuming"
+ " there is no need to migrate old players.json file.");
}
}
2019-01-07 04:04:38 +01:00
public void changeItemIDSInConfig() {
log("Starting conversion of legacy material in config to 1.13 materials.");
replaceStringInConfig("fperm-gui.relation.materials.recruit", "WOOD_SWORD", "WOODEN_SWORD");
replaceStringInConfig("fperm-gui.relation.materials.normal", "GOLD_SWORD", "GOLDEN_SWORD");
replaceStringInConfig("fperm-gui.relation.materials.ally", "GOLD_AXE", "GOLDEN_AXE");
replaceStringInConfig("fperm-gui.relation.materials.neutral", "WOOD_AXE", "WOODEN_AXE");
ConfigurationSection actionMaterialsConfigSection = getConfig().getConfigurationSection("fperm-gui.action.materials");
Set<String> actionMaterialKeys = actionMaterialsConfigSection.getKeys(true);
for (String key : actionMaterialKeys) {
replaceStringInConfig("fperm-gui.action.materials." + key, "STAINED_GLASS", "GRAY_STAINED_GLASS");
}
replaceStringInConfig("fperm-gui.dummy-items.0.material", "STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE");
replaceStringInConfig("fwarp-gui.dummy-items.0.material", "STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE");
replaceStringInConfig("fupgrades.MainMenu.DummyItem.Type", "STAINED_GLASS_PANE", "GRAY_STAINED_GLASS_PANE");
replaceStringInConfig("fupgrades.MainMenu.EXP.EXPItem.Type", "EXP_BOTTLE", "EXPERIENCE_BOTTLE");
replaceStringInConfig("fupgrades.MainMenu.Spawners.SpawnerItem.Type", "MOB_SPAWNER", "SPAWNER");
replaceStringInConfig("fperm-gui.action.access.allow", "LIME", "LIME_STAINED_GLASS");
replaceStringInConfig("fperm-gui.action.access.deny", "RED", "RED_STAINED_GLASS");
replaceStringInConfig("fperm-gui.action.access.undefined", "CYAN", "CYAN_STAINED_GLASS");
}
public void replaceStringInConfig(String path, String stringToReplace, String replacementString) {
if (getConfig().getString(path).equals(stringToReplace)) {
// SavageFactions.plugin.log("Replacing legacy material '" + stringToReplace + "' with '" + replacementString + "' for config node '" + path + "'.");
// log("Replacing legacy material '" + stringToReplace + "' with '" + replacementString + "' for config node '" + path + "'.");
getConfig().set(path, replacementString);
}
}
2018-01-07 01:56:43 +01:00
public boolean isClipPlaceholderAPIHooked() {
return this.clipPlaceholderAPIManager != null;
}
2018-01-07 01:56:43 +01:00
public boolean isMVdWPlaceholderAPIHooked() {
return this.mvdwPlaceholderAPIManager;
}
private boolean setupPermissions() {
try {
RegisteredServiceProvider<Permission> rsp = getServer().getServicesManager().getRegistration(Permission.class);
if (rsp != null) {
perms = rsp.getProvider();
}
} catch (NoClassDefFoundError ex) {
return false;
}
return perms != null;
}
private boolean setupPlayervaults() {
Plugin plugin = getServer().getPluginManager().getPlugin("PlayerVaults");
return plugin != null && plugin.isEnabled();
}
2014-04-04 20:55:21 +02:00
@Override
public GsonBuilder getGsonBuilder() {
2014-11-06 01:36:47 +01:00
Type mapFLocToStringSetType = new TypeToken<Map<FLocation, Set<String>>>() {
}.getType();
2014-07-01 21:52:40 +02:00
2018-02-06 04:46:43 +01:00
Type accessTypeAdatper = new TypeToken<Map<Permissable, Map<PermissableAction, Access>>>() {
}.getType();
return new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().enableComplexMapKeySerialization().excludeFieldsWithModifiers(Modifier.TRANSIENT, Modifier.VOLATILE)
.registerTypeAdapter(accessTypeAdatper, new PermissionsMapTypeAdapter())
.registerTypeAdapter(LazyLocation.class, new MyLocationTypeAdapter())
.registerTypeAdapter(mapFLocToStringSetType, new MapFLocToStringSetTypeAdapter())
.registerTypeAdapter(Inventory.class, new InventoryTypeAdapter())
.registerTypeAdapter(Location.class, new LocationTypeAdapter())
.registerTypeAdapterFactory(EnumTypeAdapter.ENUM_FACTORY);
2018-07-12 18:11:07 +02:00
}
2014-04-04 20:55:21 +02:00
private void divider() {
System.out.println(" .-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-");
System.out.println(" / / \\ \\ / / \\ \\ / / \\ \\ / / \\ \\ / / \\ \\ / / \\ \\ / / \\ \\ / / \\");
System.out.println("`-' `-`-' `-`-' `-`-' `-`-' `-`-' `-`-' `-`-'");
}
2014-04-04 20:55:21 +02:00
@Override
public void onDisable() {
// only save data if plugin actually completely loaded successfully
if (this.loadSuccessful) {
// Dont save, as this is kind of pointless, as the /f config command manually saves.
// So any edits done are saved, this way manual edits to json can go through.
// Conf.save();
2014-07-01 22:10:18 +02:00
}
2014-07-01 22:10:18 +02:00
if (AutoLeaveTask != null) {
this.getServer().getScheduler().cancelTask(AutoLeaveTask);
AutoLeaveTask = null;
}
2014-07-01 22:10:18 +02:00
super.onDisable();
2014-04-04 20:55:21 +02:00
}
public void startAutoLeaveTask(boolean restartIfRunning) {
if (AutoLeaveTask != null) {
if (!restartIfRunning) {
2014-07-01 22:10:18 +02:00
return;
}
this.getServer().getScheduler().cancelTask(AutoLeaveTask);
2014-04-04 20:55:21 +02:00
}
if (Conf.autoLeaveRoutineRunsEveryXMinutes > 0.0) {
long ticks = (long) (20 * 60 * Conf.autoLeaveRoutineRunsEveryXMinutes);
AutoLeaveTask = getServer().getScheduler().scheduleSyncRepeatingTask(this, new AutoLeaveTask(), ticks, ticks);
}
}
@Override
public void postAutoSave() {
//Board.getInstance().forceSave(); Not sure why this was there as it's called after the board is already saved.
2014-07-01 22:10:18 +02:00
Conf.save();
2014-04-04 20:55:21 +02:00
}
2018-07-12 18:11:07 +02:00
2018-03-26 23:43:15 +02:00
public ItemStack createItem(Material material, int amount, short datavalue, String name, List<String> lore) {
ItemStack item = new ItemStack(material, amount, datavalue);
ItemMeta meta = item.getItemMeta();
meta.setDisplayName(color(name));
meta.setLore(colorList(lore));
item.setItemMeta(meta);
return item;
}
2014-04-04 20:55:21 +02:00
2018-03-26 23:43:15 +02:00
public ItemStack createLazyItem(Material material, int amount, short datavalue, String name, String lore) {
ItemStack item = new ItemStack(material, amount, datavalue);
ItemMeta meta = item.getItemMeta();
meta.setDisplayName(color(SavageFactions.plugin.getConfig().getString(name)));
meta.setLore(colorList(SavageFactions.plugin.getConfig().getStringList(lore)));
2018-03-26 23:43:15 +02:00
item.setItemMeta(meta);
return item;
}
public Economy getEcon() {
RegisteredServiceProvider<Economy> rsp = SavageFactions.plugin.getServer().getServicesManager().getRegistration(Economy.class);
2018-03-26 23:43:15 +02:00
Economy econ = rsp.getProvider();
return econ;
}
2018-07-12 18:11:07 +02:00
2014-04-04 20:55:21 +02:00
@Override
public boolean logPlayerCommands() {
return Conf.logPlayerCommands;
}
@Override
public boolean handleCommand(CommandSender sender, String commandString, boolean testOnly) {
2014-07-02 08:37:42 +02:00
return sender instanceof Player && FactionsPlayerListener.preventCommand(commandString, (Player) sender) || super.handleCommand(sender, commandString, testOnly);
2014-04-04 20:55:21 +02:00
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] split) {
if (split.length == 0) {
return handleCommand(sender, "/f help", false);
2014-07-01 22:10:18 +02:00
}
2014-04-04 20:55:21 +02:00
// otherwise, needs to be handled; presumably another plugin directly ran the command
String cmd = Conf.baseCommandAliases.isEmpty() ? "/f" : "/" + Conf.baseCommandAliases.get(0);
return handleCommand(sender, cmd + " " + TextUtil.implode(Arrays.asList(split), " "), false);
}
@Override
public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
FPlayer fPlayer = FPlayers.getInstance().getByPlayer((Player) sender);
List<String> completions = new ArrayList<>();
String cmd = Conf.baseCommandAliases.isEmpty() ? "/f" : "/" + Conf.baseCommandAliases.get(0);
List<String> argsList = new ArrayList<>(Arrays.asList(args));
argsList.remove(argsList.size() - 1);
String cmdValid = (cmd + " " + TextUtil.implode(argsList, " ")).trim();
MCommand<?> commandEx = cmdBase;
List<MCommand<?>> commandsList = cmdBase.subCommands;
for (; !commandsList.isEmpty() && !argsList.isEmpty(); argsList.remove(0))
{
String cmdName = argsList.get(0).toLowerCase();
MCommand<?> commandFounded = commandsList.stream()
.filter(c -> c.aliases.contains(cmdName))
.findFirst().orElse(null);
if (commandFounded != null)
{
commandEx = commandFounded;
commandsList = commandFounded.subCommands;
}
else break;
}
if (argsList.isEmpty())
{
for (MCommand<?> subCommand: commandEx.subCommands)
{
subCommand.setCommandSender(sender);
if (handleCommand(sender, cmdValid + " " + subCommand.aliases.get(0), true)
&& subCommand.visibility != CommandVisibility.INVISIBLE
&& subCommand.validSenderType(sender, false)
&& subCommand.validSenderPermissions(sender, false))
completions.addAll(subCommand.aliases);
}
}
String lastArg = args[args.length - 1].toLowerCase();
completions = completions.stream()
.filter(m -> m.toLowerCase().startsWith(lastArg))
.collect(Collectors.toList());
return completions;
}
2014-04-04 20:55:21 +02:00
2018-07-12 18:11:07 +02:00
public void createTimedHologram(final Location location, String text, Long timeout) {
ArmorStand as = (ArmorStand) location.add(0.5, 1, 0.5).getWorld().spawnEntity(location, EntityType.ARMOR_STAND); //Spawn the ArmorStand
2018-03-26 23:43:15 +02:00
as.setVisible(false); //Makes the ArmorStand invisible
as.setGravity(false); //Make sure it doesn't fall
as.setCanPickupItems(false); //I'm not sure what happens if you leave this as it is, but you might as well disable it
as.setCustomName(SavageFactions.plugin.color(text)); //Set this to the text you want
2018-03-26 23:43:15 +02:00
as.setCustomNameVisible(true); //This makes the text appear no matter if your looking at the entity or not
final ArmorStand armorStand = as;
Bukkit.getScheduler().scheduleSyncDelayedTask(SavageFactions.plugin, () -> {
armorStand.remove();
getLogger().info("Removing Hologram.");
}
, timeout * 20);
2018-03-26 23:43:15 +02:00
}
2014-04-04 20:55:21 +02:00
// -------------------------------------------- //
// Functions for other plugins to hook into
// -------------------------------------------- //
// This value will be updated whenever new hooks are added
public int hookSupportVersion() {
return 3;
}
// If another plugin is handling insertion of chat tags, this should be used to notify Factions
public void handleFactionTagExternally(boolean notByFactions) {
Conf.chatTagHandledByAnotherPlugin = notByFactions;
}
// Simply put, should this chat event be left for Factions to handle? For now, that means players with Faction Chat
// enabled or use of the Factions f command without a slash; combination of isPlayerFactionChatting() and isFactionsCommand()
public boolean shouldLetFactionsHandleThisChat(AsyncPlayerChatEvent event) {
2014-07-02 08:37:42 +02:00
return event != null && (isPlayerFactionChatting(event.getPlayer()) || isFactionsCommand(event.getMessage()));
2014-04-04 20:55:21 +02:00
}
2014-04-04 20:55:21 +02:00
// Does player have Faction Chat enabled? If so, chat plugins should preferably not do channels,
// local chat, or anything else which targets individual recipients, so Faction Chat can be done
public boolean isPlayerFactionChatting(Player player) {
2014-07-01 22:10:18 +02:00
if (player == null) {
return false;
}
FPlayer me = FPlayers.getInstance().getByPlayer(player);
2014-04-04 20:55:21 +02:00
2014-07-02 08:37:42 +02:00
return me != null && me.getChatMode().isAtLeast(ChatMode.ALLIANCE);
2014-04-04 20:55:21 +02:00
}
// Is this chat message actually a Factions command, and thus should be left alone by other plugins?
// TODO: GET THIS BACK AND WORKING
public boolean isFactionsCommand(String check) {
return !(check == null || check.isEmpty()) && this.handleCommand(null, check, true);
2014-04-04 20:55:21 +02:00
}
// Get a player's faction tag (faction name), mainly for usage by chat plugins for local/channel chat
public String getPlayerFactionTag(Player player) {
return getPlayerFactionTagRelation(player, null);
}
// Same as above, but with relation (enemy/neutral/ally) coloring potentially added to the tag
public String getPlayerFactionTagRelation(Player speaker, Player listener) {
String tag = "~";
2014-07-01 22:10:18 +02:00
if (speaker == null) {
return tag;
}
2014-04-04 20:55:21 +02:00
FPlayer me = FPlayers.getInstance().getByPlayer(speaker);
2014-07-01 22:10:18 +02:00
if (me == null) {
return tag;
}
2014-04-04 20:55:21 +02:00
// if listener isn't set, or config option is disabled, give back uncolored tag
if (listener == null || !Conf.chatTagRelationColored) {
2014-04-04 20:55:21 +02:00
tag = me.getChatTag().trim();
2014-07-01 21:52:40 +02:00
} else {
FPlayer you = FPlayers.getInstance().getByPlayer(listener);
2014-07-01 22:10:18 +02:00
if (you == null) {
tag = me.getChatTag().trim();
} else // everything checks out, give the colored tag
{
tag = me.getChatTag(you).trim();
}
}
if (tag.isEmpty()) {
tag = "~";
}
2014-04-04 20:55:21 +02:00
return tag;
}
// Get a player's title within their faction, mainly for usage by chat plugins for local/channel chat
public String getPlayerTitle(Player player) {
2014-07-01 22:10:18 +02:00
if (player == null) {
return "";
}
2014-04-04 20:55:21 +02:00
FPlayer me = FPlayers.getInstance().getByPlayer(player);
2014-07-01 22:10:18 +02:00
if (me == null) {
return "";
}
2014-04-04 20:55:21 +02:00
return me.getTitle().trim();
}
2018-03-26 23:43:15 +02:00
public String color(String line) {
line = ChatColor.translateAlternateColorCodes('&', line);
return line;
}
//colors a string list
public List<String> colorList(List<String> lore) {
2018-07-12 18:11:07 +02:00
for (int i = 0; i <= lore.size() - 1; i++) {
lore.set(i, color(lore.get(i)));
2018-03-26 23:43:15 +02:00
}
return lore;
}
2014-04-04 20:55:21 +02:00
// Get a list of all faction tags (names)
public Set<String> getFactionTags() {
return Factions.getInstance().getFactionTags();
2014-04-04 20:55:21 +02:00
}
// Get a list of all players in the specified faction
public Set<String> getPlayersInFaction(String factionTag) {
2017-12-19 11:18:13 +01:00
Set<String> players = new HashSet<>();
Faction faction = Factions.getInstance().getByTag(factionTag);
2014-04-04 20:55:21 +02:00
if (faction != null) {
for (FPlayer fplayer : faction.getFPlayers()) {
players.add(fplayer.getName());
}
2014-07-01 22:10:18 +02:00
}
return players;
2014-04-04 20:55:21 +02:00
}
// Get a list of all online players in the specified faction
public Set<String> getOnlinePlayersInFaction(String factionTag) {
2017-12-19 11:18:13 +01:00
Set<String> players = new HashSet<>();
Faction faction = Factions.getInstance().getByTag(factionTag);
2014-04-04 20:55:21 +02:00
if (faction != null) {
for (FPlayer fplayer : faction.getFPlayersWhereOnline(true)) {
players.add(fplayer.getName());
}
2014-07-01 22:10:18 +02:00
}
return players;
2014-04-04 20:55:21 +02:00
}
public boolean isHookedPlayervaults() {
return hookedPlayervaults;
}
public String getPrimaryGroup(OfflinePlayer player) {
return perms == null || !perms.hasGroupSupport() ? " " : perms.getPrimaryGroup(Bukkit.getWorlds().get(0).toString(), player);
}
public void debug(Level level, String s) {
if (getConfig().getBoolean("debug", false)) {
getLogger().log(level, s);
}
}
public void debug(String s) {
debug(Level.INFO, s);
}
}