Upstream
/
war
mirror of https://github.com/taoneill/war.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Closes gh-6. Closes gh-39. Team specific settings. New YAML file format and working converter. You can delete a setting to restore config inheritance with, for example, /zonecfg delete:maxscore. New colors for /war-zone-teamcfg. Fixed a bunch of bugs introduced by mega-changes - there are probably a few more lurking around.

This commit is contained in:
taoneill 2012-01-06 02:01:08 -05:00
parent 983e90ca38
commit 143afa4473
22 changed files with 482 additions and 2428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

733
war/src/main/java/bukkit/tommytony/war/War.java
View File

@ -70,49 +70,20 @@ public class War extends JavaPlugin {
// Zones and hub
private List<Warzone> warzones = new ArrayList<Warzone>();
private WarHub warHub;
private final List<Warzone> incompleteZones = new ArrayList<Warzone>();
private final List<String> zoneMakerNames = new ArrayList<String>();
private final List<String> commandWhitelist = new ArrayList<String>();
private final List<Warzone> incompleteZones = new ArrayList<Warzone>();
private final List<String> zoneMakersImpersonatingPlayers = new ArrayList<String>();
private HashMap<String, PlayerState> disconnected = new HashMap<String, PlayerState>();
private final HashMap<String, String> wandBearers = new HashMap<String, String>(); // playername to zonename
// Global settings
// private boolean pvpInZonesOnly = false;
// private boolean disablePvpMessage = false;
// private boolean buildInZonesOnly = false;
// private boolean disableBuildMessage = false;
// private boolean tntInZonesOnly = false;
// private int maxZones = 12;
private final List<String> deadlyAdjectives = new ArrayList<String>();
private final List<String> killerVerbs = new ArrayList<String>();
// Default warzone settings
private final InventoryBag defaultInventories = new InventoryBag();
// private int defaultLifepool = 7;
// private int defaultTeamCap = 7;
// private int defaultScoreCap = 10;
// private int defaultMonumentHeal = 5;
// private boolean defaultBlockHeads = true;
// private boolean defaultFriendlyFire = false;
// private boolean defaultAutoAssignOnly = false;
// private boolean defaultFlagPointsOnly = false;
// private boolean defaultFlagMustBeHome = true;
// private boolean defaultUnbreakableZoneBlocks = false;
// private boolean defaultNoCreatures = false;
// private boolean defaultGlassWalls = true;
// private boolean defaultPvpInZone = true;
// private boolean defaultInstaBreak = false;
// private boolean defaultNoDrops = false;
// private boolean defaultNoHunger = false;
// private int defaultRespawnTimer = 0;
// private int defaultSaturation = 10;
// private int defaultMinPlayers = 1; // By default, 1 player on 1 team is enough for unlocking the cant-exit-spawn guard
// private int defaultMinTeams = 1;
// private FlagReturn defaultFlagReturn = FlagReturn.BOTH;
// private boolean defaultResetOnEmpty = false, defaultResetOnLoad = false, defaultResetOnUnload = false;
// private TeamSpawnStyle defaultSpawnStyle = TeamSpawnStyle.BIG;
private final WarConfigBag warConfig = new WarConfigBag();
private final WarzoneConfigBag warzoneDefaultConfig = new WarzoneConfigBag();
private final TeamConfigBag teamDefaultConfig = new TeamConfigBag();
@ -230,11 +201,26 @@ public class War extends JavaPlugin {
this.getDefaultInventories().getLoadouts().clear();
HashMap<Integer, ItemStack> defaultLoadout = new HashMap<Integer, ItemStack>();
defaultLoadout.put(0, new ItemStack(Material.STONE_SWORD, 1, (byte) 8));
defaultLoadout.put(1, new ItemStack(Material.BOW, 1, (byte) 8));
defaultLoadout.put(2, new ItemStack(Material.ARROW, 7));
defaultLoadout.put(3, new ItemStack(Material.IRON_PICKAXE, 1, (byte) 8));
defaultLoadout.put(4, new ItemStack(Material.STONE_SPADE, 1, (byte) 8));
ItemStack stoneSword = new ItemStack(Material.STONE_SWORD, 1, (byte) 8);
stoneSword.setDurability((short) 8);
defaultLoadout.put(0, stoneSword);
ItemStack bow = new ItemStack(Material.BOW, 1, (byte) 8);
bow.setDurability((short) 8);
defaultLoadout.put(1, bow);
ItemStack arrows = new ItemStack(Material.ARROW, 7);
defaultLoadout.put(2, arrows);
ItemStack stonePick = new ItemStack(Material.IRON_PICKAXE, 1, (byte) 8);
stonePick.setDurability((short) 8);
defaultLoadout.put(3, stonePick);
ItemStack stoneSpade = new ItemStack(Material.STONE_SPADE, 1, (byte) 8);
stoneSword.setDurability((short) 8);
defaultLoadout.put(4, stoneSpade);
this.getDefaultInventories().addLoadout("default", defaultLoadout);
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
@ -386,8 +372,7 @@ public class War extends JavaPlugin {
}
StringBuilder returnMessage = new StringBuilder();
returnMessage.append(this.getTeamDefaultConfig().updateFromNamedParams(namedParams));
returnMessage.append(team.getTeamConfig().updateFromNamedParams(namedParams));
if (commandSender instanceof Player) {
Player player = (Player) commandSender;
@ -456,156 +441,7 @@ public class War extends JavaPlugin {
returnMessage.append(warzone.getWarzoneConfig().updateFromNamedParams(namedParams));
returnMessage.append(warzone.getTeamDefaultConfig().updateFromNamedParams(namedParams));
// if (namedParams.containsKey("lifepool")) {
// warzone.setLifePool(Integer.parseInt(namedParams.get("lifepool")));
// returnMessage.append(" lifepool set to " + warzone.getLifePool() + ".");
// }
// if (namedParams.containsKey("monumentheal")) {
// warzone.setMonumentHeal(Integer.parseInt(namedParams.get("monumentheal")));
// returnMessage.append(" monumentheal set to " + warzone.getMonumentHeal() + ".");
// }
// if (namedParams.containsKey("teamsize")) {
// warzone.setTeamCap(Integer.parseInt(namedParams.get("teamsize")));
// returnMessage.append(" teamsize set to " + warzone.getTeamCap() + ".");
// }
// if (namedParams.containsKey("maxscore")) {
// warzone.setScoreCap(Integer.parseInt(namedParams.get("maxscore")));
// returnMessage.append(" maxscore set to " + warzone.getScoreCap() + ".");
// }
// if (namedParams.containsKey("respawntimer")) {
// warzone.setRespawnTimer(Integer.parseInt(namedParams.get("respawntimer")));
// returnMessage.append(" respawntimer set to " + warzone.getRespawnTimer() + ".");
// }
// if (namedParams.containsKey("ff")) {
// String onOff = namedParams.get("ff");
// warzone.setFriendlyFire(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" ff set to " + String.valueOf(warzone.getFriendlyFire()) + ".");
// }
// if (namedParams.containsKey("autoassign")) {
// String onOff = namedParams.get("autoassign");
// warzone.setAutoAssignOnlyAndResetLobby(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" autoassign set to " + String.valueOf(warzone.isAutoAssignOnly()) + ".");
// }
// if (namedParams.containsKey("flagpointsonly")) {
// String onOff = namedParams.get("flagpointsonly");
// warzone.setFlagPointsOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" flagpointsonly set to " + String.valueOf(warzone.isFlagPointsOnly()) + ".");
// }
// if (namedParams.containsKey("flagmustbehome")) {
// String onOff = namedParams.get("flagmustbehome");
// warzone.setFlagMustBeHome(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" flagmustbehome set to " + String.valueOf(warzone.isFlagMustBeHome()) + ".");
// }
// if (namedParams.containsKey("blockheads")) {
// String onOff = namedParams.get("blockheads");
// warzone.setBlockHeads(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" blockheads set to " + String.valueOf(warzone.isBlockHeads()) + ".");
// }
// if (namedParams.containsKey("spawnstyle")) {
// String spawnStyle = namedParams.get("spawnstyle");
// warzone.setSpawnStyle(TeamSpawnStyle.getStyleFromString(spawnStyle));
// returnMessage.append(" spawnstyle set to " + warzone.getSpawnStyle().toString() + ".");
// }
// if (namedParams.containsKey("flagreturn")) {
// String flagReturn = namedParams.get("flagreturn").toLowerCase();
// if (flagReturn.equals("flag")) {
// warzone.setFlagReturn(FlagReturn.FLAG);
// } else if (flagReturn.equals("spawn")) {
// warzone.setFlagReturn(FlagReturn.SPAWN);
// } else {
// warzone.setFlagReturn(FlagReturn.BOTH);
// }
// returnMessage.append(" flagreturn set to " + warzone.getFlagReturn().toString() + ".");
// }
// if (namedParams.containsKey("unbreakable")) {
// String onOff = namedParams.get("unbreakable");
// warzone.setUnbreakableZoneBlocks(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" unbreakable set to " + String.valueOf(warzone.isUnbreakableZoneBlocks()) + ".");
// }
// if (namedParams.containsKey("disabled")) {
// String onOff = namedParams.get("disabled");
// warzone.setDisabled(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" disabled set to " + String.valueOf(warzone.isDisabled()) + ".");
// }
// if (namedParams.containsKey("nocreatures")) {
// String onOff = namedParams.get("nocreatures");
// warzone.setNoCreatures(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nocreatures set to " + String.valueOf(warzone.isNoCreatures()) + ".");
// }
// if (namedParams.containsKey("glasswalls")) {
// String onOff = namedParams.get("glasswalls");
// warzone.setGlassWalls(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" glasswalls set to " + String.valueOf(warzone.isGlassWalls()) + ".");
// }
// if (namedParams.containsKey("pvpinzone")) {
// String onOff = namedParams.get("pvpinzone");
// warzone.setPvpInZone(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" pvpinzone set to " + String.valueOf(warzone.isPvpInZone()) + ".");
// }
// if (namedParams.containsKey("instabreak")) {
// String onOff = namedParams.get("instabreak");
// warzone.setInstaBreak(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" instabreak set to " + String.valueOf(warzone.isInstaBreak()) + ".");
// }
// if (namedParams.containsKey("nodrops")) {
// String onOff = namedParams.get("nodrops");
// warzone.setNoDrops(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nodrops set to " + String.valueOf(warzone.isNoDrops()) + ".");
// }
// if (namedParams.containsKey("nohunger")) {
// String onOff = namedParams.get("nohunger");
// warzone.setNoHunger(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nohunger set to " + String.valueOf(warzone.isNoHunger()) + ".");
// }
// if (namedParams.containsKey("saturation")) {
// int sat = Integer.parseInt(namedParams.get("saturation"));
// if (sat > 20) {
// sat = 20;
// } else if (sat < 0) {
// sat = 0;
// }
// warzone.setSaturation(sat);
// returnMessage.append(" saturation set to " + warzone.getSaturation() + ".");
// }
// if (namedParams.containsKey("minplayers")) {
// int val = Integer.parseInt(namedParams.get("minplayers"));
// if (val > warzone.getTeamCap()) {
// returnMessage.append(" minplayers can't be greater than teamsize.");
// } else {
// warzone.setMinPlayers(val);
// returnMessage.append(" minplayers set to " + warzone.getMinPlayers() + ".");
// }
// }
// if (namedParams.containsKey("minteams")) {
// int val = Integer.parseInt(namedParams.get("minteams"));
// if (val > warzone.getTeams().size()) {
// returnMessage.append(" minteams can't be higher than number of teams.");
// } else {
// warzone.setMinTeams(val);
// returnMessage.append(" minteams set to " + warzone.getMinTeams() + ".");
// }
// }
// if (namedParams.containsKey("respawntimer")) {
// warzone.setRespawnTimer(Integer.parseInt(namedParams.get("respawntimer")));
// returnMessage.append(" respawntimer set to " + warzone.getRespawnTimer() + ".");
// }
//
// if (namedParams.containsKey("resetonempty")) {
// String onOff = namedParams.get("resetonempty");
// warzone.setResetOnEmpty(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonempty set to " + String.valueOf(warzone.isResetOnEmpty()) + ".");
// }
// if (namedParams.containsKey("resetonload")) {
// String onOff = namedParams.get("resetonload");
// warzone.setResetOnLoad(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonload set to " + String.valueOf(warzone.isResetOnLoad()) + ".");
// }
// if (namedParams.containsKey("resetonunload")) {
// String onOff = namedParams.get("resetonunload");
// warzone.setResetOnUnload(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonunload set to " + String.valueOf(warzone.isResetOnUnload()) + ".");
// }
if (commandSender instanceof Player) {
Player player = (Player) commandSender;
if (namedParams.containsKey("loadout")) {
@ -658,177 +494,7 @@ public class War extends JavaPlugin {
returnMessage.append(this.getWarConfig().updateFromNamedParams(namedParams));
returnMessage.append(this.getWarzoneDefaultConfig().updateFromNamedParams(namedParams));
returnMessage.append(this.getTeamDefaultConfig().updateFromNamedParams(namedParams));
// if (namedParams.containsKey("pvpinzonesonly")) {
// String onOff = namedParams.get("pvpinzonesonly");
// this.setPvpInZonesOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" pvpinzonesonly set to " + String.valueOf(war.isPvpInZonesOnly()) + ".");
// }
// if (namedParams.containsKey("disablepvpmessage")) {
// String onOff = namedParams.get("disablepvpmessage");
// this.setDisablePvpMessage(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" disablepvpmessage set to " + String.valueOf(war.isDisablePvpMessage()) + ".");
// }
// if (namedParams.containsKey("disablebuildmessage")) {
// String onOff = namedParams.get("disablebuildmessage");
// this.setDisableBuildMessage(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" disablebuildmessage set to " + String.valueOf(war.isDisableBuildMessage()) + ".");
// }
// if (namedParams.containsKey("buildinzonesonly")) {
// String onOff = namedParams.get("buildinzonesonly");
// this.setBuildInZonesOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" buildinzonesonly set to " + String.valueOf(war.isBuildInZonesOnly()) + ".");
// }
// if (namedParams.containsKey("tntinzonesonly")) {
// String onOff = namedParams.get("tntinzonesonly");
// this.setTntInZonesOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" tntinzonesonly set to " + String.valueOf(war.isTntInZonesOnly()) + ".");
// }
// if (namedParams.containsKey("maxzones")) {
// this.setMaxZones(Integer.parseInt(namedParams.get("maxzones")));
// returnMessage.append(" maxzones set to " + war.getMaxZones() + ".");
// }
//
// if (namedParams.containsKey("lifepool")) {
// this.setDefaultLifepool(Integer.parseInt(namedParams.get("lifepool")));
// returnMessage.append(" lifepool set to " + war.getDefaultLifepool() + ".");
// }
// if (namedParams.containsKey("monumentheal")) {
// this.setDefaultMonumentHeal(Integer.parseInt(namedParams.get("monumentheal")));
// returnMessage.append(" monumentheal set to " + war.getDefaultMonumentHeal() + ".");
// }
// if (namedParams.containsKey("teamsize")) {
// this.setDefaultTeamCap(Integer.parseInt(namedParams.get("teamsize")));
// returnMessage.append(" teamsize set to " + war.getDefaultTeamCap() + ".");
// }
// if (namedParams.containsKey("maxscore")) {
// this.setDefaultScoreCap(Integer.parseInt(namedParams.get("maxscore")));
// returnMessage.append(" maxscore set to " + war.getDefaultScoreCap() + ".");
// }
// if (namedParams.containsKey("respawntimer")) {
// this.setDefaultRespawnTimer(Integer.parseInt(namedParams.get("respawntimer")));
// returnMessage.append(" respawntimer set to " + war.getDefaultRespawnTimer() + ".");
// }
// if (namedParams.containsKey("ff")) {
// String onOff = namedParams.get("ff");
// this.setDefaultFriendlyFire(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" ff set to " + String.valueOf(war.isDefaultFriendlyFire()) + ".");
// }
// if (namedParams.containsKey("autoassign")) {
// String onOff = namedParams.get("autoassign");
// this.setDefaultAutoAssignOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" autoassign set to " + String.valueOf(war.isDefaultAutoAssignOnly()) + ".");
// }
// if (namedParams.containsKey("flagpointsonly")) {
// String onOff = namedParams.get("flagpointsonly");
// this.setDefaultFlagPointsOnly(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" flagpointsonly set to " + String.valueOf(war.isDefaultFlagPointsOnly()) + ".");
// }
// if (namedParams.containsKey("flagmustbehome")) {
// String onOff = namedParams.get("flagmustbehome");
// this.setDefaultFlagMustBeHome(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" flagmustbehome set to " + String.valueOf(war.isDefaultFlagMustBeHome()) + ".");
// }
// if (namedParams.containsKey("blockheads")) {
// String onOff = namedParams.get("blockheads");
// this.setDefaultBlockHeads(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" blockheads set to " + String.valueOf(war.isDefaultBlockHeads()) + ".");
// }
// if (namedParams.containsKey("spawnstyle")) {
// String spawnStyle = namedParams.get("spawnstyle");
// this.setDefaultSpawnStyle(TeamSpawnStyle.getStyleFromString(spawnStyle));
// returnMessage.append(" spawnstyle set to " + war.getDefaultSpawnStyle().toString() + ".");
// }
// if (namedParams.containsKey("flagreturn")) {
// String flagreturn = namedParams.get("flagreturn").toLowerCase();
// if (flagreturn.equals("flag")) {
// this.setDefaultFlagReturn(FlagReturn.FLAG);
// } else if (flagreturn.equals("spawn")) {
// this.setDefaultFlagReturn(FlagReturn.SPAWN);
// } else {
// this.setDefaultFlagReturn(FlagReturn.BOTH);
// }
// returnMessage.append(" flagreturn set to " + war.getDefaultFlagReturn().toString() + ".");
// }
//
// if (namedParams.containsKey("unbreakable")) {
// String onOff = namedParams.get("unbreakable");
// this.setDefaultUnbreakableZoneBlocks(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" unbreakable set to " + String.valueOf(war.isDefaultUnbreakableZoneBlocks()) + ".");
// }
// if (namedParams.containsKey("nocreatures")) {
// String onOff = namedParams.get("nocreatures");
// this.setDefaultNoCreatures(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nocreatures set to " + String.valueOf(war.isDefaultNoCreatures()) + ".");
// }
// if (namedParams.containsKey("glasswalls")) {
// String onOff = namedParams.get("glasswalls");
// this.setDefaultGlassWalls(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" glasswalls set to " + String.valueOf(war.isDefaultGlassWalls()) + ".");
// }
// if (namedParams.containsKey("pvpinzone")) {
// String onOff = namedParams.get("pvpinzone");
// this.setDefaultPvpInZone(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" pvpinzone set to " + String.valueOf(war.isDefaultPvpInZone()) + ".");
// }
// if (namedParams.containsKey("instabreak")) {
// String onOff = namedParams.get("instabreak");
// this.setDefaultInstaBreak(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" instabreak set to " + String.valueOf(war.isDefaultInstaBreak()) + ".");
// }
// if (namedParams.containsKey("nodrops")) {
// String onOff = namedParams.get("nodrops");
// war.setDefaultNoDrops(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nodrops set to " + String.valueOf(war.isDefaultNoDrops()) + ".");
// }
// if (namedParams.containsKey("nohunger")) {
// String onOff = namedParams.get("nohunger");
// this.setDefaultNoHunger(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" nohunger set to " + String.valueOf(this.isDefaultNoHunger()) + ".");
// }
// if (namedParams.containsKey("saturation")) {
// int sat = Integer.parseInt(namedParams.get("saturation"));
// if (sat > 20) {
// sat = 20;
// } else if (sat < 0) {
// sat = 0;
// }
// this.setDefaultSaturation(sat);
// returnMessage.append(" saturation set to " + this.getDefaultSaturation() + ".");
// }
// if (namedParams.containsKey("minplayers")) {
// int val = Integer.parseInt(namedParams.get("minplayers"));
// if (val > this.getDefaultTeamCap()) {
// returnMessage.append(" minplayers can't be greater than teamsize.");
// } else {
// this.setDefaultMinPlayers(val);
// returnMessage.append(" minplayers set to " + this.getDefaultMinPlayers() + ".");
// }
// }
// if (namedParams.containsKey("minteams")) {
// this.setDefaultMinTeams(Integer.parseInt(namedParams.get("minteams")));
// returnMessage.append(" minteams set to " + this.getDefaultMinTeams() + ".");
// }
// if (namedParams.containsKey("respawntimer")) {
// this.setDefaultRespawnTimer(Integer.parseInt(namedParams.get("respawntimer")));
// returnMessage.append(" respawntimer set to " + this.getDefaultRespawnTimer() + ".");
// }
//
// if (namedParams.containsKey("resetonempty")) {
// String onOff = namedParams.get("resetonempty");
// this.setDefaultResetOnEmpty(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonempty set to " + String.valueOf(war.isDefaultResetOnEmpty()) + ".");
// }
// if (namedParams.containsKey("resetonload")) {
// String onOff = namedParams.get("resetonload");
// this.setDefaultResetOnLoad(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonload set to " + String.valueOf(war.isDefaultResetOnLoad()) + ".");
// }
// if (namedParams.containsKey("resetonunload")) {
// String onOff = namedParams.get("resetonunload");
// this.setDefaultResetOnUnload(onOff.equals("on") || onOff.equals("true"));
// returnMessage.append(" resetonunload set to " + String.valueOf(war.isDefaultResetOnUnload()) + ".");
// }
if (commandSender instanceof Player) {
Player player = (Player) commandSender;
if (namedParams.containsKey("loadout")) {
@ -876,77 +542,62 @@ public class War extends JavaPlugin {
}
public String printConfig(Team team) {
ChatColor teamColor = ChatColor.BLUE;
ChatColor teamColor = ChatColor.AQUA;
ChatColor normalColor = ChatColor.WHITE;
String teamConfigStr = "";
for (TeamConfig teamConfig : TeamConfig.values()) {
teamConfigStr += " " + teamConfig.toStringWithValue(this.getTeamDefaultConfig().getValue(teamConfig)).replace(":", ":" + teamColor) + normalColor;
Object value = team.getTeamConfig().getValue(teamConfig);
if (value != null) {
teamConfigStr += " " + teamConfig.toStringWithValue(value).replace(":", ":" + teamColor) + normalColor;
}
}
return "Team " + team.getName() + " config -"+ ifEmptyInheritedForTeam(teamConfigStr);
return teamColor + " ::" + normalColor + "Team " + team.getName() + " config" + teamColor + "::" + normalColor
+ ifEmptyInheritedForTeam(teamConfigStr);
}
public String printConfig(Warzone zone) {
ChatColor teamColor = ChatColor.BLUE;
ChatColor teamColor = ChatColor.AQUA;
ChatColor zoneColor = ChatColor.RED;
ChatColor authorColor = ChatColor.GREEN;
ChatColor normalColor = ChatColor.WHITE;
String warzoneConfigStr = "";
for (WarzoneConfig warzoneConfig : WarzoneConfig.values()) {
warzoneConfigStr += " " + warzoneConfig.toStringWithValue(this.getWarzoneDefaultConfig().getValue(warzoneConfig)).replace(":", ":" + zoneColor) + normalColor;
Object value = zone.getWarzoneConfig().getValue(warzoneConfig);
if (value != null) {
warzoneConfigStr += " " + warzoneConfig.toStringWithValue(value).replace(":", ":" + zoneColor) + normalColor;
}
}
String teamDefaultsStr = "";
for (TeamConfig teamConfig : TeamConfig.values()) {
teamDefaultsStr += " " + teamConfig.toStringWithValue(this.getTeamDefaultConfig().getValue(teamConfig)).replace(":", ":" + teamColor) + normalColor;
Object value = zone.getTeamDefaultConfig().getValue(teamConfig);
if (value != null) {
teamDefaultsStr += " " + teamConfig.toStringWithValue(value).replace(":", ":" + teamColor) + normalColor;
}
}
return "Warzone " + zone.getName() + " config -"
return zoneColor + "::" + normalColor + "Warzone " + zone.getName() + " config" + zoneColor + "::" + normalColor
+ " author:" + authorColor + ifEmptyEveryone(zone.getAuthorsString()) + normalColor
+ ifEmptyInheritedForWarzone(warzoneConfigStr)
+ " Team defaults -" + ifEmptyInheritedForWarzone(teamDefaultsStr);
// + " lifepool:" + color + zone.getLifePool() + normal
// + " teamsize:" + color + zone.getTeamCap() + normal
// + " maxscore:" + color + zone.getScoreCap() + normal
// + " ff:" + color + String.valueOf(zone.getFriendlyFire()) + normal
// + " autoassign:" + color + String.valueOf(zone.isAutoAssignOnly()) + normal
// + " flagpointsonly:" + color + String.valueOf(zone.isFlagPointsOnly()) + normal
// + " flagmustbehome:" + color + String.valueOf(zone.isFlagMustBeHome()) + normal
// + " blockheads:" + color + String.valueOf(zone.isBlockHeads()) + normal
// + " spawnstyle:" + color + zone.getSpawnStyle() + normal
// + " flagreturn:" + color + zone.getFlagReturn() + normal
// + " monumentheal:" + color + zone.getMonumentHeal() + normal
// + " unbreakable:" + color + String.valueOf(zone.isUnbreakableZoneBlocks()) + normal
// + " disabled:" + color + String.valueOf(zone.isDisabled()) + normal
// + " nocreatures:" + color + String.valueOf(zone.isNoCreatures()) + normal
// + " glasswalls:" + color + String.valueOf(zone.isGlassWalls()) + normal
// + " pvpinzone:" + color + String.valueOf(zone.isPvpInZone()) + normal
// + " instabreak:" + color + String.valueOf(zone.isInstaBreak()) + normal
// + " nodrops:" + color + String.valueOf(zone.isNoDrops()) + normal
// + " nohunger:" + color + String.valueOf(zone.isNoHunger()) + normal
// + " saturation:" + color + zone.getSaturation() + normal
// + " minplayers:" + color + zone.getMinPlayers() + normal
// + " minteams:" + color + zone.getMinTeams() + normal
// + " respawntimer:" + color + zone.getRespawnTimer() + normal
// + " resetonempty:" + color + String.valueOf(zone.isResetOnEmpty()) + normal
// + " resetonload:" + color + String.valueOf(zone.isResetOnLoad()) + normal
// + " resetonunload:" + color + String.valueOf(zone.isResetOnUnload());
+ teamColor + " ::" + normalColor + "Team defaults" + teamColor + "::" + normalColor
+ ifEmptyInheritedForWarzone(teamDefaultsStr);
}
private String ifEmptyInheritedForWarzone(String maybeEmpty) {
if (maybeEmpty.equals("")) {
maybeEmpty = " all values inherited (see /warcfg)";
maybeEmpty = " all values inherited (see " + ChatColor.GREEN + "/warcfg -p)" + ChatColor.WHITE;
}
return maybeEmpty;
}
private String ifEmptyInheritedForTeam(String maybeEmpty) {
if (maybeEmpty.equals("")) {
maybeEmpty = " all values inherited (see /warcfg and /zonecfg)";
maybeEmpty = " all values inherited (see " + ChatColor.GREEN + "/warcfg -p" + ChatColor.WHITE
+ " and " + ChatColor.GREEN + "/zonecfg -p" + ChatColor.WHITE + ")";
}
return maybeEmpty;
}
@ -959,7 +610,7 @@ public class War extends JavaPlugin {
}
public String printConfig() {
ChatColor teamColor = ChatColor.BLUE;
ChatColor teamColor = ChatColor.AQUA;
ChatColor zoneColor = ChatColor.RED;
ChatColor globalColor = ChatColor.GREEN;
ChatColor normalColor = ChatColor.WHITE;
@ -979,39 +630,9 @@ public class War extends JavaPlugin {
teamDefaultsStr += " " + teamConfig.toStringWithValue(this.getTeamDefaultConfig().getValue(teamConfig)).replace(":", ":" + teamColor) + normalColor;
}
return "War config -" + warConfigStr + " Warzone defaults -" + warzoneDefaultsStr + " Team defaults -" + teamDefaultsStr;
// + " pvpinzonesonly:" + global + String.valueOf(this.isPvpInZonesOnly()) + normal
// + " disablepvpmessage:" + global + String.valueOf(this.isDisablePvpMessage()) + normal
// + " disablebuildmessage:" + global + String.valueOf(this.isDisableBuildMessage()) + normal
// + " buildinzonesonly:" + global + String.valueOf(this.isBuildInZonesOnly()) + normal
// + " tntinzonesonly:" + global + String.valueOf(this.isTntInZonesOnly()) + normal
// + " maxzones:" + global + this.getMaxZones() + normal
// + " - Warzone defaults -"
// + " lifepool:" + color + this.getDefaultLifepool() + normal
// + " teamsize:" + color + this.getDefaultTeamCap() + normal
// + " maxscore:" + color + this.getDefaultScoreCap() + normal
// + " ff:" + color + String.valueOf(this.isDefaultFriendlyFire()) + normal
// + " autoassign:" + color + String.valueOf(this.isDefaultAutoAssignOnly()) + normal
// + " flagpointsonly:" + color + String.valueOf(this.isDefaultFlagPointsOnly()) + normal
// + " flagmustbehome:" + color + String.valueOf(this.isDefaultFlagMustBeHome()) + normal
// + " blockheads:" + color + String.valueOf(this.isDefaultBlockHeads()) + normal
// + " spawnstyle:" + color + this.getDefaultSpawnStyle() + normal
// + " flagreturn:" + color + this.getDefaultFlagReturn() + normal
// + " monumentheal:" + color + this.getDefaultMonumentHeal() + normal
// + " unbreakable:" + color + String.valueOf(this.isDefaultUnbreakableZoneBlocks()) + normal
// + " nocreatures:" + color + String.valueOf(this.isDefaultNoCreatures()) + normal
// + " glasswalls:" + color + String.valueOf(this.isDefaultGlassWalls()) + normal
// + " pvpinzone:" + color + String.valueOf(this.isDefaultPvpInZone()) + normal
// + " instabreak:" + color + String.valueOf(this.isDefaultInstaBreak()) + normal
// + " nodrops:" + color + String.valueOf(this.isDefaultNoDrops()) + normal
// + " nohunger:" + color + String.valueOf(this.isDefaultNoHunger()) + normal
// + " saturation:" + color + this.getDefaultSaturation() + normal
// + " minplayers:" + color + this.getDefaultMinPlayers() + normal
// + " minteams:" + color + this.getDefaultMinTeams() + normal
// + " respawntimer:" + color + this.getDefaultRespawnTimer() + normal
// + " resetonempty:" + color + String.valueOf(this.isDefaultResetOnEmpty()) + normal
// + " resetonload:" + color + String.valueOf(this.isDefaultResetOnLoad()) + normal
// + " resetonunload:" + color + String.valueOf(this.isDefaultResetOnUnload());
return globalColor + "::" + normalColor + "War config" + globalColor + "::" + normalColor + warConfigStr
+ zoneColor + " ::" + normalColor + "Warzone defaults" + zoneColor + "::" + normalColor + warzoneDefaultsStr
+ teamColor + " ::" + normalColor + "Team defaults" + teamColor + "::" + normalColor + teamDefaultsStr;
}
private void setZoneRallyPoint(String warzoneName, Player player) {
@ -1336,150 +957,6 @@ public class War extends JavaPlugin {
this.loaded = loaded;
}
// public boolean isPvpInZonesOnly() {
// return this.pvpInZonesOnly;
// }
//
// public void setPvpInZonesOnly(boolean pvpInZonesOnly) {
// this.pvpInZonesOnly = pvpInZonesOnly;
// }
//
// public boolean isDisablePvpMessage() {
// return this.disablePvpMessage;
// }
//
// public void setDisablePvpMessage(boolean disablePvpMessage) {
// this.disablePvpMessage = disablePvpMessage;
// }
//
// public boolean isDisableBuildMessage() {
// return this.disableBuildMessage;
// }
//
// public void setDisableBuildMessage(boolean disableBuildMessage) {
// this.disableBuildMessage = disableBuildMessage;
// }
//
// public boolean isBuildInZonesOnly() {
// return this.buildInZonesOnly;
// }
//
// public void setBuildInZonesOnly(boolean buildInZonesOnly) {
// this.buildInZonesOnly = buildInZonesOnly;
// }
// public int getDefaultLifepool() {
// return this.defaultLifepool;
// }
//
// public void setDefaultLifepool(int defaultLifepool) {
// this.defaultLifepool = defaultLifepool;
// }
//
// public int getDefaultTeamCap() {
// return this.defaultTeamCap;
// }
//
// public void setDefaultTeamCap(int defaultTeamCap) {
// this.defaultTeamCap = defaultTeamCap;
// }
//
// public int getDefaultScoreCap() {
// return this.defaultScoreCap;
// }
//
// public void setDefaultScoreCap(int defaultScoreCap) {
// this.defaultScoreCap = defaultScoreCap;
// }
//
// public int getDefaultMonumentHeal() {
// return this.defaultMonumentHeal;
// }
//
// public void setDefaultMonumentHeal(int defaultMonumentHeal) {
// this.defaultMonumentHeal = defaultMonumentHeal;
// }
//
// public boolean isDefaultBlockHeads() {
// return this.defaultBlockHeads;
// }
//
// public void setDefaultBlockHeads(boolean defaultBlockHeads) {
// this.defaultBlockHeads = defaultBlockHeads;
// }
//
// public boolean isDefaultFriendlyFire() {
// return this.defaultFriendlyFire;
// }
//
// public void setDefaultFriendlyFire(boolean defaultFriendlyFire) {
// this.defaultFriendlyFire = defaultFriendlyFire;
// }
//
// public boolean isDefaultAutoAssignOnly() {
// return this.defaultAutoAssignOnly;
// }
//
// public void setDefaultAutoAssignOnly(boolean defaultAutoAssignOnly) {
// this.defaultAutoAssignOnly = defaultAutoAssignOnly;
// }
//
// public boolean isDefaultUnbreakableZoneBlocks() {
// return this.defaultUnbreakableZoneBlocks;
// }
//
// public void setDefaultUnbreakableZoneBlocks(boolean defaultUnbreakableZoneBlocks) {
// this.defaultUnbreakableZoneBlocks = defaultUnbreakableZoneBlocks;
// }
//
// public boolean isDefaultNoCreatures() {
// return this.defaultNoCreatures;
// }
//
// public void setDefaultNoCreatures(boolean defaultNoCreatures) {
// this.defaultNoCreatures = defaultNoCreatures;
// }
//
// public boolean isDefaultResetOnEmpty() {
// return this.defaultResetOnEmpty;
// }
//
// public void setDefaultResetOnEmpty(boolean defaultResetOnEmpty) {
// this.defaultResetOnEmpty = defaultResetOnEmpty;
// }
//
// public boolean isDefaultResetOnLoad() {
// return this.defaultResetOnLoad;
// }
//
// public void setDefaultResetOnLoad(boolean defaultResetOnLoad) {
// this.defaultResetOnLoad = defaultResetOnLoad;
// }
//
// public boolean isDefaultResetOnUnload() {
// return this.defaultResetOnUnload;
// }
//
// public void setDefaultResetOnUnload(boolean defaultResetOnUnload) {
// this.defaultResetOnUnload = defaultResetOnUnload;
// }
//
// public TeamSpawnStyle getDefaultSpawnStyle() {
// return this.defaultSpawnStyle;
// }
//
// public void setDefaultSpawnStyle(TeamSpawnStyle defaultSpawnStyle) {
// this.defaultSpawnStyle = defaultSpawnStyle;
// }
//
// public void setDefaultFlagReturn(FlagReturn defaultFlagReturn) {
// this.defaultFlagReturn = defaultFlagReturn;
// }
//
// public FlagReturn getDefaultFlagReturn() {
// return this.defaultFlagReturn;
// }
public HashMap<String, PlayerState> getDisconnected() {
return this.disconnected;
}
@ -1488,66 +965,10 @@ public class War extends JavaPlugin {
this.disconnected = disconnected;
}
// public void setDefaultGlassWalls(boolean defaultGlassWalls) {
// this.defaultGlassWalls = defaultGlassWalls;
// }
//
// public boolean isDefaultGlassWalls() {
// return this.defaultGlassWalls;
// }
//
// public void setDefaultFlagPointsOnly(boolean defaultFlagPointsOnly) {
// this.defaultFlagPointsOnly = defaultFlagPointsOnly;
// }
//
// public boolean isDefaultFlagPointsOnly() {
// return this.defaultFlagPointsOnly;
// }
//
// public void setDefaultFlagMustBeHome(boolean defaultFlagMustBeHome) {
// this.defaultFlagMustBeHome = defaultFlagMustBeHome;
// }
//
// public boolean isDefaultFlagMustBeHome() {
// return this.defaultFlagMustBeHome;
// }
//
// public void setDefaultMinPlayers(int defaultMinPlayers) {
// this.defaultMinPlayers = defaultMinPlayers;
// }
//
// public int getDefaultMinPlayers() {
// return defaultMinPlayers;
// }
//
// public void setDefaultMinTeams(int defaultMinTeams) {
// this.defaultMinTeams = defaultMinTeams;
// }
//
// public int getDefaultMinTeams() {
// return defaultMinTeams;
// }
public InventoryBag getDefaultInventories() {
return defaultInventories;
}
// public void setDefaultPvpInZone(boolean defaultPvpInZone) {
// this.defaultPvpInZone = defaultPvpInZone;
// }
//
// public boolean isDefaultPvpInZone() {
// return defaultPvpInZone;
// }
//
// public void setDefaultInstaBreak(boolean defaultInstaBreak) {
// this.defaultInstaBreak = defaultInstaBreak;
// }
//
// public boolean isDefaultInstaBreak() {
// return defaultInstaBreak;
// }
public List<String> getDeadlyAdjectives() {
return deadlyAdjectives;
}
@ -1556,54 +977,6 @@ public class War extends JavaPlugin {
return killerVerbs;
}
// public boolean isTntInZonesOnly() {
// return tntInZonesOnly;
// }
//
// public void setTntInZonesOnly(boolean tntInZonesOnly) {
// this.tntInZonesOnly = tntInZonesOnly;
// }
// public boolean isDefaultNoDrops() {
// return defaultNoDrops;
// }
//
// public void setDefaultNoDrops(boolean defaultNoDrops) {
// this.defaultNoDrops = defaultNoDrops;
// }
//
// public boolean isDefaultNoHunger() {
// return defaultNoHunger;
// }
//
// public void setDefaultNoHunger(boolean defaultNoHunger) {
// this.defaultNoHunger = defaultNoHunger;
// }
//
// public int getDefaultSaturation() {
// return defaultSaturation;
// }
//
// public void setDefaultSaturation(int defaultSaturation) {
// this.defaultSaturation = defaultSaturation;
// }
// public void setMaxZones(int maxZones) {
// this.maxZones = maxZones;
// }
//
// public int getMaxZones() {
// return maxZones;
// }
// public void setDefaultRespawnTimer(int defaultRespawnTimer) {
// this.defaultRespawnTimer = defaultRespawnTimer;
// }
//
// public int getDefaultRespawnTimer() {
// return defaultRespawnTimer;
// }
public TeamConfigBag getTeamDefaultConfig() {
return this.teamDefaultConfig ;
}

6
war/src/main/java/bukkit/tommytony/war/WarBlockListener.java
View File

@ -235,9 +235,9 @@ public class WarBlockListener extends BlockListener {
block.setType(Material.AIR);
String spawnOrFlag = "spawn or flag";
if (team.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN).equals(FlagReturn.FLAG)
|| team.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN) == FlagReturn.SPAWN) {
spawnOrFlag = team.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN).toString();
if (team.getTeamConfig().resolveFlagReturn().equals(FlagReturn.FLAG)
|| team.getTeamConfig().resolveFlagReturn() == FlagReturn.SPAWN) {
spawnOrFlag = team.getTeamConfig().resolveFlagReturn().toString();
}
for (Team t : warzone.getTeams()) {

4
war/src/main/java/bukkit/tommytony/war/WarEntityListener.java
View File

@ -427,7 +427,7 @@ public class WarEntityListener extends EntityListener {
Team team = Team.getTeamByPlayerName(player.getName());
if ((event.getRegainReason() == RegainReason.EATING
|| event.getRegainReason().toString() != "SATIATED" )
&& team.getTeamConfig().getBoolean(TeamConfig.NOHUNGER)) {
&& team.getTeamConfig().resolveBoolean(TeamConfig.NOHUNGER)) {
// noHunger setting means you can't auto-heal with full hunger bar (use saturation instead to control how fast you get hungry)
event.setCancelled(true);
} else if (event.getRegainReason() == RegainReason.REGEN) {
@ -446,7 +446,7 @@ public class WarEntityListener extends EntityListener {
Player player = (Player) event.getEntity();
Warzone zone = Warzone.getZoneByPlayerName(player.getName());
Team team = Team.getTeamByPlayerName(player.getName());
if (zone != null && team.getTeamConfig().getBoolean(TeamConfig.NOHUNGER)){
if (zone != null && team.getTeamConfig().resolveBoolean(TeamConfig.NOHUNGER)){
event.setCancelled(true);
}
}

16
war/src/main/java/bukkit/tommytony/war/WarPlayerListener.java
View File

@ -306,7 +306,7 @@ public class WarPlayerListener extends PlayerListener {
int totalCap = 0;
for (Team t : zone.getTeams()) {
noOfPlayers += t.getPlayers().size();
totalCap += t.getTeamConfig().getInt(TeamConfig.MAXSCORE);
totalCap += t.getTeamConfig().resolveInt(TeamConfig.MAXSCORE);
}
if (noOfPlayers < totalCap) {
@ -330,7 +330,7 @@ public class WarPlayerListener extends PlayerListener {
this.dropFromOldTeamIfAny(player);
if (zone.getWarzoneConfig().getBoolean(WarzoneConfig.DISABLED)) {
this.handleDisabledZone(event, player, zone);
} else if (team.getPlayers().size() < team.getTeamConfig().getInt(TeamConfig.TEAMSIZE)) {
} else if (team.getPlayers().size() < team.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE)) {
team.addPlayer(player);
team.resetSign();
if (War.war.getWarHub() != null) {
@ -444,7 +444,7 @@ public class WarPlayerListener extends PlayerListener {
return;
}
if (playerWarzone.isRespawning(player)) {
int rt = playerTeam.getTeamConfig().getInt(TeamConfig.RESPAWNTIMER);
int rt = playerTeam.getTeamConfig().resolveInt(TeamConfig.RESPAWNTIMER);
String isS = "s";
if (rt==1) isS = "";
War.war.badMsg(player, "Can't leave spawn for "+rt+" second"+isS+" after spawning!");
@ -479,18 +479,18 @@ public class WarPlayerListener extends PlayerListener {
boolean inSpawn = playerTeam.getSpawnVolume().contains(player.getLocation());
boolean inFlag = (playerTeam.getFlagVolume() != null && playerTeam.getFlagVolume().contains(player.getLocation()));
if (playerTeam.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN).equals(FlagReturn.BOTH)) {
if (playerTeam.getTeamConfig().resolveFlagReturn().equals(FlagReturn.BOTH)) {
if (!inSpawn && !inFlag) {
return;
}
} else if (playerTeam.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN).equals(FlagReturn.SPAWN)) {
} else if (playerTeam.getTeamConfig().resolveFlagReturn().equals(FlagReturn.SPAWN)) {
if (inFlag) {
War.war.badMsg(player, "You have to capture the enemy flag at your team's spawn.");
return;
} else if (!inSpawn) {
return;
}
} else if (playerTeam.getTeamConfig().getFlagReturn(TeamConfig.FLAGRETURN).equals(FlagReturn.FLAG)) {
} else if (playerTeam.getTeamConfig().resolveFlagReturn().equals(FlagReturn.FLAG)) {
if (inSpawn) {
War.war.badMsg(player, "You have to capture the enemy flag at your team's flag.");
return;
@ -499,13 +499,13 @@ public class WarPlayerListener extends PlayerListener {
}
}
if (playerWarzone.isTeamFlagStolen(playerTeam) && playerTeam.getTeamConfig().getBoolean(TeamConfig.FLAGMUSTBEHOME)) {
if (playerWarzone.isTeamFlagStolen(playerTeam) && playerTeam.getTeamConfig().resolveBoolean(TeamConfig.FLAGMUSTBEHOME)) {
War.war.badMsg(player, "You can't capture the enemy flag until your team's flag is returned.");
} else {
synchronized (playerWarzone) {
// flags can be captured at own spawn or own flag pole
playerTeam.addPoint();
if (playerTeam.getPoints() >= playerTeam.getTeamConfig().getInt(TeamConfig.MAXSCORE)) {
if (playerTeam.getPoints() >= playerTeam.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)) {
if (playerWarzone.hasPlayerState(player.getName())) {
playerWarzone.restorePlayerState(player);
}

4
war/src/main/java/bukkit/tommytony/war/WarSpoutListener.java
View File

@ -77,7 +77,7 @@ public class WarSpoutListener extends SpoutListener {
linecounter = 0;
for (Team t : zone.getTeams()) {
// scores
line = new GenericLabel(t.getPoints()+"/"+t.getTeamConfig().getInt(TeamConfig.MAXSCORE)+" points");
line = new GenericLabel(t.getPoints()+"/"+t.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)+" points");
if (t.getPlayers().size()==0) line.setTextColor(new Color(100,100,100));
line.setTooltip("Warzone: "+zone.getName()).setAnchor(WidgetAnchor.TOP_LEFT);
line.setAlign(WidgetAnchor.TOP_LEFT).setX(3+teammax+15+playmax+15).setY(3+linecounter*(GenericLabel.getStringHeight("O")+3)).setWidth(GenericLabel.getStringWidth(line.getText())).setHeight(GenericLabel.getStringHeight(line.getText()));
@ -92,7 +92,7 @@ public class WarSpoutListener extends SpoutListener {
// and finally, lives.
linecounter = 0;
for (Team t : zone.getTeams()) {
line = new GenericLabel(t.getRemainingLifes()+"/"+t.getTeamConfig().getInt(TeamConfig.LIFEPOOL)+" lives");
line = new GenericLabel(t.getRemainingLifes()+"/"+t.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL)+" lives");
if (t.getPlayers().size()==0) line.setTextColor(new Color(100,100,100));
line.setTooltip("Warzone: "+zone.getName()).setAnchor(WidgetAnchor.TOP_LEFT);
line.setAlign(WidgetAnchor.TOP_LEFT).setX(3+teammax+15+playmax+15+scoremax+15).setY(3+linecounter*(GenericLabel.getStringHeight("O")+3)).setWidth(GenericLabel.getStringWidth(line.getText())).setHeight(GenericLabel.getStringHeight(line.getText()));

2
war/src/main/java/bukkit/tommytony/war/command/JoinCommand.java
View File

@ -104,7 +104,7 @@ public class JoinCommand extends AbstractWarCommand {
zone.keepPlayerState(player);
this.msg("Your inventory is in storage until you use '/war leave'.");
}
if (team.getPlayers().size() < team.getTeamConfig().getInt(TeamConfig.TEAMSIZE)) {
if (team.getPlayers().size() < team.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE)) {
team.addPlayer(player);
team.resetSign();
zone.respawnPlayer(team, player);

2
war/src/main/java/bukkit/tommytony/war/command/SetTeamCommand.java
View File

@ -54,7 +54,7 @@ public class SetTeamCommand extends AbstractZoneMakerCommand {
} else {
// new team (use default TeamKind name for now)
Team newTeam = new Team(teamKind.toString(), teamKind, player.getLocation(), zone);
newTeam.setRemainingLives(newTeam.getTeamConfig().getInt(TeamConfig.LIFEPOOL));
newTeam.setRemainingLives(newTeam.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
zone.getTeams().add(newTeam);
if (zone.getLobby() != null) {
zone.getLobby().getVolume().resetBlocks();

2
war/src/main/java/bukkit/tommytony/war/command/SetTeamConfigCommand.java
View File

@ -99,7 +99,7 @@ public class SetTeamConfigCommand extends AbstractZoneMakerCommand {
if (this.args.length > 0 && (this.args[0].equals("-p") || this.args[0].equals("print"))) {
// only printing
if (this.args.length == 1) {
this.msg(War.war.printConfig(zone));
this.msg(War.war.printConfig(team));
return true;
} else {
// first param was to print, shift again

28
war/src/main/java/com/tommytony/war/Team.java
View File

@ -71,10 +71,11 @@ public class Team {
int y = this.teamSpawn.getBlockY();
int z = this.teamSpawn.getBlockZ();
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.INVISIBLE)) {
TeamSpawnStyle style = this.getTeamConfig().resolveSpawnStyle();
if (style.equals(TeamSpawnStyle.INVISIBLE)) {
this.spawnVolume.setCornerOne(this.warzone.getWorld().getBlockAt(x, y - 1, z));
this.spawnVolume.setCornerTwo(this.warzone.getWorld().getBlockAt(x, y + 3, z));
} else if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.SMALL)) {
} else if (style.equals(TeamSpawnStyle.SMALL)) {
this.spawnVolume.setCornerOne(this.warzone.getWorld().getBlockAt(x - 1, y - 1, z - 1));
this.spawnVolume.setCornerTwo(this.warzone.getWorld().getBlockAt(x + 1, y + 3, z + 1));
} else {
@ -94,7 +95,8 @@ public class Team {
int y = this.teamSpawn.getBlockY();
int z = this.teamSpawn.getBlockZ();
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.INVISIBLE)) {
TeamSpawnStyle style = this.getTeamConfig().resolveSpawnStyle();
if (style.equals(TeamSpawnStyle.INVISIBLE)) {
// nothing but glowstone
this.warzone.getWorld().getBlockAt(x, y - 1, z).setType(Material.GLOWSTONE);
} else {
@ -120,7 +122,7 @@ public class Team {
Block signBlock = null;
int signData = 0;
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.INVISIBLE)) {
if (style.equals(TeamSpawnStyle.INVISIBLE)) {
// INVISIBLE style
signBlock = this.warzone.getWorld().getBlockAt(x, y, z);
if (yaw >= 0 && yaw < 90) {
@ -132,7 +134,7 @@ public class Team {
} else if (yaw >= 270 && yaw <= 360) {
signData = 6;
}
} else if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.SMALL)) {
} else if (style.equals(TeamSpawnStyle.SMALL)) {
// SMALL style
if (yaw >= 0 && yaw < 90) {
signData = 10;
@ -178,7 +180,7 @@ public class Team {
signData = 10;
signBlock = this.warzone.getWorld().getBlockAt(x, y, z).getRelative(BlockFace.NORTH, 2).getRelative(BlockFace.WEST, 2);
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.BIG)) {
if (style.equals(TeamSpawnStyle.BIG)) {
// rim
this.setBlock(x - 2, y, z - 1, this.kind);
this.setBlock(x - 2, y, z - 2, this.kind);
@ -210,7 +212,7 @@ public class Team {
opposite = BlockFace.SOUTH_WEST;
signData = 14;
signBlock = this.warzone.getWorld().getBlockAt(x, y, z).getRelative(BlockFace.NORTH, 2).getRelative(BlockFace.EAST, 2);
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.BIG)) {
if (style.equals(TeamSpawnStyle.BIG)) {
// rim
this.setBlock(x + 1, y, z - 2, this.kind);
this.setBlock(x + 2, y, z - 2, this.kind);
@ -242,7 +244,7 @@ public class Team {
opposite = BlockFace.NORTH_WEST;
signData = 2;
signBlock = this.warzone.getWorld().getBlockAt(x, y, z).getRelative(BlockFace.SOUTH, 2).getRelative(BlockFace.EAST, 2);
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.BIG)) {
if (style.equals(TeamSpawnStyle.BIG)) {
// rim
this.setBlock(x + 2, y, z + 1, this.kind);
this.setBlock(x + 2, y, z + 2, this.kind);
@ -274,7 +276,7 @@ public class Team {
opposite = BlockFace.NORTH_EAST;
signData = 6;
signBlock = this.warzone.getWorld().getBlockAt(x, y, z).getRelative(BlockFace.SOUTH, 2).getRelative(BlockFace.WEST, 2);
if (this.getTeamConfig().getInt(TeamConfig.SPAWNSTYLE).equals(TeamSpawnStyle.BIG)) {
if (style.equals(TeamSpawnStyle.BIG)) {
// rim
this.setBlock(x - 1, y, z + 2, this.kind);
this.setBlock(x - 2, y, z + 2, this.kind);
@ -307,12 +309,12 @@ public class Team {
if (signBlock != null) {
String[] lines = new String[4];
lines[0] = "Team " + this.name;
lines[1] = this.players.size() + "/" + this.getTeamConfig().getInt(TeamConfig.TEAMSIZE) + " players";
lines[2] = this.points + "/" + this.getTeamConfig().getInt(TeamConfig.MAXSCORE)+ " pts";
if (this.getTeamConfig().getInt(TeamConfig.LIFEPOOL) == -1) {
lines[1] = this.players.size() + "/" + this.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE) + " players";
lines[2] = this.points + "/" + this.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)+ " pts";
if (this.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL) == -1) {
lines[3] = "unlimited lives";
} else {
lines[3] = this.remainingLives + "/" + this.getTeamConfig().getInt(TeamConfig.LIFEPOOL) + " lives left";
lines[3] = this.remainingLives + "/" + this.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL) + " lives left";
}
SignHelper.setToSign(War.war, signBlock, (byte) signData, lines);

2
war/src/main/java/com/tommytony/war/WarHub.java
View File

@ -235,7 +235,7 @@ public class WarHub {
int zonePlayers = 0;
for (Team t : zone.getTeams()) {
zonePlayers += t.getPlayers().size();
zoneCap += t.getTeamConfig().getInt(TeamConfig.TEAMSIZE);
zoneCap += t.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE);
}
String[] lines = new String[4];
lines[0] = "Warzone";

308
war/src/main/java/com/tommytony/war/Warzone.java
View File

@ -45,51 +45,22 @@ import com.tommytony.war.volumes.ZoneVolume;
public class Warzone {
private String name;
private ZoneVolume volume;
private World world;
private final List<Team> teams = new ArrayList<Team>();
private final List<Monument> monuments = new ArrayList<Monument>();
private Location teleport;
private ZoneLobby lobby;
private Location rallyPoint;
private final List<String> authors = new ArrayList<String>();
private final List<Player> respawn = new ArrayList<Player>();
private Location teleport;
// private boolean friendlyFire = false;
// private int lifePool = 7;
// private int teamCap = 5;
// private int scoreCap = 5;
// private int monumentHeal = 5;
// private FlagReturn flagReturn = FlagReturn.BOTH;
// private TeamSpawnStyle spawnStyle = TeamSpawnStyle.BIG;
private final int minSafeDistanceFromWall = 6;
private List<ZoneWallGuard> zoneWallGuards = new ArrayList<ZoneWallGuard>();
private HashMap<String, PlayerState> playerStates = new HashMap<String, PlayerState>();
private HashMap<String, Team> flagThieves = new HashMap<String, Team>();
private HashMap<String, LoadoutSelection> loadoutSelections = new HashMap<String, LoadoutSelection>();
private World world;
private final int minSafeDistanceFromWall = 6;
private List<ZoneWallGuard> zoneWallGuards = new ArrayList<ZoneWallGuard>();
private ZoneLobby lobby;
// private boolean autoAssignOnly = false;
// private boolean flagPointsOnly = false;
// private boolean flagMustBeHome = true;
// private boolean blockHeads = true;
// private boolean unbreakableZoneBlocks = false;
// private boolean disabled = false;
// private boolean noCreatures = false;
// private boolean glassWalls = true;
// private boolean pvpInZone = true;
// private boolean instaBreak = false;
// private boolean noDrops = false;
// private boolean noHunger = false;
// private int respawnTimer = 0;
// private int saturation = 10;
// private int minPlayers = 1;
// private int minTeams = 1;
// private boolean resetOnEmpty = false;
// private boolean resetOnLoad = false;
// private boolean resetOnUnload = false;
private HashMap<String, PlayerState> deadMenInventories = new HashMap<String, PlayerState>();
private Location rallyPoint;
private final List<Player> respawn = new ArrayList<Player>();
private final WarzoneConfigBag warzoneConfig = new WarzoneConfigBag();
private final TeamConfigBag teamDefaultConfig = new TeamConfigBag();
@ -98,33 +69,6 @@ public class Warzone {
public Warzone(World world, String name) {
this.world = world;
this.name = name;
// this.friendlyFire = War.war.isDefaultFriendlyFire();
// this.setLifePool(War.war.getDefaultLifepool());
// this.loadouts = (HashMap<String, HashMap<Integer, ItemStack>>)War.war.getDefaultLoadouts().clone();
// this.reward = (HashMap<Integer, ItemStack>)War.war.getDefaultReward().clone();
// this.autoAssignOnly = War.war.isDefaultAutoAssignOnly();
// this.setFlagPointsOnly(War.war.isDefaultFlagPointsOnly());
// this.setFlagMustBeHome(War.war.isDefaultFlagMustBeHome());
// this.teamCap = War.war.getDefaultTeamCap();
// this.scoreCap = War.war.getDefaultScoreCap();
// this.monumentHeal = War.war.getDefaultMonumentHeal();
// this.spawnStyle = War.war.getDefaultSpawnStyle(); // don't use side-effect-full setters instead of this
// this.flagReturn = War.war.getDefaultFlagReturn();
// this.setBlockHeads(War.war.isDefaultBlockHeads());
// this.setUnbreakableZoneBlocks(War.war.isDefaultUnbreakableZoneBlocks());
// this.setNoCreatures(War.war.isDefaultNoCreatures());
// this.setGlassWalls(War.war.isDefaultGlassWalls());
// this.setPvpInZone(War.war.isDefaultPvpInZone());
// this.setInstaBreak(War.war.isDefaultInstaBreak());
// this.setNoDrops(War.war.isDefaultNoDrops());
// this.setNoHunger(War.war.isDefaultNoHunger());
// this.setRespawnTimer(War.war.getDefaultRespawnTimer());
// this.setSaturation(War.war.getDefaultSaturation());
// this.setMinPlayers(War.war.getDefaultMinPlayers());
// this.setMinTeams(War.war.getDefaultMinTeams());
// this.setResetOnEmpty(War.war.isDefaultResetOnEmpty());
// this.setResetOnLoad(War.war.isDefaultResetOnLoad());
// this.setResetOnUnload(War.war.isDefaultResetOnUnload());
this.volume = new ZoneVolume(name, this.getWorld(), this);
}
@ -194,7 +138,7 @@ public class Warzone {
} else {
for (Team team : this.getTeams()) {
teamsMessage += team.getName() + " (" + team.getPoints() + " points, " + team.getRemainingLifes() + "/"
+ team.getTeamConfig().getInt(TeamConfig.LIFEPOOL) + " lives left. ";
+ team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL) + " lives left. ";
for (Player member : team.getPlayers()) {
teamsMessage += member.getName() + " ";
}
@ -273,7 +217,7 @@ public class Warzone {
this.respawnPlayer(team, player);
}
}
team.setRemainingLives(team.getTeamConfig().getInt(TeamConfig.LIFEPOOL));
team.setRemainingLives(team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
team.initializeTeamSpawn();
if (team.getTeamFlag() != null) {
team.setTeamFlag(team.getTeamFlag());
@ -348,7 +292,7 @@ public class Warzone {
player.setRemainingAir(300);
player.setHealth(20);
player.setFoodLevel(20);
player.setSaturation(team.getTeamConfig().getInt(TeamConfig.SATURATION));
player.setSaturation(team.getTeamConfig().resolveInt(TeamConfig.SATURATION));
player.setExhaustion(0);
player.setFireTicks(0); //this works fine here, why put it in LoudoutResetJob...? I'll keep it over there though
@ -374,7 +318,7 @@ public class Warzone {
}
final LoadoutResetJob job = new LoadoutResetJob(this, team, player, isFirstRespawn, false);
if (team.getTeamConfig().getInt(TeamConfig.RESPAWNTIMER) == 0 || isFirstRespawn) {
if (team.getTeamConfig().resolveInt(TeamConfig.RESPAWNTIMER) == 0 || isFirstRespawn) {
War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, job);
}
else {
@ -386,7 +330,7 @@ public class Warzone {
respawn.remove(player);
War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, job);
}
}, team.getTeamConfig().getInt(TeamConfig.RESPAWNTIMER) * 20L); // 20 ticks = 1 second
}, team.getTeamConfig().resolveInt(TeamConfig.RESPAWNTIMER) * 20L); // 20 ticks = 1 second
}
}
@ -464,31 +408,11 @@ public class Warzone {
return this.monuments;
}
// public boolean getFriendlyFire() {
// return this.friendlyFire;
// }
//
// public void setFriendlyFire(boolean ffOn) {
// this.friendlyFire = ffOn;
// }
//
// public void setLifePool(int lifePool) {
// this.lifePool = lifePool;
// for (Team team : this.teams) {
// team.setRemainingLives(lifePool);
// }
// }
//
// public int getLifePool() {
// return this.lifePool;
// }
//
// public void setMonumentHeal(int monumentHeal) {
// this.monumentHeal = monumentHeal;
// }
//
// public int getMonumentHeal() {
// return this.monumentHeal;
// }
public boolean hasPlayerState(String playerName) {
@ -743,16 +667,6 @@ public class Warzone {
if (guard.getPlayer().getName().equals(player.getName())) {
playerGuards.add(guard);
guard.deactivate();
// BlockFace guardWall = guard.getWall();
// getVolume().resetWallBlocks(guardWall);
// if (isDrawZoneOutline()) {
// addZoneOutline(guard.getWall());
// }
// if (lobby != null) {
// lobby.getVolume().resetBlocks(); // always reset the lobby even if the guard is on another wall
// // because player can go around corner
// lobby.initialize();
// }
}
}
// now remove those zone guards
@ -792,37 +706,6 @@ public class Warzone {
return lowestNoOfPlayers;
}
// public void setTeamCap(int teamCap) {
// this.teamCap = teamCap;
// }
//
// public int getTeamCap() {
// return this.teamCap;
// }
//
// public void setScoreCap(int scoreCap) {
// this.scoreCap = scoreCap;
// }
//
// public int getScoreCap() {
// return this.scoreCap;
// }
// public void setAutoAssignOnlyAndResetLobby(boolean autoAssignOnly) {
// this.autoAssignOnly = autoAssignOnly;
// if (this.getLobby() != null) {
// this.getLobby().setLocation(this.getTeleport());
// }
// }
//
// public void setAutoAssignOnlyWithoutResettingLobby(boolean autoAssignOnly) {
// this.autoAssignOnly = autoAssignOnly;
// }
//
// public boolean isAutoAssignOnly() {
// return this.autoAssignOnly;
// }
public void handleDeath(Player player) {
Team playerTeam = Team.getTeamByPlayerName(player.getName());
Warzone playerWarzone = Warzone.getZoneByPlayerName(player.getName());
@ -837,13 +720,13 @@ public class Warzone {
for (Team t : teams) {
t.teamcast("The battle is over. Team " + playerTeam.getName() + " lost: " + player.getName() + " died and there were no lives left in their life pool.");
if (t.getPlayers().size() != 0 && !t.getTeamConfig().getBoolean(TeamConfig.FLAGPOINTSONLY)) {
if (t.getPlayers().size() != 0 && !t.getTeamConfig().resolveBoolean(TeamConfig.FLAGPOINTSONLY)) {
if (!t.getName().equals(playerTeam.getName())) {
// all other teams get a point
t.addPoint();
t.resetSign();
}
scores += t.getName() + "(" + t.getPoints() + "/" + t.getTeamConfig().getInt(TeamConfig.MAXSCORE) + ") ";
scores += t.getName() + "(" + t.getPoints() + "/" + t.getTeamConfig().resolveInt(TeamConfig.MAXSCORE) + ") ";
}
}
if (!scores.equals("")) {
@ -854,7 +737,7 @@ public class Warzone {
// detect score cap
List<Team> scoreCapTeams = new ArrayList<Team>();
for (Team t : teams) {
if (t.getPoints() == t.getTeamConfig().getInt(TeamConfig.MAXSCORE)) {
if (t.getPoints() == t.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)) {
scoreCapTeams.add(t);
}
}
@ -970,7 +853,7 @@ public class Warzone {
// reset the zone for a new game when the last player leaves
for (Team team : this.getTeams()) {
team.resetPoints();
team.setRemainingLives(team.getTeamConfig().getInt(TeamConfig.LIFEPOOL));
team.setRemainingLives(team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
}
this.getVolume().resetBlocksAsJob();
this.initializeZoneAsJob();
@ -1052,56 +935,11 @@ public class Warzone {
}
}
// public void setBlockHeads(boolean blockHeads) {
// this.blockHeads = blockHeads;
// }
//
// public boolean isBlockHeads() {
// return this.blockHeads;
// }
// public void setSpawnStyle(TeamSpawnStyle spawnStyle) {
// this.spawnStyle = spawnStyle;
// for (Team team : this.teams) {
// team.setTeamSpawn(team.getTeamSpawn());
// }
// }
//
// public TeamSpawnStyle getSpawnStyle() {
// return this.spawnStyle;
// }
//
//
// public void setFlagReturn(FlagReturn flagReturn) {
// this.flagReturn = flagReturn;
// }
//
// public FlagReturn getFlagReturn() {
// return this.flagReturn;
// }
// public void setUnbreakableZoneBlocks(boolean unbreakableZoneBlocks) {
// this.unbreakableZoneBlocks = unbreakableZoneBlocks;
// }
//
// public boolean isUnbreakableZoneBlocks() {
// return this.unbreakableZoneBlocks;
// }
//
// public void setDisabled(boolean disabled) {
// this.disabled = disabled;
// }
//
// public boolean isDisabled() {
// return this.disabled;
// }
//
// public boolean isNoCreatures() {
// return this.noCreatures;
// }
//
// public void setNoCreatures(boolean noCreatures) {
// this.noCreatures = noCreatures;
// }
public boolean isDeadMan(String playerName) {
@ -1158,114 +996,10 @@ public class Warzone {
return false;
}
// public void setResetOnLoad(boolean resetOnLoad) {
// this.resetOnLoad = resetOnLoad;
// }
//
// public boolean isResetOnLoad() {
// return this.resetOnLoad;
// }
//
// public void setResetOnUnload(boolean resetOnUnload) {
// this.resetOnUnload = resetOnUnload;
// }
//
// public boolean isResetOnUnload() {
// return this.resetOnUnload;
// }
//
// public void setResetOnEmpty(boolean resetOnEmpty) {
// this.resetOnEmpty = resetOnEmpty;
// }
//
// public boolean isResetOnEmpty() {
// return this.resetOnEmpty;
// }
//
// public void setGlassWalls(boolean glassWalls) {
// this.glassWalls = glassWalls;
// }
//
// public boolean isGlassWalls() {
// return this.glassWalls;
// }
// public void setFlagPointsOnly(boolean flagPointsOnly) {
// this.flagPointsOnly = flagPointsOnly;
// }
//
// public boolean isFlagPointsOnly() {
// return this.flagPointsOnly;
// }
//
// public void setFlagMustBeHome(boolean flagMustBeHome) {
// this.flagMustBeHome = flagMustBeHome;
// }
//
// public boolean isFlagMustBeHome() {
// return this.flagMustBeHome;
// }
//
// public void setMinPlayers(int minPlayers) {
// this.minPlayers = minPlayers;
// }
//
// public int getMinPlayers() {
// return minPlayers;
// }
//
// public void setMinTeams(int minTeams) {
// this.minTeams = minTeams;
// }
//
// public int getMinTeams() {
// return minTeams;
// }
public HashMap<String, LoadoutSelection> getLoadoutSelections() {
return loadoutSelections;
}
// public boolean isPvpInZone() {
// return pvpInZone;
// }
//
// public void setPvpInZone(boolean stopPvp) {
// this.pvpInZone = stopPvp;
// }
//
// public boolean isInstaBreak() {
// return instaBreak;
// }
//
// public void setInstaBreak(boolean instaBreak) {
// this.instaBreak = instaBreak;
// }
//
// public boolean isNoDrops() {
// return noDrops;
// }
//
// public void setNoDrops(boolean noDrops) {
// this.noDrops = noDrops;
// }
// public boolean isNoHunger() {
// return noHunger;
// }
//
// public void setNoHunger(boolean noHunger) {
// this.noHunger = noHunger;
// }
//
// public int getSaturation() {
// return this.saturation;
// }
//
// public void setSaturation(int saturation) {
// this.saturation = saturation;
// }
public boolean isAuthor(Player player) {
// if no authors, all zonemakers can edit the zone
return authors.size() == 0 || authors.contains(player.getName());
@ -1308,14 +1042,6 @@ public class Warzone {
}
}
// public void setRespawnTimer(int respawnTimer) {
// this.respawnTimer = respawnTimer;
// }
//
// public int getRespawnTimer() {
// return this.respawnTimer;
// }
public WarzoneConfigBag getWarzoneConfig() {
return this.warzoneConfig;
}

8
war/src/main/java/com/tommytony/war/ZoneLobby.java
View File

@ -588,12 +588,12 @@ public class ZoneLobby {
if (gate != null) {
String[] lines = new String[4];
lines[0] = "Team " + team.getName();
lines[1] = team.getPlayers().size() + "/" + team.getTeamConfig().getInt(TeamConfig.TEAMSIZE) + " players";
lines[2] = team.getPoints() + "/" + team.getTeamConfig().getInt(TeamConfig.MAXSCORE) + " pts";
if (team.getTeamConfig().getInt(TeamConfig.LIFEPOOL) == -1) {
lines[1] = team.getPlayers().size() + "/" + team.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE) + " players";
lines[2] = team.getPoints() + "/" + team.getTeamConfig().resolveInt(TeamConfig.MAXSCORE) + " pts";
if (team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL) == -1) {
lines[3] = "unlimited lives";
} else {
lines[3] = team.getRemainingLifes() + "/" + team.getTeamConfig().getInt(TeamConfig.TEAMSIZE) + " lives left";
lines[3] = team.getRemainingLifes() + "/" + team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL) + " lives left";
}
this.resetGateSign(gate, lines, true);
}

93
war/src/main/java/com/tommytony/war/config/TeamConfigBag.java
View File

@ -35,64 +35,100 @@ public class TeamConfigBag {
public void put(TeamConfig config, Object value) {
this.bag.put(config, value);
}
public Object getValue(TeamConfig config) {
if (this.contains(config)) {
return this.bag.get(config);
} else {
return null;
}
}
public Object resolveValue(TeamConfig config) {
if (this.contains(config)) {
return this.bag.get(config);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(config)){
// use Warzone default config
return this.warzone.getTeamDefaultConfig().getValue(config);
return this.warzone.getTeamDefaultConfig().resolveValue(config);
} else {
// use War default config
return War.war.getTeamDefaultConfig().getValue(config);
return War.war.getTeamDefaultConfig().resolveValue(config);
}
}
public Integer getInt(TeamConfig config) {
if (this.contains(config)) {
return (Integer)this.bag.get(config);
}
return null;
}
public Integer resolveInt(TeamConfig config) {
if (this.contains(config)) {
return (Integer)this.bag.get(config);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(config)){
// use Warzone default config
return this.warzone.getTeamDefaultConfig().getInt(config);
return this.warzone.getTeamDefaultConfig().resolveInt(config);
} else {
// use War default config
return War.war.getTeamDefaultConfig().getInt(config);
return War.war.getTeamDefaultConfig().resolveInt(config);
}
}
public Boolean getBoolean(TeamConfig config) {
if (this.contains(config)) {
return (Boolean)this.bag.get(config);
}
return null;
}
public Boolean resolveBoolean(TeamConfig config) {
if (this.contains(config)) {
return (Boolean)this.bag.get(config);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(config)){
// use Warzone default config
return this.warzone.getTeamDefaultConfig().getBoolean(config);
return this.warzone.getTeamDefaultConfig().resolveBoolean(config);
} else {
// use War default config
return War.war.getTeamDefaultConfig().getBoolean(config);
return War.war.getTeamDefaultConfig().resolveBoolean(config);
}
}
public FlagReturn getFlagReturn(TeamConfig config) {
if (this.contains(config)) {
return (FlagReturn)this.bag.get(config);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(config)){
public FlagReturn resolveFlagReturn() {
if (this.contains(TeamConfig.FLAGRETURN)) {
return (FlagReturn)this.bag.get(TeamConfig.FLAGRETURN);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(TeamConfig.FLAGRETURN)){
// use Warzone default config
return this.warzone.getTeamDefaultConfig().getFlagReturn(config);
return this.warzone.getTeamDefaultConfig().resolveFlagReturn();
} else {
// use War default config
return War.war.getTeamDefaultConfig().getFlagReturn(config);
return War.war.getTeamDefaultConfig().resolveFlagReturn();
}
}
public TeamSpawnStyle getSpawnStyle(TeamConfig config) {
if (this.contains(config)) {
return (TeamSpawnStyle)this.bag.get(config);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(config)){
// use War default config
return this.warzone.getTeamDefaultConfig().getSpawnStyle(config);
} else {
return War.war.getTeamDefaultConfig().getSpawnStyle(config);
public FlagReturn getFlagReturn() {
if (this.contains(TeamConfig.FLAGRETURN)) {
return (FlagReturn)this.bag.get(TeamConfig.FLAGRETURN);
}
return null;
}
public TeamSpawnStyle resolveSpawnStyle() {
if (this.contains(TeamConfig.SPAWNSTYLE)) {
return (TeamSpawnStyle)this.bag.get(TeamConfig.SPAWNSTYLE);
} else if (this.warzone != null && this.warzone.getTeamDefaultConfig().contains(TeamConfig.SPAWNSTYLE)){
// use War default config
return this.warzone.getTeamDefaultConfig().resolveSpawnStyle();
} else {
return War.war.getTeamDefaultConfig().resolveSpawnStyle();
}
}
public TeamSpawnStyle getSpawnStyle() {
if (this.contains(TeamConfig.SPAWNSTYLE)) {
return (TeamSpawnStyle)this.bag.get(TeamConfig.SPAWNSTYLE);
}
return null;
}
public void loadFrom(ConfigurationSection teamConfigSection) {
@ -122,7 +158,12 @@ public class TeamConfigBag {
public void saveTo(ConfigurationSection teamConfigSection) {
for (TeamConfig config : TeamConfig.values()) {
if (this.contains(config)) {
teamConfigSection.set(config.toString(), this.bag.get(config).toString());
if (config.getConfigType().equals(Integer.class)
|| config.getConfigType().equals(Boolean.class)) {
teamConfigSection.set(config.toString(), this.bag.get(config));
} else {
teamConfigSection.set(config.toString(), this.bag.get(config).toString());
}
}
}
}
@ -145,15 +186,15 @@ public class TeamConfigBag {
TeamSpawnStyle spawnValue = TeamSpawnStyle.getStyleFromString(namedParams.get(namedParam));
this.bag.put(teamConfig, spawnValue);
}
returnMessage += teamConfig.toString() + " set to " + namedParams.get(namedParam);
} else if (namedParam.startsWith("delete")) {
String toDelete = namedParam.replace("delete", "");
returnMessage += " " + teamConfig.toString() + " set to " + namedParams.get(namedParam);
} else if (namedParam.equals("delete")) {
String toDelete = namedParams.get(namedParam);
teamConfig = TeamConfig.teamConfigFromString(toDelete);
// param delete (to restore inheritance)
if (teamConfig != null) {
this.bag.remove(teamConfig);
returnMessage += teamConfig.toString() + " removed";
returnMessage += " " + teamConfig.toString() + " removed";
}
}
}

4
war/src/main/java/com/tommytony/war/config/WarzoneConfigBag.java
View File

@ -81,8 +81,8 @@ public class WarzoneConfigBag {
this.bag.put(warzoneConfig, onOff.equals("on") || onOff.equals("true"));
}
returnMessage += warzoneConfig.toString() + " set to " + namedParams.get(namedParam);
} else if (namedParam.startsWith("delete")) {
String toDelete = namedParam.replace("delete", "");
} else if (namedParam.equals("delete")) {
String toDelete = namedParams.get(namedParam);
warzoneConfig = WarzoneConfig.warzoneConfigFromString(toDelete);
// param delete (to restore inheritance)

21
war/src/main/java/com/tommytony/war/jobs/RestoreWarzonesJob.java
View File

@ -6,29 +6,34 @@ import bukkit.tommytony.war.War;
import com.tommytony.war.Warzone;
import com.tommytony.war.config.WarzoneConfig;
import com.tommytony.war.mappers.WarYmlMapper;
import com.tommytony.war.mappers.WarzoneTxtMapper;
import com.tommytony.war.mappers.WarzoneYmlMapper;
public class RestoreWarzonesJob implements Runnable {
private final String warzonesStr;
private final boolean newWarInstall;
private final boolean convertingToYml;
public RestoreWarzonesJob(String warzonesStr, boolean newWarInstall) {
public RestoreWarzonesJob(String warzonesStr, boolean newWarInstall, boolean convertingToYml) {
this.warzonesStr = warzonesStr;
this.newWarInstall = newWarInstall;
this.convertingToYml = convertingToYml;
}
public void run() {
String[] warzoneSplit = this.warzonesStr.split(",");
War.war.getWarzones().clear();
for (String warzoneName : warzoneSplit) {
if (warzoneName != null && !warzoneName.equals("")) {
War.war.log("Loading zone " + warzoneName + "...", Level.INFO);
Warzone zone = WarzoneTxtMapper.load(warzoneName, !this.newWarInstall);
if (zone != null) { // could have failed, would've been logged already
War.war.getWarzones().add(zone);
// zone.getVolume().loadCorners();
zone.getVolume().loadCorners();
if (zone.getLobby() != null) {
zone.getLobby().getVolume().resetBlocks();
}
@ -39,9 +44,21 @@ public class RestoreWarzonesJob implements Runnable {
}
}
}
if (War.war.getWarzones().size() > 0) {
War.war.log("Warzones ready.", Level.INFO);
}
if (convertingToYml) {
// Loading process is over, we can convert (i.e. save in new format)
WarYmlMapper.save();
War.war.log("Converted war.txt to war.yml.", Level.INFO);
for (Warzone zone : War.war.getWarzones()) {
WarzoneYmlMapper.save(zone, false);
War.war.log("Converted warzone-" + zone.getName() + ".txt to warzone-" + zone.getName() + ".yml.", Level.INFO);
}
}
}
}

55
war/src/main/java/com/tommytony/war/mappers/LoadoutYmlMapper.java
View File

@ -3,6 +3,7 @@ package com.tommytony.war.mappers;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.enchantments.Enchantment;
@ -26,9 +27,9 @@ public class LoadoutYmlMapper {
String prefix = loadoutName + "." + slot + ".";
int id = config.getInt(prefix + "id");
byte data = Byte.parseByte(config.getString(prefix + "data"));
byte data = (byte)config.getInt(prefix + "data");
int amount = config.getInt(prefix + "amount");
short durability = Short.parseShort(config.getString(prefix + "durability"));
short durability = (short)config.getInt(prefix + "durability");
ItemStack stack = new ItemStack(id, amount, durability, data);
stack.setDurability(durability);
@ -47,40 +48,48 @@ public class LoadoutYmlMapper {
}
}
public static void fromLoadoutsToConfig(HashMap<String, HashMap<Integer, ItemStack>> loadouts, ConfigurationSection config) {
config.set("names", loadouts.keySet());
public static void fromLoadoutsToConfig(HashMap<String, HashMap<Integer, ItemStack>> loadouts, ConfigurationSection section) {
section.set("names", toStringList(loadouts.keySet()));
for (String name : loadouts.keySet()) {
fromLoadoutToConfig(loadouts.get(name), config, name);
fromLoadoutToConfig(name, loadouts.get(name), section);
}
}
public static void fromLoadoutToConfig(HashMap<Integer, ItemStack> loadout, ConfigurationSection config, String loadoutName) {
//ConfigurationSection loadoutSection = config.createSection(loadoutName);
//loadoutSection.set("slots", loadout.keySet());
config.set(loadoutName + ".slots", loadout.keySet());
private static List<String> toStringList(Set<String> keySet) {
List<String> list = new ArrayList<String>();
for (String key : keySet) {
list.add(key);
}
return list;
}
private static List<Integer> toIntList(Set<Integer> keySet) {
List<Integer> list = new ArrayList<Integer>();
for (Integer key : keySet) {
list.add(key);
}
return list;
}
public static void fromLoadoutToConfig(String loadoutName, HashMap<Integer, ItemStack> loadout, ConfigurationSection section) {
ConfigurationSection loadoutSection = section.createSection(loadoutName);
loadoutSection.set("slots", toIntList(loadout.keySet()));
for (Integer slot : loadout.keySet()) {
// ConfigurationSection slotSection = loadoutSection.createSection(slot.toString());
// ItemStack stack = loadout.get(slot);
//
// slotSection.set("id", stack.getTypeId());
// slotSection.set("data", Byte.toString(stack.getData().getData()));
// slotSection.set("amount", stack.getAmount());
// slotSection.set("durability", Short.toString(stack.getDurability()));
ConfigurationSection slotSection = loadoutSection.createSection(slot.toString());
ItemStack stack = loadout.get(slot);
String slotPrefix = loadoutName + "." + slot + ".";
config.set(slotPrefix + "id", stack.getTypeId());
config.set(slotPrefix + "data", Byte.toString(stack.getData().getData()));
config.set(slotPrefix + "amount", stack.getAmount());
config.set(slotPrefix + "durability", Short.toString(stack.getDurability()));
slotSection.set("id", stack.getTypeId());
slotSection.set("data", stack.getData().getData());
slotSection.set("amount", stack.getAmount());
slotSection.set("durability", stack.getDurability());
if (stack.getEnchantments().keySet().size() > 0) {
List<String> enchantmentStringList = new ArrayList<String>();
for (Enchantment enchantment : stack.getEnchantments().keySet()) {
int level = stack.getEnchantments().get(enchantment);
enchantmentStringList.add(enchantment.getId() + "," + level);
}
config.set(slotPrefix + "enchantments", enchantmentStringList);
slotSection.set("enchantments", enchantmentStringList);
}
}
}

475
war/src/main/java/com/tommytony/war/mappers/WarMapper.java
View File

@ -1,475 +0,0 @@
package com.tommytony.war.mappers;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.logging.Level;
import org.bukkit.inventory.ItemStack;
import bukkit.tommytony.war.War;
import com.tommytony.war.FlagReturn;
import com.tommytony.war.TeamSpawnStyle;
import com.tommytony.war.WarHub;
import com.tommytony.war.Warzone;
import com.tommytony.war.jobs.RestoreWarhubJob;
import com.tommytony.war.jobs.RestoreWarzonesJob;
/**
*
* @author tommytony
*
*/
public class WarMapper {
public static void load() {
(War.war.getDataFolder()).mkdir();
(new File(War.war.getDataFolder().getPath() + "/dat")).mkdir();
PropertiesFile warConfig = new PropertiesFile(War.war.getDataFolder().getPath() + "/war.txt");
try {
warConfig.load();
} catch (IOException e) {
War.war.log("Failed to load war.txt file.", Level.WARNING);
e.printStackTrace();
}
// Create file if need be
boolean newWar = false;
if (!warConfig.containsKey("warzones")) {
newWar = true;
WarMapper.save();
War.war.log("war.txt settings file created.", Level.INFO);
try {
warConfig.load();
} catch (IOException e) {
War.war.log("Failed to reload war.txt file after creating it.", Level.WARNING);
e.printStackTrace();
}
}
// warzones
String warzonesStr = warConfig.getString("warzones");
RestoreWarzonesJob restoreWarzones = new RestoreWarzonesJob(warzonesStr, newWar);
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarzones) == -1) {
War.war.log("Failed to schedule warzone-restore job. No warzone was loaded.", Level.WARNING);
}
// zone makers
String[] makers = warConfig.getString("zoneMakers").split(",");
War.war.getZoneMakerNames().clear();
for (String makerName : makers) {
if (makerName != null && !makerName.equals("")) {
War.war.getZoneMakerNames().add(makerName);
}
}
// command whitelist
String[] whitelist = warConfig.getString("commandWhitelist").split(",");
War.war.getCommandWhitelist().clear();
for (String command : whitelist) {
if (command != null && !command.equals("")) {
War.war.getCommandWhitelist().add(command);
}
}
// defaultLoadout
String defaultLoadoutStr = warConfig.getString("defaultLoadout");
String[] defaultLoadoutSplit = defaultLoadoutStr.split(";");
War.war.getDefaultLoadout().clear();
for (String itemStr : defaultLoadoutSplit) {
if (itemStr != null && !itemStr.equals("")) {
String[] itemStrSplit = itemStr.split(",");
ItemStack item = new ItemStack(Integer.parseInt(itemStrSplit[0]), Integer.parseInt(itemStrSplit[1]));
War.war.getDefaultLoadout().put(Integer.parseInt(itemStrSplit[2]), item);
}
}
// defaultExtraLoadouts
String extraLoadoutStr = warConfig.getString("defaultExtraLoadouts");
String[] extraLoadoutsSplit = extraLoadoutStr.split(",");
War.war.getDefaultExtraLoadouts().clear();
for (String nameStr : extraLoadoutsSplit) {
if (nameStr != null && !nameStr.equals("")) {
War.war.getDefaultExtraLoadouts().put(nameStr, new HashMap<Integer, ItemStack>());
}
}
for (String name : War.war.getDefaultExtraLoadouts().keySet()) {
String loadoutStr = warConfig.getString(name + "Loadout");
String[] loadoutSplit = loadoutStr.split(";");
HashMap<Integer, ItemStack> loadout = War.war.getDefaultExtraLoadouts().get(name);
loadout.clear();
for (String str : loadoutSplit) {
if (str != null && !str.equals("")) {
String[] strSplit = str.split(",");
ItemStack item = new ItemStack(Integer.parseInt(strSplit[0]), Integer.parseInt(strSplit[1]));
loadout.put(Integer.parseInt(strSplit[2]), item);
}
}
}
// maxZones
if (warConfig.keyExists("maxZones")) {
War.war.setMaxZones(warConfig.getInt("maxZones"));
}
// defaultLifePool
if (warConfig.keyExists("defaultLifePool")) {
War.war.setDefaultLifepool(warConfig.getInt("defaultLifePool"));
}
// defaultMonumentHeal
if (warConfig.keyExists("defaultMonumentHeal")) {
War.war.setDefaultMonumentHeal(warConfig.getInt("defaultMonumentHeal"));
}
// defaultFriendlyFire
if (warConfig.keyExists("defaultFriendlyFire")) {
War.war.setDefaultFriendlyFire(warConfig.getBoolean("defaultFriendlyFire"));
}
// defaultAutoAssignOnly
if (warConfig.keyExists("defaultAutoAssignOnly")) {
War.war.setDefaultAutoAssignOnly(warConfig.getBoolean("defaultAutoAssignOnly"));
}
// defaultFlagPointsOnly
if (warConfig.keyExists("defaultFlagPointsOnly")) {
War.war.setDefaultFlagPointsOnly(warConfig.getBoolean("defaultFlagPointsOnly"));
}
// defaultFlagMustBeHome
if (warConfig.keyExists("defaultFlagMustBeHome")) {
War.war.setDefaultFlagMustBeHome(warConfig.getBoolean("defaultFlagMustBeHome"));
}
// defaultTeamCap
if (warConfig.keyExists("defaultTeamCap")) {
War.war.setDefaultTeamCap(warConfig.getInt("defaultTeamCap"));
}
// defaultScoreCap
if (warConfig.keyExists("defaultScoreCap")) {
War.war.setDefaultScoreCap(warConfig.getInt("defaultScoreCap"));
}
// defaultRespawnTimer
if (warConfig.keyExists("defaultRespawnTimer")) {
War.war.setDefaultRespawnTimer(warConfig.getInt("defaultRespawnTimer"));
}
// pvpInZonesOnly
if (warConfig.keyExists("pvpInZonesOnly")) {
War.war.setPvpInZonesOnly(warConfig.getBoolean("pvpInZonesOnly"));
}
// defaultBlockHeads
if (warConfig.keyExists("defaultBlockHeads")) {
War.war.setDefaultBlockHeads(warConfig.getBoolean("defaultBlockHeads"));
}
// buildInZonesOnly
if (warConfig.keyExists("buildInZonesOnly")) {
War.war.setBuildInZonesOnly(warConfig.getBoolean("buildInZonesOnly"));
}
// disablePVPMessage
if (warConfig.keyExists("disablePvpMessage")) {
War.war.setDisablePvpMessage(warConfig.getBoolean("disablePvpMessage"));
}
// tntInZonesOnly
if (warConfig.keyExists("tntInZonesOnly")) {
War.war.setTntInZonesOnly(warConfig.getBoolean("tntInZonesOnly"));
}
// defaultSpawnStyle
String spawnStyle = warConfig.getString("defaultspawnStyle");
if (spawnStyle != null && !spawnStyle.equals("")) {
War.war.setDefaultSpawnStyle(TeamSpawnStyle.getStyleFromString(spawnStyle));
}
// defaultFlagReturn
String flagReturn = warConfig.getString("defaultFlagReturn");
if (flagReturn != null && !flagReturn.equals("")) {
War.war.setDefaultFlagReturn(FlagReturn.getFromString(flagReturn));
}
// defaultReward
String defaultRewardStr = warConfig.getString("defaultReward");
if (defaultRewardStr != null && !defaultRewardStr.equals("")) {
String[] defaultRewardStrSplit = defaultRewardStr.split(";");
War.war.getDefaultReward().clear();
for (String itemStr : defaultRewardStrSplit) {
if (itemStr != null && !itemStr.equals("")) {
String[] itemStrSplit = itemStr.split(",");
ItemStack item = new ItemStack(Integer.parseInt(itemStrSplit[0]), Integer.parseInt(itemStrSplit[1]));
War.war.getDefaultReward().put(Integer.parseInt(itemStrSplit[2]), item);
}
}
}
// defaultUnbreakableZoneBlocks
if (warConfig.keyExists("defaultUnbreakableZoneBlocks")) {
War.war.setDefaultUnbreakableZoneBlocks(warConfig.getBoolean("defaultUnbreakableZoneBlocks"));
}
// defaultNoCreatures
if (warConfig.keyExists("defaultNoCreatures")) {
War.war.setDefaultNoCreatures(warConfig.getBoolean("defaultNoCreatures"));
}
// defaultGlassWalls
if (warConfig.keyExists("defaultGlassWalls")) {
War.war.setDefaultGlassWalls(warConfig.getBoolean("defaultGlassWalls"));
}
// defaultPvpInZone
if (warConfig.keyExists("defaultPvpInZone")) {
War.war.setDefaultPvpInZone(warConfig.getBoolean("defaultPvpInZone"));
}
// defaultInstaBreak
if (warConfig.keyExists("defaultInstaBreak")) {
War.war.setDefaultInstaBreak(warConfig.getBoolean("defaultInstaBreak"));
}
// defaultNoDrops
if (warConfig.keyExists("defaultNoDrops")) {
War.war.setDefaultNoDrops(warConfig.getBoolean("defaultNoDrops"));
}
// defaultNoHunger
if (warConfig.keyExists("defaultNoHunger")) {
War.war.setDefaultNoHunger(warConfig.getBoolean("defaultNoHunger"));
}
// defaultSaturation
if (warConfig.keyExists("defaultSaturation")) {
War.war.setDefaultSaturation(warConfig.getInt("defaultSaturation"));
}
// defaultMinPlayers
if (warConfig.keyExists("defaultMinPlayers")) {
War.war.setDefaultMinPlayers(warConfig.getInt("defaultMinPlayers"));
}
// defaultMinTeams
if (warConfig.keyExists("defaultMinTeams")) {
War.war.setDefaultMinTeams(warConfig.getInt("defaultMinTeams"));
}
// defaultResetOnEmpty
if (warConfig.keyExists("defaultResetOnEmpty")) {
War.war.setDefaultResetOnEmpty(warConfig.getBoolean("defaultResetOnEmpty"));
}
// defaultResetOnLoad
if (warConfig.keyExists("defaultResetOnLoad")) {
War.war.setDefaultResetOnLoad(warConfig.getBoolean("defaultResetOnLoad"));
}
// defaultResetOnUnload
if (warConfig.keyExists("defaultResetOnUnload")) {
War.war.setDefaultResetOnUnload(warConfig.getBoolean("defaultResetOnUnload"));
}
// warhub
String hubStr = warConfig.getString("warhub");
if (hubStr != null && !hubStr.equals("")) {
RestoreWarhubJob restoreWarhub = new RestoreWarhubJob(hubStr);
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarhub) == -1) {
War.war.log("Failed to schedule warhub-restore job. War hub was not loaded.", Level.WARNING);
}
}
warConfig.close();
}
public static void save() {
PropertiesFile warConfig = new PropertiesFile(War.war.getDataFolder().getPath() + "/war.txt");
String warzonesStr = "";
// warzones
for (Warzone zone : War.war.getWarzones()) {
warzonesStr += zone.getName() + ",";
}
warConfig.setString("warzones", warzonesStr);
// zone makers: default is none and it means everyone can use /setzone
String makersStr = ""; // everyone
for (String name : War.war.getZoneMakerNames()) {
makersStr += name + ",";
}
warConfig.setString("zoneMakers", makersStr);
// whitelisted commands during a game
String commandWhitelistStr = ""; // everyone
for (String command : War.war.getCommandWhitelist()) {
commandWhitelistStr += command + ",";
}
warConfig.setString("commandWhitelist", commandWhitelistStr);
// defaultLoadout
String defaultLoadoutStr = "";
HashMap<Integer, ItemStack> items = War.war.getDefaultLoadout();
for (Integer slot : items.keySet()) {
ItemStack item = items.get(slot);
if (item != null) {
defaultLoadoutStr += item.getTypeId() + "," + item.getAmount() + "," + slot + ";";
}
}
warConfig.setString("defaultLoadout", defaultLoadoutStr);
// defaultExtraLoadouts
String defaultExtraLoadoutsStr = "";
for (String name : War.war.getDefaultExtraLoadouts().keySet()) {
defaultExtraLoadoutsStr += name + ",";
String loadoutStr = "";
HashMap<Integer, ItemStack> loadout = War.war.getDefaultExtraLoadouts().get(name);
for (Integer slot : loadout.keySet()) {
ItemStack item = loadout.get(slot);
if (item != null) {
loadoutStr += item.getTypeId() + "," + item.getAmount() + "," + slot + ";";
}
}
warConfig.setString(name + "Loadout", loadoutStr);
}
warConfig.setString("defaultExtraLoadouts", defaultExtraLoadoutsStr);
// maxZones
warConfig.setInt("maxZones", War.war.getMaxZones());
// defaultLifepool
warConfig.setInt("defaultLifePool", War.war.getDefaultLifepool());
// defaultMonumentHeal
warConfig.setInt("defaultMonumentHeal", War.war.getDefaultMonumentHeal());
// defaultFriendlyFire
warConfig.setBoolean("defaultFriendlyFire", War.war.isDefaultFriendlyFire());
// defaultAutoAssignOnly
warConfig.setBoolean("defaultAutoAssignOnly", War.war.isDefaultAutoAssignOnly());
// defaultFlagPointsOnly
warConfig.setBoolean("defaultFlagPointsOnly", War.war.isDefaultFlagPointsOnly());
// defaultFlagMustBeHome
warConfig.setBoolean("defaultFlagMustBeHome", War.war.isDefaultFlagMustBeHome());
// defaultTeamCap
warConfig.setInt("defaultTeamCap", War.war.getDefaultTeamCap());
// defaultScoreCap
warConfig.setInt("defaultScoreCap", War.war.getDefaultScoreCap());
// defaultRespawnTimer
warConfig.setInt("defaultRespawnTimer", War.war.getDefaultRespawnTimer());
// pvpInZonesOnly
warConfig.setBoolean("pvpInZonesOnly", War.war.isPvpInZonesOnly());
// defaultBlockHeads
warConfig.setBoolean("defaultBlockHeads", War.war.isDefaultBlockHeads());
// buildInZonesOnly
warConfig.setBoolean("buildInZonesOnly", War.war.isBuildInZonesOnly());
// disablePVPMessage
warConfig.setBoolean("disablePvpMessage", War.war.isDisablePvpMessage());
// disableBuildMessage
warConfig.setBoolean("disableBuildMessage", War.war.isDisableBuildMessage());
// tntInZonesOnly
warConfig.setBoolean("tntInZonesOnly", War.war.isTntInZonesOnly());
// spawnStyle
warConfig.setString("spawnStyle", War.war.getDefaultSpawnStyle().toString());
// flagReturn
warConfig.setString("flagReturn", War.war.getDefaultFlagReturn().toString());
// defaultReward
String defaultRewardStr = "";
HashMap<Integer, ItemStack> rewardItems = War.war.getDefaultReward();
for (Integer slot : rewardItems.keySet()) {
ItemStack item = items.get(slot);
if (item != null) {
defaultRewardStr += item.getTypeId() + "," + item.getAmount() + "," + slot + ";";
}
}
warConfig.setString("defaultReward", defaultRewardStr);
// defaultUnbreakableZoneBlocks
warConfig.setBoolean("defaultUnbreakableZoneBlocks", War.war.isDefaultUnbreakableZoneBlocks());
// defaultNoCreatures
warConfig.setBoolean("defaultNoCreatures", War.war.isDefaultNoCreatures());
// defaultGlassWalls
warConfig.setBoolean("defaultGlassWalls", War.war.isDefaultGlassWalls());
// defaultPvpInZone
warConfig.setBoolean("defaultPvpInZone", War.war.isDefaultPvpInZone());
// defaultInstaBreak
warConfig.setBoolean("defaultInstaBreak", War.war.isDefaultInstaBreak());
// defaultNoDrops
warConfig.setBoolean("defaultNoDrops", War.war.isDefaultNoDrops());
// defaultNoHunger
warConfig.setBoolean("defaultNoHunger", War.war.isDefaultNoHunger());
// defaultSaturation
warConfig.setInt("defaultSaturation", War.war.getDefaultSaturation());
// defaultMinPlayers
warConfig.setInt("defaultMinPlayers", War.war.getDefaultMinPlayers());
// defaultMinTeams
warConfig.setInt("defaultMinTeams", War.war.getDefaultMinTeams());
// defaultResetOnEmpty
warConfig.setBoolean("defaultResetOnEmpty", War.war.isDefaultResetOnEmpty());
// defaultResetOnLoad
warConfig.setBoolean("defaultResetOnLoad", War.war.isDefaultResetOnLoad());
// defaultResetOnUnload
warConfig.setBoolean("defaultResetOnUnload", War.war.isDefaultResetOnUnload());
// warhub
String hubStr = "";
WarHub hub = War.war.getWarHub();
if (hub != null) {
String orientationStr = "";
switch (hub.getOrientation()) {
case SOUTH:
orientationStr = "south";
break;
case EAST:
orientationStr = "east";
break;
case NORTH:
orientationStr = "north";
break;
case WEST:
default:
orientationStr = "west";
break;
}
hubStr = hub.getLocation().getBlockX() + "," + hub.getLocation().getBlockY() + "," + hub.getLocation().getBlockZ() + ","
+ hub.getLocation().getWorld().getName() + "," + orientationStr;
VolumeMapper.save(hub.getVolume(), "");
}
warConfig.setString("warhub", hubStr);
warConfig.save();
warConfig.close();
}
}

12
war/src/main/java/com/tommytony/war/mappers/WarTxtMapper.java
View File

@ -55,14 +55,12 @@ public class WarTxtMapper {
// warzones
String warzonesStr = warConfig.getString("warzones");
if (!convertingToYml) {
// No need to load the warzones if we're about to convert them
RestoreWarzonesJob restoreWarzones = new RestoreWarzonesJob(warzonesStr, newWar);
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarzones) == -1) {
War.war.log("Failed to schedule warzone-restore job. No warzone was loaded.", Level.WARNING);
}
RestoreWarzonesJob restoreWarzones = new RestoreWarzonesJob(warzonesStr, newWar, convertingToYml);
// make sure warhub job is over before this one ends, because this job will launch conversion (which needs the warhub)
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarzones, 20) == -1) {
War.war.log("Failed to schedule warzone-restore job. No warzone was loaded.", Level.WARNING);
}
// zone makers
String[] makers = warConfig.getString("zoneMakers").split(",");
War.war.getZoneMakerNames().clear();

79
war/src/main/java/com/tommytony/war/mappers/WarYmlMapper.java
View File

@ -30,8 +30,8 @@ public class WarYmlMapper {
if (warTxtFile.exists() && !warYmlFile.exists()) {
// Load both War and warzones (with delay) in old format, save War to new format immediatly
WarTxtMapper.load(true);
WarYmlMapper.save();
War.war.log("Converted war.txt to war.yml.", Level.INFO);
// Warzones are getting loaded by TxtMapper launched job. That job will in turn save the Warzones to their new format.
return;
} else if (!warTxtFile.exists() && !warYmlFile.exists()) {
// Save defaults to disk
newWar = true;
@ -40,16 +40,17 @@ public class WarYmlMapper {
}
YamlConfiguration warYmlConfig = YamlConfiguration.loadConfiguration(warYmlFile);
ConfigurationSection warRootSection = warYmlConfig.getConfigurationSection("set");
// warzones
List<String> warzones = warYmlConfig.getStringList("war.info.warzones");
List<String> warzones = warRootSection.getStringList("war.info.warzones");
RestoreYmlWarzonesJob restoreWarzones = new RestoreYmlWarzonesJob(warzones, newWar); // during conversion, this should execute just after the RestoreTxtWarzonesJob
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarzones) == -1) {
War.war.log("Failed to schedule warzone-restore job. No warzone was loaded.", Level.WARNING);
}
// zone makers
List<String> makers = warYmlConfig.getStringList("war.info.zonemakers");
List<String> makers = warRootSection.getStringList("war.info.zonemakers");
War.war.getZoneMakerNames().clear();
for (String makerName : makers) {
if (makerName != null && !makerName.equals("")) {
@ -58,7 +59,7 @@ public class WarYmlMapper {
}
// command whitelist
List<String> whitelist = warYmlConfig.getStringList("war.info.commandwhitelist");
List<String> whitelist = warRootSection.getStringList("war.info.commandwhitelist");
War.war.getCommandWhitelist().clear();
for (String command : whitelist) {
if (command != null && !command.equals("")) {
@ -67,29 +68,29 @@ public class WarYmlMapper {
}
// defaultLoadouts
ConfigurationSection loadoutsSection = warYmlConfig.getConfigurationSection("team.default.loadout");
ConfigurationSection loadoutsSection = warRootSection.getConfigurationSection("team.default.loadout");
LoadoutYmlMapper.fromConfigToLoadouts(loadoutsSection, War.war.getDefaultInventories().getLoadouts());
// defaultReward
ConfigurationSection rewardsSection = warYmlConfig.getConfigurationSection("team.default.reward");
ConfigurationSection rewardsSection = warRootSection.getConfigurationSection("team.default.reward");
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutYmlMapper.fromConfigToLoadout(rewardsSection, reward, "default");
War.war.getDefaultInventories().setReward(reward);
// War settings
ConfigurationSection warConfigSection = warYmlConfig.getConfigurationSection("war.config");
ConfigurationSection warConfigSection = warRootSection.getConfigurationSection("war.config");
War.war.getWarConfig().loadFrom(warConfigSection);
// Warzone default settings
ConfigurationSection warzoneConfigSection = warYmlConfig.getConfigurationSection("warzone.default.config");
ConfigurationSection warzoneConfigSection = warRootSection.getConfigurationSection("warzone.default.config");
War.war.getWarzoneDefaultConfig().loadFrom(warzoneConfigSection);
// Team default settings
ConfigurationSection teamConfigSection = warYmlConfig.getConfigurationSection("team.default.config");
ConfigurationSection teamConfigSection = warRootSection.getConfigurationSection("team.default.config");
War.war.getTeamDefaultConfig().loadFrom(teamConfigSection);
// warhub
ConfigurationSection hubConfigSection = warYmlConfig.getConfigurationSection("war.info.warhub");
ConfigurationSection hubConfigSection = warRootSection.getConfigurationSection("war.info.warhub");
if (hubConfigSection != null) {
RestoreYmlWarhubJob restoreWarhub = new RestoreYmlWarhubJob(hubConfigSection);
if (War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, restoreWarhub) == -1) {
@ -100,42 +101,46 @@ public class WarYmlMapper {
public static void save() {
YamlConfiguration warYmlConfig = new YamlConfiguration();
ConfigurationSection warRootSection = warYmlConfig.createSection("set");
(new File(War.war.getDataFolder().getPath())).mkdir();
(new File(War.war.getDataFolder().getPath() + "/dat")).mkdir();
// War settings
ConfigurationSection warConfigSection = warRootSection.createSection("war.config");
War.war.getWarConfig().saveTo(warConfigSection);
// Warzone default settings
ConfigurationSection warzoneConfigSection = warRootSection.createSection("warzone.default.config");
War.war.getWarzoneDefaultConfig().saveTo(warzoneConfigSection);
// Team default settings
ConfigurationSection teamDefault = warRootSection.createSection("team.default");
ConfigurationSection teamConfigSection = teamDefault.createSection("config");
War.war.getTeamDefaultConfig().saveTo(teamConfigSection);
// defaultLoadouts
ConfigurationSection loadoutSection = teamDefault.createSection("loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(War.war.getDefaultInventories().getLoadouts(), loadoutSection);
// defaultReward
ConfigurationSection rewardsSection = teamDefault.createSection("reward");
LoadoutYmlMapper.fromLoadoutToConfig("default", War.war.getDefaultInventories().getReward(), rewardsSection);
ConfigurationSection warInfoSection = warRootSection.createSection("war.info");
// warzones
List<String> warzones = new ArrayList<String>();
for (Warzone zone : War.war.getWarzones()) {
warzones.add(zone.getName());
}
warYmlConfig.set("war.info.warzones", warzones);
warInfoSection.set("warzones", warzones);
// zone makers
warYmlConfig.set("war.info.zonemakers", War.war.getZoneMakerNames());
warInfoSection.set("zonemakers", War.war.getZoneMakerNames());
// whitelisted commands during a game
warYmlConfig.set("war.info.commandwhitelist", War.war.getCommandWhitelist());
// defaultLoadouts
ConfigurationSection loadoutsSection = warYmlConfig.createSection("team.default.loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(War.war.getDefaultInventories().getLoadouts(), loadoutsSection);
warInfoSection.set("commandwhitelist", War.war.getCommandWhitelist());
// defaultReward
ConfigurationSection rewardsSection = warYmlConfig.createSection("team.default.reward");
LoadoutYmlMapper.fromLoadoutToConfig(War.war.getDefaultInventories().getReward(), rewardsSection, "default");
// War settings
ConfigurationSection warConfigSection = warYmlConfig.createSection("war.config");
War.war.getWarConfig().saveTo(warConfigSection);
// Warzone default settings
ConfigurationSection warzoneConfigSection = warYmlConfig.createSection("warzone.default.config");
War.war.getWarzoneDefaultConfig().saveTo(warzoneConfigSection);
// Team default settings
ConfigurationSection teamConfigSection = warYmlConfig.createSection("team.default.config");
War.war.getTeamDefaultConfig().saveTo(teamConfigSection);
// warhub
WarHub hub = War.war.getWarHub();
if (hub != null) {
@ -156,7 +161,7 @@ public class WarYmlMapper {
break;
}
ConfigurationSection hubConfigSection = warYmlConfig.createSection("war.info.warhub");
ConfigurationSection hubConfigSection = warInfoSection.createSection("warhub");
hubConfigSection.set("x", hub.getLocation().getBlockX());
hubConfigSection.set("y", hub.getLocation().getBlockY());
hubConfigSection.set("z", hub.getLocation().getBlockZ());

669
war/src/main/java/com/tommytony/war/mappers/WarzoneMapper.java
View File

@ -1,669 +0,0 @@
package com.tommytony.war.mappers;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.logging.Level;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.BlockFace;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
import bukkit.tommytony.war.War;
import com.tommytony.war.FlagReturn;
import com.tommytony.war.Monument;
import com.tommytony.war.Team;
import com.tommytony.war.TeamKind;
import com.tommytony.war.TeamSpawnStyle;
import com.tommytony.war.Warzone;
import com.tommytony.war.ZoneLobby;
import com.tommytony.war.volumes.Volume;
import com.tommytony.war.volumes.ZoneVolume;
/**
*
* @author tommytony
*
*/
public class WarzoneMapper {
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")) {
WarzoneMapper.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));
}
// 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.getLifePool());
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
}
}
}
}
// ff
if (warzoneConfig.containsKey("friendlyFire")) {
warzone.setFriendlyFire(warzoneConfig.getBoolean("friendlyFire"));
}
// loadout
String loadoutStr = warzoneConfig.getString("loadout");
if (loadoutStr != null && !loadoutStr.equals("")) {
fromStringToLoadout(loadoutStr, warzone.getLoadout());
}
// extraLoadouts
String extraLoadoutStr = warzoneConfig.getString("extraLoadouts");
String[] extraLoadoutsSplit = extraLoadoutStr.split(",");
War.war.getDefaultExtraLoadouts().clear();
for (String nameStr : extraLoadoutsSplit) {
if (nameStr != null && !nameStr.equals("")) {
warzone.getExtraLoadouts().put(nameStr, new HashMap<Integer, ItemStack>());
}
}
for (String extraName : warzone.getExtraLoadouts().keySet()) {
String loadoutString = warzoneConfig.getString(extraName + "Loadout");
HashMap<Integer, ItemStack> loadout = warzone.getExtraLoadouts().get(extraName);
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.setLifePool(warzoneConfig.getInt("lifePool"));
}
// monument heal
if (warzoneConfig.containsKey("monumentHeal")) {
warzone.setMonumentHeal(warzoneConfig.getInt("monumentHeal"));
}
// autoAssignOnly
if (warzoneConfig.containsKey("autoAssignOnly")) {
warzone.setAutoAssignOnlyWithoutResettingLobby(warzoneConfig.getBoolean("autoAssignOnly"));
}
// flagPointsOnly
if (warzoneConfig.containsKey("flagPointsOnly")) {
warzone.setFlagPointsOnly(warzoneConfig.getBoolean("flagPointsOnly"));
}
// flagMustBeHome
if (warzoneConfig.containsKey("flagMustBeHome")) {
warzone.setFlagMustBeHome(warzoneConfig.getBoolean("flagMustBeHome"));
}
// team cap
if (warzoneConfig.containsKey("teamCap")) {
warzone.setTeamCap(warzoneConfig.getInt("teamCap"));
}
// score cap
if (warzoneConfig.containsKey("scoreCap")) {
warzone.setScoreCap(warzoneConfig.getInt("scoreCap"));
}
// respawn timer
if (warzoneConfig.containsKey("respawnTimer")) {
warzone.setRespawnTimer(warzoneConfig.getInt("respawnTimer"));
}
// blockHeads
if (warzoneConfig.containsKey("blockHeads")) {
warzone.setBlockHeads(warzoneConfig.getBoolean("blockHeads"));
}
// spawnStyle
String spawnStyle = warzoneConfig.getString("spawnStyle");
if (spawnStyle != null && !spawnStyle.equals("")) {
warzone.setSpawnStyle(TeamSpawnStyle.getStyleFromString(spawnStyle));
}
// flagReturn
String flagReturn = warzoneConfig.getString("flagReturn");
if (flagReturn != null && !flagReturn.equals("")) {
warzone.setFlagReturn(FlagReturn.getFromString(flagReturn));
}
// reward
String rewardStr = warzoneConfig.getString("reward");
if (rewardStr != null && !rewardStr.equals("")) {
fromStringToLoadout(rewardStr, warzone.getReward());
}
// unbreakableZoneBlocks
if (warzoneConfig.containsKey("unbreakableZoneBlocks")) {
warzone.setUnbreakableZoneBlocks(warzoneConfig.getBoolean("unbreakableZoneBlocks"));
}
// disabled
if (warzoneConfig.containsKey("disabled")) {
warzone.setDisabled(warzoneConfig.getBoolean("disabled"));
}
// noCreatures
if (warzoneConfig.containsKey("noCreatures")) {
warzone.setNoCreatures(warzoneConfig.getBoolean("noCreatures"));
}
// glassWalls
if (warzoneConfig.containsKey("glassWalls")) {
warzone.setGlassWalls(warzoneConfig.getBoolean("glassWalls"));
}
// pvpInZone
if (warzoneConfig.containsKey("pvpInZone")) {
warzone.setPvpInZone(warzoneConfig.getBoolean("pvpInZone"));
}
// instaBreak
if (warzoneConfig.containsKey("instaBreak")) {
warzone.setInstaBreak(warzoneConfig.getBoolean("instaBreak"));
}
// noDrops
if (warzoneConfig.containsKey("noDrops")) {
warzone.setNoDrops(warzoneConfig.getBoolean("noDrops"));
}
// noHunger
if (warzoneConfig.containsKey("noHunger")) {
warzone.setNoHunger(warzoneConfig.getBoolean("noHunger"));
}
// saturation
if (warzoneConfig.containsKey("saturation")) {
warzone.setSaturation(warzoneConfig.getInt("saturation"));
}
// minPlayers
if (warzoneConfig.containsKey("minPlayers")) {
warzone.setMinPlayers(warzoneConfig.getInt("minPlayers"));
}
// minTeams
if (warzoneConfig.containsKey("minTeams")) {
warzone.setMinTeams(warzoneConfig.getInt("minTeams"));
}
// resetOnEmpty
if (warzoneConfig.containsKey("resetOnEmpty")) {
warzone.setResetOnEmpty(warzoneConfig.getBoolean("resetOnEmpty"));
}
// resetOnLoad
if (warzoneConfig.containsKey("resetOnLoad")) {
warzone.setResetOnLoad(warzoneConfig.getBoolean("resetOnLoad"));
}
// resetOnUnload
if (warzoneConfig.containsKey("resetOnUnload")) {
warzone.setResetOnUnload(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);
}
}
}
// 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 = BlockFace.SOUTH;
} else if (lobbyStrSplit[0].equals("east")) {
lobbyFace = BlockFace.EAST;
} else if (lobbyStrSplit[0].equals("north")) {
lobbyFace = BlockFace.NORTH;
} else if (lobbyStrSplit[0].equals("west")) {
lobbyFace = BlockFace.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;
}
public static void save(Warzone warzone, boolean saveAllBlocks) {
(new File(War.war.getDataFolder().getPath() + "/dat/warzone-" + warzone.getName())).mkdir();
PropertiesFile warzoneConfig = new PropertiesFile(War.war.getDataFolder().getPath() + "/warzone-" + warzone.getName() + ".txt");
// war.getLogger().info("Saving warzone " + warzone.getName() + "...");
// name
warzoneConfig.setString("name", warzone.getName());
// world
warzoneConfig.setString("world", warzone.getWorld().getName()); // default for now
// teleport
String teleportStr = "";
Location tele = warzone.getTeleport();
if (tele != null) {
int intYaw = 0;
if (tele.getYaw() >= 0) {
intYaw = (int) (tele.getYaw() % 360);
} else {
intYaw = (int) (360 + (tele.getYaw() % 360));
}
teleportStr = tele.getBlockX() + "," + tele.getBlockY() + "," + tele.getBlockZ() + "," + intYaw;
}
warzoneConfig.setString("teleport", teleportStr);
// teams
String teamsStr = "";
List<Team> teams = warzone.getTeams();
for (Team team : teams) {
Location spawn = team.getTeamSpawn();
int intYaw = 0;
if (spawn.getYaw() >= 0) {
intYaw = (int) (spawn.getYaw() % 360);
} else {
intYaw = (int) (360 + (spawn.getYaw() % 360));
}
teamsStr += team.getName() + "," + spawn.getBlockX() + "," + spawn.getBlockY() + "," + spawn.getBlockZ() + "," + intYaw + ";";
}
warzoneConfig.setString("teams", teamsStr);
// team flags
String teamFlagsStr = "";;
for (Team team : teams) {
if (team.getFlagVolume() != null) {
Location flag = team.getTeamFlag();
int intYaw = 0;
if (flag.getYaw() >= 0) {
intYaw = (int) (flag.getYaw() % 360);
} else {
intYaw = (int) (360 + (flag.getYaw() % 360));
}
teamFlagsStr += team.getName() + "," + flag.getBlockX() + "," + flag.getBlockY() + "," + flag.getBlockZ() + "," + intYaw + ";";
}
}
warzoneConfig.setString("teamFlags", teamFlagsStr);
// ff
warzoneConfig.setBoolean("friendlyFire", warzone.getFriendlyFire());
// loadout
HashMap<Integer, ItemStack> items = warzone.getLoadout();
warzoneConfig.setString("loadout", fromLoadoutToString(items));
// defaultExtraLoadouts
String extraLoadoutsStr = "";
for (String name : warzone.getExtraLoadouts().keySet()) {
extraLoadoutsStr += name + ",";
HashMap<Integer, ItemStack> loadout = warzone.getExtraLoadouts().get(name);
warzoneConfig.setString(name + "Loadout", fromLoadoutToString(loadout));
}
warzoneConfig.setString("extraLoadouts", extraLoadoutsStr);
// authors
warzoneConfig.setString("author", warzone.getAuthorsString());
// life pool
warzoneConfig.setInt("lifePool", warzone.getLifePool());
// monument heal
warzoneConfig.setInt("monumentHeal", warzone.getMonumentHeal());
// autoAssignOnly
warzoneConfig.setBoolean("autoAssignOnly", warzone.isAutoAssignOnly());
// flagPointsOnly
warzoneConfig.setBoolean("flagPointsOnly", warzone.isFlagPointsOnly());
// flagMustBeHome
warzoneConfig.setBoolean("flagMustBeHome", warzone.isFlagMustBeHome());
// team cap
warzoneConfig.setInt("teamCap", warzone.getTeamCap());
// score cap
warzoneConfig.setInt("scoreCap", warzone.getScoreCap());
// respawn timer
warzoneConfig.setInt("respawnTimer", warzone.getRespawnTimer());
// blockHeads
warzoneConfig.setBoolean("blockHeads", warzone.isBlockHeads());
// spawnStyle
warzoneConfig.setString("spawnStyle", warzone.getSpawnStyle().toString());
// flagReturn
warzoneConfig.setString("flagReturn", warzone.getFlagReturn().toString());
// reward
HashMap<Integer, ItemStack> rewardItems = warzone.getReward();
warzoneConfig.setString("reward", fromLoadoutToString(rewardItems));
// unbreakableZoneBlocks
warzoneConfig.setBoolean("unbreakableZoneBlocks", warzone.isUnbreakableZoneBlocks());
// disabled
warzoneConfig.setBoolean("disabled", warzone.isDisabled());
// noCreatures
warzoneConfig.setBoolean("noCreatures", warzone.isNoCreatures());
// glassWalls
warzoneConfig.setBoolean("glassWalls", warzone.isGlassWalls());
// pvpInZone
warzoneConfig.setBoolean("pvpInZone", warzone.isPvpInZone());
// instaBreak
warzoneConfig.setBoolean("instaBreak", warzone.isInstaBreak());
// noDrops
warzoneConfig.setBoolean("noDrops", warzone.isNoDrops());
// noHunger
warzoneConfig.setBoolean("noHunger", warzone.isNoHunger());
// saturation
warzoneConfig.setInt("saturation", warzone.getSaturation());
// minPlayers
warzoneConfig.setInt("minPlayers", warzone.getMinPlayers());
// minTeams
warzoneConfig.setInt("minTeams", warzone.getMinTeams());
// resetOnEmpty
warzoneConfig.setBoolean("resetOnEmpty", warzone.isResetOnEmpty());
// resetOnLoad
warzoneConfig.setBoolean("resetOnLoad", warzone.isResetOnLoad());
// resetOnUnload
warzoneConfig.setBoolean("resetOnUnload", warzone.isResetOnUnload());
// rallyPoint
String rpStr = "";
Location rp = warzone.getRallyPoint();
if (rp != null) {
rpStr = rp.getBlockX() + "," + rp.getBlockY() + "," + rp.getBlockZ();
}
warzoneConfig.setString("rallyPoint", rpStr);
// defaultDropLootOnDeath
// warzoneConfig.setBoolean("dropLootOnDeath", warzone.isDropLootOnDeath());
// monuments
String monumentsStr = "";
List<Monument> monuments = warzone.getMonuments();
for (Monument monument : monuments) {
Location monumentLoc = monument.getLocation();
monumentsStr += monument.getName() + "," + monumentLoc.getBlockX() + "," + monumentLoc.getBlockY() + "," + monumentLoc.getBlockZ() + ";";
}
warzoneConfig.setString("monuments", monumentsStr);
// lobby
String lobbyStr = "";
if (warzone.getLobby() != null) {
if (BlockFace.SOUTH == warzone.getLobby().getWall()) {
lobbyStr = "south";
} else if (BlockFace.EAST == warzone.getLobby().getWall()) {
lobbyStr = "east";
} else if (BlockFace.NORTH == warzone.getLobby().getWall()) {
lobbyStr = "north";
} else if (BlockFace.WEST == warzone.getLobby().getWall()) {
lobbyStr = "west";
}
}
warzoneConfig.setString("lobby", lobbyStr + "," + warzone.getLobby().getVolume().getWorld().getName());
warzoneConfig.save();
warzoneConfig.close();
// monument blocks
for (Monument monument : monuments) {
VolumeMapper.save(monument.getVolume(), warzone.getName());
}
// team spawn & flag blocks
for (Team team : teams) {
VolumeMapper.save(team.getSpawnVolume(), warzone.getName());
if (team.getFlagVolume() != null) {
VolumeMapper.save(team.getFlagVolume(), warzone.getName());
}
}
if (warzone.getLobby() != null) {
VolumeMapper.save(warzone.getLobby().getVolume(), warzone.getName());
}
}
public static void delete(String name) {
File zoneFolder = new File(War.war.getDataFolder().getPath() + "/dat/warzone-" + name);
File[] files = zoneFolder.listFiles();
for (File file : files) {
boolean deletedData = file.delete();
if (!deletedData) {
War.war.log("Failed to delete file " + file.getName(), Level.WARNING);
}
}
boolean deletedData = zoneFolder.delete();
if (!deletedData) {
War.war.log("Failed to delete folder " + zoneFolder.getName(), Level.WARNING);
}
File zoneFile = new File(War.war.getDataFolder().getPath() + "/warzone-" + name + ".txt");
deletedData = zoneFile.delete();
if (!deletedData) {
War.war.log("Failed to delete file " + zoneFile.getName(), Level.WARNING);
}
}
private static String fromLoadoutToString(HashMap<Integer, ItemStack> loadout) {
String loadoutString = "";
for (Integer slot : loadout.keySet()) {
ItemStack item = loadout.get(slot);
if (item != null) {
loadoutString += item.getTypeId() + "," + item.getAmount() + "," + slot + "," + item.getDurability() + "," + item.getData().getData();
if (item.getEnchantments().keySet().size() > 0) {
String enchantmentsStr = "";
for (Enchantment enchantment : item.getEnchantments().keySet()) {
enchantmentsStr += enchantment.getId() + ":" + item.getEnchantments().get(enchantment) + "::";
}
loadoutString += "," + enchantmentsStr;
}
}
loadoutString += ";";
}
return loadoutString;
}
private static void fromStringToLoadout(String loadoutString, HashMap<Integer, ItemStack> destinationLoadout) {
String[] rewardStrSplit = loadoutString.split(";");
destinationLoadout.clear();
for (String itemStr : rewardStrSplit) {
if (itemStr != null && !itemStr.equals("")) {
String[] itemStrSplit = itemStr.split(",");
ItemStack item = null;
if (itemStrSplit.length == 3) {
item = new ItemStack(Integer.parseInt(itemStrSplit[0]), Integer.parseInt(itemStrSplit[1]));
} else if (itemStrSplit.length == 5) {
short durability = Short.parseShort(itemStrSplit[3]);
item = new ItemStack(Integer.parseInt(itemStrSplit[0]), Integer.parseInt(itemStrSplit[1]), durability, Byte.parseByte(itemStrSplit[4]));
item.setDurability(durability);
} else if (itemStrSplit.length == 6) {
short durability = Short.parseShort(itemStrSplit[3]);
item = new ItemStack(Integer.parseInt(itemStrSplit[0]), Integer.parseInt(itemStrSplit[1]), durability, Byte.parseByte(itemStrSplit[4]));
item.setDurability(durability);
// enchantments
String[] enchantmentsSplit = itemStrSplit[5].split("::");
for (String enchantmentStr : enchantmentsSplit) {
if (!enchantmentStr.equals("")) {
String[] enchantmentSplit = enchantmentStr.split(":");
int enchantId = Integer.parseInt(enchantmentSplit[0]);
int level = Integer.parseInt(enchantmentSplit[1]);
item.addEnchantment(Enchantment.getById(enchantId), level);
}
}
}
destinationLoadout.put(Integer.parseInt(itemStrSplit[2]), item);
}
}
}
}

10
war/src/main/java/com/tommytony/war/mappers/WarzoneTxtMapper.java
View File

@ -104,9 +104,11 @@ public class WarzoneTxtMapper {
}
for (String extraName : extraLoadoutsSplit) {
String loadoutString = warzoneConfig.getString(extraName + "Loadout");
HashMap<Integer, ItemStack> loadout = warzone.getDefaultInventories().getLoadouts().get(extraName);
LoadoutTxtMapper.fromStringToLoadout(loadoutString, loadout);
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
@ -299,7 +301,7 @@ public class WarzoneTxtMapper {
teamLocation.setYaw(yaw);
}
Team team = new Team(teamStrSplit[0], TeamKind.teamKindFromString(teamStrSplit[0]), teamLocation, warzone);
team.setRemainingLives(warzone.getTeamDefaultConfig().getInt(TeamConfig.LIFEPOOL));
team.setRemainingLives(warzone.getTeamDefaultConfig().resolveInt(TeamConfig.LIFEPOOL));
warzone.getTeams().add(team);
}
}

377
war/src/main/java/com/tommytony/war/mappers/WarzoneYmlMapper.java
View File

@ -44,47 +44,53 @@ public class WarzoneYmlMapper {
War.war.log("File warzone-" + name + ".yml not found", Level.WARNING);
} else {
YamlConfiguration warzoneYmlConfig = YamlConfiguration.loadConfiguration(warzoneYmlFile);
ConfigurationSection warzoneRootSection = warzoneYmlConfig.getConfigurationSection("set");
String zoneInfoPrefix = "warzone." + name + ".info.";
// world
String worldStr = warzoneYmlConfig.getString(zoneInfoPrefix + "world");
String worldStr = warzoneRootSection.getString(zoneInfoPrefix + "world");
World world = War.war.getServer().getWorld(worldStr);
// Create the zone
Warzone warzone = new Warzone(world, name);
// teleport
int teleX = warzoneYmlConfig.getInt(zoneInfoPrefix + "teleport.x");
int teleY = warzoneYmlConfig.getInt(zoneInfoPrefix + "teleport.y");
int teleZ = warzoneYmlConfig.getInt(zoneInfoPrefix + "teleport.z");
int teleYaw = warzoneYmlConfig.getInt(zoneInfoPrefix + "teleport.yaw");
int teleX = warzoneRootSection.getInt(zoneInfoPrefix + "teleport.x");
int teleY = warzoneRootSection.getInt(zoneInfoPrefix + "teleport.y");
int teleZ = warzoneRootSection.getInt(zoneInfoPrefix + "teleport.z");
int teleYaw = warzoneRootSection.getInt(zoneInfoPrefix + "teleport.yaw");
warzone.setTeleport(new Location(world, teleX, teleY, teleZ, teleYaw, 0));
if (warzoneYmlConfig.contains("team.default")) {
// defaultLoadouts
ConfigurationSection loadoutsSection = warzoneYmlConfig.getConfigurationSection("team.default.loadout");
// defaultLoadouts
if (warzoneRootSection.contains("team.default.loadout")) {
ConfigurationSection loadoutsSection = warzoneRootSection.getConfigurationSection("team.default.loadout");
LoadoutYmlMapper.fromConfigToLoadouts(loadoutsSection, warzone.getDefaultInventories().getLoadouts());
}
// defaultReward
ConfigurationSection rewardsSection = warzoneYmlConfig.getConfigurationSection("team.default.reward");
// defaultReward
if (warzoneRootSection.contains("team.default.reward")) {
ConfigurationSection rewardsSection = warzoneRootSection.getConfigurationSection("team.default.reward");
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutYmlMapper.fromConfigToLoadout(rewardsSection, reward, "default");
warzone.getDefaultInventories().setReward(reward);
// Team default settings
ConfigurationSection teamConfigSection = warzoneYmlConfig.getConfigurationSection("team.default.config");
}
// Team default settings
if (warzoneRootSection.contains("team.default.config")) {
ConfigurationSection teamConfigSection = warzoneRootSection.getConfigurationSection("team.default.config");
warzone.getTeamDefaultConfig().loadFrom(teamConfigSection);
}
// Warzone settings
if (warzoneYmlConfig.contains("warzone.config")) {
ConfigurationSection warzoneConfigSection = warzoneYmlConfig.getConfigurationSection("warzone.config");
if (warzoneRootSection.contains("warzone." + warzone.getName() + ".config")) {
ConfigurationSection warzoneConfigSection = warzoneRootSection.getConfigurationSection("warzone." + warzone.getName() + ".config");
warzone.getWarzoneConfig().loadFrom(warzoneConfigSection);
}
// authors
if (warzoneYmlConfig.contains(zoneInfoPrefix + "authors")) {
for(String authorStr : warzoneYmlConfig.getStringList("authors")) {
if (warzoneRootSection.contains(zoneInfoPrefix + "authors")) {
for(String authorStr : warzoneRootSection.getStringList(zoneInfoPrefix + "authors")) {
if (!authorStr.equals("")) {
warzone.addAuthor(authorStr);
}
@ -92,77 +98,79 @@ public class WarzoneYmlMapper {
}
// rallyPoint
if (warzoneYmlConfig.contains(zoneInfoPrefix + "rallypoint")) {
int rpX = warzoneYmlConfig.getInt(zoneInfoPrefix + "rallypoint.x");
int rpY = warzoneYmlConfig.getInt(zoneInfoPrefix + "rallypoint.y");
int rpZ = warzoneYmlConfig.getInt(zoneInfoPrefix + "rallypoint.z");
int rpYaw = warzoneYmlConfig.getInt(zoneInfoPrefix + "rallypoint.yaw");
if (warzoneRootSection.contains(zoneInfoPrefix + "rallypoint")) {
int rpX = warzoneRootSection.getInt(zoneInfoPrefix + "rallypoint.x");
int rpY = warzoneRootSection.getInt(zoneInfoPrefix + "rallypoint.y");
int rpZ = warzoneRootSection.getInt(zoneInfoPrefix + "rallypoint.z");
int rpYaw = warzoneRootSection.getInt(zoneInfoPrefix + "rallypoint.yaw");
Location rallyPoint = new Location(world, rpX, rpY, rpZ, rpYaw, 0);
warzone.setRallyPoint(rallyPoint);
}
// monuments
if (warzoneYmlConfig.contains(zoneInfoPrefix + "monument")) {
List<String> monunmentNames = warzoneYmlConfig.getStringList(zoneInfoPrefix + "monument.names");
if (warzoneRootSection.contains(zoneInfoPrefix + "monument")) {
List<String> monunmentNames = warzoneRootSection.getStringList(zoneInfoPrefix + "monument.names");
for (String monumentName : monunmentNames) {
if (monumentName != null && !monumentName.equals("")) {
String monumentPrefix = zoneInfoPrefix + "monument." + monumentName + ".";
int monumentX = warzoneYmlConfig.getInt(monumentPrefix + "x");
int monumentY = warzoneYmlConfig.getInt(monumentPrefix + "y");
int monumentZ = warzoneYmlConfig.getInt(monumentPrefix + "z");
int monumentYaw = warzoneYmlConfig.getInt(monumentPrefix + "yaw");
int monumentX = warzoneRootSection.getInt(monumentPrefix + "x");
int monumentY = warzoneRootSection.getInt(monumentPrefix + "y");
int monumentZ = warzoneRootSection.getInt(monumentPrefix + "z");
int monumentYaw = warzoneRootSection.getInt(monumentPrefix + "yaw");
Monument monument = new Monument(monumentName, warzone, new Location(world, monumentX, monumentY, monumentZ, monumentYaw, 0));
warzone.getMonuments().add(monument);
}
}
}
// teams
List<String> teamsNames = warzoneYmlConfig.getStringList("team.names");
for (String teamName : teamsNames) {
// team info
String teamInfoPrefix = "team." + teamName + ".info";
int teamX = warzoneYmlConfig.getInt(teamInfoPrefix + "spawn.x");
int teamY = warzoneYmlConfig.getInt(teamInfoPrefix + "spawn.y");
int teamZ = warzoneYmlConfig.getInt(teamInfoPrefix + "spawn.z");
int teamYaw = warzoneYmlConfig.getInt(teamInfoPrefix + "spawn.yaw");
Location teamLocation = new Location(world, teamX, teamY, teamZ, teamYaw, 0);
Team team = new Team(teamName, TeamKind.teamKindFromString(teamName), teamLocation, warzone);
warzone.getTeams().add(team);
if (warzoneYmlConfig.contains(teamInfoPrefix + "flag")) {
int flagX = warzoneYmlConfig.getInt(teamInfoPrefix + "flag.x");
int flagY = warzoneYmlConfig.getInt(teamInfoPrefix + "flag.y");
int flagZ = warzoneYmlConfig.getInt(teamInfoPrefix + "flag.z");
int flagYaw = warzoneYmlConfig.getInt(teamInfoPrefix + "flag.yaw");
Location flagLocation = new Location(world, flagX, flagY, flagZ, flagYaw, 0);
team.setTeamFlag(flagLocation);
}
String teamConfigPrefix = "team." + teamName + ".config";
if (warzoneYmlConfig.contains(teamConfigPrefix)) {
// team specific config
ConfigurationSection teamConfigSection = warzoneYmlConfig.getConfigurationSection(teamConfigPrefix);
team.getTeamConfig().loadFrom(teamConfigSection);
}
team.setRemainingLives(team.getTeamConfig().getInt(TeamConfig.LIFEPOOL));
String teamLoadoutPrefix = "team." + teamName + ".loadout";
if (warzoneYmlConfig.contains(teamLoadoutPrefix)) {
// team specific loadouts
ConfigurationSection loadoutsSection = warzoneYmlConfig.getConfigurationSection(teamLoadoutPrefix);
LoadoutYmlMapper.fromConfigToLoadouts(loadoutsSection, team.getInventories().getLoadouts());
}
String teamRewardPrefix = "team." + teamName + ".reward";
if (warzoneYmlConfig.contains(teamRewardPrefix)) {
// team specific reward
ConfigurationSection rewardsSection = warzoneYmlConfig.getConfigurationSection(teamRewardPrefix);
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutYmlMapper.fromConfigToLoadout(rewardsSection, reward, "default");
warzone.getDefaultInventories().setReward(reward);
// teams (maybe no teams)
if (warzoneRootSection.contains("team.names")) {
List<String> teamsNames = warzoneRootSection.getStringList("team.names");
for (String teamName : teamsNames) {
// team info
String teamInfoPrefix = "team." + teamName + ".info";
int teamX = warzoneRootSection.getInt(teamInfoPrefix + "spawn.x");
int teamY = warzoneRootSection.getInt(teamInfoPrefix + "spawn.y");
int teamZ = warzoneRootSection.getInt(teamInfoPrefix + "spawn.z");
int teamYaw = warzoneRootSection.getInt(teamInfoPrefix + "spawn.yaw");
Location teamLocation = new Location(world, teamX, teamY, teamZ, teamYaw, 0);
Team team = new Team(teamName, TeamKind.teamKindFromString(teamName), teamLocation, warzone);
warzone.getTeams().add(team);
if (warzoneRootSection.contains(teamInfoPrefix + "flag")) {
int flagX = warzoneRootSection.getInt(teamInfoPrefix + "flag.x");
int flagY = warzoneRootSection.getInt(teamInfoPrefix + "flag.y");
int flagZ = warzoneRootSection.getInt(teamInfoPrefix + "flag.z");
int flagYaw = warzoneRootSection.getInt(teamInfoPrefix + "flag.yaw");
Location flagLocation = new Location(world, flagX, flagY, flagZ, flagYaw, 0);
team.setTeamFlag(flagLocation);
}
String teamConfigPrefix = "team." + teamName + ".config";
if (warzoneRootSection.contains(teamConfigPrefix)) {
// team specific config
ConfigurationSection teamConfigSection = warzoneRootSection.getConfigurationSection(teamConfigPrefix);
team.getTeamConfig().loadFrom(teamConfigSection);
}
team.setRemainingLives(team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
String teamLoadoutPrefix = "team." + teamName + ".loadout";
if (warzoneRootSection.contains(teamLoadoutPrefix)) {
// team specific loadouts
ConfigurationSection loadoutsSection = warzoneRootSection.getConfigurationSection(teamLoadoutPrefix);
LoadoutYmlMapper.fromConfigToLoadouts(loadoutsSection, team.getInventories().getLoadouts());
}
String teamRewardPrefix = "team." + teamName + ".reward";
if (warzoneRootSection.contains(teamRewardPrefix)) {
// team specific reward
ConfigurationSection rewardsSection = warzoneRootSection.getConfigurationSection(teamRewardPrefix);
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutYmlMapper.fromConfigToLoadout(rewardsSection, reward, "default");
warzone.getDefaultInventories().setReward(reward);
}
}
}
@ -188,7 +196,7 @@ public class WarzoneYmlMapper {
String lobbyPrefix = zoneInfoPrefix + "lobby.";
// lobby orientation
String lobbyOrientation = warzoneYmlConfig.getString(lobbyPrefix + "orientation");
String lobbyOrientation = warzoneRootSection.getString(lobbyPrefix + "orientation");
BlockFace lobbyFace = null;
if (lobbyOrientation.equals("south")) {
lobbyFace = BlockFace.SOUTH;
@ -201,7 +209,7 @@ public class WarzoneYmlMapper {
}
// lobby world
String lobbyWorldName = warzoneYmlConfig.getString(lobbyPrefix + "world");
String lobbyWorldName = warzoneRootSection.getString(lobbyPrefix + "world");
World lobbyWorld = War.war.getServer().getWorld(lobbyWorldName);
// create the lobby
@ -217,114 +225,32 @@ public class WarzoneYmlMapper {
public static void save(Warzone warzone, boolean saveAllBlocks) {
YamlConfiguration warzoneYmlConfig = new YamlConfiguration();
ConfigurationSection warzoneRootSection = warzoneYmlConfig.createSection("set");
(new File(War.war.getDataFolder().getPath() + "/dat/warzone-" + warzone.getName())).mkdir(); // create folder
String zoneInfoPrefix = "warzone." + warzone.getName() + ".info.";
// world
warzoneYmlConfig.set(zoneInfoPrefix + "world", warzone.getWorld().getName());
// teleport
ConfigurationSection teleSection = warzoneYmlConfig.createSection(zoneInfoPrefix + "teleport");
teleSection.set(zoneInfoPrefix + "teleport.x", warzone.getTeleport().getBlockX());
teleSection.set(zoneInfoPrefix + "teleport.y", warzone.getTeleport().getBlockY());
teleSection.set(zoneInfoPrefix + "teleport.z", warzone.getTeleport().getBlockZ());
teleSection.set(zoneInfoPrefix + "teleport.yaw", toIntYaw(warzone.getTeleport().getYaw()));
// teams
List<Team> teams = warzone.getTeams();
List<String> teamNames = new ArrayList<String>();
for (Team team : teams) {
String teamPrefix = "team." + team.getName() + ".";
teamNames.add(team.getName());
Location spawn = team.getTeamSpawn();
warzoneYmlConfig.set(teamPrefix + "spawn.x", spawn.getBlockX());
warzoneYmlConfig.set(teamPrefix + "spawn.y", spawn.getBlockY());
warzoneYmlConfig.set(teamPrefix + "spawn.z", spawn.getBlockZ());
warzoneYmlConfig.set(teamPrefix + "spawn.yaw", toIntYaw(spawn.getYaw()));
if (team.getTeamFlag() != null) {
Location teamFlag = team.getTeamFlag();
warzoneYmlConfig.set(teamPrefix + "flag.x", teamFlag.getBlockX());
warzoneYmlConfig.set(teamPrefix + "flag.y", teamFlag.getBlockY());
warzoneYmlConfig.set(teamPrefix + "flag.z", teamFlag.getBlockZ());
warzoneYmlConfig.set(teamPrefix + "flag.yaw", toIntYaw(teamFlag.getYaw()));
}
if (!team.getTeamConfig().isEmpty()) {
// team specific config
ConfigurationSection teamConfigSection = warzoneYmlConfig.createSection("team." + team.getName() + ".config");
team.getTeamConfig().saveTo(teamConfigSection);
}
if (team.getInventories().hasLoadouts()) {
// team specific loadouts
ConfigurationSection loadoutsSection = warzoneYmlConfig.createSection("team." + team.getName() + ".loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(team.getInventories().getLoadouts(), loadoutsSection);
}
if (team.getInventories().hasReward()) {
// team specific reward
ConfigurationSection rewardsSection = warzoneYmlConfig.createSection("team." + team.getName() + ".reward");
LoadoutYmlMapper.fromLoadoutToConfig(team.getInventories().getReward(), rewardsSection, "default");
}
}
if (teamNames.size() > 0) {
warzoneYmlConfig.set("team.names", teamNames);
}
// defaultLoadouts
if (warzone.getDefaultInventories().hasLoadouts()) {
ConfigurationSection loadoutsSection = warzoneYmlConfig.createSection("team.default.loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(warzone.getDefaultInventories().getLoadouts(), loadoutsSection);
}
// defaultReward
if (warzone.getDefaultInventories().hasReward()) {
ConfigurationSection rewardsSection = warzoneYmlConfig.createSection("team.default.reward");
LoadoutYmlMapper.fromLoadoutToConfig(warzone.getDefaultInventories().getReward(), rewardsSection, "default");
}
ConfigurationSection warzoneSection = warzoneRootSection.createSection("warzone." + warzone.getName());
// Warzone settings
if (!warzone.getWarzoneConfig().isEmpty()) {
ConfigurationSection warzoneConfigSection = warzoneYmlConfig.createSection("warzone." + warzone.getName() + ".config");
ConfigurationSection warzoneConfigSection = warzoneSection.createSection("config");
warzone.getWarzoneConfig().saveTo(warzoneConfigSection);
}
// Team default settings
if (!warzone.getTeamDefaultConfig().isEmpty()) {
ConfigurationSection teamConfigSection = warzoneYmlConfig.createSection("team.default.config");
warzone.getTeamDefaultConfig().saveTo(teamConfigSection);
}
ConfigurationSection warzoneInfoSection = warzoneSection.createSection("info");
// authors
warzoneYmlConfig.set(zoneInfoPrefix + "authors", warzone.getAuthors());
warzoneInfoSection.set("authors", warzone.getAuthors());
// teleport
ConfigurationSection teleSection = warzoneInfoSection.createSection("teleport");
teleSection.set("x", warzone.getTeleport().getBlockX());
teleSection.set("y", warzone.getTeleport().getBlockY());
teleSection.set("z", warzone.getTeleport().getBlockZ());
teleSection.set("yaw", toIntYaw(warzone.getTeleport().getYaw()));
// world
warzoneInfoSection.set("world", warzone.getWorld().getName());
// rallyPoint
if (warzone.getRallyPoint() != null) {
ConfigurationSection rpSection = warzoneYmlConfig.createSection(zoneInfoPrefix + "rallypoint");
rpSection.set(zoneInfoPrefix + "x", warzone.getTeleport().getBlockX());
rpSection.set(zoneInfoPrefix + "y", warzone.getTeleport().getBlockY());
rpSection.set(zoneInfoPrefix + "z", warzone.getTeleport().getBlockZ());
rpSection.set(zoneInfoPrefix + "yaw", toIntYaw(warzone.getTeleport().getYaw()));
}
// monuments
if (warzone.getMonuments().size() > 0) {
ConfigurationSection monumentSection = warzoneYmlConfig.createSection(zoneInfoPrefix + "monument");
List<String> monumentNames = new ArrayList<String>();
for (Monument monument : warzone.getMonuments()) {
monumentNames.add(monument.getName());
monumentSection.set(monument.getName() + ".x", monument.getLocation().getBlockX());
monumentSection.set(monument.getName() + ".y", monument.getLocation().getBlockX());
monumentSection.set(monument.getName() + ".z", monument.getLocation().getBlockX());
monumentSection.set(monument.getName() + ".yaw", toIntYaw(monument.getLocation().getYaw()));
}
monumentSection.set("names", monumentNames);
}
// lobby
if (warzone.getLobby() != null) {
String lobbyOrientation = "";
@ -338,10 +264,109 @@ public class WarzoneYmlMapper {
lobbyOrientation = "west";
}
warzoneYmlConfig.set(zoneInfoPrefix + "lobby.orientation", lobbyOrientation);
warzoneYmlConfig.set(zoneInfoPrefix + "lobby.world", warzone.getLobby().getVolume().getWorld().getName());
ConfigurationSection lobbySection = warzoneInfoSection.createSection("lobby");
lobbySection.set("orientation", lobbyOrientation);
lobbySection.set("world", warzone.getLobby().getVolume().getWorld().getName());
}
// rallyPoint
if (warzone.getRallyPoint() != null) {
ConfigurationSection rpSection = warzoneInfoSection.createSection("rallypoint");
rpSection.set("x", warzone.getRallyPoint().getBlockX());
rpSection.set("y", warzone.getRallyPoint().getBlockY());
rpSection.set("z", warzone.getRallyPoint().getBlockZ());
rpSection.set("yaw", toIntYaw(warzone.getRallyPoint().getYaw()));
}
// monuments
if (warzone.getMonuments().size() > 0) {
ConfigurationSection monumentsSection = warzoneInfoSection.createSection("monument");
List<String> monumentNames = new ArrayList<String>();
for (Monument monument : warzone.getMonuments()) {
monumentNames.add(monument.getName());
}
monumentsSection.set("names", monumentNames);
for (Monument monument : warzone.getMonuments()) {
ConfigurationSection monumentSection = monumentsSection.createSection(monument.getName());
monumentSection.set("x", monument.getLocation().getBlockX());
monumentSection.set("y", monument.getLocation().getBlockY());
monumentSection.set("z", monument.getLocation().getBlockZ());
monumentSection.set("yaw", toIntYaw(monument.getLocation().getYaw()));
}
}
ConfigurationSection teamsSection = warzoneRootSection.createSection("team");
// teams
List<Team> teams = warzone.getTeams();
List<String> teamNames = new ArrayList<String>();
for (Team team : teams) {
teamNames.add(team.getName());
}
if (teamNames.size() > 0) {
teamsSection.set("names", teamNames);
}
// Team default settings
if (!warzone.getTeamDefaultConfig().isEmpty()) {
ConfigurationSection teamConfigSection = teamsSection.createSection("default.config");
warzone.getTeamDefaultConfig().saveTo(teamConfigSection);
}
// defaultLoadouts
if (warzone.getDefaultInventories().hasLoadouts()) {
ConfigurationSection loadoutsSection = teamsSection.createSection("default.loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(warzone.getDefaultInventories().getLoadouts(), loadoutsSection);
}
// defaultReward
if (warzone.getDefaultInventories().hasReward()) {
ConfigurationSection rewardsSection = teamsSection.createSection("default.reward");
LoadoutYmlMapper.fromLoadoutToConfig("default", warzone.getDefaultInventories().getReward(), rewardsSection);
}
for (Team team : teams) {
if (!team.getTeamConfig().isEmpty()) {
// team specific config
ConfigurationSection teamConfigSection = teamsSection.createSection(team.getName() + ".config");
team.getTeamConfig().saveTo(teamConfigSection);
}
if (team.getInventories().hasLoadouts()) {
// team specific loadouts
ConfigurationSection loadoutsSection = teamsSection.createSection(team.getName() + ".loadout");
LoadoutYmlMapper.fromLoadoutsToConfig(team.getInventories().getLoadouts(), loadoutsSection);
}
if (team.getInventories().hasReward()) {
// team specific reward
ConfigurationSection rewardsSection = teamsSection.createSection(team.getName() + ".reward");
LoadoutYmlMapper.fromLoadoutToConfig("default", team.getInventories().getReward(), rewardsSection);
}
ConfigurationSection teamInfoSection = teamsSection.createSection(team.getName() + ".info");
ConfigurationSection spawnSection = teamInfoSection.createSection("spawn");
Location spawn = team.getTeamSpawn();
spawnSection.set("x", spawn.getBlockX());
spawnSection.set("y", spawn.getBlockY());
spawnSection.set("z", spawn.getBlockZ());
spawnSection.set("yaw", toIntYaw(spawn.getYaw()));
if (team.getTeamFlag() != null) {
ConfigurationSection flagSection = teamInfoSection.createSection("flag");
Location teamFlag = team.getTeamFlag();
flagSection.set("x", teamFlag.getBlockX());
flagSection.set("y", teamFlag.getBlockY());
flagSection.set("z", teamFlag.getBlockZ());
flagSection.set("yaw", toIntYaw(teamFlag.getYaw()));
}
}
// monument blocks
for (Monument monument : warzone.getMonuments()) {
VolumeMapper.save(monument.getVolume(), warzone.getName());