public void generateTopTen(final CommandSender sender) {
List<IslandLevel> topTen = new ArrayList<>();
final File folder = directoryIslands;
final String[] listOfFiles = folder.list(FileUtil.createIslandFilenameFilter());
for (String file : listOfFiles) {
String islandName = FileUtil.getBasename(file);
try {
boolean wasLoaded = islands.containsKey(islandName);
IslandInfo islandInfo = getIslandInfo(islandName);
double level = islandInfo != null ? islandInfo.getLevel() : 0;
if (islandInfo != null && level > 10) {
IslandLevel islandLevel = createIslandLevel(islandInfo, level);
topTen.add(islandLevel);
}
if (!wasLoaded) {
islands.remove(islandName);
}
} catch (Exception e) {
plugin.getLogger().log(Level.WARNING, "Error during rank generation", e);
}
}
Collections.sort(topTen);
synchronized (ranks) {
lastGenerate = System.currentTimeMillis();
ranks.clear();
ranks.addAll(topTen);
}
plugin.fireChangeEvent(sender, uSkyBlockEvent.Cause.RANK_UPDATED);
}
/**
* Comparing part of a player name with all players
*
* @param partName
* @return
*/
public String getFullPlayerName(PlayerInfo pi, String partName) {
int amount = 0;
String pName = "";
for (Player p : this.getServer().getOnlinePlayers()) {
if (p.getName().toLowerCase().startsWith(partName.toLowerCase())) {
amount++;
pName = p.getName();
}
}
if (amount == 1) return pName;
else if (amount > 1) return "0";
for (IslandInfo ii : pi.getBuiltPermissionList().values()) {
if (ii.getIslandOwner().toLowerCase().startsWith(partName.toLowerCase())) {
if (ii.containsFriend(pi.getPlayerName())) {
amount++;
pName = ii.getIslandOwner();
}
}
}
if (amount == 1) return pName;
else if (amount > 1) return "0";
return "-1";
}
public String getOwner(int islandNumber) {
IslandInfo ii = this.settings.getIslandInfo(islandNumber);
if (ii == null) {
return "";
}
return ii.getIslandOwner();
}
public void renamePlayer(String islandName, PlayerNameChangedEvent e) {
IslandInfo islandInfo = getIslandInfo(islandName);
if (islandInfo != null) {
islandInfo.renamePlayer(e.getPlayer(), e.getOldName());
if (!islandInfo.hasOnlineMembers()) {
removeIslandFromMemory(islandInfo.getName());
}
}
}
private IslandLevel createIslandLevel(IslandInfo islandInfo, double level) {
String partyLeader = islandInfo.getLeader();
String partyLeaderName = PlayerUtil.getPlayerDisplayName(partyLeader);
List<String> memberList = new ArrayList<>(islandInfo.getMembers());
memberList.remove(partyLeader);
List<String> names = new ArrayList<>();
for (String name : memberList) {
String displayName = PlayerUtil.getPlayerDisplayName(name);
if (displayName != null) {
names.add(displayName);
}
}
return new IslandLevel(islandInfo.getName(), partyLeaderName, names, level);
}
public void saveIslandInfo(IslandInfo ii) {
YamlConfiguration yamlIslandInfo = new YamlConfiguration();
File filePlayerInfo = new File(this.directoryIslands, ii.getIslandNumber() + ".yml");
yamlIslandInfo.set(EnumIslandConfig.ISLAND_OWNER.getPath(), ii.getIslandOwner());
yamlIslandInfo.set(
EnumIslandConfig.ISLAND_LOCATION.getPath(),
LocationParser.getStringFromLocation(ii.getIslandLocation()));
yamlIslandInfo.set(
EnumIslandConfig.HOME_LOCATION.getPath(),
LocationParser.getStringFromLocation(ii.getHomeLocation()));
yamlIslandInfo.set(EnumIslandConfig.FRIENDS.getPath(), ii.getFriends());
try {
yamlIslandInfo.save(filePlayerInfo);
} catch (IOException e) {
e.printStackTrace();
}
}
public Location getSafeHomeLocation(IslandInfo ii) {
// a) check original location
Location home = ii.getHomeLocation();
if (this.isSafeLocation(home)) {
return home;
}
// b) check if a suitable y exists on this x and z
for (int y = home.getBlockY(); y > 0; y--) {
Location n = new Location(home.getWorld(), home.getBlockX(), y, home.getBlockZ());
if (this.isSafeLocation(n)) {
return n;
}
}
for (int y = home.getBlockY(); y < 255; y++) {
Location n = new Location(home.getWorld(), home.getBlockX(), y, home.getBlockZ());
if (this.isSafeLocation(n)) {
return n;
}
}
// c) check island Location
Location island = ii.getIslandLocation();
if (this.isSafeLocation(island)) {
return island;
}
for (int y = island.getBlockY(); y > 0; y--) {
Location n = new Location(island.getWorld(), island.getBlockX(), y, island.getBlockZ());
if (this.isSafeLocation(n)) {
return n;
}
}
for (int y = island.getBlockY(); y < 255; y++) {
Location n = new Location(island.getWorld(), island.getBlockX(), y, island.getBlockZ());
if (this.isSafeLocation(n)) {
return n;
}
}
return null;
}
public void loadIslandFiles() {
ArrayList<String> playersInSkb = new ArrayList<String>();
for (Player player : this.skyBlockWorld.getPlayers()) {
playersInSkb.add(player.getName());
}
for (String f : new File(this.directoryIslands.getAbsolutePath()).list()) {
if (new File(this.directoryIslands, f).isFile()) {
IslandInfo ii = null;
try {
ii = this.loadIslandInfo(f);
} catch (Exception e) {
e.printStackTrace();
continue;
}
if (ii != null) {
if (ii.isFreeBuild()) {
settings.addIslandInfo(ii);
continue;
}
// check if a player for this island (owner or friend is online)
boolean foundPlayer = false;
if (playersInSkb.contains(ii.getIslandOwner())) {
foundPlayer = true;
} else {
for (String friend : ii.getFriends()) {
if (playersInSkb.contains(friend)) {
foundPlayer = true;
break;
}
}
}
if (foundPlayer) settings.addIslandInfo(ii);
}
}
}
}
public synchronized IslandInfo createIsland(String location, String player) {
IslandInfo info = getIslandInfo(location);
info.clearIslandConfig(player);
return info;
}
@SuppressWarnings("unchecked")
public PlayerInfo loadPlayerInfo(String playerName) {
YamlConfiguration yamlPlayerInfo = new YamlConfiguration();
File filePlayerInfo = new File(this.directoryPlayers, playerName + ".yml");
if (!filePlayerInfo.exists()) {
return null;
}
try {
yamlPlayerInfo.load(filePlayerInfo);
} catch (Exception e) {
e.printStackTrace();
return null;
}
PlayerInfo pi = new PlayerInfo(playerName);
// Find own Island
int ownsIslandNr = -1;
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_NUMBER.getPath())) {
ownsIslandNr = yamlPlayerInfo.getInt(EnumPlayerConfig.ISLAND_NUMBER.getPath());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_NUMBER.getPath(), ownsIslandNr);
}
pi.setIslandInfo(settings.getIslandInfo(ownsIslandNr));
// Check consistency
if (pi.getHasIsland() && !pi.getIslandInfo().isIslandOwner(playerName)) {
pi.setIslandInfo(null);
}
// Find Buildpermissions
// buildPermissions = new HashMap<Integer, IslandInfo>();
ArrayList<Integer> builtlist = new ArrayList<Integer>();
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_BUILTLIST.getPath())) {
builtlist =
(ArrayList<Integer>) yamlPlayerInfo.getList(EnumPlayerConfig.ISLAND_BUILTLIST.getPath());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_BUILTLIST.getPath(), builtlist);
}
// Go through buildlist with Islandnr to get IslandInfos
for (int islandnr : builtlist) {
IslandInfo friend = settings.getIslandInfo(islandnr);
if (friend != null && friend.containsFriend(playerName)) {
pi.addBuildPermission(islandnr, friend);
}
}
boolean isPlaying = false;
if (yamlPlayerInfo.contains(EnumPlayerConfig.IS_PLAYING.getPath())) {
isPlaying =
Boolean.parseBoolean(
yamlPlayerInfo.get(EnumPlayerConfig.IS_PLAYING.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.IS_PLAYING.getPath(), false);
}
pi.setIsPlaying(isPlaying);
boolean isDead = false;
if (yamlPlayerInfo.contains(EnumPlayerConfig.IS_DEAD.getPath())) {
isDead =
Boolean.parseBoolean(yamlPlayerInfo.get(EnumPlayerConfig.IS_DEAD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.IS_DEAD.getPath(), false);
}
pi.setDead(isDead);
int islandFood = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_FOOD.getPath())) {
islandFood =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_FOOD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_FOOD.getPath(), 20);
}
} catch (Exception e) {
}
pi.setIslandFood(islandFood);
int islandHealth = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_HEALTH.getPath())) {
islandHealth =
Integer.parseInt(
yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_HEALTH.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_HEALTH.getPath(), 20);
}
} catch (Exception e) {
}
pi.setIslandHealth(islandHealth);
int islandExp = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_EXP.getPath())) {
islandExp =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_EXP.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_EXP.getPath(), 0);
}
} catch (Exception e) {
}
pi.setIslandExp(islandExp);
int islandLevel = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_LEVEL.getPath())) {
islandLevel =
Integer.parseInt(
yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_LEVEL.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_LEVEL.getPath(), 0);
}
} catch (Exception e) {
}
pi.setIslandLevel(islandLevel);
ItemStack[] islandInventory = new ItemStack[36];
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_INVENTORY.getPath())) {
ArrayList<String> listIslandInventory =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_INVENTORY.getPath());
islandInventory = ItemParser.getItemStackArrayFromList(listIslandInventory, 36);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_INVENTORY.getPath(), new ArrayList<String>());
}
pi.setIslandInventory(islandInventory);
ItemStack[] islandArmor = new ItemStack[4];
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_ARMOR.getPath())) {
ArrayList<String> listIslandArmor =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_ARMOR.getPath());
islandArmor = ItemParser.getItemStackArrayFromList(listIslandArmor, 4);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_ARMOR.getPath(), new ArrayList<String>());
}
pi.setIslandArmor(islandArmor);
Location oldLocation = null;
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_LOCATION.getPath())) {
oldLocation =
LocationParser.parseStringToLocation(
yamlPlayerInfo.get(EnumPlayerConfig.OLD_LOCATION.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_LOCATION.getPath(), "");
}
pi.setOldLocation(oldLocation);
int oldFood = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_FOOD.getPath())) {
oldFood =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_FOOD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_FOOD.getPath(), 20);
}
} catch (Exception e) {
}
pi.setOldFood(oldFood);
int oldHealth = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_HEALTH.getPath())) {
oldHealth =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_HEALTH.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_HEALTH.getPath(), 20);
}
} catch (Exception e) {
}
pi.setOldHealth(oldHealth);
int oldExp = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_EXP.getPath())) {
oldExp =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_EXP.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_EXP.getPath(), 0);
}
} catch (Exception e) {
}
pi.setOldExp(oldExp);
int oldLevel = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_LEVEL.getPath())) {
oldLevel =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_LEVEL.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_LEVEL.getPath(), 0);
}
} catch (Exception e) {
}
pi.setOldLevel(oldLevel);
ItemStack[] oldInventory = new ItemStack[36];
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_INVENTORY.getPath())) {
ArrayList<String> listOldInventory =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.OLD_INVENTORY.getPath());
oldInventory = ItemParser.getItemStackArrayFromList(listOldInventory, 36);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_INVENTORY.getPath(), new ArrayList<String>());
}
pi.setOldInventory(oldInventory);
ItemStack[] oldArmor = new ItemStack[4];
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_ARMOR.getPath())) {
ArrayList<String> listOldArmor =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.OLD_ARMOR.getPath());
oldArmor = ItemParser.getItemStackArrayFromList(listOldArmor, 4);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_ARMOR.getPath(), new ArrayList<String>());
}
pi.setOldArmor(oldArmor);
try {
yamlPlayerInfo.save(filePlayerInfo);
} catch (IOException e) {
e.printStackTrace();
return null;
}
return pi;
}
@SuppressWarnings("unchecked")
public IslandInfo loadIslandInfo(String island) {
YamlConfiguration yamlIslandInfo = new YamlConfiguration();
File fileIslandInfo = new File(this.directoryIslands, island);
if (!fileIslandInfo.exists()) {
return null;
}
try {
yamlIslandInfo.load(fileIslandInfo);
} catch (Exception e) {
e.printStackTrace();
return null;
}
int islandNumber = Integer.parseInt(fileIslandInfo.getName().replace(".yml", ""));
IslandInfo ii = new IslandInfo(islandNumber);
String islandOwner = "";
if (yamlIslandInfo.contains(EnumIslandConfig.ISLAND_OWNER.getPath())) {
islandOwner = yamlIslandInfo.get(EnumIslandConfig.ISLAND_OWNER.getPath()).toString();
} else {
yamlIslandInfo.set(EnumIslandConfig.ISLAND_OWNER.getPath(), false);
}
ii.setIslandOwner(islandOwner);
Location islandLocation = null;
if (yamlIslandInfo.contains(EnumIslandConfig.ISLAND_LOCATION.getPath())) {
islandLocation =
LocationParser.parseStringToLocation(
yamlIslandInfo.get(EnumIslandConfig.ISLAND_LOCATION.getPath()).toString());
} else {
yamlIslandInfo.set(
EnumIslandConfig.ISLAND_LOCATION.getPath(),
LocationParser.getStringFromLocation(ii.getIslandLocation()));
}
ii.setIslandLocation(islandLocation);
Location homeLocation = null;
if (yamlIslandInfo.contains(EnumIslandConfig.HOME_LOCATION.getPath())) {
islandLocation =
LocationParser.parseStringToLocation(
yamlIslandInfo.get(EnumIslandConfig.HOME_LOCATION.getPath()).toString());
} else {
yamlIslandInfo.set(
EnumIslandConfig.HOME_LOCATION.getPath(),
LocationParser.getStringFromLocation(ii.getHomeLocation()));
}
ii.setHomeLocation(homeLocation);
ArrayList<String> friends = new ArrayList<String>();
if (yamlIslandInfo.contains(EnumIslandConfig.FRIENDS.getPath())) {
friends = (ArrayList<String>) yamlIslandInfo.get(EnumIslandConfig.FRIENDS.getPath());
} else {
yamlIslandInfo.set(EnumIslandConfig.FRIENDS.getPath(), ii.getFriends());
}
ii.setFriends(friends);
boolean freeBuild = false;
if (yamlIslandInfo.contains(EnumIslandConfig.FREE_BUILD.getPath())) {
freeBuild =
Boolean.parseBoolean(
yamlIslandInfo.get(EnumIslandConfig.FREE_BUILD.getPath()).toString());
} else {
yamlIslandInfo.set(EnumIslandConfig.FREE_BUILD.getPath(), ii.isFreeBuild());
}
ii.setFreeBuild(freeBuild);
try {
yamlIslandInfo.save(fileIslandInfo);
} catch (IOException e) {
e.printStackTrace();
return null;
}
return ii;
}
