693 lines
29 KiB
Java
693 lines
29 KiB
Java
/*
|
|
* To change this template, choose Tools | Templates
|
|
* and open the template in the editor.
|
|
*/
|
|
package org.anjocaido.groupmanager.dataholder.worlds;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.anjocaido.groupmanager.GroupManager;
|
|
import org.anjocaido.groupmanager.dataholder.OverloadedWorldHolder;
|
|
import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
|
|
import org.anjocaido.groupmanager.permissions.AnjoPermissionsHandler;
|
|
import org.anjocaido.groupmanager.utils.Tasks;
|
|
import org.bukkit.World;
|
|
import org.bukkit.entity.Player;
|
|
|
|
/**
|
|
*
|
|
* @author gabrielcouto
|
|
*/
|
|
public class WorldsHolder {
|
|
/**
|
|
* Map with instances of loaded worlds.
|
|
*/
|
|
private Map<String, OverloadedWorldHolder> worldsData = new HashMap<String, OverloadedWorldHolder>();
|
|
/**
|
|
* Map of mirrors: <nonExistingWorldName, existingAndLoadedWorldName>
|
|
* The key is the mirror.
|
|
* The object is the mirrored.
|
|
*
|
|
* Mirror shows the same data of mirrored.
|
|
*/
|
|
private Map<String, String> mirrorsGroup = new HashMap<String, String>();
|
|
private Map<String, String> mirrorsUser = new HashMap<String, String>();
|
|
private String serverDefaultWorldName;
|
|
private final GroupManager plugin;
|
|
private File worldsFolder;
|
|
|
|
/**
|
|
*
|
|
* @param plugin
|
|
*/
|
|
public WorldsHolder(final GroupManager plugin) {
|
|
this.plugin = plugin;
|
|
resetWorldsHolder();
|
|
}
|
|
|
|
/**
|
|
* Returns all physically loaded worlds which have at least one of their own
|
|
* data sets for users or groups which isn't an identical mirror.
|
|
*
|
|
* @return ArrayList<OverloadedWorldHolder> of all loaded worlds
|
|
*/
|
|
public ArrayList<OverloadedWorldHolder> allWorldsDataList() {
|
|
final ArrayList<OverloadedWorldHolder> list = new ArrayList<OverloadedWorldHolder>();
|
|
for (final String world : worldsData.keySet()) {
|
|
if (!world.equalsIgnoreCase("all_unnamed_worlds")) {
|
|
// Fetch the relevant world object
|
|
OverloadedWorldHolder data = getWorldData(world);
|
|
if (!list.contains(data)) {
|
|
final String worldNameLowered = data.getName().toLowerCase();
|
|
final String usersMirror = mirrorsUser.get(worldNameLowered);
|
|
final String groupsMirror = mirrorsGroup.get(worldNameLowered);
|
|
// is users mirrored?
|
|
if (usersMirror != null) {
|
|
// If both are mirrored
|
|
if (groupsMirror != null) {
|
|
// if the data sources are the same, return the parent
|
|
if (usersMirror == groupsMirror) {
|
|
data = getWorldData(usersMirror.toLowerCase());
|
|
// Only add the parent if it's not already listed.
|
|
if (!list.contains(data))
|
|
list.add(data);
|
|
continue;
|
|
}
|
|
// Both data sources are mirrors, but they are from different parents
|
|
// so fall through to add the actual data object.
|
|
}
|
|
// Groups isn't a mirror so fall through to add this this worlds data source
|
|
}
|
|
// users isn't mirrored so we need to add this worlds data source
|
|
list.add(data);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Copies the specified world data to another world
|
|
*
|
|
* @param fromWorld
|
|
* @param toWorld
|
|
* @return true if successfully copied.
|
|
*/
|
|
public boolean cloneWorld(final String fromWorld, final String toWorld) {
|
|
final File fromWorldFolder = new File(worldsFolder, fromWorld.toLowerCase());
|
|
final File toWorldFolder = new File(worldsFolder, toWorld.toLowerCase());
|
|
if (toWorldFolder.exists() || !fromWorldFolder.exists()) {
|
|
return false;
|
|
}
|
|
final File fromWorldGroups = new File(fromWorldFolder, "groups.yml");
|
|
final File fromWorldUsers = new File(fromWorldFolder, "users.yml");
|
|
if (!fromWorldGroups.exists() || !fromWorldUsers.exists()) {
|
|
return false;
|
|
}
|
|
final File toWorldGroups = new File(toWorldFolder, "groups.yml");
|
|
final File toWorldUsers = new File(toWorldFolder, "users.yml");
|
|
toWorldFolder.mkdirs();
|
|
try {
|
|
Tasks.copy(fromWorldGroups, toWorldGroups);
|
|
Tasks.copy(fromWorldUsers, toWorldUsers);
|
|
} catch (final IOException ex) {
|
|
Logger.getLogger(WorldsHolder.class.getName()).log(Level.SEVERE, null, ex);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return the defaultWorld
|
|
*/
|
|
public OverloadedWorldHolder getDefaultWorld() {
|
|
return getUpdatedWorldData(serverDefaultWorldName);
|
|
}
|
|
|
|
/**
|
|
* @return the mirrorsGroup
|
|
*/
|
|
public Map<String, String> getMirrorsGroup() {
|
|
return mirrorsGroup;
|
|
}
|
|
|
|
/**
|
|
* @return the mirrorsUser
|
|
*/
|
|
public Map<String, String> getMirrorsUser() {
|
|
return mirrorsUser;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the field player.getWorld().getName() and do
|
|
* getWorld(worldName)
|
|
*
|
|
* @param player
|
|
* @return OverloadedWorldHolder
|
|
*/
|
|
public OverloadedWorldHolder getWorldData(final Player player) {
|
|
return getWorldData(player.getWorld().getName());
|
|
}
|
|
|
|
/**
|
|
* Returns the dataHolder for the given world.
|
|
* If the world is not on the worlds list, returns the default world
|
|
* holder.
|
|
*
|
|
* Mirrors return their parent world data.
|
|
* If no mirroring data it returns the default world.
|
|
*
|
|
* @param worldName
|
|
* @return OverloadedWorldHolder
|
|
*/
|
|
public OverloadedWorldHolder getWorldData(final String worldName) {
|
|
final String worldNameLowered = worldName.toLowerCase();
|
|
// Find this worlds data
|
|
if (worldsData.containsKey(worldNameLowered))
|
|
return getUpdatedWorldData(worldNameLowered);
|
|
// Oddly no data source was found for this world so attempt to return the global mirror.
|
|
if (worldsData.containsKey("all_unnamed_worlds")) {
|
|
GroupManager.logger.finest("加载世界 " + worldName + " 时未找到或配置错误. 返回 all_unnamed_worlds 配置...");
|
|
return getUpdatedWorldData("all_unnamed_worlds");
|
|
}
|
|
// Oddly no data source or global mirror was found for this world so return the default.
|
|
GroupManager.logger.finest("加载世界 " + worldName + " 时未找到或配置错误. 返回默认世界...");
|
|
return getDefaultWorld();
|
|
}
|
|
|
|
/**
|
|
* Do a matching of playerName, if its found only one player, do
|
|
* getWorldData(player)
|
|
*
|
|
* @param playerName
|
|
* @return null if matching returned no player, or more than one.
|
|
*/
|
|
public OverloadedWorldHolder getWorldDataByPlayerName(final String playerName) {
|
|
final List<Player> matchPlayer = plugin.getServer().matchPlayer(playerName);
|
|
if (matchPlayer.size() == 1) {
|
|
return getWorldData(matchPlayer.get(0));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the PermissionsHandler for this player data
|
|
*
|
|
* @param player
|
|
* @return AnjoPermissionsHandler
|
|
*/
|
|
public AnjoPermissionsHandler getWorldPermissions(final Player player) {
|
|
return getWorldData(player).getPermissionsHandler();
|
|
}
|
|
|
|
/**
|
|
* It does getWorld(worldName).getPermissionsHandler()
|
|
*
|
|
* @param worldName
|
|
* @return AnjoPermissionsHandler
|
|
*/
|
|
public AnjoPermissionsHandler getWorldPermissions(final String worldName) {
|
|
return getWorldData(worldName).getPermissionsHandler();
|
|
}
|
|
|
|
/**
|
|
* Id does getWorldDataByPlayerName(playerName).
|
|
* If it doesnt return null, it will return result.getPermissionsHandler()
|
|
*
|
|
* @param playerName
|
|
* @return null if the player matching gone wrong.
|
|
*/
|
|
public AnjoPermissionsHandler getWorldPermissionsByPlayerName(final String playerName) {
|
|
final WorldDataHolder dh = getWorldDataByPlayerName(playerName);
|
|
if (dh != null) {
|
|
return dh.getPermissionsHandler();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Verify if world has it's own file permissions.
|
|
*
|
|
* @param worldName
|
|
* @return true if it has its own holder. false if not.
|
|
*/
|
|
public boolean hasOwnData(final String worldName) {
|
|
if (worldsData.containsKey(worldName.toLowerCase()) && (!mirrorsGroup.containsKey(worldName.toLowerCase()) || !mirrorsUser.containsKey(worldName.toLowerCase()))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Tells if the such world has been mapped.
|
|
*
|
|
* It will return true if world is a mirror.
|
|
*
|
|
* @param worldName
|
|
* @return true if world is loaded or mirrored. false if not listed
|
|
*/
|
|
public boolean isInList(final String worldName) {
|
|
if (worldsData.containsKey(worldName.toLowerCase()) || mirrorsGroup.containsKey(worldName.toLowerCase()) || mirrorsUser.containsKey(worldName.toLowerCase())) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isWorldKnown(final String name) {
|
|
return worldsData.containsKey(name.toLowerCase());
|
|
}
|
|
|
|
/**
|
|
* Wrapper for LoadWorld(String,Boolean) for backwards compatibility
|
|
*
|
|
* Load a world from file.
|
|
* If it already been loaded, summon reload method from dataHolder.
|
|
*
|
|
* @param worldName
|
|
*/
|
|
public void loadWorld(final String worldName) {
|
|
loadWorld(worldName, false);
|
|
}
|
|
|
|
/**
|
|
* Load a world from file.
|
|
* If it already been loaded, summon reload method from dataHolder.
|
|
*
|
|
* @param worldName
|
|
*/
|
|
public void loadWorld(final String worldName, final Boolean isMirror) {
|
|
final String worldNameLowered = worldName.toLowerCase();
|
|
if (worldsData.containsKey(worldNameLowered)) {
|
|
worldsData.get(worldNameLowered).reload();
|
|
return;
|
|
}
|
|
GroupManager.logger.finest("Trying to load world " + worldName + "...");
|
|
final File thisWorldFolder = new File(worldsFolder, worldNameLowered);
|
|
if ((isMirror) || (thisWorldFolder.exists() && thisWorldFolder.isDirectory())) {
|
|
// Setup file handles, if not mirrored
|
|
final File groupsFile = (mirrorsGroup.containsKey(worldNameLowered)) ? null : new File(thisWorldFolder, "groups.yml");
|
|
final File usersFile = (mirrorsUser.containsKey(worldNameLowered)) ? null : new File(thisWorldFolder, "users.yml");
|
|
if ((groupsFile != null) && (!groupsFile.exists())) {
|
|
throw new IllegalArgumentException("世界 '" + worldName + "' 的组配置文件未找到: " + groupsFile.getPath());
|
|
}
|
|
if ((usersFile != null) && (!usersFile.exists())) {
|
|
throw new IllegalArgumentException("世界 '" + worldName + "' 的用户配置文件未找到: " + usersFile.getPath());
|
|
}
|
|
WorldDataHolder tempHolder = new WorldDataHolder(worldNameLowered);
|
|
// Map the group object for any mirror
|
|
if (mirrorsGroup.containsKey(worldNameLowered))
|
|
tempHolder.setGroupsObject(this.getWorldData(mirrorsGroup.get(worldNameLowered)).getGroupsObject());
|
|
else
|
|
tempHolder.loadGroups(groupsFile);
|
|
// Map the user object for any mirror
|
|
if (mirrorsUser.containsKey(worldNameLowered))
|
|
tempHolder.setUsersObject(this.getWorldData(mirrorsUser.get(worldNameLowered)).getUsersObject());
|
|
else
|
|
tempHolder.loadUsers(usersFile);
|
|
final OverloadedWorldHolder thisWorldData = new OverloadedWorldHolder(tempHolder);
|
|
// null the object so we don't keep file handles open where we shouldn't
|
|
tempHolder = null;
|
|
// Set the file TimeStamps as it will be default from the initial load.
|
|
thisWorldData.setTimeStamps();
|
|
if (thisWorldData != null) {
|
|
GroupManager.logger.finest("成功载入世界 " + worldName + "...");
|
|
worldsData.put(worldNameLowered, thisWorldData);
|
|
return;
|
|
}
|
|
// GroupManager.logger.severe("Failed to load world " + worldName + "...");
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
public void mirrorSetUp() {
|
|
mirrorsGroup.clear();
|
|
mirrorsUser.clear();
|
|
final Map<String, Object> mirrorsMap = plugin.getGMConfig().getMirrorsMap();
|
|
final HashSet<String> mirroredWorlds = new HashSet<String>();
|
|
if (mirrorsMap != null) {
|
|
for (final String source : mirrorsMap.keySet()) {
|
|
// Make sure all non mirrored worlds have a set of data files.
|
|
setupWorldFolder(source);
|
|
// Load the world data
|
|
if (!worldsData.containsKey(source.toLowerCase()))
|
|
loadWorld(source);
|
|
if (mirrorsMap.get(source) instanceof ArrayList) {
|
|
final ArrayList mirrorList = (ArrayList) mirrorsMap.get(source);
|
|
// These worlds fully mirror their parent
|
|
for (final Object o : mirrorList) {
|
|
final String world = o.toString().toLowerCase();
|
|
if (!world.equalsIgnoreCase(serverDefaultWorldName)) {
|
|
try {
|
|
mirrorsGroup.remove(world);
|
|
mirrorsUser.remove(world);
|
|
} catch (final Exception e) {
|
|
}
|
|
mirrorsGroup.put(world, getWorldData(source).getName());
|
|
mirrorsUser.put(world, getWorldData(source).getName());
|
|
// Track this world so we can create a datasource for it later
|
|
mirroredWorlds.add(o.toString());
|
|
} else
|
|
GroupManager.logger.log(Level.WARNING, "镜像错误 " + o.toString() + ". 检测到递归循环!");
|
|
}
|
|
} else if (mirrorsMap.get(source) instanceof Map) {
|
|
final Map subSection = (Map) mirrorsMap.get(source);
|
|
for (final Object key : subSection.keySet()) {
|
|
if (!((String) key).equalsIgnoreCase(serverDefaultWorldName)) {
|
|
if (subSection.get(key) instanceof ArrayList) {
|
|
final ArrayList mirrorList = (ArrayList) subSection.get(key);
|
|
// These worlds have defined mirroring
|
|
for (final Object o : mirrorList) {
|
|
final String type = o.toString().toLowerCase();
|
|
try {
|
|
if (type.equals("groups"))
|
|
mirrorsGroup.remove(((String) key).toLowerCase());
|
|
if (type.equals("users"))
|
|
mirrorsUser.remove(((String) key).toLowerCase());
|
|
} catch (final Exception e) {
|
|
}
|
|
if (type.equals("groups")) {
|
|
mirrorsGroup.put(((String) key).toLowerCase(), getWorldData(source).getName());
|
|
GroupManager.logger.log(Level.FINE, "添加组镜像 " + key + ".");
|
|
}
|
|
if (type.equals("users")) {
|
|
mirrorsUser.put(((String) key).toLowerCase(), getWorldData(source).getName());
|
|
GroupManager.logger.log(Level.FINE, "添加用户镜像 " + key + ".");
|
|
}
|
|
}
|
|
// Track this world so we can create a datasource for it later
|
|
mirroredWorlds.add((String) key);
|
|
} else
|
|
throw new IllegalStateException("位置的镜像格式 " + (String) key);
|
|
} else {
|
|
GroupManager.logger.log(Level.WARNING, "镜像错误 " + (String) key + ". 检测到递归循环!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Create a datasource for any worlds not already loaded
|
|
for (final String world : mirroredWorlds) {
|
|
if (!worldsData.containsKey(world.toLowerCase())) {
|
|
GroupManager.logger.log(Level.FINE, "世界 " + world + " 没有数据.");
|
|
setupWorldFolder(world);
|
|
loadWorld(world, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public void reloadAll() {
|
|
// Load global groups
|
|
GroupManager.getGlobalGroups().load();
|
|
final ArrayList<WorldDataHolder> alreadyDone = new ArrayList<WorldDataHolder>();
|
|
for (final WorldDataHolder w : worldsData.values()) {
|
|
if (alreadyDone.contains(w)) {
|
|
continue;
|
|
}
|
|
if (!mirrorsGroup.containsKey(w.getName().toLowerCase()))
|
|
w.reloadGroups();
|
|
if (!mirrorsUser.containsKey(w.getName().toLowerCase()))
|
|
w.reloadUsers();
|
|
alreadyDone.add(w);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param worldName
|
|
*/
|
|
public void reloadWorld(final String worldName) {
|
|
if (!mirrorsGroup.containsKey(worldName.toLowerCase()))
|
|
getWorldData(worldName).reloadGroups();
|
|
if (!mirrorsUser.containsKey(worldName.toLowerCase()))
|
|
getWorldData(worldName).reloadUsers();
|
|
}
|
|
|
|
public void resetWorldsHolder() {
|
|
worldsData = new HashMap<String, OverloadedWorldHolder>();
|
|
mirrorsGroup = new HashMap<String, String>();
|
|
mirrorsUser = new HashMap<String, String>();
|
|
// Setup folders and check files exist for the primary world
|
|
verifyFirstRun();
|
|
initialLoad();
|
|
if (serverDefaultWorldName == null)
|
|
throw new IllegalStateException("当前没有默认组! OMG!");
|
|
}
|
|
|
|
/**
|
|
* Wrapper to retain backwards compatibility
|
|
* (call this function to auto overwrite files)
|
|
*/
|
|
public void saveChanges() {
|
|
saveChanges(true);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public boolean saveChanges(final boolean overwrite) {
|
|
boolean changed = false;
|
|
final ArrayList<WorldDataHolder> alreadyDone = new ArrayList<WorldDataHolder>();
|
|
Tasks.removeOldFiles(plugin, plugin.getBackupFolder());
|
|
// Write Global Groups
|
|
if (GroupManager.getGlobalGroups().haveGroupsChanged()) {
|
|
GroupManager.getGlobalGroups().writeGroups(overwrite);
|
|
} else {
|
|
if (GroupManager.getGlobalGroups().getTimeStampGroups() < GroupManager.getGlobalGroups().getGlobalGroupsFile().lastModified()) {
|
|
System.out.print("发现新的全局组配置 (载入数据)!");
|
|
GroupManager.getGlobalGroups().load();
|
|
}
|
|
}
|
|
for (final OverloadedWorldHolder w : worldsData.values()) {
|
|
if (alreadyDone.contains(w)) {
|
|
continue;
|
|
}
|
|
if (w == null) {
|
|
GroupManager.logger.severe("发生了什么!?");
|
|
continue;
|
|
}
|
|
if (!mirrorsGroup.containsKey(w.getName().toLowerCase()))
|
|
if (w.haveGroupsChanged()) {
|
|
if (overwrite || (!overwrite && (w.getTimeStampGroups() >= w.getGroupsFile().lastModified()))) {
|
|
// Backup Groups file
|
|
backupFile(w, true);
|
|
WorldDataHolder.writeGroups(w, w.getGroupsFile());
|
|
changed = true;
|
|
// w.removeGroupsChangedFlag();
|
|
} else {
|
|
// Newer file found.
|
|
GroupManager.logger.log(Level.WARNING, "Newer Groups file found for " + w.getName() + ", but we have local changes!");
|
|
throw new IllegalStateException("Unable to save unless you issue a '/mansave force'");
|
|
}
|
|
} else {
|
|
// Check for newer file as no local changes.
|
|
if (w.getTimeStampGroups() < w.getGroupsFile().lastModified()) {
|
|
System.out.print("发现新的组配置 (载入数据)!");
|
|
// Backup Groups file
|
|
backupFile(w, true);
|
|
w.reloadGroups();
|
|
changed = true;
|
|
}
|
|
}
|
|
if (!mirrorsUser.containsKey(w.getName().toLowerCase()))
|
|
if (w.haveUsersChanged()) {
|
|
if (overwrite || (!overwrite && (w.getTimeStampUsers() >= w.getUsersFile().lastModified()))) {
|
|
// Backup Users file
|
|
backupFile(w, false);
|
|
WorldDataHolder.writeUsers(w, w.getUsersFile());
|
|
changed = true;
|
|
// w.removeUsersChangedFlag();
|
|
} else {
|
|
// Newer file found.
|
|
GroupManager.logger.log(Level.WARNING, "Newer Users file found for " + w.getName() + ", but we have local changes!");
|
|
throw new IllegalStateException("Unable to save unless you issue a '/mansave force'");
|
|
}
|
|
} else {
|
|
// Check for newer file as no local changes.
|
|
if (w.getTimeStampUsers() < w.getUsersFile().lastModified()) {
|
|
System.out.print("发现新的用户配置 (载入数据)!");
|
|
// Backup Users file
|
|
backupFile(w, false);
|
|
w.reloadUsers();
|
|
changed = true;
|
|
}
|
|
}
|
|
alreadyDone.add(w);
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
public void setupWorldFolder(final String worldName) {
|
|
final String worldNameLowered = worldName.toLowerCase();
|
|
worldsFolder = new File(plugin.getDataFolder(), "worlds");
|
|
if (!worldsFolder.exists()) {
|
|
worldsFolder.mkdirs();
|
|
}
|
|
final File defaultWorldFolder = new File(worldsFolder, worldNameLowered);
|
|
if ((!defaultWorldFolder.exists()) && ((!mirrorsGroup.containsKey(worldNameLowered))) || (!mirrorsUser.containsKey(worldNameLowered))) {
|
|
/*
|
|
* check and convert all old case sensitive folders to lower case
|
|
*/
|
|
final File casedWorldFolder = new File(worldsFolder, worldName);
|
|
if ((casedWorldFolder.exists()) && (casedWorldFolder.getName().toLowerCase().equals(worldNameLowered))) {
|
|
/*
|
|
* Rename the old folder to the new lower cased format
|
|
*/
|
|
casedWorldFolder.renameTo(new File(worldsFolder, worldNameLowered));
|
|
} else {
|
|
/*
|
|
* Else we just create the folder
|
|
*/
|
|
defaultWorldFolder.mkdirs();
|
|
}
|
|
}
|
|
if (defaultWorldFolder.exists()) {
|
|
if (!mirrorsGroup.containsKey(worldNameLowered)) {
|
|
final File groupsFile = new File(defaultWorldFolder, "groups.yml");
|
|
if (!groupsFile.exists() || groupsFile.length() == 0) {
|
|
final InputStream template = plugin.getResourceAsStream("groups.yml");
|
|
try {
|
|
Tasks.copy(template, groupsFile);
|
|
} catch (final IOException ex) {
|
|
GroupManager.logger.log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
}
|
|
if (!mirrorsUser.containsKey(worldNameLowered)) {
|
|
final File usersFile = new File(defaultWorldFolder, "users.yml");
|
|
if (!usersFile.exists() || usersFile.length() == 0) {
|
|
final InputStream template = plugin.getResourceAsStream("users.yml");
|
|
try {
|
|
Tasks.copy(template, usersFile);
|
|
} catch (final IOException ex) {
|
|
GroupManager.logger.log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Backup the Groups/Users file
|
|
*
|
|
* @param w
|
|
* @param groups
|
|
*/
|
|
private void backupFile(final OverloadedWorldHolder w, final Boolean groups) {
|
|
final File backupFile = new File(plugin.getBackupFolder(), "bkp_" + w.getName() + (groups ? "_g_" : "_u_") + Tasks.getDateString() + ".yml");
|
|
try {
|
|
Tasks.copy((groups ? w.getGroupsFile() : w.getUsersFile()), backupFile);
|
|
} catch (final IOException ex) {
|
|
GroupManager.logger.log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the requested world data and update it's dataSource to be relevant
|
|
* for this world
|
|
*
|
|
* @param worldName
|
|
* @return updated world holder
|
|
*/
|
|
private OverloadedWorldHolder getUpdatedWorldData(final String worldName) {
|
|
final String worldNameLowered = worldName.toLowerCase();
|
|
if (worldsData.containsKey(worldNameLowered)) {
|
|
final OverloadedWorldHolder data = worldsData.get(worldNameLowered);
|
|
data.updateDataSource();
|
|
return data;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void initialLoad() {
|
|
// load the initial world
|
|
initialWorldLoading();
|
|
// Configure and load any mirrors and additional worlds as defined in config.yml
|
|
mirrorSetUp();
|
|
// search the worlds folder for any manually created worlds (not listed in config.yml)
|
|
loadAllSearchedWorlds();
|
|
}
|
|
|
|
private void initialWorldLoading() {
|
|
// Load the default world
|
|
loadWorld(serverDefaultWorldName);
|
|
// defaultWorld = getUpdatedWorldData(serverDefaultWorldName);
|
|
}
|
|
|
|
private void loadAllSearchedWorlds() {
|
|
/*
|
|
* Read all known worlds from Bukkit Create the data files if they don't
|
|
* already exist, and they are not mirrored.
|
|
*/
|
|
for (final World world : plugin.getServer().getWorlds()) {
|
|
GroupManager.logger.log(Level.FINE, "检查世界 " + world.getName() + " 的数据.");
|
|
if ((!worldsData.containsKey(world.getName().toLowerCase())) && ((!mirrorsGroup.containsKey(world.getName().toLowerCase())) || (!mirrorsUser.containsKey(world.getName().toLowerCase())))) {
|
|
if (worldsData.containsKey("all_unnamed_worlds")) {
|
|
final String usersMirror = mirrorsUser.get("all_unnamed_worlds");
|
|
final String groupsMirror = mirrorsGroup.get("all_unnamed_worlds");
|
|
if (usersMirror != null)
|
|
mirrorsUser.put(world.getName().toLowerCase(), usersMirror);
|
|
if (groupsMirror != null)
|
|
mirrorsGroup.put(world.getName().toLowerCase(), groupsMirror);
|
|
}
|
|
GroupManager.logger.log(Level.FINE, "创建世界 " + world.getName() + " 的数据.");
|
|
setupWorldFolder(world.getName());
|
|
}
|
|
}
|
|
/*
|
|
* Loop over all folders within the worlds folder and attempt to load
|
|
* the world data
|
|
*/
|
|
for (final File folder : worldsFolder.listFiles()) {
|
|
if (folder.isDirectory() && !folder.getName().startsWith(".")) {
|
|
GroupManager.logger.info("载入世界数据: " + folder.getName());
|
|
/*
|
|
* don't load any worlds which are already loaded or fully
|
|
* mirrored worlds that don't need data.
|
|
*/
|
|
if (!worldsData.containsKey(folder.getName().toLowerCase()) && ((!mirrorsGroup.containsKey(folder.getName().toLowerCase())) || (!mirrorsUser.containsKey(folder.getName().toLowerCase())))) {
|
|
/*
|
|
* Call setupWorldFolder to check case sensitivity and
|
|
* convert to lower case, before we attempt to load this
|
|
* world.
|
|
*/
|
|
setupWorldFolder(folder.getName());
|
|
loadWorld(folder.getName().toLowerCase());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void verifyFirstRun() {
|
|
/*
|
|
* Do not use the folder name if this
|
|
* is a Bukkit Forge server.
|
|
*/
|
|
if (plugin.getServer().getName().equalsIgnoreCase("BukkitForge")) {
|
|
serverDefaultWorldName = "overworld";
|
|
} else {
|
|
final Properties server = new Properties();
|
|
try {
|
|
server.load(new FileInputStream(new File("server.properties")));
|
|
serverDefaultWorldName = server.getProperty("level-name").toLowerCase();
|
|
} catch (final IOException ex) {
|
|
GroupManager.logger.log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
setupWorldFolder(serverDefaultWorldName);
|
|
}
|
|
}
|