public static DeviceEntry getDevice(String device) {
try {
if (props.containsKey(device)) return (DeviceEntry) props.get(device);
else {
File f =
new File(
OS.getWorkDir() + File.separator + "devices" + File.separator + device + ".ftd");
if (f.exists()) {
DeviceEntry ent = null;
JarFile jar = new JarFile(f);
Enumeration e = jar.entries();
while (e.hasMoreElements()) {
JarEntry file = (JarEntry) e.nextElement();
if (file.getName().endsWith(device + ".properties")) {
InputStream is = jar.getInputStream(file); // get the input stream
PropertiesFile p = new PropertiesFile();
p.load(is);
ent = new DeviceEntry(p);
}
}
return ent;
} else return null;
}
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
public static Warzone load(String name, boolean createNewVolume) {
// war.getLogger().info("Loading warzone " + name + " config and blocks...");
PropertiesFile warzoneConfig =
new PropertiesFile(War.war.getDataFolder().getPath() + "/warzone-" + name + ".txt");
try {
warzoneConfig.load();
} catch (IOException e) {
War.war.getLogger().info("Failed to load warzone-" + name + ".txt file.");
e.printStackTrace();
}
// world
String worldStr = warzoneConfig.getProperty("world");
World world = null;
if (worldStr == null || worldStr.equals("")) {
world = War.war.getServer().getWorlds().get(0); // default to first world
} else {
world = War.war.getServer().getWorld(worldStr);
}
if (world == null) {
War.war.log(
"Failed to restore warzone "
+ name
+ ". The specified world (name: "
+ worldStr
+ ") does not exist!",
Level.WARNING);
} else {
// Create the zone
Warzone warzone = new Warzone(world, name);
// Create file if needed
if (!warzoneConfig.containsKey("name")) {
WarzoneTxtMapper.save(warzone, false);
War.war.getLogger().info("Warzone " + name + " config file created.");
try {
warzoneConfig.load();
} catch (IOException e) {
// war.getLogger().info("Failed to reload warzone-" + name + ".txt file after creating
// it.");
e.printStackTrace();
}
}
// teleport
String teleportStr = warzoneConfig.getString("teleport");
if (teleportStr != null && !teleportStr.equals("")) {
String[] teleportSplit = teleportStr.split(",");
int teleX = Integer.parseInt(teleportSplit[0]);
int teleY = Integer.parseInt(teleportSplit[1]);
int teleZ = Integer.parseInt(teleportSplit[2]);
int yaw = Integer.parseInt(teleportSplit[3]);
warzone.setTeleport(new Location(world, teleX, teleY, teleZ, yaw, 0));
}
// ff
if (warzoneConfig.containsKey("friendlyFire")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.FRIENDLYFIRE, warzoneConfig.getBoolean("friendlyFire"));
}
// loadout
warzone.getDefaultInventories().getLoadouts().clear();
String loadoutStr = warzoneConfig.getString("loadout");
if (loadoutStr != null && !loadoutStr.equals("")) {
warzone
.getDefaultInventories()
.getLoadouts()
.put("default", new HashMap<Integer, ItemStack>());
LoadoutTxtMapper.fromStringToLoadout(
loadoutStr, warzone.getDefaultInventories().getLoadouts().get("default"));
}
// extraLoadouts
String extraLoadoutStr = warzoneConfig.getString("extraLoadouts");
String[] extraLoadoutsSplit = extraLoadoutStr.split(",");
for (String nameStr : extraLoadoutsSplit) {
if (nameStr != null && !nameStr.equals("")) {
warzone
.getDefaultInventories()
.getLoadouts()
.put(nameStr, new HashMap<Integer, ItemStack>());
}
}
for (String extraName : extraLoadoutsSplit) {
if (extraName != null && !extraName.equals("")) {
String loadoutString = warzoneConfig.getString(extraName + "Loadout");
HashMap<Integer, ItemStack> loadout =
warzone.getDefaultInventories().getLoadouts().get(extraName);
LoadoutTxtMapper.fromStringToLoadout(loadoutString, loadout);
}
}
// authors
if (warzoneConfig.containsKey("author") && !warzoneConfig.getString("author").equals("")) {
for (String authorStr : warzoneConfig.getString("author").split(",")) {
if (!authorStr.equals("")) {
warzone.addAuthor(authorStr);
}
}
}
// life pool (always set after teams, so the teams' remaining lives get initialized properly
// by this setter)
if (warzoneConfig.containsKey("lifePool")) {
warzone.getTeamDefaultConfig().put(TeamConfig.LIFEPOOL, warzoneConfig.getInt("lifePool"));
}
// monument heal
if (warzoneConfig.containsKey("monumentHeal")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.MONUMENTHEAL, warzoneConfig.getInt("monumentHeal"));
}
// autoAssignOnly
if (warzoneConfig.containsKey("autoAssignOnly")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.AUTOASSIGN, warzoneConfig.getBoolean("autoAssignOnly"));
}
// flagPointsOnly
if (warzoneConfig.containsKey("flagPointsOnly")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGPOINTSONLY, warzoneConfig.getBoolean("flagPointsOnly"));
}
// flagMustBeHome
if (warzoneConfig.containsKey("flagMustBeHome")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGMUSTBEHOME, warzoneConfig.getBoolean("flagMustBeHome"));
}
// team cap
if (warzoneConfig.containsKey("teamCap")) {
warzone.getTeamDefaultConfig().put(TeamConfig.TEAMSIZE, warzoneConfig.getInt("teamCap"));
}
// score cap
if (warzoneConfig.containsKey("scoreCap")) {
warzone.getTeamDefaultConfig().put(TeamConfig.MAXSCORE, warzoneConfig.getInt("scoreCap"));
}
// respawn timer
if (warzoneConfig.containsKey("respawnTimer")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.RESPAWNTIMER, warzoneConfig.getInt("respawnTimer"));
}
// blockHeads
if (warzoneConfig.containsKey("blockHeads")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.BLOCKHEADS, warzoneConfig.getBoolean("blockHeads"));
}
// spawnStyle
String spawnStyle = warzoneConfig.getString("spawnStyle");
if (spawnStyle != null && !spawnStyle.equals("")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.SPAWNSTYLE, TeamSpawnStyle.getStyleFromString(spawnStyle));
}
// flagReturn
String flagReturn = warzoneConfig.getString("flagReturn");
if (flagReturn != null && !flagReturn.equals("")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGRETURN, FlagReturn.getFromString(flagReturn));
}
// reward
String rewardStr = warzoneConfig.getString("reward");
if (rewardStr != null && !rewardStr.equals("")) {
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutTxtMapper.fromStringToLoadout(rewardStr, reward);
warzone.getDefaultInventories().setReward(reward);
}
// unbreakableZoneBlocks
if (warzoneConfig.containsKey("unbreakableZoneBlocks")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.UNBREAKABLE, warzoneConfig.getBoolean("unbreakableZoneBlocks"));
}
// disabled
if (warzoneConfig.containsKey("disabled")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.DISABLED, warzoneConfig.getBoolean("disabled"));
}
// noCreatures
if (warzoneConfig.containsKey("noCreatures")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.NOCREATURES, warzoneConfig.getBoolean("noCreatures"));
}
// glassWalls
if (warzoneConfig.containsKey("glassWalls")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.GLASSWALLS, warzoneConfig.getBoolean("glassWalls"));
}
// pvpInZone
if (warzoneConfig.containsKey("pvpInZone")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.PVPINZONE, warzoneConfig.getBoolean("pvpInZone"));
}
// instaBreak
if (warzoneConfig.containsKey("instaBreak")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.INSTABREAK, warzoneConfig.getBoolean("instaBreak"));
}
// noDrops
if (warzoneConfig.containsKey("noDrops")) {
warzone.getWarzoneConfig().put(WarzoneConfig.NODROPS, warzoneConfig.getBoolean("noDrops"));
}
// noHunger
if (warzoneConfig.containsKey("noHunger")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.NOHUNGER, warzoneConfig.getBoolean("noHunger"));
}
// saturation
if (warzoneConfig.containsKey("saturation")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.SATURATION, warzoneConfig.getInt("saturation"));
}
// minPlayers
if (warzoneConfig.containsKey("minPlayers")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.MINPLAYERS, warzoneConfig.getInt("minPlayers"));
}
// minTeams
if (warzoneConfig.containsKey("minTeams")) {
warzone.getWarzoneConfig().put(WarzoneConfig.MINTEAMS, warzoneConfig.getInt("minTeams"));
}
// resetOnEmpty
if (warzoneConfig.containsKey("resetOnEmpty")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONEMPTY, warzoneConfig.getBoolean("resetOnEmpty"));
}
// resetOnLoad
if (warzoneConfig.containsKey("resetOnLoad")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONLOAD, warzoneConfig.getBoolean("resetOnLoad"));
}
// resetOnUnload
if (warzoneConfig.containsKey("resetOnUnload")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONUNLOAD, warzoneConfig.getBoolean("resetOnUnload"));
}
// rallyPoint
String rallyPointStr = warzoneConfig.getString("rallyPoint");
if (rallyPointStr != null && !rallyPointStr.equals("")) {
String[] rallyPointStrSplit = rallyPointStr.split(",");
int rpX = Integer.parseInt(rallyPointStrSplit[0]);
int rpY = Integer.parseInt(rallyPointStrSplit[1]);
int rpZ = Integer.parseInt(rallyPointStrSplit[2]);
Location rallyPoint = new Location(world, rpX, rpY, rpZ);
warzone.setRallyPoint(rallyPoint);
}
// monuments
String monumentsStr = warzoneConfig.getString("monuments");
if (monumentsStr != null && !monumentsStr.equals("")) {
String[] monumentsSplit = monumentsStr.split(";");
warzone.getMonuments().clear();
for (String monumentStr : monumentsSplit) {
if (monumentStr != null && !monumentStr.equals("")) {
String[] monumentStrSplit = monumentStr.split(",");
int monumentX = Integer.parseInt(monumentStrSplit[1]);
int monumentY = Integer.parseInt(monumentStrSplit[2]);
int monumentZ = Integer.parseInt(monumentStrSplit[3]);
Monument monument =
new Monument(
monumentStrSplit[0],
warzone,
new Location(world, monumentX, monumentY, monumentZ));
warzone.getMonuments().add(monument);
}
}
}
// teams
String teamsStr = warzoneConfig.getString("teams");
if (teamsStr != null && !teamsStr.equals("")) {
String[] teamsSplit = teamsStr.split(";");
warzone.getTeams().clear();
for (String teamStr : teamsSplit) {
if (teamStr != null && !teamStr.equals("")) {
String[] teamStrSplit = teamStr.split(",");
int teamX = Integer.parseInt(teamStrSplit[1]);
int teamY = Integer.parseInt(teamStrSplit[2]);
int teamZ = Integer.parseInt(teamStrSplit[3]);
Location teamLocation = new Location(world, teamX, teamY, teamZ);
if (teamStrSplit.length > 4) {
int yaw = Integer.parseInt(teamStrSplit[4]);
teamLocation.setYaw(yaw);
}
Team team =
new Team(
teamStrSplit[0],
TeamKind.teamKindFromString(teamStrSplit[0]),
teamLocation,
warzone);
team.setRemainingLives(warzone.getTeamDefaultConfig().resolveInt(TeamConfig.LIFEPOOL));
warzone.getTeams().add(team);
}
}
}
// teamFlags
String teamFlagsStr = warzoneConfig.getString("teamFlags");
if (teamFlagsStr != null && !teamFlagsStr.equals("")) {
String[] teamFlagsSplit = teamFlagsStr.split(";");
for (String teamFlagStr : teamFlagsSplit) {
if (teamFlagStr != null && !teamFlagStr.equals("")) {
String[] teamFlagStrSplit = teamFlagStr.split(",");
Team team = warzone.getTeamByKind(TeamKind.teamKindFromString(teamFlagStrSplit[0]));
if (team != null) {
int teamFlagX = Integer.parseInt(teamFlagStrSplit[1]);
int teamFlagY = Integer.parseInt(teamFlagStrSplit[2]);
int teamFlagZ = Integer.parseInt(teamFlagStrSplit[3]);
Location teamFlagLocation = new Location(world, teamFlagX, teamFlagY, teamFlagZ);
if (teamFlagStrSplit.length > 4) {
int yaw = Integer.parseInt(teamFlagStrSplit[4]);
teamFlagLocation.setYaw(yaw);
}
team.setTeamFlag(teamFlagLocation); // this may screw things up
}
}
}
}
// lobby
String lobbyStr = warzoneConfig.getString("lobby");
warzoneConfig.close();
if (createNewVolume) {
ZoneVolume zoneVolume =
new ZoneVolume(
warzone.getName(),
world,
warzone); // VolumeMapper.loadZoneVolume(warzone.getName(), warzone.getName(), war,
// warzone.getWorld(), warzone);
warzone.setVolume(zoneVolume);
}
// monument blocks
for (Monument monument : warzone.getMonuments()) {
monument.setVolume(VolumeMapper.loadVolume(monument.getName(), warzone.getName(), world));
}
// team spawn blocks
for (Team team : warzone.getTeams()) {
team.setSpawnVolume(VolumeMapper.loadVolume(team.getName(), warzone.getName(), world));
if (team.getTeamFlag() != null) {
team.setFlagVolume(
VolumeMapper.loadVolume(team.getName() + "flag", warzone.getName(), world));
}
}
// lobby
BlockFace lobbyFace = null;
if (lobbyStr != null && !lobbyStr.equals("")) {
String[] lobbyStrSplit = lobbyStr.split(",");
if (lobbyStrSplit.length > 0) {
// lobby orientation
if (lobbyStrSplit[0].equals("south")) {
lobbyFace = Direction.SOUTH();
} else if (lobbyStrSplit[0].equals("east")) {
lobbyFace = Direction.EAST();
} else if (lobbyStrSplit[0].equals("north")) {
lobbyFace = Direction.NORTH();
} else if (lobbyStrSplit[0].equals("west")) {
lobbyFace = Direction.WEST();
}
// lobby world
World lobbyWorld = world; // by default, warzone world
if (lobbyStrSplit.length > 1) {
World strWorld = War.war.getServer().getWorld(lobbyStrSplit[1]);
if (strWorld != null) {
lobbyWorld = strWorld;
}
}
// create the lobby
Volume lobbyVolume = VolumeMapper.loadVolume("lobby", warzone.getName(), lobbyWorld);
ZoneLobby lobby = new ZoneLobby(warzone, lobbyFace, lobbyVolume);
warzone.setLobby(lobby);
}
}
return warzone;
}
return null;
}
/** Loads or reloads the mod */
public final void load() {
if (properties == null) {
properties = new PropertiesFile("server.properties");
} else {
try {
properties.load();
} catch (IOException e) {
log.log(Level.SEVERE, "Exception while reading from server.properties", e);
}
}
try {
dataSourceType = properties.getString("data-source", "flatfile");
allowedItems = properties.getString("alloweditems", "").split(",");
disallowedItems = properties.getString("disalloweditems", "").split(",");
itemSpawnBlacklist = properties.getString("itemspawnblacklist", "").split(",");
motd = properties.getString("motd", "Type /help for a list of commands.").split("@");
playerLimit = properties.getInt("max-players", 20);
saveHomes = properties.getBoolean("save-homes", true);
whitelistEnabled = properties.getBoolean("whitelist", false);
whitelistMessage = properties.getString("whitelist-message", "Not on whitelist.");
if (dataSourceType.equalsIgnoreCase("flatfile")) {
usersLoc = properties.getString("admintxtlocation", "users.txt");
kitsLoc = properties.getString("kitstxtlocation", "kits.txt");
homeLoc = properties.getString("homelocation", "homes.txt");
warpLoc = properties.getString("warplocation", "warps.txt");
itemLoc = properties.getString("itemstxtlocation", "items.txt");
groupLoc = properties.getString("group-txt-location", "groups.txt");
whitelistLoc = properties.getString("whitelist-txt-location", "whitelist.txt");
reservelistLoc = properties.getString("reservelist-txt-location", "reservelist.txt");
} else {
PropertiesFile sql = new PropertiesFile("mysql.properties");
driver = sql.getString("driver", "com.mysql.jdbc.Driver");
username = sql.getString("user", "root");
password = sql.getString("pass", "root");
db = sql.getString("db", "jdbc:mysql://localhost:3306/minecraft");
}
spawnProtectionSize = properties.getInt("spawn-protection-size", 16);
logging = properties.getBoolean("logging", false);
enableHealth = properties.getBoolean("enable-health", true);
String autoHealString = properties.getString("auto-heal", "default");
if (autoHealString.equalsIgnoreCase("true")) {
autoHeal = PluginLoader.HookResult.ALLOW_ACTION;
} else if (autoHealString.equalsIgnoreCase("false")) {
autoHeal = PluginLoader.HookResult.PREVENT_ACTION;
}
showUnknownCommand = properties.getBoolean("show-unknown-command", true);
URL url = this.getClass().getResource("/version.txt");
if (url != null) {
InputStreamReader ins = new InputStreamReader(url.openStream());
BufferedReader bufferedReader = new BufferedReader(ins);
String versionParam = bufferedReader.readLine();
if (versionParam.startsWith(
"git-")) { // recommended version.txt for git builds: git-<gituser>-<shorttag>
// example: git-sk89q-591c662cf4afc8e3e09a
version = -1;
versionStr = versionParam;
tainted = true;
} else {
version = Integer.parseInt(versionParam);
versionStr = Integer.toString(version); // and back to a string.
tainted = false; // looks official. We hope.
}
} else {
// I'm a tainted build, probably.
version = -1;
versionStr = "Undefined version";
tainted = true;
// If any mods check the version.. #@!$
}
} catch (Exception e) {
log.log(Level.SEVERE, "Exception while reading from server.properties", e);
// Just in case...
disallowedItems = new String[] {""};
allowedItems = new String[] {""};
itemSpawnBlacklist = new String[] {""};
motd = new String[] {"Type /help for a list of commands."};
}
}