* Main class of War

*

* @author tommytony, Tim Düsterhus

* @package bukkit.tommytony.war

*/

  public static War war;

  // general

  private WarPlayerListener playerListener = new WarPlayerListener();

  private WarEntityListener entityListener = new WarEntityListener();

  private WarBlockListener blockListener = new WarBlockListener();

  private WarServerListener serverListener = new WarServerListener();

 

  private WarCommandHandler commandHandler = new WarCommandHandler();

  private PluginDescriptionFile desc = null;

  private boolean loaded = false;

  private boolean isSpoutServer = false;

  private boolean tagServer = false;

  // Zones and hub

  private List<Warzone> warzones = new ArrayList<Warzone>();

  private WarHub warHub;

 

  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

  private final List<String> deadlyAdjectives = new ArrayList<String>();

  private final List<String> killerVerbs = new ArrayList<String>();

  private final InventoryBag defaultInventories = new InventoryBag();

  private KillstreakReward killstreakReward;

  private MySQLConfig mysqlConfig;

  private Economy econ = null;

  private final WarConfigBag warConfig = new WarConfigBag();

  private final WarzoneConfigBag warzoneDefaultConfig = new WarzoneConfigBag();

  private final TeamConfigBag teamDefaultConfig = new TeamConfigBag();

  private SpoutDisplayer spoutMessenger = null;

  private static ResourceBundle messages = ResourceBundle.getBundle("messages");

  private HubLobbyMaterials warhubMaterials = new HubLobbyMaterials(

      new ItemStack(Material.GLASS), new ItemStack(Material.WOOD),

      new ItemStack(Material.OBSIDIAN), new ItemStack(Material.GLOWSTONE));

  public War() {

    super();

    War.war = this;

  }

  /**

   * @see JavaPlugin#onEnable()

   * @see War#loadWar()

   */

  public void onEnable() {

    this.loadWar();

  }

  /**

   * @see JavaPlugin#onDisable()

   * @see War#unloadWar()

   */

  public void onDisable() {

    this.unloadWar();

  }

  /**

   * Initializes war

   */

  public void loadWar() {

    this.setLoaded(true);

    this.desc = this.getDescription();

   

    // Spout server detection

    try {

      Class.forName("org.getspout.spoutapi.player.SpoutPlayer");

      isSpoutServer = true;

      spoutMessenger = new SpoutDisplayer();

    } catch (ClassNotFoundException e) {

      isSpoutServer = false;

    }

    try {

      Class.forName("org.sqlite.JDBC").newInstance();

    } catch (Exception e) {

      this.log("SQLite3 driver not found!", Level.SEVERE);

      this.getServer().getPluginManager().disablePlugin(this);

      return;

    }

    // Register events

    PluginManager pm = this.getServer().getPluginManager();

    pm.registerEvents(this.playerListener, this);

    pm.registerEvents(this.entityListener, this);

    pm.registerEvents(this.blockListener, this);

    pm.registerEvents(this.serverListener, this);

    if (pm.isPluginEnabled("TagAPI")) {

      try {

        Class.forName("org.kitteh.tag.TagAPI");

        pm.registerEvents(new WarTagListener(), this);

        this.tagServer = true;

      } catch (ClassNotFoundException e) {

        this.tagServer = false;

      }

    }

    // Add defaults

    warConfig.put(WarConfig.BUILDINZONESONLY, false);

    warConfig.put(WarConfig.DISABLEBUILDMESSAGE, false);

    warConfig.put(WarConfig.DISABLEPVPMESSAGE, false);

    warConfig.put(WarConfig.KEEPOLDZONEVERSIONS, true);

    warConfig.put(WarConfig.MAXZONES, 12);

    warConfig.put(WarConfig.PVPINZONESONLY, false);

    warConfig.put(WarConfig.TNTINZONESONLY, false);

    warConfig.put(WarConfig.RESETSPEED, 5000);

    warConfig.put(WarConfig.MAXSIZE, 750);

    warConfig.put(WarConfig.LANGUAGE, Locale.getDefault().toString());

    warConfig.put(WarConfig.AUTOJOIN, "");

    warConfig.put(WarConfig.TPWARMUP, 0);

    warzoneDefaultConfig.put(WarzoneConfig.AUTOASSIGN, false);

    warzoneDefaultConfig.put(WarzoneConfig.BLOCKHEADS, true);

    warzoneDefaultConfig.put(WarzoneConfig.DISABLED, false);

    warzoneDefaultConfig.put(WarzoneConfig.FRIENDLYFIRE, false);

    warzoneDefaultConfig.put(WarzoneConfig.GLASSWALLS, true);

    warzoneDefaultConfig.put(WarzoneConfig.INSTABREAK, false);

    warzoneDefaultConfig.put(WarzoneConfig.MINPLAYERS, 1);

    warzoneDefaultConfig.put(WarzoneConfig.MINTEAMS, 1);

    warzoneDefaultConfig.put(WarzoneConfig.MONUMENTHEAL, 5);

    warzoneDefaultConfig.put(WarzoneConfig.NOCREATURES, false);

    warzoneDefaultConfig.put(WarzoneConfig.NODROPS, false);

    warzoneDefaultConfig.put(WarzoneConfig.PVPINZONE, true);

    warzoneDefaultConfig.put(WarzoneConfig.REALDEATHS, false);

    warzoneDefaultConfig.put(WarzoneConfig.RESETONEMPTY, false);

    warzoneDefaultConfig.put(WarzoneConfig.RESETONCONFIGCHANGE, false);

    warzoneDefaultConfig.put(WarzoneConfig.RESETONLOAD, false);

    warzoneDefaultConfig.put(WarzoneConfig.RESETONUNLOAD, false);

    warzoneDefaultConfig.put(WarzoneConfig.UNBREAKABLE, false);

    warzoneDefaultConfig.put(WarzoneConfig.DEATHMESSAGES, true);

    warzoneDefaultConfig.put(WarzoneConfig.JOINMIDBATTLE, true);

    warzoneDefaultConfig.put(WarzoneConfig.AUTOJOIN, false);

    warzoneDefaultConfig.put(WarzoneConfig.SCOREBOARD, ScoreboardType.NONE);

    warzoneDefaultConfig.put(WarzoneConfig.XPKILLMETER, false);

    warzoneDefaultConfig.put(WarzoneConfig.SOUPHEALING, false);

    warzoneDefaultConfig.put(WarzoneConfig.ALLOWENDER, true);

    warzoneDefaultConfig.put(WarzoneConfig.RESETBLOCKS, true);

    teamDefaultConfig.put(TeamConfig.FLAGMUSTBEHOME, true);

    teamDefaultConfig.put(TeamConfig.FLAGPOINTSONLY, false);

    teamDefaultConfig.put(TeamConfig.FLAGRETURN, FlagReturn.BOTH);

    teamDefaultConfig.put(TeamConfig.LIFEPOOL, 7);

    teamDefaultConfig.put(TeamConfig.MAXSCORE, 10);

    teamDefaultConfig.put(TeamConfig.NOHUNGER, false);

    teamDefaultConfig.put(TeamConfig.PLAYERLOADOUTASDEFAULT, false);

    teamDefaultConfig.put(TeamConfig.RESPAWNTIMER, 0);

    teamDefaultConfig.put(TeamConfig.SATURATION, 10);

    teamDefaultConfig.put(TeamConfig.SPAWNSTYLE, TeamSpawnStyle.SMALL);

    teamDefaultConfig.put(TeamConfig.TEAMSIZE, 10);

    teamDefaultConfig.put(TeamConfig.PERMISSION, "war.player");

    teamDefaultConfig.put(TeamConfig.XPKILLMETER, false);

    teamDefaultConfig.put(TeamConfig.KILLSTREAK, false);

    teamDefaultConfig.put(TeamConfig.BLOCKWHITELIST, "all");

    teamDefaultConfig.put(TeamConfig.PLACEBLOCK, true);

    teamDefaultConfig.put(TeamConfig.APPLYPOTION, "");

    teamDefaultConfig.put(TeamConfig.ECOREWARD, 0.0);

    teamDefaultConfig.put(TeamConfig.INVENTORYDROP, false);

    this.getDefaultInventories().clearLoadouts();

    HashMap<Integer, ItemStack> defaultLoadout = new HashMap<Integer, ItemStack>();

   

    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>();

    reward.put(0, new ItemStack(Material.CAKE, 1));

    this.getDefaultInventories().setReward(reward);

   

    this.getCommandWhitelist().add("who");

    this.getZoneMakerNames().add("tommytony");

    this.setKillstreakReward(new KillstreakReward());

    this.setMysqlConfig(new MySQLConfig());

   

    // Add constants

    this.getDeadlyAdjectives().clear();

    for (String adjective : this.getString("pvp.kill.adjectives").split(";")) {

      this.getDeadlyAdjectives().add(adjective);

    }

    this.getKillerVerbs().clear();

    for (String verb : this.getString("pvp.kill.verbs").split(";")) {

      this.getKillerVerbs().add(verb);

    }

   

    // Load files

    WarYmlMapper.load();

   

    // Start tasks

    HelmetProtectionTask helmetProtectionTask = new HelmetProtectionTask();

    this.getServer().getScheduler().scheduleSyncRepeatingTask(this, helmetProtectionTask, 250, 100);

   

    if (this.isSpoutServer) {

      SpoutFadeOutMessageJob fadeOutMessagesTask = new SpoutFadeOutMessageJob();

      this.getServer().getScheduler().scheduleSyncRepeatingTask(this, fadeOutMessagesTask, 100, 100);

    }

    if (this.mysqlConfig.isEnabled()) {

      try {

        Class.forName("com.mysql.jdbc.Driver").newInstance();

      } catch (Exception ex) {

        this.log("MySQL driver not found!", Level.SEVERE);

        this.getServer().getPluginManager().disablePlugin(this);

      }

    }

    if (this.getServer().getPluginManager().isPluginEnabled("Vault")) {

      RegisteredServiceProvider<Economy> rsp = this.getServer().getServicesManager()

        .getRegistration(Economy.class);

      if (rsp != null) {

        this.econ = rsp.getProvider();

      }

    }

    War.reloadLanguage();

    // Get own log file

    try {

      // Create an appending file handler

      new File(this.getDataFolder() + "/temp/").mkdir();

      FileHandler handler = new FileHandler(this.getDataFolder() + "/temp/war.log", true);

      // Add to War-specific logger

      Formatter formatter = new WarLogFormatter();

      handler.setFormatter(formatter);

      this.getLogger().addHandler(handler);

    } catch (IOException e) {

      this.getLogger().log(Level.WARNING, "Failed to create War log file");

    }

   

    // Size check

    long datSize = SizeCounter.getFileOrDirectorySize(new File(this.getDataFolder() + "/dat/")) / 1024 / 1024;

    long tempSize = SizeCounter.getFileOrDirectorySize(new File(this.getDataFolder() + "/temp/")) / 1024 / 1024;

   

    if (datSize + tempSize > 100) {

      this.log("War data files are taking " + datSize + "MB and its temp files " + tempSize + "MB. Consider permanently deleting old warzone versions and backups in /plugins/War/temp/.", Level.WARNING);

    }

       

    this.log("War v" + this.desc.getVersion() + " is on.", Level.INFO);

  }

  public static void reloadLanguage() {

    String[] parts = War.war.getWarConfig().getString(WarConfig.LANGUAGE).replace("-", "_").split("_");

    Locale lang = new Locale(parts[0]);

    if (parts.length >= 2) {

      lang = new Locale(parts[0], parts[1]);

    }

    War.messages = ResourceBundle.getBundle("messages", lang);

  }

  /**

   * Cleans up war

   */

  public void unloadWar() {

    for (Warzone warzone : this.warzones) {

      warzone.unload();

    }

    this.warzones.clear();

    if (this.warHub != null) {

      this.warHub.getVolume().resetBlocks();

    }

    this.getServer().getScheduler().cancelTasks(this);

    this.playerListener.purgeLatestPositions();

    HandlerList.unregisterAll(this);

    this.log("War v" + this.desc.getVersion() + " is off.", Level.INFO);

    this.setLoaded(false);

  }

  /**

   * @see org.bukkit.command.CommandExecutor#onCommand(org.bukkit.command.CommandSender, org.bukkit.command.Command, String, String[])

   */

  public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {

    return this.commandHandler.handle(sender, cmd, args);

  }

  /**

   * Converts the player-inventory to a loadout hashmap

   *

   * @param inv

   *                inventory to get the items from

   * @param loadout

   *                the hashmap to save to

   */

  private void inventoryToLoadout(PlayerInventory inv, HashMap<Integer, ItemStack> loadout) {

    loadout.clear();

    int i = 0;

    for (ItemStack stack : inv.getContents()) {

      if (stack != null && stack.getType() != Material.AIR) {

        loadout.put(i, stack.clone());

        i++;

      }

    }

    if (inv.getBoots() != null && inv.getBoots().getType() != Material.AIR) {

      loadout.put(100, inv.getBoots().clone());

    }

    if (inv.getLeggings() != null && inv.getLeggings().getType() != Material.AIR) {

      loadout.put(101, inv.getLeggings().clone());

    }

    if (inv.getChestplate() != null && inv.getChestplate().getType() != Material.AIR) {

      loadout.put(102, inv.getChestplate().clone());

    }

    if (inv.getHelmet() != null && inv.getHelmet().getType() != Material.AIR) {

      loadout.put(103, inv.getHelmet().clone());

    }

  }

  public void safelyEnchant(ItemStack target, Enchantment enchantment, int level) {

    if (level > enchantment.getMaxLevel()) {

      target.addUnsafeEnchantment(enchantment, level);

    } else {

      target.addEnchantment(enchantment, level);

    }

  }

  /**

   * Converts the player-inventory to a loadout hashmap

   *

   * @param player

   *                player to get the inventory to get the items from

   * @param loadout

   *                the hashmap to save to

   */

  private void inventoryToLoadout(Player player, HashMap<Integer, ItemStack> loadout) {

    this.inventoryToLoadout(player.getInventory(), loadout);

  }

 

  public String updateTeamFromNamedParams(Team team, CommandSender commandSender, String[] arguments) {

    try {

      Map<String, String> namedParams = new HashMap<String, String>();

      Map<String, String> thirdParameter = new HashMap<String, String>();

      for (String namedPair : arguments) {

        String[] pairSplit = namedPair.split(":");

        if (pairSplit.length == 2) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

        } else if (pairSplit.length == 3) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

          thirdParameter.put(pairSplit[0].toLowerCase(), pairSplit[2]);

        }

      }

     

      StringBuilder returnMessage = new StringBuilder();

      returnMessage.append(team.getTeamConfig().updateFromNamedParams(namedParams));

     

      if (commandSender instanceof Player) {

        Player player = (Player) commandSender;

        if (namedParams.containsKey("loadout")) {

          String loadoutName = namedParams.get("loadout");

          HashMap<Integer, ItemStack> loadout = team.getInventories().getLoadout(loadoutName);

          if (loadout == null) {

            // Check if any loadouts exist, if not gotta use the default inventories then add the newly created one

            if(!team.getInventories().hasLoadouts()) {

              Warzone warzone = team.getZone();

              for (String key : warzone.getDefaultInventories().resolveLoadouts().keySet()) {

                HashMap<Integer, ItemStack> transferredLoadout = warzone.getDefaultInventories().resolveLoadouts().get(key);

                if (transferredLoadout != null) {

                  team.getInventories().setLoadout(key, transferredLoadout);

                } else {

                  War.war.log("Failed to transfer loadout " + key + " down to team " + team.getName() + " in warzone " + warzone.getName(), Level.WARNING);

                }

              }

            }

           

            loadout = new HashMap<Integer, ItemStack>();

            team.getInventories().setLoadout(loadoutName, loadout);

            returnMessage.append(loadoutName + " respawn loadout added.");

          } else {

            returnMessage.append(loadoutName + " respawn loadout updated.");

          }

          this.inventoryToLoadout(player, loadout);

          Loadout ldt = team.getInventories().getNewLoadout(loadoutName);

          if (thirdParameter.containsKey("loadout")) {

            String permission = thirdParameter.get("loadout");

            ldt.setPermission(permission);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission set to ").append(permission).append('.');

          } else if (ldt.requiresPermission()) {

            ldt.setPermission(null);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission deleted.");

          }

        }

        if (namedParams.containsKey("deleteloadout")) {

          String loadoutName = namedParams.get("deleteloadout");

          if (team.getInventories().containsLoadout(loadoutName)) {

            team.getInventories().removeLoadout(loadoutName);

            returnMessage.append(" " + loadoutName + " loadout removed.");

          } else {

            returnMessage.append(" " + loadoutName + " loadout not found.");

          }

        }

        if (namedParams.containsKey("reward")) {

          HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();

          this.inventoryToLoadout(player, reward);

          team.getInventories().setReward(reward);

          returnMessage.append(" game end reward updated.");

        }

      }

      return returnMessage.toString();

    } catch (Exception e) {

      return "PARSE-ERROR";

    }

  }

  public String updateZoneFromNamedParams(Warzone warzone, CommandSender commandSender, String[] arguments) {

    try {

      Map<String, String> namedParams = new HashMap<String, String>();

      Map<String, String> thirdParameter = new HashMap<String, String>();

      for (String namedPair : arguments) {

        String[] pairSplit = namedPair.split(":");

        if (pairSplit.length == 2) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

        } else if (pairSplit.length == 3) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

          thirdParameter.put(pairSplit[0].toLowerCase(), pairSplit[2]);

        }

      }

     

      StringBuilder returnMessage = new StringBuilder();

      if (namedParams.containsKey("author")) {

        for(String author : namedParams.get("author").split(",")) {

          if (!author.equals("") && !warzone.getAuthors().contains(author)) {

            warzone.addAuthor(author);

            returnMessage.append(" author " + author + " added.");

          }

        }

      }

      if (namedParams.containsKey("deleteauthor")) {

        for(String author : namedParams.get("deleteauthor").split(",")) {

          if (warzone.getAuthors().contains(author)) {

            warzone.getAuthors().remove(author);

            returnMessage.append(" " + author + " removed from zone authors.");

          }

        }

      }

     

      returnMessage.append(warzone.getWarzoneConfig().updateFromNamedParams(namedParams));

      returnMessage.append(warzone.getTeamDefaultConfig().updateFromNamedParams(namedParams));

      if (commandSender instanceof Player) {

        Player player = (Player) commandSender;

        if (namedParams.containsKey("loadout")) {

          String loadoutName = namedParams.get("loadout");

          HashMap<Integer, ItemStack> loadout = warzone.getDefaultInventories().getLoadout(loadoutName);

          if (loadout == null) {

            loadout = new HashMap<Integer, ItemStack>();

            // Check if any loadouts exist, if not gotta use the default inventories then add the newly created one

            if(!warzone.getDefaultInventories().hasLoadouts()) {

              for (String key : warzone.getDefaultInventories().resolveLoadouts().keySet()) {

                HashMap<Integer, ItemStack> transferredLoadout = warzone.getDefaultInventories().resolveLoadouts().get(key);

                if (transferredLoadout != null) {

                  warzone.getDefaultInventories().setLoadout(key, transferredLoadout);

                } else {

                  War.war.log("Failed to transfer loadout " + key + " down to warzone " + warzone.getName(), Level.WARNING);

                }

              }

            }

           

            warzone.getDefaultInventories().setLoadout(loadoutName, loadout);

            returnMessage.append(loadoutName + " respawn loadout added.");

          } else {

            returnMessage.append(loadoutName + " respawn loadout updated.");

          }

          this.inventoryToLoadout(player, loadout);

          Loadout ldt = warzone.getDefaultInventories().getNewLoadout(loadoutName);

          if (thirdParameter.containsKey("loadout")) {

            String permission = thirdParameter.get("loadout");

            ldt.setPermission(permission);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission set to ").append(permission).append('.');

          } else if (ldt.requiresPermission()) {

            ldt.setPermission(null);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission deleted.");

          }

        }

        if (namedParams.containsKey("deleteloadout")) {

          String loadoutName = namedParams.get("deleteloadout");

          if (warzone.getDefaultInventories().containsLoadout(loadoutName)) {

            warzone.getDefaultInventories().removeLoadout(loadoutName);

            returnMessage.append(" " + loadoutName + " loadout removed.");

          } else {

            returnMessage.append(" " + loadoutName + " loadout not found.");

          }

        }

        if (namedParams.containsKey("reward")) {

          HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();

          this.inventoryToLoadout(player, reward);

          warzone.getDefaultInventories().setReward(reward);

          returnMessage.append(" game end reward updated.");

        }

        if (namedParams.containsKey("lobbymaterial")) {

          String whichBlocks = namedParams.get("lobbymaterial");

          ItemStack blockInHand = player.getItemInHand();

          boolean updatedLobbyMaterials = false;

         

          if (!blockInHand.getType().isBlock() && !blockInHand.getType().equals(Material.AIR)) {

            this.badMsg(player, "Can only use blocks or air as lobby material.");

          } else {

            if (whichBlocks.equals("floor")) {

              warzone.getLobbyMaterials().setFloorBlock(blockInHand);

              returnMessage.append(" lobby floor material set to " + blockInHand.getType());

              updatedLobbyMaterials = true;

            } else if (whichBlocks.equals("outline")) {

              warzone.getLobbyMaterials().setOutlineBlock(blockInHand);

              returnMessage.append(" lobby outline material set to " + blockInHand.getType());

              updatedLobbyMaterials = true;

            } else if (whichBlocks.equals("gate")) {

              warzone.getLobbyMaterials().setGateBlock(blockInHand);

              returnMessage.append(" lobby gate material set to " + blockInHand.getType());

              updatedLobbyMaterials = true;

            } else if (whichBlocks.equals("light")) {

              warzone.getLobbyMaterials().setLightBlock(blockInHand);

              returnMessage.append(" lobby light material set to " + blockInHand.getType());

              updatedLobbyMaterials = true;

            }

           

            if (updatedLobbyMaterials && warzone.getLobby() != null) {

              warzone.getLobby().getVolume().resetBlocks();

              warzone.getLobby().initialize();

            }

          }

        }

        if (namedParams.containsKey("material")) {

          String whichBlocks = namedParams.get("material");

          ItemStack blockInHand = player.getItemInHand();

          boolean updatedMaterials = false;

         

          if (!blockInHand.getType().isBlock()) {

            this.badMsg(player, "Can only use blocks as material.");

          } else {

            if (whichBlocks.equals("main")) {

              warzone.getWarzoneMaterials().setMainBlock(blockInHand);

              returnMessage.append(" main material set to " + blockInHand.getType());

              updatedMaterials = true;

            } else if (whichBlocks.equals("stand")) {

              warzone.getWarzoneMaterials().setStandBlock(blockInHand);

              returnMessage.append(" stand material set to " + blockInHand.getType());

              updatedMaterials = true;

            } else if (whichBlocks.equals("light")) {

              warzone.getWarzoneMaterials().setLightBlock(blockInHand);

              returnMessage.append(" light material set to " + blockInHand.getType());

              updatedMaterials = true;

            }

           

            if (updatedMaterials) {

              // reset all structures

              for (Monument monument : warzone.getMonuments()) {

                monument.getVolume().resetBlocks();

                monument.addMonumentBlocks();

              }

              for (Cake cake : warzone.getCakes()) {

                cake.getVolume().resetBlocks();

                cake.addCakeBlocks();

              }

              for (Bomb bomb : warzone.getBombs()) {

                bomb.getVolume().resetBlocks();

                bomb.addBombBlocks();

              }

              for (Team team : warzone.getTeams()) {

                for (Volume spawnVolume : team.getSpawnVolumes().values()) {

                  spawnVolume.resetBlocks();

                }

                team.initializeTeamSpawns();

                if (team.getTeamFlag() != null) {

                  team.getFlagVolume().resetBlocks();

                  team.initializeTeamFlag();

                }

              }

            }

          }

        }

      }

      return returnMessage.toString();

    } catch (Exception e) {

      return "PARSE-ERROR";

    }

  }

  public String updateFromNamedParams(CommandSender commandSender, String[] arguments) {

    try {

      Map<String, String> namedParams = new HashMap<String, String>();

      Map<String, String> thirdParameter = new HashMap<String, String>();

      for (String namedPair : arguments) {

        String[] pairSplit = namedPair.split(":");

        if (pairSplit.length == 2) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

        } else if (pairSplit.length == 3) {

          namedParams.put(pairSplit[0].toLowerCase(), pairSplit[1]);

          thirdParameter.put(pairSplit[0].toLowerCase(), pairSplit[2]);

        }

      }

     

      StringBuilder returnMessage = new StringBuilder();

     

      returnMessage.append(this.getWarConfig().updateFromNamedParams(namedParams));

      returnMessage.append(this.getWarzoneDefaultConfig().updateFromNamedParams(namedParams));

      returnMessage.append(this.getTeamDefaultConfig().updateFromNamedParams(namedParams));

 

      if (commandSender instanceof Player) {

        Player player = (Player) commandSender;

        if (namedParams.containsKey("loadout")) {

          String loadoutName = namedParams.get("loadout");

          HashMap<Integer, ItemStack> loadout = this.getDefaultInventories().getLoadout(loadoutName);

          if (loadout == null) {

            loadout = new HashMap<Integer, ItemStack>();

            this.getDefaultInventories().addLoadout(loadoutName, loadout);

            returnMessage.append(loadoutName + " respawn loadout added.");

          } else {

            returnMessage.append(loadoutName + " respawn loadout updated.");

          }

          this.inventoryToLoadout(player, loadout);

          Loadout ldt = this.getDefaultInventories().getNewLoadout(loadoutName);

          if (thirdParameter.containsKey("loadout")) {

            String permission = thirdParameter.get("loadout");

            ldt.setPermission(permission);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission set to ").append(permission).append('.');

          } else if (ldt.requiresPermission()) {

            ldt.setPermission(null);

            returnMessage.append(' ').append(loadoutName).append(" respawn loadout permission deleted.");

          }

        }

        if (namedParams.containsKey("deleteloadout")) {

          String loadoutName = namedParams.get("deleteloadout");

          if (this.getDefaultInventories().containsLoadout(loadoutName)) {

            if (this.getDefaultInventories().getNewLoadouts().size() > 1) {

              this.getDefaultInventories().removeLoadout(loadoutName);

              returnMessage.append(" " + loadoutName + " loadout removed.");

            } else {

              returnMessage.append(" Can't remove only loadout.");

            }

          } else {

            returnMessage.append(" " + loadoutName + " loadout not found.");

          }

        }

        if (namedParams.containsKey("reward")) {

          HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();

          this.inventoryToLoadout(player, reward);

          this.getDefaultInventories().setReward(reward);

          returnMessage.append(" game end reward updated.");

        }

        if (namedParams.containsKey("rallypoint")) {

          String zoneName = namedParams.get("rallypoint");

          this.setZoneRallyPoint(zoneName, player);

          returnMessage.append(" rallypoint set for zone " + zoneName + ".");

        }

        if (namedParams.containsKey("warhubmaterial")) {

          String whichBlocks = namedParams.get("warhubmaterial");

          ItemStack blockInHand = player.getItemInHand();

          boolean updatedWarhubMaterials = false;

         

          if (!blockInHand.getType().isBlock() && !blockInHand.getType().equals(Material.AIR)) {

            this.badMsg(player, "Can only use blocks or air as warhub material.");

          } else {

            if (whichBlocks.equals("floor")) {

              this.warhubMaterials.setFloorBlock(blockInHand);

              returnMessage.append(" warhub floor material set to " + blockInHand.getType());

              updatedWarhubMaterials = true;

            } else if (whichBlocks.equals("outline")) {

              this.warhubMaterials.setOutlineBlock(blockInHand);

              returnMessage.append(" warhub outline material set to " + blockInHand.getType());

              updatedWarhubMaterials = true;

            } else if (whichBlocks.equals("gate")) {

              this.warhubMaterials.setGateBlock(blockInHand);

              returnMessage.append(" warhub gate material set to " + blockInHand.getType());

              updatedWarhubMaterials = true;

            } else if (whichBlocks.equals("light")) {

              this.warhubMaterials.setLightBlock(blockInHand);

              returnMessage.append(" warhub light material set to " + blockInHand.getType());

              updatedWarhubMaterials = true;

            }

           

            if (updatedWarhubMaterials && War.war.getWarHub() != null) {

              War.war.getWarHub().getVolume().resetBlocks();

              War.war.getWarHub().initialize();

            }

          }

        }

      }

      return returnMessage.toString();

    } catch (Exception e) {

      return "PARSE-ERROR";

    }

  }

 

  public String printConfig(Team team) {

    ChatColor teamColor = ChatColor.AQUA;

   

    ChatColor normalColor = ChatColor.WHITE;

   

    String teamConfigStr = "";

    InventoryBag invs = team.getInventories();

    teamConfigStr += getLoadoutsString(invs);

   

    for (TeamConfig teamConfig : TeamConfig.values()) {

      Object value = team.getTeamConfig().getValue(teamConfig);

      if (value != null) {

        teamConfigStr += " " + teamConfig.toStringWithValue(value).replace(":", ":" + teamColor) + normalColor;

      }

    }

   

    return " ::" + teamColor + "Team " + team.getName() + teamColor +  " config" + normalColor + "::" 

      + ifEmptyInheritedForTeam(teamConfigStr);

  }

  private String getLoadoutsString(InventoryBag invs) {

    StringBuilder loadoutsString = new StringBuilder();

    ChatColor loadoutColor = ChatColor.GREEN;

    ChatColor normalColor = ChatColor.WHITE;

   

    if (invs.hasLoadouts()) {

      StringBuilder loadouts = new StringBuilder();

      for (Loadout ldt : invs.getNewLoadouts()) {

        if (ldt.requiresPermission()) {

          loadouts.append(ldt.getName()).append(":").append(ldt.getPermission()).append(",");

        } else {

          loadouts.append(ldt.getName()).append(",");

        }

      }

      loadoutsString.append(" loadout:").append(loadoutColor).append(loadouts.toString()).append(normalColor);

    }

   

    if (invs.hasReward()) {

      loadoutsString.append(" reward:").append(loadoutColor).append("default").append(normalColor);

    }

   

    return loadoutsString.toString();

  }

  public String printConfig(Warzone zone) {

    ChatColor teamColor = ChatColor.AQUA;

    ChatColor zoneColor = ChatColor.DARK_AQUA;

    ChatColor authorColor = ChatColor.GREEN;

    ChatColor normalColor = ChatColor.WHITE;

   

    String warzoneConfigStr = "";

    for (WarzoneConfig warzoneConfig : WarzoneConfig.values()) {

      Object value = zone.getWarzoneConfig().getValue(warzoneConfig);

      if (value != null) {

        warzoneConfigStr += " " + warzoneConfig.toStringWithValue(value).replace(":", ":" + zoneColor) + normalColor;

      }

    }

   

    String teamDefaultsStr = "";

    teamDefaultsStr += getLoadoutsString( zone.getDefaultInventories());

    for (TeamConfig teamConfig : TeamConfig.values()) {

      Object value = zone.getTeamDefaultConfig().getValue(teamConfig);

      if (value != null) {

        teamDefaultsStr += " " + teamConfig.toStringWithValue(value).replace(":", ":" + teamColor) + normalColor;

      }

    }

   

    return "::" + zoneColor + "Warzone " + authorColor + zone.getName() + zoneColor + " config" + normalColor + "::"

     + " author:" + authorColor + ifEmptyEveryone(zone.getAuthorsString()) + normalColor

     + ifEmptyInheritedForWarzone(warzoneConfigStr)

     + " ::" + teamColor + "Team defaults" + normalColor + "::"

     + ifEmptyInheritedForWarzone(teamDefaultsStr);

  }

 

  private String ifEmptyInheritedForWarzone(String maybeEmpty) {

    if (maybeEmpty.equals("")) {

      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 " + ChatColor.GREEN + "/warcfg -p" + ChatColor.WHITE

        + " and " + ChatColor.GREEN + "/zonecfg -p" + ChatColor.WHITE + ")";

    }

    return maybeEmpty;

  }

  private String ifEmptyEveryone(String maybeEmpty) {

    if (maybeEmpty.equals("")) {

      maybeEmpty = "*";

    }

    return maybeEmpty;

  }

  public String printConfig() {

    ChatColor teamColor = ChatColor.AQUA;

    ChatColor zoneColor = ChatColor.DARK_AQUA;

    ChatColor globalColor = ChatColor.DARK_GREEN;

    ChatColor normalColor = ChatColor.WHITE;

   

    String warConfigStr = "";

    for (WarConfig warConfig : WarConfig.values()) {

      warConfigStr += " " + warConfig.toStringWithValue(this.getWarConfig().getValue(warConfig)).replace(":", ":" + globalColor) + normalColor;

    }

   

    String warzoneDefaultsStr = "";

    for (WarzoneConfig warzoneConfig : WarzoneConfig.values()) {

      warzoneDefaultsStr += " " + warzoneConfig.toStringWithValue(this.getWarzoneDefaultConfig().getValue(warzoneConfig)).replace(":", ":" + zoneColor) + normalColor;

    }

   

    String teamDefaultsStr = "";

    teamDefaultsStr += getLoadoutsString(this.getDefaultInventories());

    for (TeamConfig teamConfig : TeamConfig.values()) {

      teamDefaultsStr += " " + teamConfig.toStringWithValue(this.getTeamDefaultConfig().getValue(teamConfig)).replace(":", ":" + teamColor) + normalColor;

    }

   

    return normalColor + "::" + globalColor + "War config" + normalColor + "::" + warConfigStr 

      + normalColor + " ::" + zoneColor + "Warzone defaults" + normalColor + "::" + warzoneDefaultsStr

      + normalColor + " ::" + teamColor + "Team defaults" + normalColor + "::" + teamDefaultsStr;

  }

  private void setZoneRallyPoint(String warzoneName, Player player) {

    Warzone zone = this.findWarzone(warzoneName);

    if (zone == null) {

      this.badMsg(player, "Can't set rally point. No such warzone.");

    } else {

      zone.setRallyPoint(player.getLocation());

      WarzoneYmlMapper.save(zone);

    }

  }

  public void addWarzone(Warzone zone) {

    this.warzones.add(zone);

  }

  public List<Warzone> getWarzones() {

    return this.warzones;

  }

  /**

   * Get a list of warzones that are not disabled.

   * @return List of enabled warzones.

   */

  public List<Warzone> getEnabledWarzones() {

    List<Warzone> enabledZones = new ArrayList<Warzone>(this.warzones.size());

    for (Warzone zone : this.warzones) {

      if (zone.getWarzoneConfig().getBoolean(WarzoneConfig.DISABLED) == false) {

        enabledZones.add(zone);

      }

    }

    return enabledZones;

  }

  /**

   * Get a list of warzones that have players in them.

   * @return List of enabled warzones with players.

   */

  public List<Warzone> getActiveWarzones() {

    List<Warzone> activeZones = new ArrayList<Warzone>(this.warzones.size());

    for (Warzone zone : this.warzones) {

      if (zone.getWarzoneConfig().getBoolean(WarzoneConfig.DISABLED) == false

        && zone.getPlayerCount() > 0) {

        activeZones.add(zone);

      }

    }

    return activeZones;

  }

  static final boolean HIDE_BLANK_MESSAGES = true;

  public void msg(CommandSender sender, String str) {

    if (messages.containsKey(str)) str = this.getString(str);

    if (HIDE_BLANK_MESSAGES && (str == null || str.isEmpty())) return;

    if (sender instanceof Player) {

      StringBuilder output = new StringBuilder(ChatColor.GRAY.toString())

          .append(this.getString("war.prefix")).append(ChatColor.WHITE).append(' ');

      output.append(this.colorKnownTokens(str, ChatColor.WHITE));

      sender.sendMessage(output.toString());

    } else {

      sender.sendMessage(str);

    }

  }

  public void badMsg(CommandSender sender, String str) {

    if (messages.containsKey(str)) str = this.getString(str);

    if (HIDE_BLANK_MESSAGES && (str == null || str.isEmpty())) return;

    if (sender instanceof Player) {

      StringBuilder output = new StringBuilder(ChatColor.GRAY.toString())

          .append(this.getString("war.prefix")).append(ChatColor.RED).append(' ');

      output.append(this.colorKnownTokens(str, ChatColor.RED));

      sender.sendMessage(output.toString());

    } else {

      sender.sendMessage(str);

    }

  }

  public void msg(CommandSender sender, String str, Object... obj) {

    if (messages.containsKey(str)) str = this.getString(str);

    if (HIDE_BLANK_MESSAGES && (str == null || str.isEmpty())) return;

    if (sender instanceof Player) {

      StringBuilder output = new StringBuilder(ChatColor.GRAY.toString())

          .append(this.getString("war.prefix")).append(ChatColor.WHITE).append(' ');

      output.append(MessageFormat.format(

            this.colorKnownTokens(str, ChatColor.WHITE), obj));

      sender.sendMessage(output.toString());

    } else {

      StringBuilder output = new StringBuilder();

      output.append(MessageFormat.format(str, obj));

      sender.sendMessage(output.toString());

    }

  }

  public void badMsg(CommandSender sender, String str, Object... obj) {

    if (messages.containsKey(str)) str = this.getString(str);

    if (HIDE_BLANK_MESSAGES && (str == null || str.isEmpty())) return;

    if (sender instanceof Player) {

      StringBuilder output = new StringBuilder(ChatColor.GRAY.toString())

          .append(this.getString("war.prefix")).append(ChatColor.RED).append(' ');

      output.append(MessageFormat.format(

            this.colorKnownTokens(str, ChatColor.RED), obj));

      sender.sendMessage(output.toString());

    } else {

      StringBuilder output = new StringBuilder();

      output.append(MessageFormat.format(str, obj));

      sender.sendMessage(output.toString());

    }

  }

  /**

   * Colors the teams and examples in messages

   *

   * @param str message-string

   * @param msgColor current message-color

   * @return String Message with colored teams

   */

  private String colorKnownTokens(String str, ChatColor msgColor) {

    str = str.replaceAll("Ex -", ChatColor.BLUE + "Ex -" + ChatColor.GRAY);

    str = str.replaceAll("\\\\", ChatColor.BLUE + "\\\\" + ChatColor.GRAY);

    str = str.replaceAll("->", ChatColor.LIGHT_PURPLE + "->" + ChatColor.GRAY);

    str = str.replaceAll("/teamcfg", ChatColor.AQUA + "/teamcfg" + ChatColor.GRAY);

    str = str.replaceAll("Team defaults", ChatColor.AQUA + "Team defaults" + ChatColor.GRAY);

    str = str.replaceAll("Team config", ChatColor.AQUA + "Team config" + ChatColor.GRAY);

    str = str.replaceAll("/zonecfg", ChatColor.DARK_AQUA + "/zonecfg" + ChatColor.GRAY);

    str = str.replaceAll("Warzone defaults", ChatColor.DARK_AQUA + "Warzone defaults" + ChatColor.GRAY);

    str = str.replaceAll("Warzone config", ChatColor.DARK_AQUA + "Warzone config" + ChatColor.GRAY);

    str = str.replaceAll("/warcfg", ChatColor.DARK_GREEN + "/warcfg" + ChatColor.GRAY);